angr 9.2.158__cp310-abi3-win_amd64.whl → 9.2.159__cp310-abi3-win_amd64.whl

angr/analyses/decompiler/dephication/graph_vvar_mapping.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 import logging
 from collections import defaultdict
 
-from ailment.block import Block
-from ailment.expression import Phi, VirtualVariable, VirtualVariableCategory
-from ailment.statement import Assignment, Jump, ConditionalJump, Label
+from angr.ailment import AILBlockWalker
+from angr.ailment.block import Block
+from angr.ailment.expression import Phi, VirtualVariable, VirtualVariableCategory
+from angr.ailment.statement import Assignment, Jump, ConditionalJump, Label
 
 from angr.analyses import Analysis
 from angr.analyses.s_reaching_definitions import SRDAModel
@@ -88,6 +89,7 @@ class GraphDephicationVVarMapping(Analysis):  # pylint:disable=abstract-method
         unresolved_neighbor_map = defaultdict(set)
 
         # check for interferences
+        candidate_vvar_set_to_phiid: defaultdict[frozenset[int], set[int]] = defaultdict(set)
         for phi_id, src_and_varids in phi_to_srcvarid.items():
             candidate_vvar_set: set[int] = set()
             src_and_varids = list(src_and_varids)
@@ -135,9 +137,13 @@ class GraphDephicationVVarMapping(Analysis):  # pylint:disable=abstract-method
                         if not unresolved_neighbor_map[neighbor]:
                             del unresolved_neighbor_map[neighbor]
 
+            if candidate_vvar_set:
+                candidate_vvar_set_to_phiid[frozenset(candidate_vvar_set)].add(phi_id)
+
+        for vvar_set, phi_ids in candidate_vvar_set_to_phiid.items():
             # insert copies of variables as needed
-            for varid in candidate_vvar_set:
-                insertion_type, new_vvar_ids = self._insert_vvar_copy(varid, phi_id)
+            for varid in vvar_set:
+                insertion_type, new_vvar_ids = self._insert_vvar_copy(varid, phi_ids)
 
                 if insertion_type == 0:
                     for src, old_vvar_id, new_vvar_id in new_vvar_ids:
@@ -159,19 +165,20 @@ class GraphDephicationVVarMapping(Analysis):  # pylint:disable=abstract-method
                             interference.add_edge(new_vvar_id, vvar_id)
 
                 else:  # insertion_type == 1, i.e. the set has only one element
-                    phi_block_loc, old_phi_varid, new_phi_varid = next(iter(new_vvar_ids))
-                    self.copied_vvar_ids.add(new_phi_varid)
+                    for phi_block_loc, old_phi_varid, new_phi_varid in new_vvar_ids:
+                        self.copied_vvar_ids.add(new_phi_varid)
 
-                    phi_congruence_class[new_phi_varid] = {new_phi_varid}
+                        phi_congruence_class[new_phi_varid] = {new_phi_varid}
 
-                    live_ins[phi_block_loc].discard(old_phi_varid)
-                    live_ins[phi_block_loc].add(new_phi_varid)
+                        live_ins[phi_block_loc].discard(old_phi_varid)
+                        live_ins[phi_block_loc].add(new_phi_varid)
 
-                    # update interference graph
-                    for vvar_id in live_ins[phi_block_loc]:
-                        interference.add_edge(new_phi_varid, vvar_id)
+                        # update interference graph
+                        for vvar_id in live_ins[phi_block_loc]:
+                            interference.add_edge(new_phi_varid, vvar_id)
 
-            # update phi_congruence_class
+        # update phi_congruence_class
+        for phi_id in phi_to_srcvarid:
             (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_id]
             phi_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
             # phi_stmt is the newly created phi statement with variables replaced
@@ -199,82 +206,112 @@ class GraphDephicationVVarMapping(Analysis):  # pylint:disable=abstract-method
 
         return mapping
 
-    def _insert_vvar_copy(self, varid: int, phi_varid: int) -> tuple[int, set]:
-        (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_varid]
-        if varid != phi_varid:
+    def _insert_vvar_copy(
+        self, varid: int, phi_varids: set[int]
+    ) -> tuple[int, set[tuple[tuple[int, int | None], int, int]]]:
+        new_vvar_info: set[tuple[tuple[int, int | None], int, int]] = set()
+        new_vvar_id = self.vvar_id_start
+        self.vvar_id_start += 1
+
+        if varid not in phi_varids:
             # it's one of the source vvars
 
-            phi_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
-            phi_stmt = phi_block.statements[phidef_stmt_idx]
+            stmt_appended_locs: dict[tuple[int, int | None], VirtualVariable] = {}
 
-            new_vvar_ids = set()
-
-            for src, vvar in list(phi_stmt.src.src_and_vvars):
-                if vvar is None or vvar.varid != varid:
-                    continue
-
-                new_vvar_id = self.vvar_id_start
-                self.vvar_id_start += 1
-
-                vvar = self._rd.varid_to_vvar[varid]
-                src_block_addr, src_block_idx = src
-
-                the_block = self._blocks[(src_block_addr, src_block_idx)]
-                ins_addr = the_block.addr + the_block.original_size - 1
-                if vvar.category == VirtualVariableCategory.PARAMETER:
-                    # it's a parameter, so we copy the variable into a dummy register vvar
-                    # a parameter vvar should never be assigned to
-                    new_category = VirtualVariableCategory.REGISTER
-                    new_oident = DEPHI_VVAR_REG_OFFSET
-                else:
-                    new_category = vvar.category
-                    new_oident = vvar.oident
-                new_vvar = VirtualVariable(
-                    None, new_vvar_id, vvar.bits, new_category, oident=new_oident, ins_addr=ins_addr
-                )
-                assignment = Assignment(None, new_vvar, vvar, ins_addr=ins_addr)
+            # update all phi statements
+            for phi_varid in phi_varids:
+                (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_varid]
+                phi_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
+                phi_stmt = phi_block.statements[phidef_stmt_idx]
+
+                for src, vvar in list(phi_stmt.src.src_and_vvars):
+                    if vvar is None or vvar.varid != varid:
+                        continue
+
+                    if src not in stmt_appended_locs:
+                        # we have not yet appended a statement to this block
+                        the_block = self._blocks[src]
+                        ins_addr = the_block.addr + the_block.original_size - 1
+                        if vvar.category == VirtualVariableCategory.PARAMETER:
+                            # it's a parameter, so we copy the variable into a dummy register vvar
+                            # a parameter vvar should never be assigned to
+                            new_category = VirtualVariableCategory.REGISTER
+                            new_oident = DEPHI_VVAR_REG_OFFSET
+                        else:
+                            new_category = vvar.category
+                            new_oident = vvar.oident
+                        new_vvar = VirtualVariable(
+                            None, new_vvar_id, vvar.bits, new_category, oident=new_oident, ins_addr=ins_addr
+                        )
+                        assignment = Assignment(None, new_vvar, vvar, ins_addr=ins_addr)
+
+                        self._append_stmt(the_block, assignment, old_vvarid=varid, new_vvarid=new_vvar_id)
+
+                        stmt_appended_locs[src] = new_vvar
 
-                self._append_stmt(the_block, assignment)
+                    else:
+                        new_vvar = stmt_appended_locs[src]
 
-                # update the phi statement
-                replaced_vvars: set[int] = set()
-                for _, phi_used_vvar in list(phi_stmt.src.src_and_vvars):
-                    if phi_used_vvar is not None and phi_used_vvar.varid == varid and varid not in replaced_vvars:
-                        replaced, phi_stmt = phi_stmt.replace(phi_used_vvar, new_vvar)
-                        assert replaced
-                        replaced_vvars.add(varid)
-                phi_block.statements[phidef_stmt_idx] = phi_stmt
+                    replaced_vvars: set[int] = set()
+                    for _, phi_used_vvar in list(phi_stmt.src.src_and_vvars):
+                        if phi_used_vvar is not None and phi_used_vvar.varid == varid and varid not in replaced_vvars:
+                            replaced, phi_stmt = phi_stmt.replace(phi_used_vvar, new_vvar)
+                            assert replaced
+                            replaced_vvars.add(varid)
+                    phi_block.statements[phidef_stmt_idx] = phi_stmt
 
-                new_vvar_ids.add((src, varid, new_vvar_id))
+                    new_vvar_info.add((src, varid, new_vvar_id))
 
-            return 0, new_vvar_ids
+            return 0, new_vvar_info
 
         # it's the phi assignment destination vvar
 
-        new_vvar_id = self.vvar_id_start
-        self.vvar_id_start += 1
+        for phi_varid in phi_varids:
+            phi_vvar = self._rd.varid_to_vvar[phi_varid]
+            (phidef_block_addr, phidef_block_idx), phidef_stmt_idx = self._vvar_defloc[phi_varid]
+            the_block = self._blocks[(phidef_block_addr, phidef_block_idx)]
+            ins_addr = the_block.addr
+            new_vvar = VirtualVariable(
+                None, new_vvar_id, phi_vvar.bits, phi_vvar.category, oident=phi_vvar.oident, ins_addr=ins_addr
+            )
+            assignment = Assignment(None, phi_vvar, new_vvar, ins_addr=ins_addr)
 
-        phi_vvar = self._rd.varid_to_vvar[phi_varid]
-        phi_block_addr, phi_block_idx = self._vvar_defloc[phi_varid][0]
-        the_block = self._blocks[(phi_block_addr, phi_block_idx)]
-        ins_addr = the_block.addr
-        new_vvar = VirtualVariable(
-            None, new_vvar_id, phi_vvar.bits, phi_vvar.category, oident=phi_vvar.oident, ins_addr=ins_addr
-        )
-        assignment = Assignment(None, phi_vvar, new_vvar, ins_addr=ins_addr)
+            phi_stmt = the_block.statements[phidef_stmt_idx]
+            replaced, phi_stmt = phi_stmt.replace(phi_vvar, new_vvar)
+            the_block.statements[phidef_stmt_idx] = phi_stmt
 
-        phi_stmt = the_block.statements[phidef_stmt_idx]
-        replaced, phi_stmt = phi_stmt.replace(phi_vvar, new_vvar)
-        the_block.statements[phidef_stmt_idx] = phi_stmt
+            self._record_stmt_for_prepending(the_block, assignment)
 
-        self._record_stmt_for_prepending(the_block, assignment)
+            new_vvar_info.add(((phidef_block_addr, phidef_block_idx), phi_varid, new_vvar_id))
 
-        return 1, {((phi_block_addr, phi_block_idx), phi_varid, new_vvar_id)}
+        return 1, new_vvar_info
 
     @staticmethod
-    def _append_stmt(block, stmt):
+    def _append_stmt(block, stmt, old_vvarid: int | None = None, new_vvarid: int | None = None):
+
+        def _handle_VirtualVariable(  # pylint:disable=unused-argument
+            expr_idx: int, expr: VirtualVariable, stmt_idx: int, stmt, block: Block | None
+        ):
+            assert old_vvarid is not None and new_vvarid is not None
+            return (
+                None
+                if expr.varid != old_vvarid
+                else VirtualVariable(
+                    None, new_vvarid, expr.bits, expr.category, oident=expr.oident, ins_addr=expr.ins_addr
+                )
+            )
+
         if block.statements and isinstance(block.statements[-1], (Jump, ConditionalJump)):
             block.statements.insert(len(block.statements) - 1, stmt)
+
+            # replace the vvar usage in the last statement if it's used there
+            if old_vvarid is not None and new_vvarid is not None:
+                replacer = AILBlockWalker()
+                replacer.expr_handlers[VirtualVariable] = _handle_VirtualVariable
+                new_stmt = replacer.walk_statement(block.statements[-1])
+                if new_stmt is not None and new_stmt is not block.statements[-1]:
+                    block.statements[-1] = new_stmt
+
         else:
             block.statements.append(stmt)
 

angr/analyses/decompiler/dephication/rewriting_engine.py

@@ -1,9 +1,10 @@
 # pylint:disable=unused-argument,no-self-use,too-many-boolean-expressions
 from __future__ import annotations
+from typing import TYPE_CHECKING
 import logging
 
-from ailment.block import Block
-from ailment.statement import (
+from angr.ailment.block import Block
+from angr.ailment.statement import (
     Statement,
     Assignment,
     Store,
@@ -14,7 +15,7 @@ from ailment.statement import (
     DirtyStatement,
     WeakAssignment,
 )
-from ailment.expression import (
+from angr.ailment.expression import (
     Atom,
     Expression,
     VirtualVariable,
@@ -28,9 +29,11 @@ from ailment.expression import (
     DirtyExpression,
     Reinterpret,
 )
-
 from angr.engines.light import SimEngineNostmtAIL
 
+if TYPE_CHECKING:
+    from angr import KnowledgeBase
+
 
 _l = logging.getLogger(__name__)
 
@@ -47,11 +50,15 @@ class SimEngineDephiRewriting(SimEngineNostmtAIL[None, Expression | None, Statem
         self,
         project,
         vvar_to_vvar: dict[int, int],
+        func_addr: int | None = None,
+        variable_kb: KnowledgeBase | None = None,
     ):
         super().__init__(project)
 
         self.vvar_to_vvar = vvar_to_vvar
         self.out_block = None
+        self.func_addr = func_addr
+        self.variable_kb = variable_kb
 
         self._stmt_handlers["IncompleteSwitchCaseHeadStatement"] = self._handle_stmt_IncompleteSwitchCaseHeadStatement
 
@@ -99,13 +106,29 @@ class SimEngineDephiRewriting(SimEngineNostmtAIL[None, Expression | None, Statem
                 **stmt.dst.tags,
             )
 
-        if new_dst is not None or new_src is not None:
-            # ensure we do not generate vvar_A = vvar_A
-            dst = stmt.dst if new_dst is None else new_dst
-            src = stmt.src if new_src is None else new_src
-            if isinstance(dst, VirtualVariable) and isinstance(src, VirtualVariable) and dst.varid == src.varid:
+        # ensure we do not generate vvar_A = vvar_A or var_A = var_A (even if lhs and rhs are different vvars, they
+        # can be mapped to the same variable)
+        dst = stmt.dst if new_dst is None else new_dst
+        src = stmt.src if new_src is None else new_src
+        if isinstance(dst, VirtualVariable) and isinstance(src, VirtualVariable):
+            if dst.varid == src.varid:
                 # skip it
                 return ()
+            if (
+                self.func_addr is not None
+                and self.variable_kb is not None
+                and self.func_addr in self.variable_kb.variables
+            ):
+                dst_var = getattr(dst, "variable", None)
+                src_var = getattr(src, "variable", None)
+                var_manager = self.variable_kb.variables[self.func_addr]
+                if (
+                    dst_var is not None
+                    and src_var is not None
+                    and var_manager.unified_variable(dst_var) is var_manager.unified_variable(src_var)
+                ):
+                    # skip it
+                    return ()
 
             return Assignment(stmt.idx, dst, src, **stmt.tags)
         return None

angr/analyses/decompiler/dephication/seqnode_dephication.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 from collections import defaultdict
 import logging
-from typing import Any
+from typing import Any, TYPE_CHECKING
 
-from ailment.block import Block
-from ailment.statement import Assignment
-from ailment.expression import VirtualVariable, Phi, BinaryOp, UnaryOp
+from angr.ailment.block import Block
+from angr.ailment.statement import Assignment
+from angr.ailment.expression import VirtualVariable, Phi, BinaryOp, UnaryOp
 
 import angr
 from angr.utils.ail import is_phi_assignment
@@ -16,6 +16,9 @@ from angr.analyses.decompiler.sequence_walker import SequenceWalker
 from .dephication_base import DephicationBase
 from .rewriting_engine import SimEngineDephiRewriting
 
+if TYPE_CHECKING:
+    from angr import KnowledgeBase
+
 
 l = logging.getLogger(__name__)
 
@@ -54,7 +57,14 @@ class SeqNodeRewriter(SequenceWalker):
     variables.
     """
 
-    def __init__(self, seq_node: SequenceNode, vvar_to_vvar: dict[int, int], project: angr.Project):
+    def __init__(
+        self,
+        seq_node: SequenceNode,
+        vvar_to_vvar: dict[int, int],
+        project: angr.Project,
+        variable_kb: KnowledgeBase | None = None,
+        func_addr: int | None = None,
+    ):
         super().__init__(
             handlers={
                 Block: self._handle_Block,
@@ -67,7 +77,7 @@ class SeqNodeRewriter(SequenceWalker):
         )
 
         self.vvar_to_vvar = vvar_to_vvar
-        self.engine = SimEngineDephiRewriting(project, self.vvar_to_vvar)
+        self.engine = SimEngineDephiRewriting(project, self.vvar_to_vvar, func_addr=func_addr, variable_kb=variable_kb)
 
         self.output = self.walk(seq_node)
         if self.output is None:
@@ -109,13 +119,19 @@ class SeqNodeRewriter(SequenceWalker):
 
 class SeqNodeDephication(DephicationBase):
     """
-    SeqNodeDephication removes phi expressions from an AIL SeqNode and its children.
+    SeqNodeDephication removes phi expressions from a SequenceNode and its children. It also removes redundant variable
+    assignments, e.g., `vvar_2 = vvar_1` where both vvar_1 and vvar_2 are mapped to the same variable.
     """
 
     def __init__(
-        self, func: Function | str, seq_node, vvar_to_vvar_mapping: dict[int, int] | None = None, rewrite: bool = False
+        self,
+        func: Function | str,
+        seq_node,
+        vvar_to_vvar_mapping: dict[int, int] | None = None,
+        rewrite: bool = False,
+        variable_kb: KnowledgeBase | None = None,
     ):
-        super().__init__(func, vvar_to_vvar_mapping=vvar_to_vvar_mapping, rewrite=rewrite)
+        super().__init__(func, vvar_to_vvar_mapping=vvar_to_vvar_mapping, rewrite=rewrite, variable_kb=variable_kb)
 
         self._seq_node = seq_node
 
@@ -127,7 +143,13 @@ class SeqNodeDephication(DephicationBase):
         return collector.phi_to_src
 
     def _rewrite_container(self) -> Any:
-        rewriter = SeqNodeRewriter(self._seq_node, self.vvar_to_vvar_mapping, self.project)
+        rewriter = SeqNodeRewriter(
+            self._seq_node,
+            self.vvar_to_vvar_mapping,
+            self.project,
+            func_addr=self._function.addr,
+            variable_kb=self.variable_kb,
+        )
         return rewriter.output
 
 

angr/analyses/decompiler/empty_node_remover.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 from collections import OrderedDict
 
 import claripy
-import ailment
-from ailment.expression import negate
+import angr.ailment as ailment
+from angr.ailment.expression import negate
 
 from .sequence_walker import SequenceWalker
 from .structuring.structurer_nodes import (

angr/analyses/decompiler/expression_narrower.py

@@ -3,15 +3,15 @@ from typing import Any, TYPE_CHECKING
 from collections import defaultdict
 import logging
 
-from ailment import AILBlockWalkerBase, AILBlockWalker
-from ailment.statement import Assignment, Call
-from ailment.expression import VirtualVariable, Convert, BinaryOp, Phi
+from angr.ailment import AILBlockWalkerBase, AILBlockWalker
+from angr.ailment.statement import Assignment, Call
+from angr.ailment.expression import VirtualVariable, Convert, BinaryOp, Phi
 
 from angr.knowledge_plugins.key_definitions import atoms
 from angr.code_location import CodeLocation
 
 if TYPE_CHECKING:
-    from ailment.expression import (
+    from angr.ailment.expression import (
         Expression,
         Load,
         UnaryOp,
@@ -19,8 +19,8 @@ if TYPE_CHECKING:
         DirtyExpression,
         VEXCCallExpression,
     )
-    from ailment.statement import Statement
-    from ailment.block import Block
+    from angr.ailment.statement import Statement
+    from angr.ailment.block import Block
 
 
 _l = logging.getLogger(__name__)

angr/analyses/decompiler/goto_manager.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
-import ailment
-from ailment.block import Block
+import angr.ailment as ailment
+from angr.ailment.block import Block
 import networkx
 
 from .utils import find_block_by_addr

angr/analyses/decompiler/jump_target_collector.py

@@ -1,7 +1,7 @@
 # pylint:disable=unused-argument
 from __future__ import annotations
 
-import ailment
+import angr.ailment as ailment
 
 from .sequence_walker import SequenceWalker
 

angr/analyses/decompiler/label_collector.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 from collections import defaultdict
 
-import ailment
+import angr.ailment as ailment
 
 from .sequence_walker import SequenceWalker
 

angr/analyses/decompiler/optimization_passes/base_ptr_save_simplifier.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 import logging
 
-import ailment
+import angr.ailment as ailment
 
 from angr.analyses.decompiler.stack_item import StackItem, StackItemType
 from .optimization_pass import OptimizationPass, OptimizationPassStage
@@ -88,32 +88,32 @@ class BasePointerSaveSimplifier(OptimizationPass):
         :rtype:     tuple|None
         """
 
-        first_block = self._get_block(self._func.addr)
-        if first_block is None:
-            return None
-
-        for idx, stmt in enumerate(first_block.statements):
-            if (
-                isinstance(stmt, ailment.Stmt.Assignment)
-                and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
-                and stmt.dst.was_stack
-                and stmt.dst.stack_offset < 0
-            ):
-                if (
-                    isinstance(stmt.src, ailment.Expr.VirtualVariable)
-                    and stmt.src.was_reg
-                    and stmt.src.reg_offset == self.project.arch.bp_offset
-                ):
-                    return first_block, idx, stmt.dst
-                if isinstance(stmt.src, ailment.Expr.StackBaseOffset) and stmt.src.offset == 0:
-                    return first_block, idx, stmt.dst
+        # scan the first N blocks of the function until we find the first baseptr save statement
+        max_level = 5
+
+        for block in self.bfs_nodes(depth=max_level):
+            for idx, stmt in enumerate(block.statements):
                 if (
-                    isinstance(stmt.src, ailment.Expr.UnaryOp)
-                    and isinstance(stmt.src.operand, ailment.Expr.VirtualVariable)
-                    and stmt.src.operand.was_stack
-                    and stmt.src.operand.stack_offset == 0
+                    isinstance(stmt, ailment.Stmt.Assignment)
+                    and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                    and stmt.dst.was_stack
+                    and stmt.dst.stack_offset < 0
                 ):
-                    return first_block, idx, stmt.dst
+                    if (
+                        isinstance(stmt.src, ailment.Expr.VirtualVariable)
+                        and stmt.src.was_reg
+                        and stmt.src.reg_offset == self.project.arch.bp_offset
+                    ):
+                        return block, idx, stmt.dst
+                    if isinstance(stmt.src, ailment.Expr.StackBaseOffset) and stmt.src.offset == 0:
+                        return block, idx, stmt.dst
+                    if (
+                        isinstance(stmt.src, ailment.Expr.UnaryOp)
+                        and isinstance(stmt.src.operand, ailment.Expr.VirtualVariable)
+                        and stmt.src.operand.was_stack
+                        and stmt.src.operand.stack_offset == 0
+                    ):
+                        return block, idx, stmt.dst
 
         # Not found
         return None

angr/analyses/decompiler/optimization_passes/call_stmt_rewriter.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import logging
 
-from ailment.statement import Call, Assignment
+from angr.ailment.statement import Call, Assignment
 
 from .optimization_pass import OptimizationPass, OptimizationPassStage
 

angr/analyses/decompiler/optimization_passes/code_motion.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 import itertools
 import logging
 
-from ailment import Block
-from ailment.statement import Jump, ConditionalJump, Statement, DirtyStatement
+from angr.ailment import Block
+from angr.ailment.statement import Jump, ConditionalJump, Statement, DirtyStatement
 import networkx as nx
 
 from angr.analyses.decompiler.optimization_passes.optimization_pass import OptimizationPass, OptimizationPassStage

angr/analyses/decompiler/optimization_passes/condition_constprop.py

@@ -4,9 +4,9 @@ from collections import defaultdict
 
 import networkx
 
-from ailment import AILBlockWalker, Block
-from ailment.statement import ConditionalJump, Statement, Assignment
-from ailment.expression import Const, BinaryOp, VirtualVariable
+from angr.ailment import AILBlockWalker, Block
+from angr.ailment.statement import ConditionalJump, Statement, Assignment
+from angr.ailment.expression import Const, BinaryOp, VirtualVariable
 
 from angr.analyses.decompiler.utils import first_nonlabel_nonphi_statement
 from angr.utils.graph import dominates

angr/analyses/decompiler/optimization_passes/const_derefs.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 import logging
 
-from ailment import Block, AILBlockWalker
-from ailment.expression import Load, Const, BinaryOp, UnaryOp
-from ailment.statement import Statement, Assignment, Call, ConditionalJump
+from angr.ailment import Block, AILBlockWalker
+from angr.ailment.expression import Load, Const, BinaryOp, UnaryOp
+from angr.ailment.statement import Statement, Assignment, Call, ConditionalJump
 
 from angr.analyses.decompiler.ailgraph_walker import AILGraphWalker
 from .optimization_pass import OptimizationPass, OptimizationPassStage

angr/analyses/decompiler/optimization_passes/const_prop_reverter.py

@@ -5,10 +5,10 @@ import itertools
 
 import networkx
 import claripy
-from ailment import Const
-from ailment.block_walker import AILBlockWalkerBase
-from ailment.statement import Call, Statement, ConditionalJump, Assignment, Store, Return
-from ailment.expression import Convert, Register, Expression, Load
+from angr.ailment import Const
+from angr.ailment.block_walker import AILBlockWalkerBase
+from angr.ailment.statement import Call, Statement, ConditionalJump, Assignment, Store, Return
+from angr.ailment.expression import Convert, Register, Expression, Load
 
 from .optimization_pass import OptimizationPass, OptimizationPassStage
 from angr.analyses.decompiler.structuring import SAILRStructurer, DreamStructurer

angr/analyses/decompiler/optimization_passes/deadblock_remover.py

@@ -6,8 +6,8 @@ import networkx
 
 import claripy
 
-from ailment.statement import Jump
-from ailment.expression import Const
+from angr.ailment.statement import Jump
+from angr.ailment.expression import Const
 from angr.utils.graph import to_acyclic_graph
 from angr.analyses.decompiler.condition_processor import ConditionProcessor
 from .optimization_pass import OptimizationPass, OptimizationPassStage

angr/analyses/decompiler/optimization_passes/determine_load_sizes.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 import logging
 
-from ailment.constant import UNDETERMINED_SIZE
-from ailment.expression import BinaryOp, Load, Const
-from ailment.statement import Assignment, WeakAssignment
+from angr.ailment.constant import UNDETERMINED_SIZE
+from angr.ailment.expression import BinaryOp, Load, Const
+from angr.ailment.statement import Assignment, WeakAssignment
 
 from .optimization_pass import OptimizationPass, OptimizationPassStage
 

angr/analyses/decompiler/optimization_passes/div_simplifier.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import logging
 import math
 
-from ailment import Expr
+from angr.ailment import Expr
 from unique_log_filter import UniqueLogFilter
 
 from .engine_base import SimplifierAILEngine, SimplifierAILState