feat[venom]: inline pass and call conv

tests/unit/compiler/asm/test_asm_optimizer.py

@@ -120,7 +120,9 @@ def foo():
     input_bundle = make_input_bundle({"library.vy": library})
     res = compile_code(code, input_bundle=input_bundle, output_formats=["asm"])
     asm = res["asm"]
-    assert "some_function()" in asm
+
+    if not experimental_codegen:
+        assert "some_function()" in asm  # Venom function inliner will remove this
 
     assert "unused1()" not in asm
     assert "unused2()" not in asm

tests/unit/compiler/test_source_map.py

@@ -38,16 +38,23 @@ def test_jump_map(optimize, experimental_codegen):
     jump_map = source_map["pc_jump_map"]
 
     expected_jumps = 1
+    expected_internals = 2
     if optimize == OptimizationLevel.NONE:
         # some jumps which don't get optimized out when optimizer is off
         # (slightly different behavior depending if venom pipeline is enabled):
         if not experimental_codegen:
             expected_jumps = 3
         else:
             expected_jumps = 2
+    else:
+        if not experimental_codegen:
+            expected_internals = 2
+        else:
+            expected_jumps = 0
+            expected_internals = 0
 
     assert len([v for v in jump_map.values() if v == "o"]) == expected_jumps
-    assert len([v for v in jump_map.values() if v == "i"]) == 2
+    assert len([v for v in jump_map.values() if v == "i"]) == expected_internals
 
     code_lines = [i + "\n" for i in TEST_CODE.split("\n")]
     for pc in [k for k, v in jump_map.items() if v == "o"]:

tests/unit/compiler/venom/test_call_conv.py

@@ -0,0 +1,112 @@
+def test_simple_call(get_contract):
+    code = """
+@internal
+def name(_name: uint256) -> uint256:
+    return _name + 1
+
+
+@external
+def foo(x: uint256) -> uint256:
+    u: uint256 = 1 + x
+    ret: uint256 = self.name(u + 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == 13
+
+
+def test_simple_call_multiple_args_in_call(get_contract):
+    code = """
+@internal
+def bar(_name: uint256, _name2: uint256) -> uint256:
+    return _name + 10
+
+@external
+def foo(x: uint256) -> uint256:
+    ret: uint256 = self.bar(20, 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == 30
+
+
+def test_simple_call_multiple_args(get_contract):
+    code = """
+@internal
+def bar(_name: uint256, _name2: uint256) -> (uint256, uint256):
+    return _name + 1, _name + 2
+
+@external
+def foo(x: uint256) -> (uint256, uint256):
+    ret: (uint256, uint256) = self.bar(20, 10)
+    return ret
+    """
+
+    c = get_contract(code)
+    assert c.foo(1) == (21, 22)
+
+
+def test_call_in_call(get_contract):
+    code = """
+@internal
+def _foo(a: uint256) -> uint256:
+    return a
+
+@external
+def foo() -> uint256:
+    a: uint256 = 1
+    return self._foo(a)
+"""
+
+    c = get_contract(code)
+
+    assert c.foo() == 1
+
+
+def test_2d_array_input_1(get_contract):
+    code = """
+@internal
+def test_input(arr: DynArray[DynArray[int128, 2], 1]) -> DynArray[DynArray[int128, 2], 1]:
+    return arr
+
+@external
+def test_values(arr: DynArray[DynArray[int128, 2], 1]) -> DynArray[DynArray[int128, 2], 1]:
+    return self.test_input(arr)
+    """
+
+    c = get_contract(code)
+    assert c.test_values([[1, 2]]) == ([[1, 2]])
+
+
+def test_call_with_unused_params(get_contract):
+    code = """
+@internal
+def _foo3(a: uint256, b: uint256) -> uint256:
+    return 42
+
+@external
+def foo() -> uint256:
+    return self._foo3(9, 11)
+    """
+
+    c = get_contract(code)
+
+    assert c.foo() == 42
+
+
+def test_internal_assign(get_contract):
+    code = """
+@internal
+def foo(x: uint256) -> uint256:
+    x = 10
+    return x
+
+@external
+def bar(x: uint256) -> uint256:
+    return self.foo(x)
+    """
+    c = get_contract(code)
+
+    assert c.bar(70) == 10

tests/unit/compiler/venom/test_inliner.py

@@ -0,0 +1,64 @@
+import pytest
+
+from tests.evm_backends.base_env import ExecutionReverted
+
+
+def test_call_in_call(get_contract):
+    code = """
+@internal
+def _foo(a: uint256,) -> uint256:
+    return 1 + a
+
+@internal
+def _foo2() -> uint256:
+    return 4
+
+@external
+def foo() -> uint256:
+    return self._foo(self._foo2())
+    """
+
+    c = get_contract(code)
+    assert c.foo() == 5
+
+
+def test_call_in_call_with_raise(get_contract):
+    code = """
+@internal
+def sum(a: uint256) -> uint256:
+    if a > 1:
+        return a + 1
+    raise
+
+@internal
+def middle(a: uint256) -> uint256:
+    return self.sum(a)
+
+@external
+def test(a: uint256) -> uint256:
+    return self.middle(a)
+    """
+
+    c = get_contract(code)
+
+    assert c.test(2) == 3
+
+    with pytest.raises(ExecutionReverted):
+        c.test(0)
+
+
+def test_inliner_with_unused_param(get_contract):
+    code = """
+data: public(uint256)
+
+@internal
+def _foo(start: uint256, length: uint256):
+    self.data = start
+
+@external
+def foo(x: uint256, y: uint256):
+    self._foo(x, y)
+"""
+
+    c = get_contract(code)
+    c.foo(1, 2)

tests/unit/compiler/venom/test_variable_equivalence.py

@@ -0,0 +1,38 @@
+import itertools
+
+from tests.venom_utils import parse_from_basic_block
+from vyper.venom.analysis import DFGAnalysis, IRAnalysesCache
+from vyper.venom.basicblock import IRVariable
+from vyper.venom.context import IRContext
+
+
+def _entry_fn(ctx: "IRContext"):
+    # TODO: make this part of IRContext
+    return next(iter(ctx.functions.values()))
+
+
+def test_variable_equivalence_dfg_order():
+    a_code = """
+    main:
+    %1 = 1
+    %2 = %1
+    %3 = %2
+    """
+    # technically invalid code, but variable equivalence should handle
+    # it either way
+    b_code = """
+    main:
+    %3 = %2
+    %2 = %1
+    %1 = 1
+    """
+    fn1 = _entry_fn(parse_from_basic_block(a_code))
+    fn2 = _entry_fn(parse_from_basic_block(b_code))
+
+    dfg1 = IRAnalysesCache(fn1).request_analysis(DFGAnalysis)
+    dfg2 = IRAnalysesCache(fn2).request_analysis(DFGAnalysis)
+
+    vars_ = map(IRVariable, ("%1", "%2", "%3"))
+    for var1, var2 in itertools.combinations(vars_, 2):
+        assert dfg1.are_equivalent(var1, var2)
+        assert dfg2.are_equivalent(var1, var2)

vyper/codegen/function_definitions/internal_function.py

@@ -78,6 +78,9 @@ def generate_ir_for_internal_function(
 
     ir_node = IRnode.from_list(["seq", body, cleanup_routine])
 
+    ir_node.passthrough_metadata["func_t"] = func_t
+    ir_node.passthrough_metadata["context"] = context
+
     # tag gas estimate and frame info
     func_t._ir_info.gas_estimate = ir_node.gas
     tag_frame_info(func_t, context)

vyper/codegen/self_call.py

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

vyper/compiler/phases.py

@@ -328,7 +328,7 @@ def generate_ir_nodes(global_ctx: ModuleT, settings: Settings) -> tuple[IRnode,
 
     with anchor_settings(settings):
         ir_nodes, ir_runtime = module.generate_ir_for_module(global_ctx)
-    if settings.optimize != OptimizationLevel.NONE:
+    if settings.optimize != OptimizationLevel.NONE and not settings.experimental_codegen:
         ir_nodes = optimizer.optimize(ir_nodes)
         ir_runtime = optimizer.optimize(ir_runtime)
     return ir_nodes, ir_runtime

vyper/utils.py

@@ -693,3 +693,14 @@ def safe_relpath(path):
         # on Windows, if path and curdir are on different drives, an exception
         # can be thrown
         return path
+
+
+def all_nonempty(iter):
+    """
+    This function checks if all elements in the given `iterable` are truthy,
+    similar to Python's built-in `all()` function. However, `all_nonempty`
+    diverges by returning `False` if the iterable is empty, whereas `all()`
+    would return `True` for an empty iterable.
+    """
+    items = list(iter)
+    return len(items) > 0 and all(items)

vyper/venom/__init__.py

@@ -15,6 +15,7 @@
     BranchOptimizationPass,
     DFTPass,
     FloatAllocas,
+    FuncInlinerPass,
     LoadElimination,
     LowerDloadPass,
     MakeSSA,
@@ -46,12 +47,10 @@ def generate_assembly_experimental(
     return compiler.generate_evm(optimize == OptimizationLevel.NONE)
 
 
-def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
+def _run_passes(fn: IRFunction, optimize: OptimizationLevel, ac: IRAnalysesCache) -> None:
     # Run passes on Venom IR
     # TODO: Add support for optimization levels
 
-    ac = IRAnalysesCache(fn)
-
     FloatAllocas(ac, fn).run_pass()
 
     SimplifyCFGPass(ac, fn).run_pass()
@@ -94,14 +93,29 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     DFTPass(ac, fn).run_pass()
 
 
-def run_passes_on(ctx: IRContext, optimize: OptimizationLevel):
+def _run_global_passes(ctx: IRContext, optimize: OptimizationLevel, ir_analyses: dict) -> None:
+    FuncInlinerPass(ir_analyses, ctx).run_pass()
+
+
+def run_passes_on(ctx: IRContext, optimize: OptimizationLevel) -> None:
+    ir_analyses = {}
     for fn in ctx.functions.values():
-        _run_passes(fn, optimize)
+        ir_analyses[fn] = IRAnalysesCache(fn)
+
+    _run_global_passes(ctx, optimize, ir_analyses)
+
+    ir_analyses = {}
+    for fn in ctx.functions.values():
+        ir_analyses[fn] = IRAnalysesCache(fn)
+
+    for fn in ctx.functions.values():
+        _run_passes(fn, optimize, ir_analyses[fn])
 
 
 def generate_ir(ir: IRnode, optimize: OptimizationLevel) -> IRContext:
     # Convert "old" IR to "new" IR
     ctx = ir_node_to_venom(ir)
+
     run_passes_on(ctx, optimize)
 
     return ctx

vyper/venom/analysis/__init__.py

@@ -2,5 +2,4 @@
 from .cfg import CFGAnalysis
 from .dfg import DFGAnalysis
 from .dominators import DominatorTreeAnalysis
-from .equivalent_vars import VarEquivalenceAnalysis
 from .liveness import LivenessAnalysis

vyper/venom/analysis/analysis.py

@@ -72,4 +72,8 @@ def force_analysis(self, analysis_cls: Type[IRAnalysis], *args, **kwargs):
         assert issubclass(analysis_cls, IRAnalysis), f"{analysis_cls} is not an IRAnalysis"
         if analysis_cls in self.analyses_cache:
             self.invalidate_analysis(analysis_cls)
+
+        for analysis in self.analyses_cache.values():
+            self.request_analysis(analysis.__class__)
+
         return self.request_analysis(analysis_cls, *args, **kwargs)

vyper/venom/analysis/cfg.py

@@ -53,10 +53,13 @@ def dfs_walk(self) -> Iterator[IRBasicBlock]:
     def invalidate(self):
         from vyper.venom.analysis import DFGAnalysis, DominatorTreeAnalysis, LivenessAnalysis
 
+        fn = self.function
+        for bb in fn.get_basic_blocks():
+            bb.cfg_in = OrderedSet()
+            bb.cfg_out = OrderedSet()
+            bb.out_vars = OrderedSet()
+
         self.analyses_cache.invalidate_analysis(DominatorTreeAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)
-
-        self._dfs = None
-
-        # be conservative - assume cfg invalidation invalidates dfg
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
+        self._dfs = None