feat: implement new IR for vyper (venom IR)

tests/compiler/venom/test_duplicate_operands.py

@@ -0,0 +1,28 @@
+from vyper.compiler.settings import OptimizationLevel
+from vyper.venom import generate_assembly_experimental
+from vyper.venom.basicblock import IRLiteral
+from vyper.venom.function import IRFunction
+
+
+def test_duplicate_operands():
+    """
+    Test the duplicate operands code generation.
+    The venom code:
+
+    %1 = 10
+    %2 = add %1, %1
+    %3 = mul %1, %2
+    stop
+
+    Should compile to: [PUSH1, 10, DUP1, DUP1, DUP1, ADD, MUL, STOP]
+    """
+    ctx = IRFunction()
+
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    sum = ctx.append_instruction("add", [op, op])
+    ctx.append_instruction("mul", [sum, op])
+    ctx.append_instruction("stop", [], False)
+
+    asm = generate_assembly_experimental(ctx, OptimizationLevel.CODESIZE)
+
+    assert asm == ["PUSH1", 10, "DUP1", "DUP1", "DUP1", "ADD", "MUL", "STOP", "REVERT"]

tests/compiler/venom/test_multi_entry_block.py

@@ -0,0 +1,96 @@
+from vyper.venom.analysis import calculate_cfg
+from vyper.venom.basicblock import IRLiteral
+from vyper.venom.function import IRBasicBlock, IRFunction, IRLabel
+from vyper.venom.passes.normalization import NormalizationPass
+
+
+def test_multi_entry_block_1():
+    ctx = IRFunction()
+
+    finish_label = IRLabel("finish")
+    target_label = IRLabel("target")
+    block_1_label = IRLabel("block_1", ctx)
+
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    acc = ctx.append_instruction("add", [op, op])
+    ctx.append_instruction("jnz", [acc, finish_label, block_1_label], False)
+
+    block_1 = IRBasicBlock(block_1_label, ctx)
+    ctx.append_basic_block(block_1)
+    acc = ctx.append_instruction("add", [acc, op])
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    ctx.append_instruction("mstore", [acc, op], False)
+    ctx.append_instruction("jnz", [acc, finish_label, target_label], False)
+
+    target_bb = IRBasicBlock(target_label, ctx)
+    ctx.append_basic_block(target_bb)
+    ctx.append_instruction("mul", [acc, acc])
+    ctx.append_instruction("jmp", [finish_label], False)
+
+    finish_bb = IRBasicBlock(finish_label, ctx)
+    ctx.append_basic_block(finish_bb)
+    ctx.append_instruction("stop", [], False)
+
+    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"
+
+
+# more complicated one
+def test_multi_entry_block_2():
+    ctx = IRFunction()
+
+    finish_label = IRLabel("finish")
+    target_label = IRLabel("target")
+    block_1_label = IRLabel("block_1", ctx)
+    block_2_label = IRLabel("block_2", ctx)
+
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    acc = ctx.append_instruction("add", [op, op])
+    ctx.append_instruction("jnz", [acc, finish_label, block_1_label], False)
+
+    block_1 = IRBasicBlock(block_1_label, ctx)
+    ctx.append_basic_block(block_1)
+    acc = ctx.append_instruction("add", [acc, op])
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    ctx.append_instruction("mstore", [acc, op], False)
+    ctx.append_instruction("jnz", [acc, target_label, finish_label], False)
+
+    block_2 = IRBasicBlock(block_2_label, ctx)
+    ctx.append_basic_block(block_2)
+    acc = ctx.append_instruction("add", [acc, op])
+    op = ctx.append_instruction("store", [IRLiteral(10)])
+    ctx.append_instruction("mstore", [acc, op], False)
+    # switch the order of the labels, for fun
+    ctx.append_instruction("jnz", [acc, finish_label, target_label], False)
+
+    target_bb = IRBasicBlock(target_label, ctx)
+    ctx.append_basic_block(target_bb)
+    ctx.append_instruction("mul", [acc, acc])
+    ctx.append_instruction("jmp", [finish_label], False)
+
+    finish_bb = IRBasicBlock(finish_label, ctx)
+    ctx.append_basic_block(finish_bb)
+    ctx.append_instruction("stop", [], False)
+
+    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"

tests/compiler/venom/test_stack_at_external_return.py

@@ -0,0 +1,5 @@
+def test_stack_at_external_return():
+    """
+    TODO: USE BOA DO GENERATE THIS TEST
+    """
+    pass

vyper/cli/vyper_compile.py

@@ -141,6 +141,11 @@ def _parse_args(argv):
         "-p", help="Set the root path for contract imports", default=".", dest="root_folder"
     )
     parser.add_argument("-o", help="Set the output path", dest="output_path")
+    parser.add_argument(
+        "--experimental-codegen",
+        help="The compiler use the new IR codegen. This is an experimental feature.",
+        action="store_true",
+    )
 
     args = parser.parse_args(argv)
 
@@ -188,6 +193,7 @@ def _parse_args(argv):
         settings,
         args.storage_layout,
         args.no_bytecode_metadata,
+        args.experimental_codegen,
     )
 
     if args.output_path:
@@ -225,6 +231,7 @@ def compile_files(
     settings: Optional[Settings] = None,
     storage_layout_paths: list[str] = None,
     no_bytecode_metadata: bool = False,
+    experimental_codegen: bool = False,
 ) -> dict:
     root_path = Path(root_folder).resolve()
     if not root_path.exists():
@@ -275,6 +282,7 @@ 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/function_definitions/common.py

@@ -162,5 +162,9 @@ def generate_ir_for_function(
         # (note: internal functions do not need to adjust gas estimate since
         mem_expansion_cost = calc_mem_gas(func_t._ir_info.frame_info.mem_used)  # type: ignore
         ret.common_ir.add_gas_estimate += mem_expansion_cost  # type: ignore
+        ret.common_ir.passthrough_metadata["func_t"] = func_t  # type: ignore
+        ret.common_ir.passthrough_metadata["frame_info"] = frame_info  # type: ignore
+    else:
+        ret.func_ir.passthrough_metadata["frame_info"] = frame_info  # type: ignore
 
     return ret

vyper/codegen/function_definitions/internal_function.py

@@ -68,4 +68,6 @@ def generate_ir_for_internal_function(
         ["seq"] + nonreentrant_post + [["exit_to", "return_pc"]],
     ]
 
-    return IRnode.from_list(["seq", body, cleanup_routine])
+    ir_node = IRnode.from_list(["seq", body, cleanup_routine])
+    ir_node.passthrough_metadata["func_t"] = func_t
+    return ir_node

vyper/codegen/ir_node.py

@@ -171,6 +171,10 @@ class IRnode:
     valency: int
     args: List["IRnode"]
     value: Union[str, int]
+    is_self_call: bool
+    passthrough_metadata: dict[str, Any]
+    func_ir: Any
+    common_ir: Any
 
     def __init__(
         self,
@@ -184,6 +188,8 @@ def __init__(
         mutable: bool = True,
         add_gas_estimate: int = 0,
         encoding: Encoding = Encoding.VYPER,
+        is_self_call: bool = False,
+        passthrough_metadata: dict[str, Any] = None,
     ):
         if args is None:
             args = []
@@ -201,6 +207,10 @@ def __init__(
         self.add_gas_estimate = add_gas_estimate
         self.encoding = encoding
         self.as_hex = AS_HEX_DEFAULT
+        self.is_self_call = is_self_call
+        self.passthrough_metadata = passthrough_metadata or {}
+        self.func_ir = None
+        self.common_ir = None
 
         assert self.value is not None, "None is not allowed as IRnode value"
 
@@ -585,6 +595,8 @@ def from_list(
         error_msg: Optional[str] = None,
         mutable: bool = True,
         add_gas_estimate: int = 0,
+        is_self_call: bool = False,
+        passthrough_metadata: dict[str, Any] = None,
         encoding: Encoding = Encoding.VYPER,
     ) -> "IRnode":
         if isinstance(typ, str):
@@ -617,6 +629,8 @@ def from_list(
                 source_pos=source_pos,
                 encoding=encoding,
                 error_msg=error_msg,
+                is_self_call=is_self_call,
+                passthrough_metadata=passthrough_metadata,
             )
         else:
             return cls(
@@ -630,4 +644,6 @@ def from_list(
                 add_gas_estimate=add_gas_estimate,
                 encoding=encoding,
                 error_msg=error_msg,
+                is_self_call=is_self_call,
+                passthrough_metadata=passthrough_metadata,
             )

vyper/codegen/return_.py

@@ -40,7 +40,9 @@ def finalize(fill_return_buffer):
         cleanup_loops = "cleanup_repeat" if context.forvars else "seq"
         # NOTE: because stack analysis is incomplete, cleanup_repeat must
         # come after fill_return_buffer otherwise the stack will break
-        return IRnode.from_list(["seq", fill_return_buffer, cleanup_loops, jump_to_exit])
+        jump_to_exit_ir = IRnode.from_list(jump_to_exit)
+        jump_to_exit_ir.passthrough_metadata["func_t"] = func_t
+        return IRnode.from_list(["seq", fill_return_buffer, cleanup_loops, jump_to_exit_ir])
 
     if context.return_type is None:
         if context.is_internal:

vyper/codegen/self_call.py

@@ -121,4 +121,6 @@ def ir_for_self_call(stmt_expr, context):
         add_gas_estimate=func_t._ir_info.gas_estimate,
     )
     o.is_self_call = True
+    o.passthrough_metadata["func_t"] = func_t
+    o.passthrough_metadata["args_ir"] = args_ir
     return o

vyper/compiler/__init__.py

@@ -55,6 +55,7 @@ def compile_code(
     no_bytecode_metadata: bool = False,
     show_gas_estimates: bool = False,
     exc_handler: Optional[Callable] = None,
+    experimental_codegen: bool = False,
 ) -> dict:
     """
     Generate consumable compiler output(s) from a single contract source code.
@@ -104,6 +105,7 @@ def compile_code(
         storage_layout_override,
         show_gas_estimates,
         no_bytecode_metadata,
+        experimental_codegen,
     )
 
     ret = {}

vyper/compiler/phases.py

@@ -16,6 +16,7 @@
 from vyper.semantics import set_data_positions, validate_semantics
 from vyper.semantics.types.function import ContractFunctionT
 from vyper.typing import StorageLayout
+from vyper.venom import generate_assembly_experimental, generate_ir
 
 DEFAULT_CONTRACT_NAME = PurePath("VyperContract.vy")
 
@@ -60,6 +61,7 @@ def __init__(
         storage_layout: StorageLayout = None,
         show_gas_estimates: bool = False,
         no_bytecode_metadata: bool = False,
+        experimental_codegen: bool = False,
     ) -> None:
         """
         Initialization method.
@@ -78,14 +80,18 @@ 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
         self.contract_path = contract_path
         self.source_code = source_code
         self.source_id = source_id
         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(".")])
 
@@ -160,7 +166,11 @@ def global_ctx(self) -> GlobalContext:
     @cached_property
     def _ir_output(self):
         # fetch both deployment and runtime IR
-        return generate_ir_nodes(self.global_ctx, self.settings.optimize)
+        nodes = generate_ir_nodes(self.global_ctx, self.settings.optimize)
+        if self.experimental_codegen:
+            return [generate_ir(nodes[0]), generate_ir(nodes[1])]
+        else:
+            return nodes
 
     @property
     def ir_nodes(self) -> IRnode:
@@ -183,11 +193,21 @@ def function_signatures(self) -> dict[str, ContractFunctionT]:
 
     @cached_property
     def assembly(self) -> list:
-        return generate_assembly(self.ir_nodes, self.settings.optimize)
+        if self.experimental_codegen:
+            return generate_assembly_experimental(
+                self.ir_nodes, self.settings.optimize  # type: ignore
+            )
+        else:
+            return generate_assembly(self.ir_nodes, self.settings.optimize)
 
     @cached_property
     def assembly_runtime(self) -> list:
-        return generate_assembly(self.ir_runtime, self.settings.optimize)
+        if self.experimental_codegen:
+            return generate_assembly_experimental(
+                self.ir_runtime, self.settings.optimize  # type: ignore
+            )
+        else:
+            return generate_assembly(self.ir_runtime, self.settings.optimize)
 
     @cached_property
     def bytecode(self) -> bytes: