feat[venom]: new DFTPass algorithm

vyper/ir/compile_ir.py

@@ -1033,6 +1033,9 @@ def _stack_peephole_opts(assembly):
         if assembly[i] == "SWAP1" and assembly[i + 1].lower() in COMMUTATIVE_OPS:
             changed = True
             del assembly[i]
+        if assembly[i] == "DUP1" and assembly[i + 1] == "SWAP1":
+            changed = True
+            del assembly[i + 1]
         i += 1
 
     return changed

vyper/semantics/analysis/module.py

@@ -898,7 +898,7 @@ def _import_to_path(level: int, module_str: str) -> PurePath:
         base_path = "../" * (level - 1)
     elif level == 1:
         base_path = "./"
-    return PurePath(f"{base_path}{module_str.replace('.','/')}/")
+    return PurePath(f"{base_path}{module_str.replace('.', '/')}/")
 
 
 # can add more, e.g. "vyper.builtins.interfaces", etc.

vyper/venom/__init__.py

@@ -3,6 +3,7 @@
 
 from typing import Optional
 
+from vyper.venom.passes.store_expansion import StoreExpansionPass
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.settings import OptimizationLevel
 from vyper.venom.analysis.analysis import IRAnalysesCache
@@ -56,6 +57,7 @@ def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     BranchOptimizationPass(ac, fn).run_pass()
     ExtractLiteralsPass(ac, fn).run_pass()
     RemoveUnusedVariablesPass(ac, fn).run_pass()
+    StoreExpansionPass(ac, fn).run_pass()
     DFTPass(ac, fn).run_pass()
 
 

vyper/venom/analysis/analysis.py

@@ -50,9 +50,9 @@ def request_analysis(self, analysis_cls: Type[IRAnalysis], *args, **kwargs):
         if analysis_cls in self.analyses_cache:
             return self.analyses_cache[analysis_cls]
         analysis = analysis_cls(self, self.function)
+        self.analyses_cache[analysis_cls] = analysis
         analysis.analyze(*args, **kwargs)
 
-        self.analyses_cache[analysis_cls] = analysis
         return analysis
 
     def invalidate_analysis(self, analysis_cls: Type[IRAnalysis]):

vyper/venom/analysis/cfg.py

@@ -18,7 +18,7 @@ def analyze(self) -> None:
         for bb in fn.get_basic_blocks():
             assert len(bb.instructions) > 0, "Basic block should not be empty"
             last_inst = bb.instructions[-1]
-            assert last_inst.is_bb_terminator, f"Last instruction should be a terminator {bb}"
+            assert last_inst.is_bb_terminator, "Last instruction should be a terminator"
 
             for inst in bb.instructions:
                 if inst.opcode in CFG_ALTERING_INSTRUCTIONS:

vyper/venom/analysis/dfg.py

@@ -2,7 +2,7 @@
 
 from vyper.venom.analysis.analysis import IRAnalysesCache, IRAnalysis
 from vyper.venom.analysis.liveness import LivenessAnalysis
-from vyper.venom.basicblock import IRInstruction, IRVariable
+from vyper.venom.basicblock import IRBasicBlock, IRInstruction, IRVariable
 from vyper.venom.function import IRFunction
 
 
@@ -19,6 +19,12 @@ def __init__(self, analyses_cache: IRAnalysesCache, function: IRFunction):
     def get_uses(self, op: IRVariable) -> list[IRInstruction]:
         return self._dfg_inputs.get(op, [])
 
+    def get_uses_in_bb(self, op: IRVariable, bb: IRBasicBlock):
+        """
+        Get uses of a given variable in a specific basic block.
+        """
+        return [inst for inst in self.get_uses(op) if inst.parent == bb]
+
     # the instruction which produces this variable.
     def get_producing_instruction(self, op: IRVariable) -> Optional[IRInstruction]:
         return self._dfg_outputs.get(op)

vyper/venom/analysis/liveness.py

@@ -61,7 +61,7 @@ def _calculate_out_vars(self, bb: IRBasicBlock) -> bool:
         Compute out_vars of basic block.
         Returns True if out_vars changed
         """
-        out_vars = bb.out_vars
+        out_vars = bb.out_vars.copy()
         bb.out_vars = OrderedSet()
         for out_bb in bb.cfg_out:
             target_vars = self.input_vars_from(bb, out_bb)

vyper/venom/basicblock.py

@@ -1,5 +1,6 @@
 from typing import TYPE_CHECKING, Any, Iterator, Optional, Union
 
+import vyper.venom.effects as effects
 from vyper.codegen.ir_node import IRnode
 from vyper.utils import OrderedSet
 
@@ -21,8 +22,6 @@
         "istore",
         "tload",
         "tstore",
-        "assert",
-        "assert_unreachable",
         "mstore",
         "mload",
         "calldatacopy",
@@ -210,7 +209,6 @@
     # set of live variables at this instruction
     liveness: OrderedSet[IRVariable]
     parent: "IRBasicBlock"
-    fence_id: int
     annotation: Optional[str]
     ast_source: Optional[IRnode]
     error_msg: Optional[str]
@@ -227,7 +225,6 @@
         self.operands = list(operands)  # in case we get an iterator
         self.output = output
         self.liveness = OrderedSet()
-        self.fence_id = -1
         self.annotation = None
         self.ast_source = None
         self.error_msg = None
@@ -239,6 +236,34 @@
     @property
     def is_bb_terminator(self) -> bool:
         return self.opcode in BB_TERMINATORS
+
+    def get_read_effects(self):
+        return effects.reads.get(self.opcode, ())
+
+    def get_write_effects(self):
+        return effects.writes.get(self.opcode, ())
+
+    @property
+    def is_phi(self) -> bool:
+        return self.opcode == "phi"
+
+    @property
+    def is_param(self) -> bool:
+        return self.opcode == "param"
+
+    @property
+    def is_pseudo(self) -> bool:
+        """
+        Check if instruction is pseudo, i.e. not an actual instruction but
+        a construct for intermediate representation like phi and param.
+        """
+        return self.is_phi or self.is_param
+
+    def get_read_effects(self):
+        return effects.reads.get(self.opcode, effects.EMPTY)
+
+    def get_write_effects(self):
+        return effects.writes.get(self.opcode, effects.EMPTY)
 
     def get_label_operands(self) -> Iterator[IRLabel]:
         """
@@ -319,6 +344,20 @@
                 return inst.ast_source
         return self.parent.parent.ast_source
 
+    def str_short(self) -> str:
+        s = ""
+        if self.output:
+            s += f"{self.output} = "
+        opcode = f"{self.opcode} " if self.opcode != "store" else ""
+        s += opcode
+        operands = self.operands
+        if opcode not in ["jmp", "jnz", "invoke"]:
+            operands = list(reversed(operands))
+        s += ", ".join(
+            [(f"label %{op}" if isinstance(op, IRLabel) else str(op)) for op in operands]
+        )
+        return s
+
     def __repr__(self) -> str:
         s = ""
         if self.output:
@@ -335,10 +374,7 @@
         if self.annotation:
             s += f" <{self.annotation}>"
 
-        if self.liveness:
-            return f"{s: <30} # {self.liveness}"
-
-        return s
+        return f"{s: <30}"
 
 
 def _ir_operand_from_value(val: Any) -> IROperand:
@@ -477,6 +513,34 @@
     def clear_instructions(self) -> None:
         self.instructions = []
 
+    @property
+    def phi_instructions(self) -> Iterator[IRInstruction]:
+        for inst in self.instructions:
+            if inst.opcode == "phi":
+                yield inst
+            else:
+                return
+
+    @property
+    def non_phi_instructions(self) -> Iterator[IRInstruction]:
+        return (inst for inst in self.instructions if inst.opcode != "phi")
+
+    @property
+    def param_instructions(self) -> Iterator[IRInstruction]:
+        for inst in self.instructions:
+            if inst.opcode == "param":
+                yield inst
+            else:
+                return
+
+    @property
+    def pseudo_instructions(self) -> Iterator[IRInstruction]:
+        return (inst for inst in self.instructions if inst.is_pseudo)
+
+    @property
+    def body_instructions(self) -> Iterator[IRInstruction]:
+        return (inst for inst in self.instructions[:-1] if not inst.is_pseudo)
+
     def replace_operands(self, replacements: dict) -> None:
         """
         Update operands with replacements.

vyper/venom/effects.py

@@ -0,0 +1,59 @@
+from enum import Flag, auto
+
+
+class Effects(Flag):
+    STORAGE = auto()
+    TRANSIENT = auto()
+    MEMORY = auto()
+    IMMUTABLES = auto()
+    BALANCE = auto()
+    RETURNDATA = auto()
+
+
+EMPTY = Effects(0)
+ALL = ~EMPTY
+STORAGE = Effects.STORAGE
+TRANSIENT = Effects.TRANSIENT
+MEMORY = Effects.MEMORY
+IMMUTABLES = Effects.IMMUTABLES
+BALANCE = Effects.BALANCE
+RETURNDATA = Effects.RETURNDATA
+
+
+writes = {
+    "sstore": STORAGE,
+    "tstore": TRANSIENT,
+    "mstore": MEMORY,
+    "istore": IMMUTABLES,
+    "call": ALL,
+    "delegatecall": ALL,
+    "staticcall": MEMORY | RETURNDATA,
+    "create": ALL,
+    "create2": ALL,
+    "invoke": ALL,  # could be smarter, look up the effects of the invoked function
+    "dloadbytes": MEMORY,
+    "returndatacopy": MEMORY,
+    "calldatacopy": MEMORY,
+    "codecopy": MEMORY,
+    "extcodecopy": MEMORY,
+    "mcopy": MEMORY,
+}
+
+reads = {
+    "sload": STORAGE,
+    "tload": TRANSIENT,
+    "iload": IMMUTABLES,
+    "mload": MEMORY,
+    "mcopy": MEMORY,
+    "call": ALL,
+    "delegatecall": ALL,
+    "staticcall": ALL,
+    "returndatasize": RETURNDATA,
+    "returndatacopy": RETURNDATA,
+    "balance": BALANCE,
+    "selfbalance": BALANCE,
+    "log": MEMORY,
+    "revert": MEMORY,
+    "return": MEMORY,
+    "sha3": MEMORY,
+}