squash commit: add is_volatile and mark method

vyper/venom/analysis/mem_alias.py

@@ -93,3 +93,27 @@ def may_alias(self, loc1: MemoryLocation, loc2: MemoryLocation) -> bool:
         start2, end2 = loc2.offset, loc2.offset + loc2.size
 
         return (start1 <= start2 < end1) or (start2 <= start1 < end2)
+
+    def mark_volatile(self, loc: MemoryLocation) -> MemoryLocation:
+        volatile_loc = MemoryLocation(
+            base=loc.base, 
+            offset=loc.offset, 
+            size=loc.size, 
+            is_alloca=loc.is_alloca, 
+            is_volatile=True
+        )
+
+        if loc in self.alias_sets:
+            self.alias_sets[volatile_loc] = OrderedSet([volatile_loc])
+
+            # new and old locations are aliased            
+            self.alias_sets[volatile_loc].add(loc)
+            self.alias_sets[loc].add(volatile_loc)
+
+            # copy aliasing relationships
+            for other_loc in self.alias_sets[loc]:
+                if other_loc != loc and other_loc != volatile_loc:
+                    self.alias_sets[volatile_loc].add(other_loc)
+                    self.alias_sets[other_loc].add(volatile_loc)
+
+        return volatile_loc

vyper/venom/analysis/mem_ssa.py

@@ -13,15 +13,16 @@ class MemoryAccess:
     def __init__(self, id: int):
         self.id = id
         self.reaching_def: Optional[MemoryAccess] = None
-
-    @property
-    def loc(self) -> MemoryLocation:
-        raise NotImplementedError("Subclasses must implement this method")
+        self.loc: Optional[MemoryLocation] = None
 
     @property
     def is_live_on_entry(self) -> bool:
         return self.id == 0
 
+    @property
+    def is_volatile(self) -> bool:
+        return self.loc.is_volatile
+
     @property
     def id_str(self) -> str:
         if self.is_live_on_entry:
@@ -38,23 +39,15 @@ class MemoryDef(MemoryAccess):
     def __init__(self, id: int, store_inst: IRInstruction):
         super().__init__(id)
         self.store_inst = store_inst
-
-    @property
-    def loc(self) -> MemoryLocation:
-        return self.store_inst.get_write_memory_location()
-
+        self.loc = store_inst.get_write_memory_location()
 
 class MemoryUse(MemoryAccess):
     """Represents a use of memory state"""
 
     def __init__(self, id: int, load_inst: IRInstruction):
         super().__init__(id)
         self.load_inst = load_inst
-
-    @property
-    def loc(self) -> MemoryLocation:
-        return self.load_inst.get_read_memory_location()
-
+        self.loc = load_inst.get_read_memory_location()
 
 class MemoryPhi(MemoryAccess):
     """Represents a phi node for memory states"""
@@ -103,6 +96,23 @@ def analyze(self):
         # Clean up unnecessary phi nodes
         self._remove_redundant_phis()
 
+    def mark_location_volatile(self, loc: MemoryLocation) -> MemoryLocation:
+        volatile_loc = self.alias.mark_volatile(loc)
+
+        for bb in self.memory_defs:
+            for mem_def in self.memory_defs[bb]:
+                if self.alias.may_alias(mem_def.loc, loc):
+                    new_loc = MemoryLocation(
+                        base=mem_def.loc.base,
+                        offset=mem_def.loc.offset,
+                        size=mem_def.loc.size,
+                        is_alloca=mem_def.loc.is_alloca,
+                        is_volatile=True
+                    )
+                    mem_def.loc = new_loc
+
+        return volatile_loc
+
     def get_memory_def(self, inst: IRInstruction) -> Optional[MemoryDef]:
         if inst in self.inst_to_def:
             return self.inst_to_def[inst]
@@ -319,7 +329,7 @@ def get_clobbering_memory_access(self, access: MemoryAccess) -> Optional[MemoryA
                                 return next_def
                             mem_use = self.inst_to_use.get(inst)
                             if mem_use and mem_use.reaching_def == access:
-                                return None  # Use of this def in phi’s block
+                                return None
 
             # Check instructions in successor block
             for inst in succ.instructions:

vyper/venom/basicblock.py

@@ -247,6 +247,7 @@ class MemoryLocation:
     offset: int = 0
     size: int = 0
     is_alloca: bool = False
+    is_volatile: bool = False
 
 
 FULL_MEMORY_ACCESS = MemoryLocation(base=IROperand(0), offset=0, size=-1, is_alloca=False)