feat[venom]: implement new calling convention (#4482)

this commit updates the IRnode->venom translator to use
stack arguments when the arguments are word-size and under
a certain threshold. to ensure that all the contracts in
`tests/functional/examples/thirdparty/` compile, the threshold
is set to 6. we could relax this later if we have interprocedural
optimizations which can migrate the stack arguments back to memory.

it also updates the inliner and mem2var to handle cases from the new
calling convention.

---------

Co-authored-by: Charles Cooper <[email protected]>

Author: harkal

tests/functional/codegen/calling_convention/test_new_call_convention.py

@@ -0,0 +1,38 @@
+def test_call_unused_param_return_tuple(get_contract):
+    code = """
+@internal
+def _foo(a: uint256, b: uint256) -> (uint256, uint256):
+    return a, b
+
+@external
+def foo() -> (uint256, uint256):
+    return self._foo(1, 2)
+    """
+
+    c = get_contract(code)
+
+    assert c.foo() == (1, 2)
+
+
+def test_returning_immutables(get_contract):
+    """
+    This test checks that we can return an immutable from an internal function, which results in
+    the immutable being copied into the return buffer with `dloadbytes`.
+    """
+    contract = """
+a: immutable(uint256)
+
+@deploy
+def __init__():
+    a = 5
+
+@internal
+def get_my_immutable() -> uint256:
+    return a
+
+@external
+def get_immutable() -> uint256:
+    return self.get_my_immutable()
+    """
+    c = get_contract(contract)
+    assert c.get_immutable() == 5

tests/functional/venom/parser/test_parsing.py

@@ -151,7 +151,7 @@ def test_multi_function():
     expected_ctx.add_function(entry_fn := IRFunction(IRLabel("entry")))
 
     entry_bb = entry_fn.get_basic_block("entry")
-    entry_bb.append_instruction("invoke", IRLabel("check_cv"))
+    entry_bb.append_invoke_instruction([IRLabel("check_cv")], returns=False)
     entry_bb.append_instruction("jmp", IRLabel("wow"))
 
     entry_fn.append_basic_block(wow_bb := IRBasicBlock(IRLabel("wow"), entry_fn))
@@ -213,7 +213,7 @@ def test_multi_function_and_data():
     expected_ctx.add_function(entry_fn := IRFunction(IRLabel("entry")))
 
     entry_bb = entry_fn.get_basic_block("entry")
-    entry_bb.append_instruction("invoke", IRLabel("check_cv"))
+    entry_bb.append_invoke_instruction([IRLabel("check_cv")], returns=False)
     entry_bb.append_instruction("jmp", IRLabel("wow"))
 
     entry_fn.append_basic_block(wow_bb := IRBasicBlock(IRLabel("wow"), entry_fn))

tests/functional/venom/test_venom_repr.py

@@ -25,6 +25,9 @@ def test_round_trip_examples(vy_filename, debug, optimize, compiler_settings, re
     """
     Check all examples round trip
     """
+    if not compiler_settings.experimental_codegen:
+        pytest.skip("tests n/a when venom is not enabled")
+
     path = f"examples/{vy_filename}"
     with open(path) as f:
         vyper_source = f.read()
@@ -55,6 +58,9 @@ def test_round_trip_sources(vyper_source, debug, optimize, compiler_settings, re
     """
     Test vyper_sources round trip
     """
+    if not compiler_settings.experimental_codegen:
+        pytest.skip("tests n/a when venom is not enabled")
+
     vyper_source = textwrap.dedent(vyper_source)
 
     if debug and optimize == OptimizationLevel.CODESIZE:

tests/unit/compiler/test_source_map.py

@@ -143,6 +143,7 @@ def foo(i: uint256):
 
 @pure
 def bar(i: uint256) -> String[85]:
+    # ensure the mod doesn't get erased
     return concat("foo foo", uint2str(i))
     """
     error_map = compile_code(code, output_formats=["source_map"])["source_map"]["error_map"]

vyper/codegen/arithmetic.py

@@ -334,6 +334,8 @@ def safe_div(x, y):
 def safe_mod(x, y):
     typ = x.typ
     MOD = "smod" if typ.is_signed else "mod"
+    # TODO: (force) propagate safemod error msg down to all children,
+    # overriding the "clamp" error msg.
     return IRnode.from_list([MOD, x, clamp("gt", y, 0)], error_msg="safemod")
 
 

vyper/codegen/self_call.py

@@ -85,6 +85,7 @@ def ir_for_self_call(stmt_expr, context):
             alloca = dataclasses.replace(alloca, _callsite=return_label)
             irnode = var.as_ir_node()
             irnode.passthrough_metadata["alloca"] = alloca
+            irnode.passthrough_metadata["callsite_func"] = func_t
             arg_items.append(irnode)
         args_dst = IRnode.from_list(arg_items, typ=dst_tuple_t)
     else:

vyper/venom/basicblock.py

@@ -76,7 +76,6 @@
         "selfdestruct",
         "stop",
         "invalid",
-        "invoke",
         "jmp",
         "djmp",
         "jnz",
@@ -389,7 +388,7 @@ def remove_phi_operand(self, label: IRLabel) -> None:
     def code_size_cost(self) -> int:
         if self.opcode in ("ret", "param"):
             return 0
-        if self.opcode == "store":
+        if self.opcode in ("store", "palloca", "alloca", "calloca"):
             return 1
         return 2
 
@@ -680,6 +679,12 @@ def __repr__(self) -> str:
             if printer and hasattr(printer, "_post_instruction"):
                 s += printer._post_instruction(inst)
             s += "\n"
+
+        if len(self.instructions) > 30:
+            s += f"  ; {self.label}\n"
+        if len(self.instructions) > 30 or self.parent.num_basic_blocks > 5:
+            s += f"  ; ({self.parent.name})\n\n"
+
         return s
 
 

vyper/venom/function.py

@@ -13,15 +13,16 @@
     from vyper.venom.context import IRContext
 
 
-@dataclass
+@dataclass(frozen=True)
 class IRParameter:
     name: str
-    index: int
-    offset: int
-    size: int
-    call_site_var: Optional[IRVariable]
-    func_var: Optional[IRVariable]
-    addr_var: Optional[IRVariable]
+    index: int  # needed?
+    offset: int  # needed?
+    size: int  # needed?
+    id_: int
+    call_site_var: Optional[IRVariable]  # needed?
+    func_var: IRVariable
+    addr_var: Optional[IRVariable]  # needed?
 
 
 class IRFunction:
@@ -136,9 +137,9 @@ def pop_source(self):
         assert len(self._error_msg_stack) > 0, "Empty error stack"
         self._error_msg_stack.pop()
 
-    def get_param_at_offset(self, offset: int) -> Optional[IRParameter]:
+    def get_param_by_id(self, id_: int) -> Optional[IRParameter]:
         for param in self.args:
-            if param.offset == offset:
+            if param.id_ == id_:
                 return param
         return None