feat[venom]: implement mem2var and sccp passes

tests/functional/builtins/codegen/test_abi_decode.py

@@ -2,7 +2,7 @@
 from eth.codecs import abi
 
 from tests.utils import decimal_to_int
-from vyper.exceptions import ArgumentException, StackTooDeep, StructureException
+from vyper.exceptions import ArgumentException, StructureException
 
 TEST_ADDR = "0x" + b"".join(chr(i).encode("utf-8") for i in range(20)).hex()
 
@@ -201,7 +201,6 @@ def abi_decode(x: Bytes[{len}]) -> DynArray[DynArray[uint256, 3], 3]:
 
 @pytest.mark.parametrize("args", nested_3d_array_args)
 @pytest.mark.parametrize("unwrap_tuple", (True, False))
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_abi_decode_nested_dynarray2(get_contract, args, unwrap_tuple):
     if unwrap_tuple is True:
         encoded = abi.encode("(uint256[][][])", (args,))
@@ -279,7 +278,6 @@ def foo(bs: Bytes[160]) -> (uint256, DynArray[uint256, 3]):
     assert c.foo(encoded) == [2**256 - 1, bs]
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_abi_decode_private_nested_dynarray(get_contract):
     code = """
 bytez: DynArray[DynArray[DynArray[uint256, 3], 3], 3]

tests/functional/builtins/codegen/test_abi_encode.py

@@ -2,7 +2,6 @@
 from eth.codecs import abi
 
 from tests.utils import decimal_to_int
-from vyper.exceptions import StackTooDeep
 
 
 # @pytest.mark.parametrize("string", ["a", "abc", "abcde", "potato"])
@@ -227,7 +226,6 @@ def abi_encode(
 
 
 @pytest.mark.parametrize("args", nested_3d_array_args)
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_abi_encode_nested_dynarray_2(get_contract, args):
     code = """
 @external
@@ -332,7 +330,6 @@ def foo(bs: DynArray[uint256, 3]) -> (uint256, Bytes[160]):
     assert c.foo(bs) == [2**256 - 1, abi.encode("(uint256[])", (bs,))]
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_abi_encode_private_nested_dynarray(get_contract):
     code = """
 bytez: Bytes[1696]

tests/functional/codegen/features/iteration/test_for_range.py

@@ -1,5 +1,7 @@
 import pytest
 
+from vyper.exceptions import StaticAssertionException
+
 
 def test_basic_repeater(get_contract_with_gas_estimation):
     basic_repeater = """
@@ -271,17 +273,21 @@ def test():
 
 
 @pytest.mark.parametrize("typ", ["uint8", "int128", "uint256"])
-def test_for_range_oob_check(get_contract, tx_failed, typ):
+def test_for_range_oob_check(get_contract, tx_failed, typ, experimental_codegen):
     code = f"""
 @external
 def test():
     x: {typ} = max_value({typ})
     for i: {typ} in range(x, x + 2, bound=2):
         pass
     """
-    c = get_contract(code)
-    with tx_failed():
-        c.test()
+    if experimental_codegen:
+        with pytest.raises(StaticAssertionException):
+            get_contract(code)
+    else:
+        c = get_contract(code)
+        with tx_failed():
+            c.test()
 
 
 @pytest.mark.parametrize("typ", ["int128", "uint256"])
@@ -416,7 +422,7 @@ def foo(a: {typ}) -> {typ}:
     assert c.foo(0) == 31337
 
 
-def test_for_range_signed_int_overflow(get_contract, tx_failed):
+def test_for_range_signed_int_overflow(get_contract, tx_failed, experimental_codegen):
     code = """
 @external
 def foo() -> DynArray[int256, 10]:
@@ -427,6 +433,11 @@ def foo() -> DynArray[int256, 10]:
         res.append(i)
     return res
     """
-    c = get_contract(code)
-    with tx_failed():
-        c.foo()
+
+    if experimental_codegen:
+        with pytest.raises(StaticAssertionException):
+            get_contract(code)
+    else:
+        c = get_contract(code)
+        with tx_failed():
+            c.foo()

tests/functional/codegen/features/test_constructor.py

@@ -1,8 +1,6 @@
 import pytest
 from web3.exceptions import ValidationError
 
-from vyper.exceptions import StackTooDeep
-
 
 def test_init_argument_test(get_contract_with_gas_estimation):
     init_argument_test = """
@@ -165,7 +163,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(w3, get_contract_with_gas_estimation):
     code = """
 foo: int128
@@ -211,7 +208,6 @@ def get_foo() -> DynArray[DynArray[uint256, 3], 3]:
     assert c.get_foo() == [[37, 41, 73], [37041, 41073, 73037], [146, 123, 148]]
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_initialise_nested_dynamic_array_2(w3, get_contract_with_gas_estimation):
     code = """
 foo: DynArray[DynArray[DynArray[int128, 3], 3], 3]

tests/functional/codegen/features/test_immutable.py

@@ -1,7 +1,6 @@
 import pytest
 
 from vyper.compiler.settings import OptimizationLevel
-from vyper.exceptions import StackTooDeep
 
 
 @pytest.mark.parametrize(
@@ -199,7 +198,6 @@ def get_idx_two() -> uint256:
     assert c.get_idx_two() == expected_values[2][2]
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_nested_dynarray_immutable(get_contract):
     code = """
 my_list: immutable(DynArray[DynArray[DynArray[int128, 3], 3], 3])

tests/functional/codegen/types/numbers/test_signed_ints.py

@@ -8,6 +8,7 @@
 from vyper.exceptions import (
     InvalidOperation,
     OverflowException,
+    StaticAssertionException,
     TypeMismatch,
     ZeroDivisionException,
 )
@@ -73,18 +74,22 @@ def foo(x: int256) -> int256:
 
 # TODO: make this test pass
 @pytest.mark.parametrize("base", (0, 1))
-def test_exponent_negative_power(get_contract, tx_failed, base):
+def test_exponent_negative_power(get_contract, tx_failed, base, experimental_codegen):
     # #2985
     code = f"""
 @external
 def bar() -> int16:
     x: int16 = -2
     return {base} ** x
     """
-    c = get_contract(code)
-    # known bug: 2985
-    with tx_failed():
-        c.bar()
+    if experimental_codegen:
+        with pytest.raises(StaticAssertionException):
+            get_contract(code)
+    else:
+        c = get_contract(code)
+        # known bug: 2985
+        with tx_failed():
+            c.bar()
 
 
 def test_exponent_min_int16(get_contract):

tests/functional/codegen/types/test_dynamic_array.py

@@ -62,7 +62,6 @@ def loo(x: DynArray[DynArray[int128, 2], 2]) -> int128:
     print("Passed list tests")
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_string_list(get_contract):
     code = """
 @external
@@ -1491,7 +1490,6 @@ def foo(x: int128) -> int128:
     assert c.foo(7) == 392
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_struct_of_lists(get_contract):
     code = """
 struct Foo:
@@ -1580,7 +1578,6 @@ def bar(x: int128) -> DynArray[int128, 3]:
     assert c.bar(7) == [7, 14]
 
 
-@pytest.mark.venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
 def test_nested_struct_of_lists(get_contract, assert_compile_failed, optimize):
     code = """
 struct nestedFoo:
@@ -1710,9 +1707,7 @@ def __init__():
         ("DynArray[DynArray[DynArray[uint256, 5], 5], 5]", [[[], []], []]),
     ],
 )
-def test_empty_nested_dynarray(get_contract, typ, val, venom_xfail):
-    if val == [[[], []], []]:
-        venom_xfail(raises=StackTooDeep, reason="stack scheduler regression")
+def test_empty_nested_dynarray(get_contract, typ, val):
     code = f"""
 @external
 def foo() -> {typ}:

tests/unit/compiler/venom/test_sccp.py

@@ -0,0 +1,139 @@
+from vyper.venom.basicblock import IRBasicBlock, IRLabel, IRVariable
+from vyper.venom.function import IRFunction
+from vyper.venom.passes.make_ssa import MakeSSA
+from vyper.venom.passes.sccp import SCCP
+from vyper.venom.passes.sccp.sccp import LatticeEnum
+
+
+def test_simple_case():
+    ctx = IRFunction(IRLabel("_global"))
+
+    bb = ctx.get_basic_block()
+    p1 = bb.append_instruction("param")
+    op1 = bb.append_instruction("store", 32)
+    op2 = bb.append_instruction("store", 64)
+    op3 = bb.append_instruction("add", op1, op2)
+    bb.append_instruction("return", p1, op3)
+
+    make_ssa_pass = MakeSSA()
+    make_ssa_pass.run_pass(ctx, ctx.basic_blocks[0])
+    sccp = SCCP(make_ssa_pass.dom)
+    sccp.run_pass(ctx, ctx.basic_blocks[0])
+
+    assert sccp.lattice[IRVariable("%1")] == LatticeEnum.BOTTOM
+    assert sccp.lattice[IRVariable("%2")].value == 32
+    assert sccp.lattice[IRVariable("%3")].value == 64
+    assert sccp.lattice[IRVariable("%4")].value == 96
+
+
+def test_cont_jump_case():
+    ctx = IRFunction(IRLabel("_global"))
+
+    bb = ctx.get_basic_block()
+
+    br1 = IRBasicBlock(IRLabel("then"), ctx)
+    ctx.append_basic_block(br1)
+    br2 = IRBasicBlock(IRLabel("else"), ctx)
+    ctx.append_basic_block(br2)
+
+    p1 = bb.append_instruction("param")
+    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)
+
+    br1.append_instruction("add", op3, 10)
+    br1.append_instruction("stop")
+    br2.append_instruction("add", op3, p1)
+    br2.append_instruction("stop")
+
+    make_ssa_pass = MakeSSA()
+    make_ssa_pass.run_pass(ctx, ctx.basic_blocks[0])
+    sccp = SCCP(make_ssa_pass.dom)
+    sccp.run_pass(ctx, ctx.basic_blocks[0])
+
+    assert sccp.lattice[IRVariable("%1")] == LatticeEnum.BOTTOM
+    assert sccp.lattice[IRVariable("%2")].value == 32
+    assert sccp.lattice[IRVariable("%3")].value == 64
+    assert sccp.lattice[IRVariable("%4")].value == 96
+    assert sccp.lattice[IRVariable("%5")].value == 106
+    assert sccp.lattice.get(IRVariable("%6")) == LatticeEnum.BOTTOM
+
+
+def test_cont_phi_case():
+    ctx = IRFunction(IRLabel("_global"))
+
+    bb = ctx.get_basic_block()
+
+    br1 = IRBasicBlock(IRLabel("then"), ctx)
+    ctx.append_basic_block(br1)
+    br2 = IRBasicBlock(IRLabel("else"), ctx)
+    ctx.append_basic_block(br2)
+    join = IRBasicBlock(IRLabel("join"), ctx)
+    ctx.append_basic_block(join)
+
+    p1 = bb.append_instruction("param")
+    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)
+
+    op4 = br1.append_instruction("add", op3, 10)
+    br1.append_instruction("jmp", join.label)
+    br2.append_instruction("add", op3, p1, ret=op4)
+    br2.append_instruction("jmp", join.label)
+
+    join.append_instruction("return", op4, p1)
+
+    make_ssa_pass = MakeSSA()
+    make_ssa_pass.run_pass(ctx, ctx.basic_blocks[0])
+
+    sccp = SCCP(make_ssa_pass.dom)
+    sccp.run_pass(ctx, ctx.basic_blocks[0])
+
+    assert sccp.lattice[IRVariable("%1")] == LatticeEnum.BOTTOM
+    assert sccp.lattice[IRVariable("%2")].value == 32
+    assert sccp.lattice[IRVariable("%3")].value == 64
+    assert sccp.lattice[IRVariable("%4")].value == 96
+    assert sccp.lattice[IRVariable("%5", version=1)].value == 106
+    assert sccp.lattice[IRVariable("%5", version=2)] == LatticeEnum.BOTTOM
+    assert sccp.lattice[IRVariable("%5")].value == 2
+
+
+def test_cont_phi_const_case():
+    ctx = IRFunction(IRLabel("_global"))
+
+    bb = ctx.get_basic_block()
+
+    br1 = IRBasicBlock(IRLabel("then"), ctx)
+    ctx.append_basic_block(br1)
+    br2 = IRBasicBlock(IRLabel("else"), ctx)
+    ctx.append_basic_block(br2)
+    join = IRBasicBlock(IRLabel("join"), ctx)
+    ctx.append_basic_block(join)
+
+    p1 = bb.append_instruction("store", 1)
+    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)
+
+    op4 = br1.append_instruction("add", op3, 10)
+    br1.append_instruction("jmp", join.label)
+    br2.append_instruction("add", op3, p1, ret=op4)
+    br2.append_instruction("jmp", join.label)
+
+    join.append_instruction("return", op4, p1)
+
+    make_ssa_pass = MakeSSA()
+    make_ssa_pass.run_pass(ctx, ctx.basic_blocks[0])
+    sccp = SCCP(make_ssa_pass.dom)
+    sccp.run_pass(ctx, ctx.basic_blocks[0])
+
+    assert sccp.lattice[IRVariable("%1")].value == 1
+    assert sccp.lattice[IRVariable("%2")].value == 32
+    assert sccp.lattice[IRVariable("%3")].value == 64
+    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