feat[venom]: mark loads as non-volatile

tests/unit/compiler/venom/test_removeunused.py

@@ -0,0 +1,156 @@
+from tests.venom_utils import assert_ctx_eq, parse_from_basic_block, parse_venom
+from vyper.venom.analysis.analysis import IRAnalysesCache
+from vyper.venom.passes import RemoveUnusedVariablesPass
+
+
+def _check_pre_post(pre, post, scope="basicblock"):
+    if scope == "basicblock":
+        parse = parse_from_basic_block
+    else:
+        parse = parse_venom
+
+    ctx = parse(pre)
+    for fn in ctx.functions.values():
+        ac = IRAnalysesCache(fn)
+        RemoveUnusedVariablesPass(ac, fn).run_pass()
+
+    assert_ctx_eq(ctx, parse(post))
+
+
+def _check_no_change(pre, scope="basicblock"):
+    _check_pre_post(pre, pre, scope=scope)
+
+def test_removeunused_basic():
+    """
+    Check basic unused variable removal
+    """
+    pre = """
+    main:
+        %1 = add 10 20
+        %2_unused = add 10 %1
+        mstore 20 %1
+        stop
+    """
+    post = """
+    main:
+        %1 = add 10 20
+        mstore 20 %1
+        stop
+    """
+    _check_pre_post(pre, post)
+
+
+def test_removeunused_msize_basic():
+    pre = """
+    main:
+        %a = mload 32
+        %b = msize
+        %c = mload 64  # safe to remove
+        return %b, %b
+    """
+    post = """
+    main:
+        %a = mload 32
+        %b = msize
+        return %b, %b
+    """
+    _check_pre_post(pre, post)
+
+
+def test_removeunused_msize_two_msizes():
+    pre = """
+    main:
+        %a = mload 32
+        %b = msize
+        %c = mload 64  # not safe to remove
+        %d = msize
+        return %b, %d
+    """
+    _check_no_change(pre)
+
+
+def test_removeunused_msize_loop():
+    pre = """
+    main:
+        %msize = msize
+
+        # not safe to remove because the previous instruction is
+        # still reachable
+        %1 = mload %msize
+        jmp @main
+    """
+    _check_no_change(pre)
+
+
+def test_removeunused_msize_branches():
+    pre = """
+    function global {
+        main:
+            %1 = param
+            %2 = mload 10  ; looks unused, but has MSIZE effect
+            jnz %1, @branch1, @branch2
+        branch1:
+            %3 = msize  ; blocks removal of `%2 = mload 10`
+            mstore 10, %3
+            jmp @end
+        branch2:
+            jmp @end
+        end:
+            stop
+    }
+    """
+    _check_no_change(pre, scope="function")
+
+
+def test_removeunused_unused_msize_loop():
+    pre = """
+    main:
+        %1_unused = msize
+        %2_unused = mload 10
+        jmp @main
+    """
+    post = """
+    main:
+        jmp @main
+    """
+    _check_pre_post(pre, post)
+
+
+def test_removeunused_unused_msize():
+    pre = """
+    main:
+        %1_unused = mload 10
+        %2_unused = msize
+        stop
+    """
+    post = """
+    main:
+        stop
+    """
+    _check_pre_post(pre, post)
+
+
+
+def test_removeunused_loop():
+    pre = """
+    main:
+        %1 = 10
+        jmp @after
+    after:
+        %p = phi @main, %1, @after, %2
+        %2 = add %p, 1
+        %3_unused add %2, %p
+        mstore 10, %2
+        jmp @after
+    """
+    post = """
+    main:
+        %1 = 10
+        jmp @after
+    after:
+        %p = phi @main, %1, @after, %2
+        %2 = add %p, 1
+        mstore 10, %2
+        jmp @after
+    """
+    _check_pre_post(pre, post)

vyper/utils.py

@@ -75,6 +75,9 @@ def dropmany(self, iterable):
         for item in iterable:
             self._data.pop(item, None)
 
+    def clear(self):
+        self._data.clear()
+
     def difference(self, other):
         ret = self.copy()
         ret.dropmany(other)

vyper/venom/analysis/__init__.py

@@ -4,3 +4,4 @@
 from .dominators import DominatorTreeAnalysis
 from .equivalent_vars import VarEquivalenceAnalysis
 from .liveness import LivenessAnalysis
+from .reachable import ReachableAnalysis

vyper/venom/analysis/cfg.py

@@ -51,10 +51,16 @@ def dfs_walk(self) -> Iterator[IRBasicBlock]:
         return iter(self._dfs)
 
     def invalidate(self):
-        from vyper.venom.analysis import DFGAnalysis, DominatorTreeAnalysis, LivenessAnalysis
+        from vyper.venom.analysis import (
+            DFGAnalysis,
+            DominatorTreeAnalysis,
+            LivenessAnalysis,
+            ReachableAnalysis,
+        )
 
         self.analyses_cache.invalidate_analysis(DominatorTreeAnalysis)
         self.analyses_cache.invalidate_analysis(LivenessAnalysis)
+        self.analyses_cache.invalidate_analysis(ReachableAnalysis)
 
         self._dfs = None
 

vyper/venom/analysis/reachable.py

@@ -0,0 +1,42 @@
+from collections import defaultdict
+
+from vyper.utils import OrderedSet
+from vyper.venom.analysis import IRAnalysis
+from vyper.venom.analysis.cfg import CFGAnalysis
+from vyper.venom.basicblock import IRBasicBlock
+
+
+class ReachableAnalysis(IRAnalysis):
+    """
+    Compute control flow graph information for each basic block in the function.
+    """
+
+    reachable: dict[IRBasicBlock, OrderedSet[IRBasicBlock]]
+
+    def analyze(self) -> None:
+        self.analyses_cache.request_analysis(CFGAnalysis)
+        self.reachable = defaultdict(OrderedSet)
+
+        self._compute_reachable_r(self.function.entry)
+
+    def _compute_reachable_r(self, bb):
+        if bb in self.reachable:
+            return
+
+        s = bb.cfg_out.copy()
+        self.reachable[bb] = s
+
+        for out_bb in bb.cfg_out:
+            self._compute_reachable_r(out_bb)
+            s.update(self.reachable[out_bb])
+
+    def invalidate(self):
+        from vyper.venom.analysis import DFGAnalysis, DominatorTreeAnalysis, LivenessAnalysis
+
+        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)

vyper/venom/basicblock.py

@@ -16,14 +16,10 @@
         "create",
         "create2",
         "invoke",
-        "sload",
         "sstore",
-        "iload",
         "istore",
-        "tload",
         "tstore",
         "mstore",
-        "mload",
         "calldatacopy",
         "mcopy",
         "extcodecopy",
@@ -206,7 +202,7 @@ class IRInstruction:
 
     opcode: str
     operands: list[IROperand]
-    output: Optional[IROperand]
+    output: Optional[IRVariable]
     # set of live variables at this instruction
     liveness: OrderedSet[IRVariable]
     parent: "IRBasicBlock"
@@ -218,7 +214,7 @@ def __init__(
         self,
         opcode: str,
         operands: list[IROperand] | Iterator[IROperand],
-        output: Optional[IROperand] = None,
+        output: Optional[IRVariable] = None,
     ):
         assert isinstance(opcode, str), "opcode must be an str"
         assert isinstance(operands, list | Iterator), "operands must be a list"
@@ -452,6 +448,8 @@ def __init__(self, label: IRLabel, parent: "IRFunction") -> None:
         self.out_vars = OrderedSet()
         self.is_reachable = False
 
+        self._garbage_instructions: set[IRInstruction] = set()
+
     def add_cfg_in(self, bb: "IRBasicBlock") -> None:
         self.cfg_in.add(bb)
 
@@ -526,13 +524,20 @@ def insert_instruction(self, instruction: IRInstruction, index: Optional[int] =
         instruction.error_msg = self.parent.error_msg
         self.instructions.insert(index, instruction)
 
+    def mark_for_removal(self, instruction: IRInstruction) -> None:
+        self._garbage_instructions.add(instruction)
+
+    def clear_dead_instructions(self) -> None:
+        if len(self._garbage_instructions) > 0:
+            self.instructions = [
+                inst for inst in self.instructions if inst not in self._garbage_instructions
+            ]
+            self._garbage_instructions.clear()
+
     def remove_instruction(self, instruction: IRInstruction) -> None:
         assert isinstance(instruction, IRInstruction), "instruction must be an IRInstruction"
         self.instructions.remove(instruction)
 
-    def clear_instructions(self) -> None:
-        self.instructions = []
-
     @property
     def phi_instructions(self) -> Iterator[IRInstruction]:
         for inst in self.instructions:

vyper/venom/effects.py

@@ -83,11 +83,11 @@ def __iter__(self):
 writes = _writes.copy()
 
 for k, v in reads.items():
-    if MEMORY in v:
+    if MEMORY in v or IMMUTABLES in v:
         if k not in writes:
             writes[k] = EMPTY
         writes[k] |= MSIZE
 
 for k, v in writes.items():
-    if MEMORY in v:
+    if MEMORY in v or IMMUTABLES in v:
         writes[k] |= MSIZE