feat[venom]: implement mem2var and sccp passes (#3941)

This commit adds two additional optimization passes to the Venom
pipeline, `mem2var` and `Sparse Conditional Constant Propagation`.

The `mem2var` pass has the purpose of promoting some of the memory
accesses that the frontend emits to Venom variables, optimizing out
memory reads and writes. It is analogous to the `mem2reg` pass in LLVM.
Right now it only applies promotions conservatively, but is the basis
for more advanced memory optimizations in the future.

To facilitate the implementation of `mem2var` this commit additionally
modifies the original IR emitter to emit "abstract" memory locations
(i.e. "allocas") instead of hard-coded pointers if the venom pipeline is
enabled. A small amount of refactoring was done to the memory allocator
to enable this switch to be implemented cleanly.

The `sccp` pass is responsible for evaluating and propagating constants
in the code, eliminating conditional branches and performing dead code
elimination in the process. It is a linear `O(2n)` pass, based on the
classical algorithm by Wegman and Zadeck.

References:
https://dl.acm.org/doi/pdf/10.1145/103135.103136

---------

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

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,8 @@
 import pytest
 
+from vyper.exceptions import StaticAssertionException
+from vyper.utils import SizeLimits
+
 
 def test_basic_repeater(get_contract_with_gas_estimation):
     basic_repeater = """
@@ -271,17 +274,38 @@ 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_compile_time_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
+    """
+    if not experimental_codegen:
+        return
+    with pytest.raises(StaticAssertionException):
+        get_contract(code)
+
+
+@pytest.mark.parametrize(
+    "typ, max_value",
+    [
+        ("uint8", SizeLimits.MAX_UINT8),
+        ("int128", SizeLimits.MAX_INT128),
+        ("uint256", SizeLimits.MAX_UINT256),
+    ],
+)
+def test_for_range_oob_runtime_check(get_contract, tx_failed, typ, max_value):
+    code = f"""
+@external
+def test(x: {typ}):
     for i: {typ} in range(x, x + 2, bound=2):
         pass
     """
     c = get_contract(code)
     with tx_failed():
-        c.test()
+        c.test(max_value)
 
 
 @pytest.mark.parametrize("typ", ["int128", "uint256"])
@@ -416,7 +440,25 @@ 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_runtime_check(get_contract, tx_failed, experimental_codegen):
+    code = """
+@external
+def foo(_min:int256, _max: int256) -> DynArray[int256, 10]:
+    res: DynArray[int256, 10] = empty(DynArray[int256, 10])
+    x:int256 = _max
+    y:int256 = _min+2
+    for i:int256 in range(x,y , bound=10):
+        res.append(i)
+    return res
+    """
+    c = get_contract(code)
+    with tx_failed():
+        c.foo(SizeLimits.MIN_INT256, SizeLimits.MAX_INT256)
+
+
+def test_for_range_signed_int_overflow_compile_time_check(
+    get_contract, tx_failed, experimental_codegen
+):
     code = """
 @external
 def foo() -> DynArray[int256, 10]:
@@ -427,6 +469,7 @@ def foo() -> DynArray[int256, 10]:
         res.append(i)
     return res
     """
-    c = get_contract(code)
-    with tx_failed():
-        c.foo()
+    if not experimental_codegen:
+        return
+    with pytest.raises(StaticAssertionException):
+        get_contract(code)

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,35 @@ 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_runtime_check(get_contract, tx_failed, base, experimental_codegen):
     # #2985
     code = f"""
 @external
-def bar() -> int16:
-    x: int16 = -2
+def bar(negative:int16) -> int16:
+    x: int16 = negative
     return {base} ** x
     """
     c = get_contract(code)
     # known bug: 2985
     with tx_failed():
-        c.bar()
+        c.bar(-2)
+
+
+@pytest.mark.parametrize("base", (0, 1))
+def test_exponent_negative_power_compile_time_check(
+    get_contract, tx_failed, base, experimental_codegen
+):
+    # #2985
+    code = f"""
+@external
+def bar() -> int16:
+    x: int16 = -2
+    return {base} ** x
+    """
+    if not experimental_codegen:
+        return
+    with pytest.raises(StaticAssertionException):
+        get_contract(code)
 
 
 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}: