feat: remove deploy instruction from venom

tests/unit/compiler/venom/test_duplicate_operands.py

@@ -22,6 +22,6 @@ def test_duplicate_operands():
     bb.append_instruction("mul", sum, op)
     bb.append_instruction("stop")
 
-    asm = generate_assembly_experimental(ctx, OptimizationLevel.CODESIZE)
+    asm = generate_assembly_experimental((None, ctx), OptimizationLevel.CODESIZE)
 
     assert asm == ["PUSH1", 10, "DUP1", "DUP1", "DUP1", "ADD", "MUL", "STOP", "REVERT"]

tests/unit/compiler/venom/test_multi_entry_block.py

@@ -41,7 +41,7 @@ def test_multi_entry_block_1():
     finish_bb = ctx.get_basic_block(finish_label.value)
     cfg_in = list(finish_bb.cfg_in.keys())
     assert cfg_in[0].label.value == "target", "Should contain target"
-    assert cfg_in[1].label.value == "finish_split_global", "Should contain finish_split_global"
+    assert cfg_in[1].label.value == "finish_split___global", "Should contain finish_split___global"
     assert cfg_in[2].label.value == "finish_split_block_1", "Should contain finish_split_block_1"
 
 
@@ -93,5 +93,46 @@ def test_multi_entry_block_2():
     finish_bb = ctx.get_basic_block(finish_label.value)
     cfg_in = list(finish_bb.cfg_in.keys())
     assert cfg_in[0].label.value == "target", "Should contain target"
-    assert cfg_in[1].label.value == "finish_split_global", "Should contain finish_split_global"
+    assert cfg_in[1].label.value == "finish_split___global", "Should contain finish_split___global"
+    assert cfg_in[2].label.value == "finish_split_block_1", "Should contain finish_split_block_1"
+
+
+def test_multi_entry_block_with_dynamic_jump():
+    ctx = IRFunction()
+
+    finish_label = IRLabel("finish")
+    target_label = IRLabel("target")
+    block_1_label = IRLabel("block_1", ctx)
+
+    bb = ctx.get_basic_block()
+    op = bb.append_instruction("store", 10)
+    acc = bb.append_instruction("add", op, op)
+    bb.append_instruction("djmp", acc, finish_label, block_1_label)
+
+    block_1 = IRBasicBlock(block_1_label, ctx)
+    ctx.append_basic_block(block_1)
+    acc = block_1.append_instruction("add", acc, op)
+    op = block_1.append_instruction("store", 10)
+    block_1.append_instruction("mstore", acc, op)
+    block_1.append_instruction("jnz", acc, finish_label, target_label)
+
+    target_bb = IRBasicBlock(target_label, ctx)
+    ctx.append_basic_block(target_bb)
+    target_bb.append_instruction("mul", acc, acc)
+    target_bb.append_instruction("jmp", finish_label)
+
+    finish_bb = IRBasicBlock(finish_label, ctx)
+    ctx.append_basic_block(finish_bb)
+    finish_bb.append_instruction("stop")
+
+    calculate_cfg(ctx)
+    assert not ctx.normalized, "CFG should not be normalized"
+
+    NormalizationPass.run_pass(ctx)
+    assert ctx.normalized, "CFG should be normalized"
+
+    finish_bb = ctx.get_basic_block(finish_label.value)
+    cfg_in = list(finish_bb.cfg_in.keys())
+    assert cfg_in[0].label.value == "target", "Should contain target"
+    assert cfg_in[1].label.value == "finish_split___global", "Should contain finish_split___global"
     assert cfg_in[2].label.value == "finish_split_block_1", "Should contain finish_split_block_1"

vyper/cli/vyper_compile.py

@@ -147,6 +147,7 @@ def _parse_args(argv):
         "--experimental-codegen",
         help="The compiler use the new IR codegen. This is an experimental feature.",
         action="store_true",
+        dest="experimental_codegen",
     )
 
     args = parser.parse_args(argv)
@@ -184,6 +185,9 @@ def _parse_args(argv):
     if args.evm_version:
         settings.evm_version = args.evm_version
 
+    if args.experimental_codegen:
+        settings.experimental_codegen = args.experimental_codegen
+
     if args.verbose:
         print(f"cli specified: `{settings}`", file=sys.stderr)
 
@@ -195,7 +199,6 @@ def _parse_args(argv):
         settings,
         args.storage_layout,
         args.no_bytecode_metadata,
-        args.experimental_codegen,
     )
 
     if args.output_path:
@@ -233,7 +236,6 @@ def compile_files(
     settings: Optional[Settings] = None,
     storage_layout_paths: list[str] = None,
     no_bytecode_metadata: bool = False,
-    experimental_codegen: bool = False,
 ) -> dict:
     paths = paths or []
 
@@ -287,7 +289,6 @@ def compile_files(
             storage_layout_override=storage_layout_override,
             show_gas_estimates=show_gas_estimates,
             no_bytecode_metadata=no_bytecode_metadata,
-            experimental_codegen=experimental_codegen,
         )
 
         ret[file_path] = output

vyper/codegen/core.py

@@ -892,6 +892,8 @@ def make_setter(left, right):
 _opt_level = OptimizationLevel.GAS
 
 
+# FIXME: this is to get around the fact that we don't have a
+# proper context object in the IR generation phase.
 @contextlib.contextmanager
 def anchor_opt_level(new_level: OptimizationLevel) -> Generator:
     """

vyper/codegen/module.py

@@ -311,21 +311,23 @@ def _selector_section_sparse(external_functions, module_ctx):
 
         ret.append(["codecopy", dst, bucket_hdr_location, SZ_BUCKET_HEADER])
 
-        jumpdest = IRnode.from_list(["mload", 0])
-        # don't particularly like using `jump` here since it can cause
-        # issues for other backends, consider changing `goto` to allow
-        # dynamic jumps, or adding some kind of jumptable instruction
-        ret.append(["jump", jumpdest])
+        jump_targets = []
 
-        jumptable_data = ["data", "selector_buckets"]
         for i in range(n_buckets):
             if i in buckets:
                 bucket_label = f"selector_bucket_{i}"
-                jumptable_data.append(["symbol", bucket_label])
+                jump_targets.append(bucket_label)
             else:
                 # empty bucket
-                jumptable_data.append(["symbol", "fallback"])
+                jump_targets.append("fallback")
+
+        jumptable_data = ["data", "selector_buckets"]
+        jumptable_data.extend(["symbol", label] for label in jump_targets)
+
+        jumpdest = IRnode.from_list(["mload", 0])
 
+        jump_instr = IRnode.from_list(["djump", jumpdest, *jump_targets])
+        ret.append(jump_instr)
         ret.append(jumptable_data)
 
     for bucket_id, bucket in buckets.items():

vyper/compiler/__init__.py

@@ -53,7 +53,6 @@ def compile_from_file_input(
     no_bytecode_metadata: bool = False,
     show_gas_estimates: bool = False,
     exc_handler: Optional[Callable] = None,
-    experimental_codegen: bool = False,
 ) -> dict:
     """
     Main entry point into the compiler.
@@ -107,7 +106,6 @@ def compile_from_file_input(
         storage_layout_override,
         show_gas_estimates,
         no_bytecode_metadata,
-        experimental_codegen,
     )
 
     ret = {}

vyper/compiler/output.py

@@ -89,6 +89,9 @@ def build_ir_runtime_output(compiler_data: CompilerData) -> IRnode:
 
 
 def _ir_to_dict(ir_node):
+    # Currently only supported with IRnode and not VenomIR
+    if not isinstance(ir_node, IRnode):
+        return
     args = ir_node.args
     if len(args) > 0 or ir_node.value == "seq":
         return {ir_node.value: [_ir_to_dict(x) for x in args]}

vyper/compiler/phases.py

@@ -59,7 +59,6 @@ def __init__(
         storage_layout: StorageLayout = None,
         show_gas_estimates: bool = False,
         no_bytecode_metadata: bool = False,
-        experimental_codegen: bool = False,
     ) -> None:
         """
         Initialization method.
@@ -76,11 +75,9 @@ def __init__(
             Show gas estimates for abi and ir output modes
         no_bytecode_metadata: bool, optional
             Do not add metadata to bytecode. Defaults to False
-        experimental_codegen: bool, optional
-            Use experimental codegen. Defaults to False
         """
         # to force experimental codegen, uncomment:
-        # experimental_codegen = True
+        # settings.experimental_codegen = True
 
         if isinstance(file_input, str):
             file_input = FileInput(
@@ -93,7 +90,6 @@ def __init__(
         self.storage_layout_override = storage_layout
         self.show_gas_estimates = show_gas_estimates
         self.no_bytecode_metadata = no_bytecode_metadata
-        self.experimental_codegen = experimental_codegen
         self.settings = settings or Settings()
         self.input_bundle = input_bundle or FilesystemInputBundle([Path(".")])
 
@@ -142,6 +138,18 @@ def _generate_ast(self):
                 )
             self.settings.optimize = settings.optimize
 
+        if settings.experimental_codegen is not None:
+            if (
+                self.settings.experimental_codegen is not None
+                and self.settings.experimental_codegen != settings.experimental_codegen
+            ):
+                raise StructureException(
+                    f"compiler options indicate experimental codegen mode "
+                    f"{self.settings.experimental_codegen}, "
+                    f"but source pragma indicates {settings.experimental_codegen}."
+                )
+            self.settings.experimental_codegen = settings.experimental_codegen
+
         # ensure defaults
         if self.settings.optimize is None:
             self.settings.optimize = OptimizationLevel.default()
@@ -184,9 +192,12 @@ def global_ctx(self) -> ModuleT:
     @cached_property
     def _ir_output(self):
         # fetch both deployment and runtime IR
-        nodes = generate_ir_nodes(self.global_ctx, self.settings.optimize)
-        if self.experimental_codegen:
-            return [generate_ir(nodes[0]), generate_ir(nodes[1])]
+        nodes = generate_ir_nodes(
+            self.global_ctx, self.settings.optimize, self.settings.experimental_codegen
+        )
+        if self.settings.experimental_codegen:
+            ir, ir_runtime = generate_ir(nodes[0])
+            return [(ir, ir_runtime), (None, ir_runtime)]
         else:
             return nodes
 
@@ -211,7 +222,7 @@ def function_signatures(self) -> dict[str, ContractFunctionT]:
 
     @cached_property
     def assembly(self) -> list:
-        if self.experimental_codegen:
+        if self.settings.experimental_codegen:
             return generate_assembly_experimental(
                 self.ir_nodes, self.settings.optimize  # type: ignore
             )
@@ -220,7 +231,7 @@ def assembly(self) -> list:
 
     @cached_property
     def assembly_runtime(self) -> list:
-        if self.experimental_codegen:
+        if self.settings.experimental_codegen:
             return generate_assembly_experimental(
                 self.ir_runtime, self.settings.optimize  # type: ignore
             )
@@ -294,7 +305,9 @@ def generate_folded_ast(
     return vyper_module_folded, symbol_tables
 
 
-def generate_ir_nodes(global_ctx: ModuleT, optimize: OptimizationLevel) -> tuple[IRnode, IRnode]:
+def generate_ir_nodes(
+    global_ctx: ModuleT, optimize: OptimizationLevel, experimental_codegen: bool
+) -> tuple[IRnode, IRnode]:
     """
     Generate the intermediate representation (IR) from the contextualized AST.
 

vyper/compiler/settings.py

@@ -42,6 +42,7 @@ class Settings:
     compiler_version: Optional[str] = None
     optimize: Optional[OptimizationLevel] = None
     evm_version: Optional[str] = None
+    experimental_codegen: Optional[bool] = None
 
 
 _DEBUG = False

vyper/ir/compile_ir.py

@@ -702,6 +702,13 @@ def _height_of(witharg):
             o.extend(_compile_to_assembly(c, withargs, existing_labels, break_dest, height + i))
         o.extend(["_sym_" + code.args[0].value, "JUMP"])
         return o
+    elif code.value == "djump":
+        o = []
+        # "djump" compiles to a raw EVM jump instruction
+        jump_target = code.args[0]
+        o.extend(_compile_to_assembly(jump_target, withargs, existing_labels, break_dest, height))
+        o.append("JUMP")
+        return o
     # push a literal symbol
     elif code.value == "symbol":
         return ["_sym_" + code.args[0].value]

vyper/utils.py

@@ -331,6 +331,7 @@ class SizeLimits:
     "with",
     "label",
     "goto",
+    "djump",  # "dynamic jump", i.e. constrained, multi-destination jump
     "~extcode",
     "~selfcode",
     "~calldata",

vyper/venom/__init__.py

@@ -1,7 +1,7 @@
 # maybe rename this `main.py` or `venom.py`
 # (can have an `__init__.py` which exposes the API).
 
-from typing import Optional
+from typing import Any, Optional
 
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.settings import OptimizationLevel
@@ -19,17 +19,14 @@
 
 
 def generate_assembly_experimental(
-    ctx: IRFunction, optimize: Optional[OptimizationLevel] = None
+    ctxs: tuple[IRFunction, IRFunction], optimize: Optional[OptimizationLevel] = None
 ) -> list[str]:
-    compiler = VenomCompiler(ctx)
+    compiler = VenomCompiler(list(ctxs))
     return compiler.generate_evm(optimize is OptimizationLevel.NONE)
 
 
-def generate_ir(ir: IRnode, optimize: Optional[OptimizationLevel] = None) -> IRFunction:
-    # Convert "old" IR to "new" IR
-    ctx = convert_ir_basicblock(ir)
-
-    # Run passes on "new" IR
+def _run_passes(ctx: IRFunction, optimize: Optional[OptimizationLevel] = None) -> None:
+    # Run passes on Venom IR
     # TODO: Add support for optimization levels
     while True:
         changes = 0
@@ -53,4 +50,14 @@
         if changes == 0:
             break
 
-    return ctx
+
+def generate_ir(
+    ir: IRnode, optimize: Optional[OptimizationLevel] = None
+) -> tuple[IRFunction, IRFunction]:
+    # Convert "old" IR to "new" IR
+    ctx, ctx_runtime = convert_ir_basicblock(ir)
+
+    _run_passes(ctx, optimize)
+    _run_passes(ctx_runtime, optimize)
+
+    return ctx, ctx_runtime

vyper/venom/analysis.py

@@ -19,36 +19,6 @@ def calculate_cfg(ctx: IRFunction) -> None:
         bb.cfg_out = OrderedSet()
         bb.out_vars = OrderedSet()
 
-    # TODO: This is a hack to support the old IR format where `deploy` is
-    # an instruction. in the future we should have two entry points, one
-    # for the initcode and one for the runtime code.
-    deploy_bb = None
-    after_deploy_bb = None
-    for i, bb in enumerate(ctx.basic_blocks):
-        if bb.instructions[0].opcode == "deploy":
-            deploy_bb = bb
-            after_deploy_bb = ctx.basic_blocks[i + 1]
-            break
-
-    if deploy_bb is not None:
-        assert after_deploy_bb is not None, "No block after deploy block"
-        entry_block = after_deploy_bb
-        has_constructor = ctx.basic_blocks[0].instructions[0].opcode != "deploy"
-        if has_constructor:
-            deploy_bb.add_cfg_in(ctx.basic_blocks[0])
-            entry_block.add_cfg_in(deploy_bb)
-    else:
-        entry_block = ctx.basic_blocks[0]
-
-    # TODO: Special case for the jump table of selector buckets and fallback.
-    # this will be cleaner when we introduce an "indirect jump" instruction
-    # for the selector table (which includes all possible targets). it will
-    # also clean up the code for normalization because it will not have to
-    # handle this case specially.
-    for bb in ctx.basic_blocks:
-        if "selector_bucket_" in bb.label.value or bb.label.value == "fallback":
-            bb.add_cfg_in(entry_block)
-
     for bb in ctx.basic_blocks:
         assert len(bb.instructions) > 0, "Basic block should not be empty"
         last_inst = bb.instructions[-1]