feat[venom]: mem alloc

tests/functional/syntax/warnings/test_contract_size_limit_warning.py

@@ -15,9 +15,9 @@ def huge_bytestring():
 def test_contract_size_exceeded(huge_bytestring):
     code = f"""
 @external
-def a() -> bool:
+def a() -> Bytes[24577]:
     q: Bytes[24577] = {huge_bytestring}
-    return True
+    return q
 """
     with pytest.warns(vyper.warnings.ContractSizeLimit):
         vyper.compile_code(code, output_formats=["bytecode_runtime"])

tests/hevm.py

@@ -7,6 +7,7 @@
 from vyper.ir.compile_ir import assembly_to_evm
 from vyper.venom import (
     CFGNormalization,
+    ConcretizeMemLocPass,
     LowerDloadPass,
     SimplifyCFGPass,
     SingleUseExpansion,
@@ -70,6 +71,7 @@ def _prep_hevm_venom_ctx(ctx, verbose=False):
 
         # requirements for venom_to_assembly
         LowerDloadPass(ac, fn).run_pass()
+        ConcretizeMemLocPass(ac, fn).run_pass()
         SingleUseExpansion(ac, fn).run_pass()
         CFGNormalization(ac, fn).run_pass()
 

tests/unit/compiler/venom/test_abstract_mem.py

@@ -0,0 +1,19 @@
+from vyper.venom.basicblock import IRAbstractMemLoc
+from vyper.venom.memory_location import (
+    MemoryLocation,
+    MemoryLocationAbstract,
+    MemoryLocationSegment,
+)
+
+
+def test_abstract_may_overlap():
+    op1 = IRAbstractMemLoc(256, offset=0, force_id=0)
+    op2 = IRAbstractMemLoc(256, offset=128, force_id=0)
+    loc1 = MemoryLocationAbstract(
+        op=op1, segment=MemoryLocationSegment(_offset=op1.offset, _size=32)
+    )
+    loc2 = MemoryLocationAbstract(
+        op=op2, segment=MemoryLocationSegment(_offset=op2.offset, _size=32)
+    )
+
+    assert not MemoryLocation.may_overlap(loc1, loc2)

tests/unit/compiler/venom/test_common_subexpression_elimination.py

@@ -357,6 +357,16 @@ def call(callname: str, i: int, var_name: str):
         %{var_name}1 = add 1, %{callname}1
         """
 
+    def call2(callname: str, i: int, var_name: str):
+        return f"""
+        %g{2*i} = gas
+        %{callname}0 = {callname} %g0, 0, 0, 0, 0, 0, 0
+        %{var_name}0 = add 1, %{callname}0
+        %g{2*i + 1} = gas
+        %{callname}1 = {callname} %g0, 0, 0, 0, 0, 0, 0
+        %{var_name}1 = add 1, %{callname}1
+        """
+
     pre = f"""
     main:
         ; staticcall
@@ -366,7 +376,7 @@ def call(callname: str, i: int, var_name: str):
         {call("delegatecall", 1, "d")}
 
         ; call
-        {call("call", 2, "c")}
+        {call2("call", 2, "c")}
         sink %s0, %s1, %d0, %d1, %c0, %c1
     """
 
@@ -470,9 +480,7 @@ def test_cse_immutable_queries(opcode):
     _check_pre_post(pre, post, hevm=opcode != "codesize")
 
 
-@pytest.mark.parametrize(
-    "opcode", ("dloadbytes", "extcodecopy", "codecopy", "returndatacopy", "calldatacopy")
-)
+@pytest.mark.parametrize("opcode", ("dloadbytes", "codecopy", "returndatacopy", "calldatacopy"))
 def test_cse_other_mem_ops_elimination(opcode):
     pre = f"""
     main:
@@ -491,6 +499,24 @@ def test_cse_other_mem_ops_elimination(opcode):
     _check_pre_post(pre, post)
 
 
+def test_cse_other_mem_ops_elimination_extcodecopy():
+    pre = """
+    main:
+        extcodecopy 10, 20, 30, 40
+        extcodecopy 10, 20, 30, 40
+        stop
+    """
+
+    post = """
+    main:
+        extcodecopy 10, 20, 30, 40
+        nop
+        stop
+    """
+
+    _check_pre_post(pre, post, hevm=False)
+
+
 def test_cse_self_conflicting_effects():
     """
     Test that expression that have conflict in their own effects

tests/unit/compiler/venom/test_concretize_mem.py

@@ -0,0 +1,106 @@
+from tests.venom_utils import PrePostChecker
+from vyper.venom.passes import AssignElimination, ConcretizeMemLocPass, Mem2Var
+
+_check_pre_post = PrePostChecker([ConcretizeMemLocPass], default_hevm=False)
+_check_pre_post_mem2var = PrePostChecker([Mem2Var, AssignElimination], default_hevm=False)
+
+
+def test_valid_overlap():
+    pre = """
+    main:
+        calldatacopy [3,256], 100, 256
+        %1 = mload [3,256]
+        calldatacopy [4,32], 200, 32
+        %2 = mload [4,32]
+        calldatacopy [3,256], 1000, 256
+        %3 = mload [3,256]
+        sink %1, %2, %3
+    """
+    post = """
+    main:
+        calldatacopy 64, 100, 256
+        %1 = mload 64
+        calldatacopy 64, 200, 32
+        %2 = mload 64
+        calldatacopy 64, 1000, 256
+        %3 = mload 64
+        sink %1, %2, %3
+    """
+
+    _check_pre_post(pre, post)
+
+
+def test_venom_allocation():
+    pre = """
+    main:
+        %ptr = alloca 0, [3,256]
+        calldatacopy %ptr, 100, 256
+        %1 = mload %ptr
+        sink %1
+    """
+
+    post1 = """
+    main:
+        calldatacopy [3,256], 100, 256
+        %1 = mload [3,256]
+        sink %1
+    """
+
+    post2 = """
+    main:
+        calldatacopy 64, 100, 256
+        %1 = mload 64
+        sink %1
+    """
+
+    _check_pre_post_mem2var(pre, post1)
+    _check_pre_post(post1, post2)
+
+
+def test_venom_allocation_branches():
+    pre = """
+    main:
+        %ptr1 = alloca 0, [3,256]
+        %ptr2 = alloca 1, [4,128]
+        %cond = source
+        jnz %cond, @then, @else
+    then:
+        calldatacopy %ptr1, 100, 256
+        %1 = mload %ptr1
+        sink %1
+    else:
+        calldatacopy %ptr2, 1000, 64
+        %2 = mload %ptr2
+        sink %2
+    """
+
+    post1 = """
+    main:
+        %cond = source
+        jnz %cond, @then, @else
+    then:
+        calldatacopy [3,256], 100, 256
+        %1 = mload [3,256]
+        sink %1
+    else:
+        calldatacopy [4,128], 1000, 64
+        %2 = mload [4,128]
+        sink %2
+    """
+
+    post2 = """
+    main:
+        %cond = source
+        jnz %cond, @then, @else
+    then:
+        calldatacopy 64, 100, 256
+        %1 = mload 64
+        sink %1
+    else:
+        calldatacopy 64, 1000, 64
+        %2 = mload 64
+        sink %2
+    """
+
+    _check_pre_post_mem2var(pre, post1)
+    _check_pre_post(post1, post2)

tests/unit/compiler/venom/test_dead_store_elimination.py

@@ -27,7 +27,7 @@ def __init__(
             self.volatile_locations = volatile_locations
 
     def __call__(self, pre: str, post: str, hevm: bool | None = None) -> list[IRPass]:
-        from vyper.venom.memory_location import MemoryLocation
+        from vyper.venom.memory_location import MemoryLocationSegment
 
         self.pass_objects.clear()
 
@@ -41,7 +41,7 @@ def __call__(self, pre: str, post: str, hevm: bool | None = None) -> list[IRPass
             mem_ssa = ac.request_analysis(mem_ssa_type_factory(self.addr_space))
 
             for address, size in self.volatile_locations:
-                volatile_loc = MemoryLocation(offset=address, size=size, is_volatile=True)
+                volatile_loc = MemoryLocationSegment(_offset=address, _size=size, _is_volatile=True)
                 mem_ssa.mark_location_volatile(volatile_loc)
 
             for p in self.passes:
@@ -74,25 +74,26 @@ def _check_no_change(code, hevm=False):
     return _check_pre_post(code, code, hevm=hevm)
 
 
-def test_basic_dead_store():
-    pre = """
+@pytest.mark.parametrize("position", [0, "[0,32]"])
+def test_basic_dead_store(position):
+    pre = f"""
         _global:
             %val1 = 42
             %val2 = 24
-            mstore 0, %val1  ; Dead store - overwritten before read
-            mstore 0, 10     ; Dead store - overwritten before read
-            mstore 0, %val2
-            %loaded = mload 0  ; Only reads val2
+            mstore {position}, %val1  ; Dead store - overwritten before read
+            mstore {position}, 10     ; Dead store - overwritten before read
+            mstore {position}, %val2
+            %loaded = mload {position}  ; Only reads val2
             stop
     """
-    post = """
+    post = f"""
         _global:
             %val1 = 42
             %val2 = 24
             nop
             nop
-            mstore 0, %val2
-            %loaded = mload 0
+            mstore {position}, %val2
+            %loaded = mload {position}
             stop
     """
     _check_pre_post(pre, post)
@@ -117,49 +118,54 @@ def test_basic_not_dead_store():
     _check_pre_post(pre, post)
 
 
-def test_basic_not_dead_store_with_mload():
-    pre = """
+@pytest.mark.parametrize("positions", [(0, 32), ("[0,32]", "[1,32]")])
+def test_basic_not_dead_store_with_mload(positions):
+    a, b = positions
+    pre = f"""
         _global:
             %1 = source
-            mstore 0, 1
-            mstore 32, 2
-            %2 = mload 0
+            mstore {a}, 1
+            mstore {b}, 2
+            %2 = mload {a}
             stop
     """
-    post = """
+    post = f"""
         _global:
             %1 = source
-            mstore 0, 1
+            mstore {a}, 1
             nop
-            %2 = mload 0
+            %2 = mload {a}
             stop
     """
     _check_pre_post(pre, post)
 
 
-def test_basic_not_dead_store_with_return():
-    pre = """
+@pytest.mark.parametrize("positions", [(0, 32), ("[0,32]", "[1,32]"), ("[2,32]", "[3,32]")])
+def test_basic_not_dead_store_with_return(positions):
+    a, b = positions
+    pre = f"""
         _global:
             %1 = source
-            mstore 0, 1
-            mstore 32, 2
-            return 0, 32
+            mstore {a}, 1
+            mstore {b}, 2
+            return {a}, 32
     """
-    post = """
+    post = f"""
         _global:
             %1 = source
-            mstore 0, 1
+            mstore {a}, 1
             nop
-            return 0, 32
+            return {a}, 32
     """
     _check_pre_post(pre, post)
 
 
-def test_never_read_store():
-    pre = """
+@pytest.mark.parametrize("position", [0, 32, "[0,32]", "[1,32]"])
+def test_never_read_store(position):
+    pre = f"""
         _global:
             %val = 42
-            mstore 0, %val  ; Dead store - never read
+            mstore {position}, %val  ; Dead store - never read
             stop
     """
     post = """
@@ -171,34 +177,37 @@ def test_never_read_store():
     _check_pre_post(pre, post)
 
 
-def test_live_store():
-    pre = """
+@pytest.mark.parametrize("position", [0, 32, "[0,32]", "[1,32]"])
+def test_live_store(position):
+    pre = f"""
         _global:
             %val = 42
-            mstore 0, %val
-            %loaded = mload 0  ; Makes the store live
+            mstore {position}, %val
+            %loaded = mload {position}  ; Makes the store live
             stop
     """
     _check_pre_post(pre, pre)  # Should not change
 
 
-def test_dead_store_different_locations():
-    pre = """
+@pytest.mark.parametrize("positions", [(0, 32), ("[0,32]", "[1,32]"), ("[2,32]", "[3,32]")])
+def test_dead_store_different_locations(positions):
+    a, b = positions
+    pre = f"""
         _global:
             %val1 = 42
             %val2 = 24
-            mstore 0, %val1   ; Dead store - never read
-            mstore 32, %val2  ; Live store
-            %loaded = mload 32
+            mstore {a}, %val1   ; Dead store - never read
+            mstore {b}, %val2  ; Live store
+            %loaded = mload {b}
             stop
     """
-    post = """
+    post = f"""
         _global:
             %val1 = 42
             %val2 = 24
             nop
-            mstore 32, %val2
-            %loaded = mload 32
+            mstore {b}, %val2
+            %loaded = mload {b}
             stop
     """
     _check_pre_post(pre, post)