feat[venom]: mark loads as non-volatile

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",

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

vyper/venom/passes/remove_unused_variables.py

@@ -1,5 +1,6 @@
 from vyper.utils import OrderedSet
-from vyper.venom.analysis import DFGAnalysis, LivenessAnalysis
+from vyper.venom import effects
+from vyper.venom.analysis import DFGAnalysis, LivenessAnalysis, ReachableAnalysis
 from vyper.venom.basicblock import IRInstruction
 from vyper.venom.passes.base_pass import IRPass
 
@@ -11,9 +12,19 @@ class RemoveUnusedVariablesPass(IRPass):
 
     dfg: DFGAnalysis
     work_list: OrderedSet[IRInstruction]
+    reads_msize: bool
 
     def run_pass(self):
         self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
+        self.reachable = self.analyses_cache.request_analysis(ReachableAnalysis).reachable
+
+        self.reads_msize = {}
+        self.instruction_index = {}
+        for bb in self.function.get_basic_blocks():
+            for idx, inst in enumerate(bb.instructions):
+                self.instruction_index[inst] = idx
+                if inst.opcode == "msize" and bb not in self.reads_msize:
+                    self.reads_msize[bb] = idx
 
         work_list = OrderedSet()
         self.work_list = work_list
@@ -33,6 +44,14 @@ def _process_instruction(self, inst):
             return
         if inst.is_volatile or inst.is_bb_terminator:
             return
+        bb = inst.parent
+        if effects.MSIZE in inst.get_write_effects():
+            # msize after memory touch
+            if bb in self.reads_msize and self.instruction_index[inst] < self.reads_msize[bb]:
+                return
+            if any(reachable_bb in self.reachable[bb] for reachable_bb in self.reads_msize):
+                return
+
         uses = self.dfg.get_uses(inst.output)
         if len(uses) > 0:
             return