angr 9.2.132__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

angr/analyses/decompiler/optimization_passes/__init__.py

@@ -107,37 +107,37 @@ def register_optimization_pass(opt_pass, *, presets: list[str | DecompilationPre
 
 
 __all__ = (
-    "OptimizationPassStage",
-    "StackCanarySimplifier",
+    "ALL_OPTIMIZATION_PASSES",
+    "CONDENSING_OPTS",
+    "DUPLICATING_OPTS",
     "BasePointerSaveSimplifier",
+    "CallStatementRewriter",
+    "CodeMotionOptimization",
+    "ConstPropOptReverter",
+    "ConstantDereferencesSimplifier",
+    "CrossJumpReverter",
+    "DeadblockRemover",
+    "DivSimplifier",
+    "DuplicationReverter",
     "ExprOpSwapper",
-    "ITERegionConverter",
+    "FlipBooleanCmp",
     "ITEExprConverter",
+    "ITERegionConverter",
+    "InlinedStringTransformationSimplifier",
     "LoweredSwitchSimplifier",
-    "DivSimplifier",
     "ModSimplifier",
-    "ReturnDuplicatorLow",
-    "ReturnDuplicatorHigh",
-    "ConstantDereferencesSimplifier",
+    "OptimizationPassStage",
     "RegisterSaveAreaSimplifier",
     "RetAddrSaveSimplifier",
-    "X86GccGetPcSimplifier",
-    "FlipBooleanCmp",
     "ReturnDeduplicator",
-    "WinStackCanarySimplifier",
-    "CrossJumpReverter",
-    "CodeMotionOptimization",
+    "ReturnDuplicatorHigh",
+    "ReturnDuplicatorLow",
+    "StackCanarySimplifier",
     "SwitchDefaultCaseDuplicator",
     "SwitchReusedEntryRewriter",
-    "DeadblockRemover",
-    "InlinedStringTransformationSimplifier",
-    "ConstPropOptReverter",
-    "CallStatementRewriter",
-    "DuplicationReverter",
     "TagSlicer",
-    "ALL_OPTIMIZATION_PASSES",
-    "DUPLICATING_OPTS",
-    "CONDENSING_OPTS",
+    "WinStackCanarySimplifier",
+    "X86GccGetPcSimplifier",
     "get_optimization_passes",
     "register_optimization_pass",
 )

angr/analyses/decompiler/optimization_passes/deadblock_remover.py

@@ -50,8 +50,7 @@ class DeadblockRemover(OptimizationPass):
         to_remove = {
             blk
             for blk in self._graph.nodes()
-            if blk.addr != self._func.addr
-            and self._graph.in_degree(blk) == 0
+            if (blk.addr != self._func.addr and self._graph.in_degree(blk) == 0)
             or claripy.is_false(cond_proc.reaching_conditions[blk])
         }
 

angr/analyses/decompiler/optimization_passes/duplication_reverter/duplication_reverter.py

@@ -242,11 +242,8 @@ class DuplicationReverter(StructuringOptimizationPass):
                     target_candidates = []
                     for mblock, oblocks in ail_merge_graph.merge_blocks_to_originals.items():
                         for oblock in oblocks:
-                            if (
-                                isinstance(oblock, AILBlockSplit)
-                                and oblock.original.addr == target_addr
-                                or isinstance(oblock, Block)
-                                and oblock.addr == target_addr
+                            if (isinstance(oblock, AILBlockSplit) and oblock.original.addr == target_addr) or (
+                                isinstance(oblock, Block) and oblock.addr == target_addr
                             ):
                                 target_candidates.append(mblock)
 
@@ -287,7 +284,9 @@ class DuplicationReverter(StructuringOptimizationPass):
                                 break
 
                         if new_target is None:
-                            raise RuntimeError("Unable to correct a predecessor, this is a bug!")
+                            _l.debug("Unable to correct a predecessor, this is a bug!")
+                            self.write_graph = self.read_graph.copy()
+                            return False
 
                     replacement_map[target_addr] = new_target.addr
                     self.write_graph.add_edge(orig_pred, new_target)
@@ -316,7 +315,9 @@ class DuplicationReverter(StructuringOptimizationPass):
                         break
 
                 if new_succ is None:
-                    raise RuntimeError("Unable to find the successor for block with no jump or condition!")
+                    _l.debug("Unable to find the successor for block with no jump or condition!")
+                    self.write_graph = self.read_graph.copy()
+                    return False
 
                 self.write_graph.add_edge(orig_pred, new_succ)
 

angr/analyses/decompiler/optimization_passes/duplication_reverter/utils.py

@@ -8,8 +8,8 @@ from ailment import Const
 from ailment.block import Block
 from ailment.statement import Statement, ConditionalJump, Jump
 
-from .errors import UnsupportedAILNodeError
 from angr.analyses.decompiler.structuring.structurer_nodes import IncompleteSwitchCaseHeadStatement
+from .errors import UnsupportedAILNodeError
 
 
 _l = logging.getLogger(name=__name__)
@@ -47,8 +47,6 @@ def replace_node_in_graph(graph: nx.DiGraph, node, replace_with):
         else:
             graph.add_edge(replace_with, dst)
 
-    assert node not in graph
-
 
 def bfs_list_blocks(start_block: Block, graph: nx.DiGraph):
     blocks = []

angr/analyses/decompiler/optimization_passes/engine_base.py

@@ -112,7 +112,7 @@ class SimplifierAILEngine(
         return stmt
 
     def _handle_stmt_Call(self, stmt):
-        target = self._expr(stmt.target)
+        target = self._expr(stmt.target) if isinstance(stmt.target, ailment.Expr.Expression) else stmt.target
 
         new_args = None
 

angr/analyses/decompiler/optimization_passes/inlined_string_transformation_simplifier.py

@@ -548,10 +548,8 @@ class InlinedStringTransformationSimplifier(OptimizationPass):
             if len(preds) == 2 and len(succs) == 2 and node in preds and node in succs:
                 pred = next(iter(nn for nn in preds if nn is not node))
                 succ = next(iter(nn for nn in succs if nn is not node))
-                if (
-                    self._graph.out_degree[pred] == 1
-                    and self._graph.in_degree[succ] == 1
-                    or self._graph.out_degree[pred] == 2
+                if (self._graph.out_degree[pred] == 1 and self._graph.in_degree[succ] == 1) or (
+                    self._graph.out_degree[pred] == 2
                     and self._graph.in_degree[succ] == 2
                     and self._graph.has_edge(pred, succ)
                 ):

angr/analyses/decompiler/optimization_passes/ite_region_converter.py

@@ -314,9 +314,6 @@ class ITERegionConverter(OptimizationPass):
 
     @staticmethod
     def _is_assigning_to_vvar(stmt: Statement) -> bool:
-        return (
-            isinstance(stmt, Assignment)
-            and isinstance(stmt.dst, VirtualVariable)
-            or isinstance(stmt, Call)
-            and isinstance(stmt.ret_expr, VirtualVariable)
+        return (isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable)) or (
+            isinstance(stmt, Call) and isinstance(stmt.ret_expr, VirtualVariable)
         )

angr/analyses/decompiler/optimization_passes/lowered_switch_simplifier.py

@@ -31,14 +31,14 @@ class Case:
     """
 
     __slots__ = (
-        "original_node",
-        "node_type",
-        "variable_hash",
         "expr",
-        "value",
+        "next_addr",
+        "node_type",
+        "original_node",
         "target",
         "target_idx",
-        "next_addr",
+        "value",
+        "variable_hash",
     )
 
     def __init__(

angr/analyses/decompiler/optimization_passes/mod_simplifier.py

@@ -40,10 +40,16 @@ class ModSimplifierAILEngine(SimplifierAILEngine):
                 x_1 = operand_0
                 c_0 = operand_1.operands[1]
                 c_1 = operand_1.operands[0].operand.operands[1]
-            else:
-                assert False, "Unreachable"
 
-            if x_0 is not None and x_1 is not None and x_0.likes(x_1) and c_0.value == c_1.value:
+            # pylint: disable=too-many-boolean-expressions
+            if (
+                x_0 is not None
+                and x_1 is not None
+                and c_0 is not None
+                and c_1 is not None
+                and x_0.likes(x_1)
+                and c_0.value == c_1.value
+            ):
                 return Expr.BinaryOp(expr.idx, "Mod", [x_0, c_0], expr.signed, **expr.tags)
 
         if (operand_0, operand_1) != (expr.operands[0], expr.operands[1]):

angr/analyses/decompiler/optimization_passes/optimization_pass.py

@@ -125,6 +125,7 @@ class OptimizationPass(BaseOptimizationPass):
         scratch: dict[str, Any] | None = None,
         force_loop_single_exit: bool = True,
         complete_successors: bool = False,
+        avoid_vvar_ids: set[int] | None = None,
         **kwargs,
     ):
         super().__init__(func)
@@ -143,6 +144,7 @@ class OptimizationPass(BaseOptimizationPass):
         )
         self._force_loop_single_exit = force_loop_single_exit
         self._complete_successors = complete_successors
+        self._avoid_vvar_ids = avoid_vvar_ids or set()
 
         # output
         self.out_graph: networkx.DiGraph | None = None
@@ -268,6 +270,7 @@ class OptimizationPass(BaseOptimizationPass):
                 func_graph=graph,
                 use_callee_saved_regs_at_return=False,
                 gp=self._func.info.get("gp", None) if self.project.arch.name in {"MIPS32", "MIPS64"} else None,
+                avoid_vvar_ids=self._avoid_vvar_ids,
             )
             if simp.simplified:
                 graph = simp.func_graph

angr/analyses/decompiler/optimization_passes/stack_canary_simplifier.py

@@ -231,7 +231,7 @@ class StackCanarySimplifier(OptimizationPass):
                     negated = False
                     condition = stmt.condition
                 if isinstance(condition, ailment.Expr.BinaryOp) and (
-                    not negated and condition.op == "CmpEQ" or negated and condition.op == "CmpNE"
+                    (not negated and condition.op == "CmpEQ") or (negated and condition.op == "CmpNE")
                 ):
                     pass
                 else:
@@ -255,8 +255,10 @@ class StackCanarySimplifier(OptimizationPass):
                             op0 = op0_v
 
                     if not (
-                        self._is_stack_canary_load_expr(op0, self.project.arch.bits, canary_value_stack_offset)
-                        and self._is_random_number_load_expr(op1, self.project.arch.get_register_offset("fs"))
+                        (
+                            self._is_stack_canary_load_expr(op0, self.project.arch.bits, canary_value_stack_offset)
+                            and self._is_random_number_load_expr(op1, self.project.arch.get_register_offset("fs"))
+                        )
                         or (
                             self._is_stack_canary_load_expr(op1, self.project.arch.bits, canary_value_stack_offset)
                             and self._is_random_number_load_expr(op0, self.project.arch.get_register_offset("fs"))
@@ -270,8 +272,10 @@ class StackCanarySimplifier(OptimizationPass):
                 ):
                     # a == b
                     if not (
-                        self._is_stack_canary_load_expr(expr0, self.project.arch.bits, canary_value_stack_offset)
-                        and self._is_random_number_load_expr(expr1, self.project.arch.get_register_offset("fs"))
+                        (
+                            self._is_stack_canary_load_expr(expr0, self.project.arch.bits, canary_value_stack_offset)
+                            and self._is_random_number_load_expr(expr1, self.project.arch.get_register_offset("fs"))
+                        )
                         or (
                             self._is_stack_canary_load_expr(expr1, self.project.arch.bits, canary_value_stack_offset)
                             and self._is_random_number_load_expr(expr0, self.project.arch.get_register_offset("fs"))

angr/analyses/decompiler/peephole_optimizations/__init__.py

@@ -111,7 +111,7 @@ EXPR_OPTS: list[type[PeepholeOptimizationExprBase]] = [
 ]
 
 __all__ = (
+    "EXPR_OPTS",
     "MULTI_STMT_OPTS",
     "STMT_OPTS",
-    "EXPR_OPTS",
 )

angr/analyses/decompiler/peephole_optimizations/base.py

@@ -12,9 +12,9 @@ class PeepholeOptimizationStmtBase:
     """
 
     __slots__ = (
-        "project",
-        "kb",
         "func_addr",
+        "kb",
+        "project",
     )
     project: Project | None
     kb: KnowledgeBase | None
@@ -39,9 +39,9 @@ class PeepholeOptimizationMultiStmtBase:
     """
 
     __slots__ = (
-        "project",
-        "kb",
         "func_addr",
+        "kb",
+        "project",
     )
     project: Project | None
     kb: KnowledgeBase | None
@@ -66,9 +66,9 @@ class PeepholeOptimizationExprBase:
     """
 
     __slots__ = (
-        "project",
-        "kb",
         "func_addr",
+        "kb",
+        "project",
     )
     project: Project | None
     kb: KnowledgeBase | None

angr/analyses/decompiler/peephole_optimizations/rewrite_bit_extractions.py

@@ -29,8 +29,8 @@ class RewriteBitExtractions(PeepholeOptimizationExprBase):
                 return ITE(
                     expr.idx,
                     bitoffset2exprs[bit_offset],
-                    Const(None, None, 1, expr.bits),
                     Const(None, None, 0, expr.bits),
+                    Const(None, None, 1, expr.bits),
                     **expr.tags,
                 )
 

angr/analyses/decompiler/presets/__init__.py

@@ -15,6 +15,6 @@ DECOMPILATION_PRESETS = {
 
 
 __all__ = (
-    "DecompilationPreset",
     "DECOMPILATION_PRESETS",
+    "DecompilationPreset",
 )

angr/analyses/decompiler/region_simplifiers/expr_folding.py

@@ -63,8 +63,8 @@ class ExpressionLocation(LocationBase):
     __slots__ = (
         "block_addr",
         "block_idx",
-        "stmt_idx",
         "expr_idx",
+        "stmt_idx",
     )
 
     def __init__(self, block_addr, block_idx, stmt_idx, expr_idx):
@@ -94,8 +94,8 @@ class ExpressionLocation(LocationBase):
 
 class ConditionLocation(LocationBase):
     __slots__ = (
-        "node_addr",
         "case_idx",
+        "node_addr",
     )
 
     def __init__(self, cond_node_addr, case_idx: int | None = None):
@@ -171,8 +171,8 @@ class ExpressionUseFinder(AILBlockWalker):
     """
 
     __slots__ = (
-        "uses",
         "has_load",
+        "uses",
     )
 
     def __init__(self):

angr/analyses/decompiler/region_simplifiers/switch_cluster_simplifier.py

@@ -39,11 +39,11 @@ class ConditionalRegion:
     """
 
     __slots__ = (
-        "variable",
-        "op",
-        "value",
         "node",
+        "op",
         "parent",
+        "value",
+        "variable",
     )
 
     def __init__(self, variable, op: CmpOp, value: int, node: ConditionNode | ailment.Block, parent=None):
@@ -63,9 +63,9 @@ class SwitchCaseRegion:
     """
 
     __slots__ = (
-        "variable",
         "node",
         "parent",
+        "variable",
     )
 
     def __init__(self, variable, node: SwitchCaseNode, parent=None):
@@ -195,18 +195,14 @@ def is_simple_jump_node(node, case_addrs, targets: set[int] | None = None) -> bo
                     targets.add(stmt.target.value)
             elif isinstance(stmt, ailment.Stmt.ConditionalJump):
                 ok = False
-                if (
-                    stmt.true_target is None
-                    or isinstance(stmt.true_target, ailment.Expr.Const)
-                    and stmt.true_target.value in case_addrs
+                if stmt.true_target is None or (
+                    isinstance(stmt.true_target, ailment.Expr.Const) and stmt.true_target.value in case_addrs
                 ):
                     ok = True
                     if stmt.true_target is not None and targets is not None:
                         targets.add(stmt.true_target.value)
-                if (
-                    stmt.false_target is None
-                    or isinstance(stmt.false_target, ailment.Expr.Const)
-                    and stmt.false_target.value in case_addrs
+                if stmt.false_target is None or (
+                    isinstance(stmt.false_target, ailment.Expr.Const) and stmt.false_target.value in case_addrs
                 ):
                     ok = True
                     if stmt.false_target is not None and targets is not None:

angr/analyses/decompiler/ssailification/rewriting_engine.py

@@ -362,8 +362,8 @@ class SimEngineSSARewriting(
             return ITE(
                 expr.idx,
                 expr.cond if new_cond is None else new_cond,
-                expr.iftrue if new_iftrue is None else new_iftrue,
                 expr.iffalse if new_iffalse is None else new_iffalse,
+                expr.iftrue if new_iftrue is None else new_iftrue,
                 **expr.tags,
             )
         return None

angr/analyses/decompiler/structured_codegen/__init__.py

@@ -14,12 +14,12 @@ from .dummy import DummyStructuredCodeGenerator
 
 __all__ = (
     "BaseStructuredCodeGenerator",
-    "InstructionMapping",
-    "InstructionMappingElement",
-    "PositionMappingElement",
-    "PositionMapping",
     "CStructuredCodeGenerator",
     "CStructuredCodeWalker",
-    "ImportSourceCode",
     "DummyStructuredCodeGenerator",
+    "ImportSourceCode",
+    "InstructionMapping",
+    "InstructionMappingElement",
+    "PositionMapping",
+    "PositionMappingElement",
 )

angr/analyses/decompiler/structured_codegen/base.py

@@ -9,7 +9,7 @@ from angr.sim_variable import SimVariable
 
 
 class PositionMappingElement:
-    __slots__ = ("start", "length", "obj")
+    __slots__ = ("length", "obj", "start")
 
     def __init__(self, start, length, obj):
         self.start: int = start
@@ -20,7 +20,7 @@ class PositionMappingElement:
         return self.start <= offset < self.start + self.length
 
     def __repr__(self):
-        return "<%d-%d: %s>" % (self.start, self.start + self.length, self.obj)
+        return f"<{self.start}-{self.start + self.length}: {self.obj}>"
 
 
 class PositionMapping:
@@ -79,7 +79,7 @@ class InstructionMappingElement:
         return self.ins_addr == offset
 
     def __repr__(self):
-        return "<%d: %d>" % (self.ins_addr, self.posmap_pos)
+        return f"<{self.ins_addr}: {self.posmap_pos}>"
 
 
 class InstructionMapping: