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/utils.py

@@ -597,3 +597,34 @@ def annotate_source_code(
     cleanup_lines += [""] * (num_lines - len(cleanup_lines))
 
     return "\n".join(cleanup_lines)
+
+
+def find_cycles_in_directed_graph(graph):
+    visit_state = {}  # Visit states: 0 = Not visited, 1 = Visiting, 2 = Visited
+    stack = []  # Stack to keep track of the current path
+    all_cycles = []  # List to store all detected cycles
+
+    def dfs(node):
+        vs = visit_state.get(node, 0)
+        if vs == 1:  # Cycle detected
+            cycle_index = stack.index(node)
+            cycle_nodes = stack[cycle_index:]
+            all_cycles.append(cycle_nodes)
+            return
+        elif vs == 2:  # Already fully visited
+            return
+
+        visit_state[node] = 1
+        stack.append(node)
+
+        for neighbor in graph.get(node, []):
+            dfs(neighbor)
+
+        stack.pop()
+        visit_state[node] = 2
+
+    for node in graph:
+        if visit_state.get(node, 0) == 0:
+            dfs(node)
+
+    return all_cycles

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/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

@@ -211,7 +211,6 @@ class IRInstruction:
     liveness: OrderedSet[IRVariable]
     dup_requirements: OrderedSet[IRVariable]
     parent: "IRBasicBlock"
-    fence_id: int
     annotation: Optional[str]
     ast_source: Optional[IRnode]
     error_msg: Optional[str]
@@ -229,7 +228,6 @@ def __init__(
         self.output = output
         self.liveness = OrderedSet()
         self.dup_requirements = OrderedSet()
-        self.fence_id = -1
         self.annotation = None
         self.ast_source = None
         self.error_msg = None
@@ -242,6 +240,22 @@ def is_volatile(self) -> bool:
     def is_bb_terminator(self) -> bool:
         return self.opcode in BB_TERMINATORS
 
+    @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_label_operands(self) -> Iterator[IRLabel]:
         """
         Get all labels in instruction.
@@ -321,6 +335,20 @@ def get_ast_source(self) -> Optional[IRnode]:
                 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:
@@ -337,10 +365,7 @@ def __repr__(self) -> str:
         if self.annotation:
             s += f" <{self.annotation}>"
 
-        if self.liveness:
-            return f"{s: <30} # {self.liveness}"
-
-        return s
+        return f"{s: <30} # {self.liveness}"
 
 
 def _ir_operand_from_value(val: Any) -> IROperand:
@@ -479,6 +504,34 @@ def remove_instruction(self, instruction: IRInstruction) -> None:
     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.