[WIP] EOF support

README.md

@@ -52,6 +52,18 @@ make dev-init
 python setup.py test
 ```
 
+## Experimental EOFv1 support
+
+This version of the Vyper compiler supports the upcoming EOFv1 bytecode format. This is currently under
+development and in alpha state. To enable the experimental EOFv1 support you use the 
+``--experimental-eof`` command line option. Additionally a greater or equal to ``cancun`` evm version should
+be used. 
+
+Usage example:
+```bash
+vyper --experimental-eof --evm-version=cancun -f opcodes_runtime contract.vy
+```
+
 ## Developing (working on the compiler)
 
 A useful script to have in your PATH is something like the following:

vyper/cli/validate_eof.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+
+from vyper.evm.eof import EOFReader
+
+
+def _parse_args(argv):
+    parser = argparse.ArgumentParser(
+        description="Vyper EOFv1 validation utility", formatter_class=argparse.RawTextHelpFormatter
+    )
+    parser.add_argument(
+        "input_file", help="Input file containing the EOFv1 formated bytecode", nargs="?"
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.input_file:
+        with open(args.input_file, "r") as f:
+            code = bytes.fromhex(f.read())
+            EOFReader(code)
+
+
+if __name__ == "__main__":
+    _parse_args(sys.argv[1:])

vyper/cli/vyper_compile.py

@@ -182,6 +182,11 @@ def _parse_args(argv):
         dest="experimental_codegen",
     )
     parser.add_argument("--enable-decimals", help="Enable decimals", action="store_true")
+    parser.add_argument(
+        "--experimental-eof",
+        help="The compiler will emit EOFv1 formated bytecode",
+        action="store_true",
+    )
 
     args = parser.parse_args(argv)
 
@@ -244,6 +249,7 @@ def _parse_args(argv):
         settings,
         args.storage_layout,
         args.no_bytecode_metadata,
+        args.experimental_eof,
     )
 
     mode = "w"

vyper/cli/vyper_json.py

@@ -357,8 +357,13 @@
                 evm["object"] = data["bytecode_runtime"]
             if "opcodes_runtime" in data:
                 evm["opcodes"] = data["opcodes_runtime"]
-            if "source_map_runtime" in data:
-                evm["sourceMap"] = data["source_map_runtime"]
+            if "source_map" in data:
+                evm["sourceMap"] = data["source_map"]["pc_pos_map_compressed"]
+            if "source_map_full" in data:
+                evm["sourceMapFull"] = data["source_map_full"]
+            # MERGE: revisit
+            # if "source_map_runtime" in data:
+            #     evm["sourceMap"] = data["source_map_runtime"]
 
     return output_dict
 

vyper/codegen/self_call.py

@@ -1,6 +1,7 @@
 from vyper.codegen.core import _freshname, eval_once_check, make_setter
 from vyper.codegen.ir_node import IRnode
 from vyper.evm.address_space import MEMORY
+from vyper.evm.opcodes import is_eof_enabled
 from vyper.exceptions import StateAccessViolation
 from vyper.semantics.types.subscriptable import TupleT
 
@@ -93,11 +94,15 @@ def ir_for_self_call(stmt_expr, context):
     if return_buffer is not None:
         goto_op += [return_buffer]
     # pass return label to subroutine
-    goto_op.append(["symbol", return_label])
-
+    if not is_eof_enabled():
+        goto_op.append(["symbol", return_label])
+
     call_sequence = ["seq"]
     call_sequence.append(eval_once_check(_freshname(stmt_expr.node_source_code)))
-    call_sequence.extend([copy_args, goto_op, ["label", return_label, ["var_list"], "pass"]])
+    if is_eof_enabled():
+        call_sequence.extend([copy_args, goto_op])
+    else:
+        call_sequence.extend([copy_args, goto_op, ["label", return_label, ["var_list"], "pass"]])
     if return_buffer is not None:
         # push return buffer location to stack
         call_sequence += [return_buffer]

vyper/compiler/__init__.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Callable, Dict, Optional
+from typing import Callable, Optional
 
 import vyper.codegen.core as codegen
 import vyper.compiler.output as output

vyper/compiler/output.py

@@ -8,8 +8,9 @@
 from vyper.compiler.output_bundle import SolcJSONWriter, VyperArchiveWriter
 from vyper.compiler.phases import CompilerData
 from vyper.compiler.utils import build_gas_estimates
-from vyper.evm import opcodes
-from vyper.exceptions import VyperException
+from vyper.evm import eof, opcodes
+from vyper.evm.opcodes import is_eof_enabled
+from vyper.exceptions import CompilerPanic, VyperException
 from vyper.ir import compile_ir
 from vyper.semantics.types.function import FunctionVisibility, StateMutability
 from vyper.typing import StorageLayout
@@ -396,15 +397,25 @@ def build_opcodes_runtime_output(compiler_data: CompilerData) -> str:
     return _build_opcodes(compiler_data.bytecode_runtime)
 
 
-def _build_opcodes(bytecode: bytes) -> str:
+def _build_legacy_opcodes(bytecode: bytes) -> str:
     bytecode_sequence = deque(bytecode)
 
     opcode_map = dict((v[0], k) for k, v in opcodes.get_opcodes().items())
     opcode_output = []
 
     while bytecode_sequence:
         op = bytecode_sequence.popleft()
+        mnemonic = opcode_map.get(op)
+
+        if mnemonic is None:
+            raise CompilerPanic(f"Unsupported opcode {hex(op)} after {opcode_output}")
+
         opcode_output.append(opcode_map.get(op, f"VERBATIM_{hex(op)}"))
+        if mnemonic in ["RJUMP", "RJUMPI", "CALLF"]:
+            offset = int.from_bytes(
+                [bytecode_sequence.popleft() for _i in range(2)], "big", signed=True
+            )
+            opcode_output.append(hex(offset))
         if "PUSH" in opcode_output[-1] and opcode_output[-1] != "PUSH0":
             push_len = int(opcode_map[op][4:])
             # we can have push_len > len(bytecode_sequence) when there is data
@@ -415,3 +426,20 @@ def _build_opcodes(bytecode: bytes) -> str:
             opcode_output.append(f"0x{''.join(push_values)}")
 
     return " ".join(opcode_output)
+
+
+def _build_eof_opcodes(bytecode: bytes) -> str:
+    eofReader = eof.EOFReader(bytecode)
+    output = eofReader.disassemble()
+    if eofReader.bytecode_size != len(bytecode):
+        runtimeEofReader = eof.EOFReader(bytecode[eofReader.bytecode_size :])
+        output = "--- DEPLOY CODE ---\n" + output
+        output += "--- RUNTIME CODE ---\n" + runtimeEofReader.disassemble()
+    return output
+
+
+def _build_opcodes(bytecode: bytes) -> str:
+    if is_eof_enabled():
+        return _build_eof_opcodes(bytecode)
+    else:
+        return _build_legacy_opcodes(bytecode)

vyper/compiler/phases.py

@@ -61,6 +61,7 @@
         storage_layout: StorageLayout = None,
         show_gas_estimates: bool = False,
         no_bytecode_metadata: bool = False,
+        experimental_eof: bool = False,
     ) -> None:
         """
         Initialization method.
@@ -249,12 +250,25 @@
 
     @cached_property
     def bytecode(self) -> bytes:
-        insert_compiler_metadata = not self.no_bytecode_metadata
-        return generate_bytecode(self.assembly, insert_compiler_metadata=insert_compiler_metadata)
+        if self.experimental_eof:
+            return generate_EOFv1(self.assembly, no_bytecode_metadata=self.no_bytecode_metadata)
+        else:
+            return generate_bytecode(
+                self.assembly, is_runtime=False, no_bytecode_metadata=self.no_bytecode_metadata
+            )
 
     @cached_property
     def bytecode_runtime(self) -> bytes:
-        return generate_bytecode(self.assembly_runtime, insert_compiler_metadata=False)
+        if self.experimental_eof:
+            return generate_EOFv1(
+                self.assembly_runtime, no_bytecode_metadata=self.no_bytecode_metadata
+            )
+        else:
+            return generate_bytecode(
+                self.assembly_runtime,
+                is_runtime=True,
+                no_bytecode_metadata=self.no_bytecode_metadata,
+            )
 
     @cached_property
     def blueprint_bytecode(self) -> bytes:
@@ -368,3 +382,14 @@
     return compile_ir.assembly_to_evm(assembly, insert_compiler_metadata=insert_compiler_metadata)[
         0
     ]
+
+
+def generate_EOFv1(assembly: list, no_bytecode_metadata: bool = False) -> bytes:
+    bytecode, _ = compile_ir.assembly_to_evm(
+        assembly,
+        emit_headers=True,
+        disable_bytecode_metadata=no_bytecode_metadata,
+        eof_enabled=True,
+    )
+
+    return bytecode