feat[venom]: binopt

tests/functional/builtins/codegen/test_slice.py

@@ -5,7 +5,12 @@
 from vyper.compiler import compile_code
 from vyper.compiler.settings import OptimizationLevel, Settings
 from vyper.evm.opcodes import version_check
-from vyper.exceptions import ArgumentException, CompilerPanic, TypeMismatch
+from vyper.exceptions import (
+    ArgumentException,
+    CompilerPanic,
+    StaticAssertionException,
+    TypeMismatch,
+)
 
 _fun_bytes32_bounds = [(0, 32), (3, 29), (27, 5), (0, 5), (5, 3), (30, 2)]
 
@@ -533,9 +538,15 @@ def do_slice():
 
 @pytest.mark.parametrize("bad_code", oob_fail_list)
 def test_slice_buffer_oob_reverts(bad_code, get_contract, tx_failed):
-    c = get_contract(bad_code)
-    with tx_failed():
-        c.do_slice()
+    try:
+        c = get_contract(bad_code)
+        with tx_failed():
+            c.do_slice()
+    except StaticAssertionException:
+        # it should be ok if we
+        # catch the assert in compile time
+        # since it supposed to be revert
+        pass
 
 
 # tests all 3 adhoc locations: `msg.data`, `self.code`, `<address>.code`

tests/functional/codegen/features/test_constructor.py

@@ -1,7 +1,4 @@
-import pytest
-
 from tests.evm_backends.base_env import _compile
-from vyper.exceptions import StackTooDeep
 from vyper.utils import method_id
 
 
@@ -169,7 +166,6 @@ def get_foo() -> uint256:
     assert c.get_foo() == 39
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_nested_dynamic_array_constructor_arg_2(env, get_contract):
     code = """
 foo: int128

tests/unit/compiler/venom/test_algebraic_optimizer.py

@@ -128,57 +128,6 @@ def test_interleaved_case(interleave_point):
         assert bb.instructions[-1].operands[0] == op3
 
 
-def test_offsets():
-    ctx = IRContext()
-    fn = ctx.create_function("_global")
-
-    bb = fn.get_basic_block()
-
-    br1 = IRBasicBlock(IRLabel("then"), fn)
-    fn.append_basic_block(br1)
-    br2 = IRBasicBlock(IRLabel("else"), fn)
-    fn.append_basic_block(br2)
-
-    p1 = bb.append_instruction("param")
-    op1 = bb.append_instruction("store", 32)
-    op2 = bb.append_instruction("add", 0, IRLabel("mem"))
-    op3 = bb.append_instruction("store", 64)
-    bb.append_instruction("dloadbytes", op1, op2, op3)
-    op5 = bb.append_instruction("mload", op3)
-    op6 = bb.append_instruction("iszero", op5)
-    bb.append_instruction("jnz", op6, br1.label, br2.label)
-
-    op01 = br1.append_instruction("store", 32)
-    op02 = br1.append_instruction("add", 0, IRLabel("mem"))
-    op03 = br1.append_instruction("store", 64)
-    br1.append_instruction("dloadbytes", op01, op02, op03)
-    op05 = br1.append_instruction("mload", op03)
-    op06 = br1.append_instruction("iszero", op05)
-    br1.append_instruction("return", p1, op06)
-
-    op11 = br2.append_instruction("store", 32)
-    op12 = br2.append_instruction("add", 0, IRLabel("mem"))
-    op13 = br2.append_instruction("store", 64)
-    br2.append_instruction("dloadbytes", op11, op12, op13)
-    op15 = br2.append_instruction("mload", op13)
-    op16 = br2.append_instruction("iszero", op15)
-    br2.append_instruction("return", p1, op16)
-
-    ac = IRAnalysesCache(fn)
-    MakeSSA(ac, fn).run_pass()
-    AlgebraicOptimizationPass(ac, fn).run_pass()
-    RemoveUnusedVariablesPass(ac, fn).run_pass()
-
-    offset_count = 0
-    for bb in fn.get_basic_blocks():
-        for instruction in bb.instructions:
-            assert instruction.opcode != "add"
-            if instruction.opcode == "offset":
-                offset_count += 1
-
-    assert offset_count == 3
-
-
 # Test the case of https://github.com/vyperlang/vyper/issues/4288
 def test_ssa_after_algebraic_optimization():
     code = """

tests/unit/compiler/venom/test_sccp.py

@@ -112,7 +112,7 @@ def test_cont_jump_case():
     op1 = bb.append_instruction("store", 32)
     op2 = bb.append_instruction("store", 64)
     op3 = bb.append_instruction("add", op1, op2)
-    bb.append_instruction("jnz", op3, br1.label, br2.label)
+    bb.append_instruction("jnz", p1, br1.label, br2.label)
 
     br1.append_instruction("add", op3, 10)
     br1.append_instruction("stop")
@@ -149,7 +149,7 @@ def test_cont_phi_case():
     op1 = bb.append_instruction("store", 32)
     op2 = bb.append_instruction("store", 64)
     op3 = bb.append_instruction("add", op1, op2)
-    bb.append_instruction("jnz", op3, br1.label, br2.label)
+    bb.append_instruction("jnz", p1, br1.label, br2.label)
 
     op4 = br1.append_instruction("add", op3, 10)
     br1.append_instruction("jmp", join.label)
@@ -209,7 +209,7 @@ def test_cont_phi_const_case():
     assert sccp.lattice[IRVariable("%4")].value == 96
     assert sccp.lattice[IRVariable("%5", version=1)].value == 106
     assert sccp.lattice[IRVariable("%5", version=2)].value == 97
-    assert sccp.lattice[IRVariable("%5")].value == 2
+    assert sccp.lattice[IRVariable("%5")] == LatticeEnum.BOTTOM
 
 
 def test_phi_reduction_after_unreachable_block():
@@ -241,3 +241,54 @@ def test_phi_reduction_after_unreachable_block():
     assert join.instructions[0].operands == [op1]
 
     assert join.instructions[1].opcode == "stop"
+
+
+def test_sccp_offsets_opt():
+    ctx = IRContext()
+    fn = ctx.create_function("_global")
+
+    bb = fn.get_basic_block()
+
+    br1 = IRBasicBlock(IRLabel("then"), fn)
+    fn.append_basic_block(br1)
+    br2 = IRBasicBlock(IRLabel("else"), fn)
+    fn.append_basic_block(br2)
+
+    p1 = bb.append_instruction("param")
+    op1 = bb.append_instruction("store", 32)
+    op2 = bb.append_instruction("add", 0, IRLabel("mem"))
+    op3 = bb.append_instruction("store", 64)
+    bb.append_instruction("dloadbytes", op1, op2, op3)
+    op5 = bb.append_instruction("mload", op3)
+    op6 = bb.append_instruction("iszero", op5)
+    bb.append_instruction("jnz", op6, br1.label, br2.label)
+
+    op01 = br1.append_instruction("store", 32)
+    op02 = br1.append_instruction("add", 0, IRLabel("mem"))
+    op03 = br1.append_instruction("store", 64)
+    br1.append_instruction("dloadbytes", op01, op02, op03)
+    op05 = br1.append_instruction("mload", op03)
+    op06 = br1.append_instruction("iszero", op05)
+    br1.append_instruction("return", p1, op06)
+
+    op11 = br2.append_instruction("store", 32)
+    op12 = br2.append_instruction("add", 0, IRLabel("mem"))
+    op13 = br2.append_instruction("store", 64)
+    br2.append_instruction("dloadbytes", op11, op12, op13)
+    op15 = br2.append_instruction("mload", op13)
+    op16 = br2.append_instruction("iszero", op15)
+    br2.append_instruction("return", p1, op16)
+
+    ac = IRAnalysesCache(fn)
+    MakeSSA(ac, fn).run_pass()
+    SCCP(ac, fn).run_pass()
+    # RemoveUnusedVariablesPass(ac, fn).run_pass()
+
+    offset_count = 0
+    for bb in fn.get_basic_blocks():
+        for instruction in bb.instructions:
+            assert instruction.opcode != "add"
+            if instruction.opcode == "offset":
+                offset_count += 1
+
+    assert offset_count == 3

vyper/venom/__init__.py

@@ -53,8 +53,8 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     MakeSSA(ac, fn).run_pass()
     SCCP(ac, fn).run_pass()
     StoreElimination(ac, fn).run_pass()
-    SimplifyCFGPass(ac, fn).run_pass()
     AlgebraicOptimizationPass(ac, fn).run_pass()
+    SimplifyCFGPass(ac, fn).run_pass()
     # NOTE: MakeSSA is after algebraic optimization it currently produces
     #       smaller code by adding some redundant phi nodes. This is not a
     #       problem for us, but we need to be aware of it, and should be

vyper/venom/passes/algebraic_optimization.py

@@ -1,5 +1,6 @@
-from vyper.venom.analysis import DFGAnalysis, LivenessAnalysis
-from vyper.venom.basicblock import IRInstruction, IRLabel, IRLiteral, IROperand
+from vyper.venom.analysis.dfg import DFGAnalysis
+from vyper.venom.analysis.liveness import LivenessAnalysis
+from vyper.venom.basicblock import IRInstruction, IROperand, IRVariable
 from vyper.venom.passes.base_pass import IRPass
 
 
@@ -11,6 +12,8 @@ class AlgebraicOptimizationPass(IRPass):
         * iszero chains
     """
 
+    dfg: DFGAnalysis
+
     def _optimize_iszero_chains(self) -> None:
         fn = self.function
         for bb in fn.get_basic_blocks():
@@ -23,6 +26,7 @@ def _optimize_iszero_chains(self) -> None:
                 if iszero_count == 0:
                     continue
 
+                assert isinstance(inst.output, IRVariable)
                 for use_inst in self.dfg.get_uses(inst.output):
                     opcode = use_inst.opcode
 
@@ -48,6 +52,8 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain: list[IRInstruction] = []
 
         while True:
+            if not isinstance(op, IRVariable):
+                break
             inst = self.dfg.get_producing_instruction(op)
             if inst is None or inst.opcode != "iszero":
                 break
@@ -57,24 +63,10 @@ def _get_iszero_chain(self, op: IROperand) -> list[IRInstruction]:
         chain.reverse()
         return chain
 
-    def _handle_offsets(self):
-        for bb in self.function.get_basic_blocks():
-            for inst in bb.instructions:
-                # check if the instruction is of the form
-                # `add <ptr> <label>`
-                # this works only if store chains have been eliminated.
-                if (
-                    inst.opcode == "add"
-                    and isinstance(inst.operands[0], IRLiteral)
-                    and isinstance(inst.operands[1], IRLabel)
-                ):
-                    inst.opcode = "offset"
-
     def run_pass(self):
-        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
+        self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)  # type: ignore
 
         self._optimize_iszero_chains()
-        self._handle_offsets()
 
         self.analyses_cache.invalidate_analysis(DFGAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)