angr 9.2.127__py3-none-manylinux2014_aarch64.whl → 9.2.129__py3-none-manylinux2014_aarch64.whl

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.127"
+__version__ = "9.2.129"
 
 if bytes is str:
     raise Exception(

angr/analyses/decompiler/clinic.py

@@ -113,6 +113,8 @@ class Clinic(Analysis):
         vvar_id_start: int = 0,
         optimization_scratch: dict[str, Any] | None = None,
         desired_variables: set[str] | None = None,
+        force_loop_single_exit: bool = True,
+        complete_successors: bool = False,
     ):
         if not func.normalized and mode == ClinicMode.DECOMPILE:
             raise ValueError("Decompilation must work on normalized function graphs.")
@@ -157,6 +159,8 @@ class Clinic(Analysis):
         self._inlined_counts = {} if inlined_counts is None else inlined_counts
         self._inlining_parents = inlining_parents or ()
         self._desired_variables = desired_variables
+        self._force_loop_single_exit = force_loop_single_exit
+        self._complete_successors = complete_successors
 
         self._register_save_areas_removed: bool = False
 
@@ -333,6 +337,7 @@ class Clinic(Analysis):
             optimization_passes=[StackCanarySimplifier],
             sp_shift=self._max_stack_depth,
             vvar_id_start=self.vvar_id_start,
+            fail_fast=self._fail_fast,
         )
         self.vvar_id_start = callee_clinic.vvar_id_start + 1
         self._max_stack_depth = callee_clinic._max_stack_depth
@@ -787,7 +792,7 @@ class Clinic(Analysis):
 
             # case 2: the callee is a SimProcedure
             if target_func.is_simprocedure:
-                cc = self.project.analyses.CallingConvention(target_func)
+                cc = self.project.analyses.CallingConvention(target_func, fail_fast=self._fail_fast)
                 if cc.cc is not None and cc.prototype is not None:
                     target_func.calling_convention = cc.cc
                     target_func.prototype = cc.prototype
@@ -795,7 +800,7 @@ class Clinic(Analysis):
 
             # case 3: the callee is a PLT function
             if target_func.is_plt:
-                cc = self.project.analyses.CallingConvention(target_func)
+                cc = self.project.analyses.CallingConvention(target_func, fail_fast=self._fail_fast)
                 if cc.cc is not None and cc.prototype is not None:
                     target_func.calling_convention = cc.cc
                     target_func.prototype = cc.prototype
@@ -834,6 +839,7 @@ class Clinic(Analysis):
                     callsite_block_addr=callsite.addr,
                     callsite_insn_addr=callsite_ins_addr,
                     func_graph=func_graph,
+                    fail_fast=self._fail_fast,
                 )
 
                 if cc.cc is not None and cc.prototype is not None:
@@ -864,6 +870,7 @@ class Clinic(Analysis):
         # finally, recover the calling convention of the current function
         if self.function.prototype is None or self.function.calling_convention is None:
             self.project.analyses.CompleteCallingConventions(
+                fail_fast=self._fail_fast,
                 recover_variables=True,
                 prioritize_func_addrs=[self.function.addr],
                 skip_other_funcs=True,
@@ -896,6 +903,7 @@ class Clinic(Analysis):
         spt = self.project.analyses.StackPointerTracker(
             self.function,
             regs,
+            fail_fast=self._fail_fast,
             track_memory=self._sp_tracker_track_memory,
             cross_insn_opt=False,
             initial_reg_values=initial_reg_values,
@@ -1130,6 +1138,7 @@ class Clinic(Analysis):
         simp = self.project.analyses.AILBlockSimplifier(
             ail_block,
             self.function.addr,
+            fail_fast=self._fail_fast,
             remove_dead_memdefs=remove_dead_memdefs,
             stack_pointer_tracker=stack_pointer_tracker,
             peephole_optimizations=self.peephole_optimizations,
@@ -1201,6 +1210,7 @@ class Clinic(Analysis):
 
         simp = self.project.analyses.AILSimplifier(
             self.function,
+            fail_fast=self._fail_fast,
             func_graph=ail_graph,
             remove_dead_memdefs=remove_dead_memdefs,
             unify_variables=unify_variables,
@@ -1259,6 +1269,8 @@ class Clinic(Analysis):
                 vvar_id_start=self.vvar_id_start,
                 entry_node_addr=self.entry_node_addr,
                 scratch=self.optimization_scratch,
+                force_loop_single_exit=self._force_loop_single_exit,
+                complete_successors=self._complete_successors,
                 **kwargs,
             )
             if a.out_graph:
@@ -1342,6 +1354,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
+            fail_fast=self._fail_fast,
             entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_stackvars=False,
@@ -1355,6 +1368,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
+            fail_fast=self._fail_fast,
             entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_tmps=True,
@@ -1369,6 +1383,7 @@ class Clinic(Analysis):
         dephication = self.project.analyses.GraphDephicationVVarMapping(
             self.function,
             ail_graph,
+            fail_fast=self._fail_fast,
             entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             vvar_id_start=self.vvar_id_start,
         )
@@ -1421,6 +1436,7 @@ class Clinic(Analysis):
         rd = self.project.analyses.SReachingDefinitions(
             subject=self.function,
             func_graph=ail_graph,
+            fail_fast=self._fail_fast,
             # use_callee_saved_regs_at_return=not self._register_save_areas_removed,  FIXME
         )
 
@@ -1431,6 +1447,7 @@ class Clinic(Analysis):
         def _handler(block):
             csm = self.project.analyses.AILCallSiteMaker(
                 block,
+                fail_fast=self._fail_fast,
                 reaching_definitions=rd,
                 stack_pointer_tracker=stack_pointer_tracker,
                 ail_manager=self._ail_manager,
@@ -1444,6 +1461,7 @@ class Clinic(Analysis):
                 simp = self.project.analyses.AILBlockSimplifier(
                     ail_block,
                     self.function.addr,
+                    fail_fast=self._fail_fast,
                     stack_pointer_tracker=stack_pointer_tracker,
                     peephole_optimizations=self.peephole_optimizations,
                 )
@@ -1527,6 +1545,7 @@ class Clinic(Analysis):
         tmp_kb.functions = self.kb.functions
         vr = self.project.analyses.VariableRecoveryFast(
             self.function,  # pylint:disable=unused-variable
+            fail_fast=self._fail_fast,
             func_graph=ail_graph,
             kb=tmp_kb,
             track_sp=False,
@@ -1559,6 +1578,7 @@ class Clinic(Analysis):
                 vr.type_constraints,
                 vr.func_typevar,
                 kb=tmp_kb,
+                fail_fast=self._fail_fast,
                 var_mapping=vr.var_to_typevars,
                 must_struct=must_struct,
                 ground_truth=groundtruth,

angr/analyses/decompiler/decompiler.py

@@ -235,6 +235,7 @@ class Decompiler(Analysis):
             clinic = self.project.analyses.Clinic(
                 self.func,
                 kb=self.kb,
+                fail_fast=self._fail_fast,
                 variable_kb=variable_kb,
                 reset_variable_names=reset_variable_names,
                 optimization_passes=self._optimization_passes,
@@ -248,6 +249,8 @@ class Decompiler(Analysis):
                 inline_functions=self._inline_functions,
                 desired_variables=self._desired_variables,
                 optimization_scratch=self._optimization_scratch,
+                force_loop_single_exit=self._force_loop_single_exit,
+                complete_successors=self._complete_successors,
                 **self.options_to_params(self.options_by_class["clinic"]),
             )
         else:
@@ -308,7 +311,7 @@ class Decompiler(Analysis):
             self._update_progress(75.0, text="Structuring code")
 
             # structure it
-            rs = self.project.analyses[RecursiveStructurer].prep(kb=self.kb)(
+            rs = self.project.analyses[RecursiveStructurer].prep(kb=self.kb, fail_fast=self._fail_fast)(
                 ri.region,
                 cond_proc=cond_proc,
                 func=self.func,
@@ -321,6 +324,7 @@ class Decompiler(Analysis):
                 self.func,
                 rs.result,
                 kb=self.kb,
+                fail_fast=self._fail_fast,
                 variable_kb=clinic.variable_kb,
                 **self.options_to_params(self.options_by_class["region_simplifier"]),
             )
@@ -345,6 +349,7 @@ class Decompiler(Analysis):
                 flavor=self._flavor,
                 func_args=clinic.arg_list,
                 kb=self.kb,
+                fail_fast=self._fail_fast,
                 variable_kb=clinic.variable_kb,
                 expr_comments=old_codegen.expr_comments if old_codegen is not None else None,
                 stmt_comments=old_codegen.stmt_comments if old_codegen is not None else None,
@@ -365,7 +370,7 @@ class Decompiler(Analysis):
         self.kb.decompilations[(self.func.addr, self._flavor)] = self.cache
 
     def _recover_regions(self, graph: networkx.DiGraph, condition_processor, update_graph: bool = True):
-        return self.project.analyses[RegionIdentifier].prep(kb=self.kb)(
+        return self.project.analyses[RegionIdentifier].prep(kb=self.kb, fail_fast=self._fail_fast)(
             self.func,
             graph=graph,
             cond_proc=condition_processor,
@@ -418,6 +423,8 @@ class Decompiler(Analysis):
                 reaching_definitions=reaching_definitions,
                 entry_node_addr=self.clinic.entry_node_addr,
                 scratch=self._optimization_scratch,
+                force_loop_single_exit=self._force_loop_single_exit,
+                complete_successors=self._complete_successors,
                 **kwargs,
             )
 
@@ -478,6 +485,8 @@ class Decompiler(Analysis):
                 vvar_id_start=self.vvar_id_start,
                 entry_node_addr=self.clinic.entry_node_addr,
                 scratch=self._optimization_scratch,
+                force_loop_single_exit=self._force_loop_single_exit,
+                complete_successors=self._complete_successors,
                 **kwargs,
             )
 
@@ -561,6 +570,7 @@ class Decompiler(Analysis):
                 type_constraints,
                 func_typevar,
                 kb=var_kb,
+                fail_fast=self._fail_fast,
                 var_mapping=var_to_typevar,
                 must_struct=must_struct,
                 ground_truth=groundtruth,
@@ -628,11 +638,15 @@ class Decompiler(Analysis):
         )
 
     def _transform_graph_from_ssa(self, ail_graph: networkx.DiGraph) -> networkx.DiGraph:
-        dephication = self.project.analyses.GraphDephication(self.func, ail_graph, rewrite=True)
+        dephication = self.project.analyses.GraphDephication(
+            self.func, ail_graph, rewrite=True, kb=self.kb, fail_fast=self._fail_fast
+        )
         return dephication.output
 
     def _transform_seqnode_from_ssa(self, seq_node: SequenceNode) -> SequenceNode:
-        dephication = self.project.analyses.SeqNodeDephication(self.func, seq_node, rewrite=True)
+        dephication = self.project.analyses.SeqNodeDephication(
+            self.func, seq_node, rewrite=True, kb=self.kb, fail_fast=self._fail_fast
+        )
         return dephication.output
 
     @staticmethod

angr/analyses/decompiler/graph_region.py

@@ -382,12 +382,9 @@ class GraphRegion:
                         if src in graph:
                             graph.add_edge(src, dst)
                 else:
-                    # it may happen that the dst node does not exist in sub_graph
-                    # fallback
-                    l.info("Node dst is not found in sub_graph. Enter the fall back logic.")
-                    for src in sub_graph.nodes:
-                        if sub_graph.out_degree[src] == 0:
-                            graph.add_edge(src, dst)
+                    # it may happen that the dst node no longer exists in sub_graph or its successors
+                    # this is because we have deemed that the dst node is no longer a valid successor for sub_graph
+                    pass
 
         graph.add_nodes_from(sub_graph_nodes)
         graph.add_edges_from(sub_graph_edges)

angr/analyses/decompiler/label_collector.py

@@ -0,0 +1,32 @@
+# pylint:disable=unused-argument
+from __future__ import annotations
+from collections import defaultdict
+
+import ailment
+
+from .sequence_walker import SequenceWalker
+
+
+class LabelCollector:
+    """
+    Collect all labels.
+    """
+
+    def __init__(self, node):
+        self.root = node
+        self.labels: defaultdict[str, list[tuple[int, int | None]]] = defaultdict(list)
+
+        handlers = {
+            ailment.Block: self._handle_Block,
+        }
+        self._walker = SequenceWalker(handlers=handlers)
+        self._walker.walk(self.root)
+
+    #
+    # Handlers
+    #
+
+    def _handle_Block(self, block: ailment.Block, **kwargs):
+        for stmt in block.statements:
+            if isinstance(stmt, ailment.Stmt.Label):
+                self.labels[stmt.name].append((block.addr, block.idx))

angr/analyses/decompiler/optimization_passes/__init__.py

@@ -32,6 +32,7 @@ from .inlined_string_transformation_simplifier import InlinedStringTransformatio
 from .const_prop_reverter import ConstPropOptReverter
 from .call_stmt_rewriter import CallStatementRewriter
 from .duplication_reverter import DuplicationReverter
+from .switch_reused_entry_rewriter import SwitchReusedEntryRewriter
 
 if TYPE_CHECKING:
     from angr.analyses.decompiler.presets import DecompilationPreset
@@ -55,6 +56,7 @@ ALL_OPTIMIZATION_PASSES = [
     ReturnDuplicatorHigh,
     DeadblockRemover,
     SwitchDefaultCaseDuplicator,
+    SwitchReusedEntryRewriter,
     ConstPropOptReverter,
     DuplicationReverter,
     LoweredSwitchSimplifier,
@@ -129,6 +131,7 @@ __all__ = (
     "CrossJumpReverter",
     "CodeMotionOptimization",
     "SwitchDefaultCaseDuplicator",
+    "SwitchReusedEntryRewriter",
     "DeadblockRemover",
     "InlinedStringTransformationSimplifier",
     "ConstPropOptReverter",

angr/analyses/decompiler/optimization_passes/optimization_pass.py

@@ -118,6 +118,8 @@ class OptimizationPass(BaseOptimizationPass):
         vvar_id_start=None,
         entry_node_addr=None,
         scratch: dict[str, Any] | None = None,
+        force_loop_single_exit: bool = True,
+        complete_successors: bool = False,
         **kwargs,
     ):
         super().__init__(func)
@@ -134,6 +136,8 @@ class OptimizationPass(BaseOptimizationPass):
         self.entry_node_addr: tuple[int, int | None] = (
             entry_node_addr if entry_node_addr is not None else (func.addr, None)
         )
+        self._force_loop_single_exit = force_loop_single_exit
+        self._complete_successors = complete_successors
 
         # output
         self.out_graph: networkx.DiGraph | None = None
@@ -255,9 +259,8 @@ class OptimizationPass(BaseOptimizationPass):
             graph=graph,
             cond_proc=condition_processor or ConditionProcessor(self.project.arch),
             update_graph=update_graph,
-            # TODO: find a way to pass Phoenix/DREAM options here (see decompiler.py for correct use)
-            force_loop_single_exit=True,
-            complete_successors=False,
+            force_loop_single_exit=self._force_loop_single_exit,
+            complete_successors=self._complete_successors,
             entry_node_addr=self.entry_node_addr,
         )
 

angr/analyses/decompiler/optimization_passes/switch_default_case_duplicator.py

@@ -1,10 +1,15 @@
 # pylint:disable=too-many-boolean-expressions
 from __future__ import annotations
 from itertools import count
+from collections import defaultdict
 import logging
 
 import networkx
 
+from ailment.block import Block
+from ailment.statement import Jump
+from ailment.expression import Const
+
 from angr.knowledge_plugins.cfg import IndirectJumpType
 from .optimization_pass import OptimizationPass, OptimizationPassStage
 
@@ -29,17 +34,19 @@ class SwitchDefaultCaseDuplicator(OptimizationPass):
 
     ARCHES = None
     PLATFORMS = None
-    STAGE = OptimizationPassStage.BEFORE_REGION_IDENTIFICATION
+    STAGE = OptimizationPassStage.AFTER_AIL_GRAPH_CREATION
     NAME = "Duplicate default-case nodes to undo default-case node reuse caused by compiler code deduplication"
     DESCRIPTION = __doc__.strip()
 
     def __init__(self, func, **kwargs):
         super().__init__(func, **kwargs)
 
-        self.node_idx = count(start=0)
+        self.node_idx = count(start=self._scratch.get("node_idx", 0))
 
         self.analyze()
 
+        self._scratch["node_idx"] = next(self.node_idx)
+
     def _check(self):
         jumptables = self.kb.cfgs.get_most_accurate().jump_tables
         switch_jump_block_addrs = {
@@ -77,8 +84,39 @@ class SwitchDefaultCaseDuplicator(OptimizationPass):
         out_graph = None
         duplicated_default_addrs: set[int] = set()
 
+        default_addr_count = defaultdict(int)
+        goto_rewritten_default_addrs = set()
+        for _, _, default_addr in default_case_node_addrs:
+            default_addr_count[default_addr] += 1
+        for default_addr, cnt in default_addr_count.items():
+            if cnt > 1:
+                # rewrite all of them into gotos
+                default_node = self._get_block(default_addr)
+                for switch_head_addr in sorted((sa for sa, _, da in default_case_node_addrs if da == default_addr)):
+                    switch_head_node = self._get_block(switch_head_addr)
+                    goto_stmt = Jump(
+                        None,
+                        Const(None, None, default_addr, self.project.arch.bits, ins_addr=default_addr),
+                        target_idx=None,  # I'm assuming the ID of the default node is None here
+                        ins_addr=default_addr,
+                    )
+                    goto_node = Block(
+                        default_addr,
+                        0,
+                        statements=[goto_stmt],
+                        idx=next(self.node_idx),
+                    )
+
+                    if out_graph is None:
+                        out_graph = self._graph
+                    out_graph.remove_edge(switch_head_node, default_node)
+                    out_graph.add_edge(switch_head_node, goto_node)
+                    out_graph.add_edge(goto_node, default_node)
+
+                goto_rewritten_default_addrs.add(default_addr)
+
         for switch_head_addr, jump_node_addr, default_addr in default_case_node_addrs:
-            if default_addr in duplicated_default_addrs:
+            if default_addr in duplicated_default_addrs or default_addr in goto_rewritten_default_addrs:
                 continue
 
             default_case_node = self._func.get_node(default_addr)

angr/analyses/decompiler/optimization_passes/switch_reused_entry_rewriter.py

@@ -0,0 +1,102 @@
+# pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
+from itertools import count
+import logging
+
+from ailment.block import Block
+from ailment.statement import Jump
+from ailment.expression import Const
+
+from angr.knowledge_plugins.cfg import IndirectJumpType
+
+from .optimization_pass import OptimizationPass, OptimizationPassStage
+
+
+_l = logging.getLogger(name=__name__)
+
+
+class SwitchReusedEntryRewriter(OptimizationPass):
+    """
+    For each switch-case construct (identified by jump tables), rewrite the entry into a goto block when we detect
+    situations where an entry node is reused by edges in switch-case constructs that are not the current one. This code
+    reuse is usually caused by compiler code deduplication.
+    """
+
+    ARCHES = None
+    PLATFORMS = None
+    STAGE = OptimizationPassStage.AFTER_AIL_GRAPH_CREATION
+    NAME = "Rewrite switch-case entry nodes with multiple predecessors into goto statements."
+    DESCRIPTION = __doc__.strip()
+
+    def __init__(self, func, **kwargs):
+        super().__init__(func, **kwargs)
+
+        self.node_idx = count(start=self._scratch.get("node_idx", 0))
+
+        self.analyze()
+
+        self._scratch["node_idx"] = next(self.node_idx)
+
+    def _check(self):
+        jumptables = self.kb.cfgs.get_most_accurate().jump_tables
+        switch_jump_block_addrs = {
+            jumptable.addr
+            for jumptable in jumptables.values()
+            if jumptable.type
+            in {IndirectJumpType.Jumptable_AddressComputed, IndirectJumpType.Jumptable_AddressLoadedFromMemory}
+        }
+        jump_node_addrs = self._func.block_addrs_set.intersection(switch_jump_block_addrs)
+        if not jump_node_addrs:
+            return False, None
+
+        # ensure each jump table entry node has only one predecessor
+        reused_entries: dict[Block, set[Block]] = {}
+        for jumptable in jumptables.values():
+            for entry_addr in sorted(set(jumptable.jumptable_entries)):
+                entry_nodes = self._get_blocks(entry_addr)
+                for entry_node in entry_nodes:
+                    preds = list(self._graph.predecessors(entry_node))
+                    if len(preds) > 1:
+                        non_current_jumptable_preds = [pred for pred in preds if pred.addr != jumptable.addr]
+                        if any(p.addr in switch_jump_block_addrs for p in non_current_jumptable_preds):
+                            reused_entries[entry_node] = {
+                                pred for pred in preds if pred.addr in switch_jump_block_addrs
+                            }
+
+        if not reused_entries:
+            return False, None
+        cache = {"reused_entries": reused_entries}
+        return True, cache
+
+    def _analyze(self, cache=None):
+
+        reused_entries: dict[Block, set[Block]] = cache["reused_entries"]
+        out_graph = None
+
+        for entry_node, pred_nodes in reused_entries.items():
+            # we assign the entry node to the predecessor with the lowest address
+            sorted_pred_nodes = sorted(pred_nodes, key=lambda x: (x.addr, x.idx))
+
+            for head_node in sorted_pred_nodes[1:]:
+
+                # create the new goto node
+                goto_stmt = Jump(
+                    None,
+                    Const(None, None, entry_node.addr, self.project.arch.bits, ins_addr=entry_node.addr),
+                    target_idx=entry_node.idx,
+                    ins_addr=entry_node.addr,
+                )
+                goto_node = Block(
+                    entry_node.addr,
+                    0,
+                    statements=[goto_stmt],
+                    idx=next(self.node_idx),
+                )
+
+                if out_graph is None:
+                    out_graph = self._graph
+                out_graph.remove_edge(head_node, entry_node)
+                out_graph.add_edge(head_node, goto_node)
+                # we are virtualizing these edges, so we don't need to add the edge from goto_node to the entry_node
+
+        self.out_graph = out_graph

angr/analyses/decompiler/presets/basic.py

@@ -9,6 +9,7 @@ from angr.analyses.decompiler.optimization_passes import (
     RetAddrSaveSimplifier,
     X86GccGetPcSimplifier,
     CallStatementRewriter,
+    SwitchReusedEntryRewriter,
 )
 
 
@@ -23,6 +24,7 @@ preset_basic = DecompilationPreset(
         RetAddrSaveSimplifier,
         X86GccGetPcSimplifier,
         CallStatementRewriter,
+        SwitchReusedEntryRewriter,
     ],
 )
 

angr/analyses/decompiler/presets/fast.py

@@ -21,6 +21,7 @@ from angr.analyses.decompiler.optimization_passes import (
     CallStatementRewriter,
     MultiSimplifier,
     DeadblockRemover,
+    SwitchReusedEntryRewriter,
 )
 
 
@@ -41,6 +42,7 @@ preset_fast = DecompilationPreset(
         ReturnDuplicatorHigh,
         DeadblockRemover,
         SwitchDefaultCaseDuplicator,
+        SwitchReusedEntryRewriter,
         LoweredSwitchSimplifier,
         ReturnDuplicatorLow,
         ReturnDeduplicator,

angr/analyses/decompiler/presets/full.py

@@ -26,6 +26,7 @@ from angr.analyses.decompiler.optimization_passes import (
     FlipBooleanCmp,
     InlinedStringTransformationSimplifier,
     CallStatementRewriter,
+    SwitchReusedEntryRewriter,
 )
 
 
@@ -57,6 +58,7 @@ preset_full = DecompilationPreset(
         FlipBooleanCmp,
         InlinedStringTransformationSimplifier,
         CallStatementRewriter,
+        SwitchReusedEntryRewriter,
     ],
 )
 

angr/analyses/decompiler/region_identifier.py

@@ -532,7 +532,7 @@ class RegionIdentifier(Analysis):
         )
         if len(region.successors) > 1 and self._force_loop_single_exit:
             # multi-successor region. refinement is required
-            self._refine_loop_successors(region, graph)
+            self._refine_loop_successors_to_guarded_successors(region, graph)
 
         # if the head node is in the graph and it's not the head of the graph, we will need to update the head node
         # address.
@@ -543,10 +543,10 @@ class RegionIdentifier(Analysis):
 
         return region
 
-    def _refine_loop_successors(self, region, graph: networkx.DiGraph):
+    def _refine_loop_successors_to_guarded_successors(self, region, graph: networkx.DiGraph):
         """
-        If there are multiple successors of a loop, convert them into conditional gotos. Eventually there should be
-        only one loop successor.
+        If there are multiple successors of a loop, convert them into guarded successors. Eventually there should be
+        only one loop successor. This is used in the DREAM structuring algorithm.
 
         :param GraphRegion region:      The cyclic region to refine.
         :param networkx.DiGraph graph:  The current graph that is being structured.
@@ -565,11 +565,11 @@ class RegionIdentifier(Analysis):
         cond = ConditionNode(
             condnode_addr,
             None,
-            self.cond_proc.reaching_conditions[successors[0]],
-            successors[0],
-            false_node=None,
+            self.cond_proc.reaching_conditions[successors[1]],
+            successors[1],
+            false_node=successors[0],
         )
-        for succ in successors[1:]:
+        for succ in successors[2:]:
             cond = ConditionNode(
                 condnode_addr,
                 None,

angr/analyses/decompiler/structuring/phoenix.py

@@ -127,6 +127,8 @@ class PhoenixStructurer(StructurerBase):
     @staticmethod
     def _assert_graph_ok(g, msg: str) -> None:
         if _DEBUG:
+            if g is None:
+                return
             assert (
                 len(list(networkx.connected_components(networkx.Graph(g)))) <= 1
             ), f"{msg}: More than one connected component. Please report this."
@@ -229,7 +231,8 @@ class PhoenixStructurer(StructurerBase):
             )
             l.debug("... matching cyclic schemas: %s at %r", matched, node)
             any_matches |= matched
-            self._assert_graph_ok(self._region.graph, "Removed incorrect edges")
+            if matched:
+                self._assert_graph_ok(self._region.graph, "Removed incorrect edges")
         return any_matches
 
     def _match_cyclic_schemas(self, node, head, graph, full_graph) -> bool:
@@ -559,9 +562,12 @@ class PhoenixStructurer(StructurerBase):
         seq_node = SequenceNode(node.addr, nodes=[node])
         seen_nodes = set()
         while True:
-            succs = list(full_graph.successors(next_node))
+            succs = list(graph.successors(next_node))
             if len(succs) != 1:
                 return False, None
+            if full_graph.out_degree[next_node] > 1:
+                # all successors in the full graph should have been refined away at this point
+                return False, None
             next_node = succs[0]
 
             if next_node is node:
@@ -600,6 +606,8 @@ class PhoenixStructurer(StructurerBase):
             refined = self._refine_cyclic_core(head)
             l.debug("... refined: %s", refined)
             if refined:
+                self._assert_graph_ok(self._region.graph, "Refinement went wrong")
+                # cyclic refinement may create dangling nodes in the full graph
                 return True
         return False
 
@@ -1020,7 +1028,9 @@ class PhoenixStructurer(StructurerBase):
                 any_matches |= matched
                 if matched:
                     break
-            self._assert_graph_ok(self._region.graph, "Removed incorrect edges")
+
+        self._assert_graph_ok(self._region.graph, "Removed incorrect edges")
+
         return any_matches
 
     # switch cases
@@ -1094,7 +1104,7 @@ class PhoenixStructurer(StructurerBase):
             to_remove,
             graph,
             full_graph,
-            can_bail=True,
+            bail_on_nonhead_outedges=True,
         )
         if not r:
             return False
@@ -1161,18 +1171,18 @@ class PhoenixStructurer(StructurerBase):
             node_pred = next(iter(graph.predecessors(node)))
 
         case_nodes = list(graph.successors(node_a))
-        case_node_successors = set()
-        for case_node in case_nodes:
-            if case_node is node_pred:
-                continue
-            if case_node.addr in jump_table.jumptable_entries:
-                succs = set(graph.successors(case_node))
-                case_node_successors |= {succ for succ in succs if succ.addr not in jump_table.jumptable_entries}
-        if len(case_node_successors) > 1:
-            return False
 
-        # we will definitely be able to structure this into a full switch-case. remove node from switch_case_known_heads
-        self.switch_case_known_heads.remove(node)
+        # case 1: the common successor happens to be directly reachable from node_a (usually as a result of compiler
+        # optimization)
+        # example: touch_touch_no_switch.o:main
+        r = self.switch_case_entry_node_has_common_successor_case_1(graph, jump_table, case_nodes, node_pred)
+
+        # case 2: the common successor is not directly reachable from node_a. this is a more common case.
+        if not r:
+            r |= self.switch_case_entry_node_has_common_successor_case_2(graph, jump_table, case_nodes, node_pred)
+
+        if not r:
+            return False
 
         # un-structure IncompleteSwitchCaseNode
         if isinstance(node_a, SequenceNode) and node_a.nodes and isinstance(node_a.nodes[0], IncompleteSwitchCaseNode):
@@ -1186,8 +1196,10 @@ class PhoenixStructurer(StructurerBase):
             # update node_a
             node_a = next(iter(nn for nn in graph.nodes if nn.addr == target))
 
+        case_and_entry_addrs = self._find_case_and_entry_addrs(node_a, graph, cmp_lb, jump_table)
+
         cases, node_default, to_remove = self._switch_build_cases(
-            {cmp_lb + i: entry_addr for (i, entry_addr) in enumerate(jump_table.jumptable_entries)},
+            case_and_entry_addrs,
             node,
             node_a,
             node_b_addr,
@@ -1203,7 +1215,7 @@ class PhoenixStructurer(StructurerBase):
             to_remove.add(node_default)
 
         to_remove.add(node_a)  # add node_a
-        self._make_switch_cases_core(
+        r = self._make_switch_cases_core(
             node,
             cmp_expr,
             cases,
@@ -1215,7 +1227,11 @@ class PhoenixStructurer(StructurerBase):
             full_graph,
             node_a=node_a,
         )
+        if not r:
+            return False
 
+        # fully structured into a switch-case. remove node from switch_case_known_heads
+        self.switch_case_known_heads.remove(node)
         self._switch_handle_gotos(cases, node_default, switch_end_addr)
 
         return True
@@ -1253,8 +1269,10 @@ class PhoenixStructurer(StructurerBase):
         else:
             return False
 
+        case_and_entry_addrs = self._find_case_and_entry_addrs(node, graph, cmp_lb, jump_table)
+
         cases, node_default, to_remove = self._switch_build_cases(
-            {cmp_lb + i: entry_addr for (i, entry_addr) in enumerate(jump_table.jumptable_entries)},
+            case_and_entry_addrs,
             node,
             node,
             default_addr,
@@ -1265,12 +1283,10 @@ class PhoenixStructurer(StructurerBase):
             # there must be a default case
             return False
 
-        self._make_switch_cases_core(
+        return self._make_switch_cases_core(
             node, cmp_expr, cases, default_addr, node_default, node.addr, to_remove, graph, full_graph
         )
 
-        return True
-
     def _match_acyclic_incomplete_switch_cases(
         self, node, graph: networkx.DiGraph, full_graph: networkx.DiGraph, jump_tables: dict
     ) -> bool:
@@ -1322,14 +1338,9 @@ class PhoenixStructurer(StructurerBase):
         # and a case node (addr.b). The addr.a node is a successor to the head node while the addr.b node is a
         # successor to node_a
         default_node_candidates = [nn for nn in graph.nodes if nn.addr == node_b_addr]
-        if len(default_node_candidates) == 0:
-            node_default: BaseNode | None = None
-        elif len(default_node_candidates) == 1:
-            node_default: BaseNode | None = default_node_candidates[0]
-        else:
-            node_default: BaseNode | None = next(
-                iter(nn for nn in default_node_candidates if graph.has_edge(head_node, nn)), None
-            )
+        node_default: BaseNode | None = next(
+            iter(nn for nn in default_node_candidates if graph.has_edge(head_node, nn)), None
+        )
 
         if node_default is not None and not isinstance(node_default, SequenceNode):
             # make the default node a SequenceNode so that we can insert Break and Continue nodes into it later
@@ -1432,7 +1443,7 @@ class PhoenixStructurer(StructurerBase):
         graph: networkx.DiGraph,
         full_graph: networkx.DiGraph,
         node_a=None,
-        can_bail=False,
+        bail_on_nonhead_outedges: bool = False,
     ) -> bool:
         scnode = SwitchCaseNode(cmp_expr, cases, node_default, addr=addr)
 
@@ -1454,14 +1465,24 @@ class PhoenixStructurer(StructurerBase):
                 if dst not in to_remove:
                     out_edges.append((nn, dst))
 
-        if can_bail:
+        if bail_on_nonhead_outedges:
             nonhead_out_nodes = {edge[1] for edge in out_edges if edge[1] is not head}
             if len(nonhead_out_nodes) > 1:
                 # not ready to be structured yet - do it later
                 return False
 
+        # check if structuring will create any dangling nodes
+        for case_node in to_remove:
+            if case_node is not node_default and case_node is not node_a and case_node is not head:
+                for succ in graph.successors(case_node):
+                    if succ is not case_node and succ is not head and graph.in_degree[succ] == 1:
+                        # succ will be dangling - not ready to be structured yet - do it later
+                        return False
+
         if node_default is not None:
             # the head no longer goes to the default case
+            if graph.has_edge(head, node_default):
+                pass
             graph.remove_edge(head, node_default)
             full_graph.remove_edge(head, node_default)
         else:
@@ -1505,6 +1526,13 @@ class PhoenixStructurer(StructurerBase):
                 if full_graph.has_edge(head, out_dst):
                     full_graph.remove_edge(head, out_dst)
 
+                # fix full_graph if needed: remove successors that are no longer needed
+                for out_src, out_dst in out_edges[1:]:
+                    if out_dst in full_graph and out_dst not in graph and full_graph.in_degree[out_dst] == 0:
+                        full_graph.remove_node(out_dst)
+                        if out_dst in self._region.successors:
+                            self._region.successors.remove(out_dst)
+
         # remove the last statement (conditional jump) in the head node
         remove_last_statement(head)
 
@@ -1514,6 +1542,25 @@ class PhoenixStructurer(StructurerBase):
 
         return True
 
+    @staticmethod
+    def _find_case_and_entry_addrs(
+        jump_head, graph, cmp_lb: int, jump_table
+    ) -> dict[int, int | tuple[int, int | None]]:
+        case_and_entry_addrs = {}
+
+        addr_to_entry_nodes = defaultdict(list)
+        for succ in graph.successors(jump_head):
+            addr_to_entry_nodes[succ.addr].append(succ)
+
+        for i, entry_addr in enumerate(jump_table.jumptable_entries):
+            case_no = cmp_lb + i
+            if entry_addr in addr_to_entry_nodes and isinstance(addr_to_entry_nodes[entry_addr][0], (MultiNode, Block)):
+                case_and_entry_addrs[case_no] = entry_addr, addr_to_entry_nodes[entry_addr][0].idx
+            else:
+                case_and_entry_addrs[case_no] = entry_addr
+
+        return case_and_entry_addrs
+
     # other acyclic schemas
 
     def _match_acyclic_sequence(self, graph, full_graph, start_node) -> bool:
@@ -1982,6 +2029,11 @@ class PhoenixStructurer(StructurerBase):
 
             if full_graph.in_degree[left] > 1 and full_graph.in_degree[right] == 1:
                 left, right = right, left
+
+            # ensure left and right nodes are not the head of a switch-case construct
+            if left in self.switch_case_known_heads or right in self.switch_case_known_heads:
+                return None
+
             if (
                 self._is_sequential_statement_block(left)
                 and full_graph.in_degree[left] == 1
@@ -2024,6 +2076,11 @@ class PhoenixStructurer(StructurerBase):
 
             if full_graph.in_degree[left] == 1 and full_graph.in_degree[right] == 2:
                 left, right = right, left
+
+            # ensure left and right nodes are not the head of a switch-case construct
+            if left in self.switch_case_known_heads or right in self.switch_case_known_heads:
+                return None
+
             if (
                 self._is_sequential_statement_block(right)
                 and full_graph.in_degree[left] == 2
@@ -2060,6 +2117,11 @@ class PhoenixStructurer(StructurerBase):
 
             if full_graph.in_degree[left] > 1 and full_graph.in_degree[successor] == 1:
                 left, successor = successor, left
+
+            # ensure left and successor nodes are not the head of a switch-case construct
+            if left in self.switch_case_known_heads or successor in self.switch_case_known_heads:
+                return None
+
             if (
                 self._is_sequential_statement_block(left)
                 and full_graph.in_degree[left] == 1
@@ -2103,6 +2165,11 @@ class PhoenixStructurer(StructurerBase):
 
             if full_graph.in_degree[left] > 1 and full_graph.in_degree[else_node] == 1:
                 left, else_node = else_node, left
+
+            # ensure left and else nodes are not the head of a switch-case construct
+            if left in self.switch_case_known_heads or else_node in self.switch_case_known_heads:
+                return None
+
             if (
                 self._is_sequential_statement_block(left)
                 and full_graph.in_degree[left] == 1
@@ -2563,3 +2630,36 @@ class PhoenixStructurer(StructurerBase):
             graph_with_str.add_edge(f'"{src!r}"', f'"{dst!r}"')
 
         networkx.drawing.nx_pydot.write_dot(graph_with_str, path)
+
+    @staticmethod
+    def switch_case_entry_node_has_common_successor_case_1(graph, jump_table, case_nodes, node_pred) -> bool:
+        all_succs = set()
+        for case_node in case_nodes:
+            if case_node is node_pred:
+                continue
+            if case_node.addr in jump_table.jumptable_entries:
+                all_succs |= set(graph.successors(case_node))
+
+        case_node_successors = set()
+        for case_node in case_nodes:
+            if case_node is node_pred:
+                continue
+            if case_node in all_succs:
+                continue
+            if case_node.addr in jump_table.jumptable_entries:
+                succs = set(graph.successors(case_node))
+                case_node_successors |= {succ for succ in succs if succ.addr not in jump_table.jumptable_entries}
+
+        return len(case_node_successors) <= 1
+
+    @staticmethod
+    def switch_case_entry_node_has_common_successor_case_2(graph, jump_table, case_nodes, node_pred) -> bool:
+        case_node_successors = set()
+        for case_node in case_nodes:
+            if case_node is node_pred:
+                continue
+            if case_node.addr in jump_table.jumptable_entries:
+                succs = set(graph.successors(case_node))
+                case_node_successors |= {succ for succ in succs if succ.addr not in jump_table.jumptable_entries}
+
+        return len(case_node_successors) <= 1

angr/analyses/decompiler/structuring/recursive_structurer.py

@@ -83,7 +83,9 @@ class RecursiveStructurer(Analysis):
                 # Get the parent region
                 parent_region = parent_map.get(current_region)
                 # structure this region
-                st: StructurerBase = self.project.analyses[self.structurer_cls].prep()(
+                st: StructurerBase = self.project.analyses[self.structurer_cls].prep(
+                    kb=self.kb, fail_fast=self._fail_fast
+                )(
                     current_region.copy(),
                     parent_map=parent_map,
                     condition_processor=self.cond_proc,

angr/analyses/decompiler/structuring/structurer_base.py

@@ -18,6 +18,7 @@ from angr.analyses.decompiler.utils import (
     remove_last_statement,
     has_nonlabel_nonphi_statements,
 )
+from angr.analyses.decompiler.label_collector import LabelCollector
 from .structurer_nodes import (
     MultiNode,
     SequenceNode,
@@ -800,9 +801,17 @@ class StructurerBase(Analysis):
                 starting_case_ids.append(idx)
                 continue
 
+        # we can't just collect addresses and block IDs of switch-case entry nodes because SequenceNode does not keep
+        # track of block IDs.
+        case_label_addrs = set()
+        for case_node in cases.values():
+            lc = LabelCollector(case_node)
+            for lst in lc.labels.values():
+                case_label_addrs |= set(lst)
+
         for idx in starting_case_ids:
             new_cases[idx] = cases[idx]
-            self._remove_last_statement_if_jump(new_cases[idx])
+            self._remove_last_statement_if_jump_to_addr(new_cases[idx], case_label_addrs)
             succs = networkx.dfs_successors(graph, idx)
             idx_ = idx
             while idx_ in succs:
@@ -813,6 +822,29 @@ class StructurerBase(Analysis):
 
         return new_cases
 
+    @staticmethod
+    def _remove_last_statement_if_jump_to_addr(
+        node: BaseNode | ailment.Block, addr_and_ids: set[tuple[int, int | None]]
+    ) -> ailment.Stmt.Jump | ailment.Stmt.ConditionalJump | None:
+        try:
+            last_stmts = ConditionProcessor.get_last_statements(node)
+        except EmptyBlockNotice:
+            return None
+
+        if len(last_stmts) == 1 and isinstance(last_stmts[0], (ailment.Stmt.Jump, ailment.Stmt.ConditionalJump)):
+            last_stmt = last_stmts[0]
+            jump_targets = []
+            if isinstance(last_stmt, ailment.Stmt.Jump) and isinstance(last_stmt.target, ailment.Expr.Const):
+                jump_targets = [(last_stmt.target.value, last_stmt.target_idx)]
+            elif isinstance(last_stmt, ailment.Stmt.ConditionalJump):
+                if isinstance(last_stmt.true_target, ailment.Expr.Const):
+                    jump_targets.append((last_stmt.true_target.value, last_stmt.true_target_idx))
+                if isinstance(last_stmt.false_target, ailment.Expr.Const):
+                    jump_targets.append((last_stmt.false_target.value, last_stmt.false_target_idx))
+            if any(tpl in addr_and_ids for tpl in jump_targets):
+                return remove_last_statement(node)
+        return None
+
     @staticmethod
     def _remove_last_statement_if_jump(
         node: BaseNode | ailment.Block,

{angr-9.2.127.dist-info → angr-9.2.129.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: angr
-Version: 9.2.127
+Version: 9.2.129
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 Home-page: https://github.com/angr/angr
 License: BSD-2-Clause
@@ -16,13 +16,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.127
-Requires-Dist: archinfo==9.2.127
+Requires-Dist: ailment==9.2.129
+Requires-Dist: archinfo==9.2.129
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.127
-Requires-Dist: cle==9.2.127
+Requires-Dist: claripy==9.2.129
+Requires-Dist: cle==9.2.129
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
 Requires-Dist: nampa
@@ -31,7 +31,7 @@ Requires-Dist: protobuf>=5.28.2
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.127
+Requires-Dist: pyvex==9.2.129
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.127.dist-info → angr-9.2.129.dist-info}/RECORD

@@ -1,4 +1,4 @@
-angr/__init__.py,sha256=RVxXUHB8F4gQKi1KltS9-39I-4HywT29QiDLx2F1bMY,9153
+angr/__init__.py,sha256=H7vjKb7cGcs7fXtPwftz3xSELPNZUzWL7xFWRC4tvvg,9153
 angr/__main__.py,sha256=XeawhF6Cco9eWcfMTDWzYYggLB3qjnQ87IIeFOplaHM,2873
 angr/annocfg.py,sha256=5fiS9TPt5r1_8g_qSfD2XkETlBdm5MTClBIQKqhm040,10624
 angr/blade.py,sha256=GpbEumxMsb_6qD7TbtfZuW2CMzV7W1iwqYzQWYlXnxM,15394
@@ -102,19 +102,20 @@ angr/analyses/decompiler/block_io_finder.py,sha256=xMwG8Bi69OGNYVs0U0F4yxM8kEsny
 angr/analyses/decompiler/block_similarity.py,sha256=ISMoOm-TGJ_1wD2i_4m8IYTletgnP66gReQESJnfvS0,6873
 angr/analyses/decompiler/block_simplifier.py,sha256=_WYyfFW8bJ_-RkrudJIlDdHh9fc6_aHkuwzW9gylY-k,13922
 angr/analyses/decompiler/callsite_maker.py,sha256=Gs_FmlmIs5jM-XccL9OMCaj_-L83NlYzkzxsy2HmcfQ,18749
-angr/analyses/decompiler/clinic.py,sha256=pSM3UVv-HMolsBeNZwLLKxpYof_fVH5m9G95gD4-OfE,106033
+angr/analyses/decompiler/clinic.py,sha256=Psy7ljBDFOqYx_Al8xvDPe3naJi8YsdMryXo8wVlrhM,106999
 angr/analyses/decompiler/condition_processor.py,sha256=MbpbSk6zXHmMLWjLAHxpYjcLCVL1TuL08KmTBTNpm_4,52839
 angr/analyses/decompiler/decompilation_cache.py,sha256=ELz1DDVYvrs6IeUX4_L0OZDZICUifSBdJkdJXWrFZAY,1375
 angr/analyses/decompiler/decompilation_options.py,sha256=QWUGnfQ0FUekGs_I6X-ZKvAvL39VX2hFRcZrlXd72fY,7957
-angr/analyses/decompiler/decompiler.py,sha256=h6f8fsy3BzFm_-WuGdtXCb_u9xTL494lUEXI5j-PreU,27928
+angr/analyses/decompiler/decompiler.py,sha256=BF859tVg7IWwEnarW30dXoQYHXco3lngTh0vx7Q5Je8,28672
 angr/analyses/decompiler/empty_node_remover.py,sha256=_RAGjqDyRmannEGPcMmWkL7em990-_sKgl5CYreb-yI,7403
 angr/analyses/decompiler/expression_narrower.py,sha256=TvkqtgNI9aDsquqyNFH5kXLW04rP_J940GFhrGopxP4,10343
 angr/analyses/decompiler/goto_manager.py,sha256=GUWt3Y_NCpmreIt4plxX5Y3UO2V8IVGZuRtF2GqI-cw,4006
-angr/analyses/decompiler/graph_region.py,sha256=PqXOqxOtk8haGNB7zlPzvXgkE0JdeGCIpLIUSeKswo8,16661
+angr/analyses/decompiler/graph_region.py,sha256=KFJ_8qCn0bbjPO1l0D2-eVqRzkgiLNpxiynhWHhtxdA,16538
 angr/analyses/decompiler/jump_target_collector.py,sha256=qR11VsIp6H1N-19xCdXMRs1LGX31o3_Cz1Z5wRyMIl8,1173
 angr/analyses/decompiler/jumptable_entry_condition_rewriter.py,sha256=f_JyNiSZfoudElfl2kIzONoYCiosR4xYFOe8Q5SkvLg,2176
+angr/analyses/decompiler/label_collector.py,sha256=JLaGuSZu-DdJMBTYOPt4QpWJ6UigOpsC5bgNANrSao4,798
 angr/analyses/decompiler/redundant_label_remover.py,sha256=J9hpP3C_P08v84FjVU0q5Rmj5M1N9q3HKWSWsA2u7Yg,5879
-angr/analyses/decompiler/region_identifier.py,sha256=FUynH4k09y5NiTdor8PLiPFviDcdWpzwz0xa9fRocJs,47293
+angr/analyses/decompiler/region_identifier.py,sha256=DGxaIc3cy-NYxKeZgMO_BuybQvI86XXxNX88Ya6elAw,47396
 angr/analyses/decompiler/region_walker.py,sha256=u0hR0bEX1hSwkv-vejIM1gS-hcX2F2DLsDqpKhQ5_pQ,752
 angr/analyses/decompiler/return_maker.py,sha256=pKn9_y5VXqTeJnD5uzLLd9sH_Dp_9wkPcWPiJPTV-7A,2550
 angr/analyses/decompiler/seq_to_blocks.py,sha256=bB-1m8oBO59AlAp6izAROks3BBxFW8zigLlrIMt6Yfs,564
@@ -135,7 +136,7 @@ angr/analyses/decompiler/dephication/graph_rewriting.py,sha256=R0rlwYL0Cnt1UPjdE
 angr/analyses/decompiler/dephication/graph_vvar_mapping.py,sha256=nsMwppwMXrGC8_RF-neehpaz-7kmEORVhpAbjOdVFWM,13703
 angr/analyses/decompiler/dephication/rewriting_engine.py,sha256=3KUIxwUmfTZj2Jm1mB98J5vMkHqy4LLPYTrLzZfLbBA,10442
 angr/analyses/decompiler/dephication/seqnode_dephication.py,sha256=q29kS8lOs_-mxgJMtQvoZdw6l3q2lUDeXcTcGienIrY,4343
-angr/analyses/decompiler/optimization_passes/__init__.py,sha256=pCYamez51inHric94E2tD_Hy9gHl8sGHJbfG2dcpGBQ,4833
+angr/analyses/decompiler/optimization_passes/__init__.py,sha256=7CvrHdbjvebdxzXYIvLqzKNv41bc19tecWZJBnEwEyo,4965
 angr/analyses/decompiler/optimization_passes/base_ptr_save_simplifier.py,sha256=uUzQWVkeKL2C9Lq8NZ7UkkZBAXydxOd0F1jxr0Zi__Q,5514
 angr/analyses/decompiler/optimization_passes/call_stmt_rewriter.py,sha256=G1CEWo62dAMrm-3V4DfEDxT6kwXxuks10bcTtW9C_tA,1320
 angr/analyses/decompiler/optimization_passes/code_motion.py,sha256=7o6lf-qahXv5H8jLqEASVXHaz-_PGo3r6l7qH5PbDtU,15343
@@ -153,7 +154,7 @@ angr/analyses/decompiler/optimization_passes/ite_region_converter.py,sha256=zTpl
 angr/analyses/decompiler/optimization_passes/lowered_switch_simplifier.py,sha256=1Yto_EBmmB5FkwZzaAO7S0MEvbQNEknFbbq-nUU0Eao,38818
 angr/analyses/decompiler/optimization_passes/mod_simplifier.py,sha256=papR480h-t_wEWMEdu6UTmc33lPSy_MOmiMgidPGnxc,3115
 angr/analyses/decompiler/optimization_passes/multi_simplifier.py,sha256=sIp2YISvafpyFzn8sgGMfohJsARiS3JFX_Y3IUXD_vo,10119
-angr/analyses/decompiler/optimization_passes/optimization_pass.py,sha256=Ot9iYGqHK_5TZM8cU8IUaUazDH8LJjf1EcG4Av0Udv8,21382
+angr/analyses/decompiler/optimization_passes/optimization_pass.py,sha256=ZCGlsTK_3pF2uKdUkLoI2zkQTVvR3w1zt0ZLhy0_BcA,21530
 angr/analyses/decompiler/optimization_passes/register_save_area_simplifier.py,sha256=tc4FruEl0sFpm1DUu9g8gWlueRm0t9rhfHsdUrVplBo,7932
 angr/analyses/decompiler/optimization_passes/ret_addr_save_simplifier.py,sha256=GIFiYM_C_ChHrD2D1JGRFlE--PU3FOxTqzOX-lXmJLY,6404
 angr/analyses/decompiler/optimization_passes/ret_deduplicator.py,sha256=STMnRyZWiqdoGPa3c7Q4KCHv-JHUdJ2t4oLEltEMpII,7995
@@ -161,7 +162,8 @@ angr/analyses/decompiler/optimization_passes/return_duplicator_base.py,sha256=7Q
 angr/analyses/decompiler/optimization_passes/return_duplicator_high.py,sha256=ICDYwQJt5E2OVasdqn42jzbjwUXhSj6Plh3Y1iUHpAQ,2178
 angr/analyses/decompiler/optimization_passes/return_duplicator_low.py,sha256=-mBEVfwGz986lDDEGwBG8wvGQTrFZHE7TLV-7rWt-H0,10076
 angr/analyses/decompiler/optimization_passes/stack_canary_simplifier.py,sha256=cEbZ5jyYbRiBJSzVJbnqssUY5MzirXXgzvzpxllY_Zk,14343
-angr/analyses/decompiler/optimization_passes/switch_default_case_duplicator.py,sha256=pxb0jyDQ5BXkjzzo4JiHEA1NZeKVmp0G5Pd-T5_UIa8,4758
+angr/analyses/decompiler/optimization_passes/switch_default_case_duplicator.py,sha256=nMI9geZiLG5diaI3YciNKvJ0PAZXtUBLgAfknCf48QE,6539
+angr/analyses/decompiler/optimization_passes/switch_reused_entry_rewriter.py,sha256=m7ZMkqE2qbl4rl4M_Fi8xS6I1vUaTzUBIzsE6qpbwkM,4020
 angr/analyses/decompiler/optimization_passes/tag_slicer.py,sha256=8_gmoeYgDD1Hb8Rpqcb-01_B4897peDF-J6KA5PjQT8,1176
 angr/analyses/decompiler/optimization_passes/win_stack_canary_simplifier.py,sha256=cpbsP6_ilZDu2M_jX8TEnwVrsQXljHEjSMw25HyK6PM,12806
 angr/analyses/decompiler/optimization_passes/x86_gcc_getpc_simplifier.py,sha256=6NxaX2oT6BMkevb8xt9vlS3Jl-CmSK59F0FVab68B48,3088
@@ -219,9 +221,9 @@ angr/analyses/decompiler/peephole_optimizations/single_bit_cond_to_boolexpr.py,s
 angr/analyses/decompiler/peephole_optimizations/single_bit_xor.py,sha256=tnjWYeKWL63rvLVcicVSD1NbVQJfHtLT85E_PNeYt6s,979
 angr/analyses/decompiler/peephole_optimizations/tidy_stack_addr.py,sha256=RRzuc2iGzQPvYaZAmpLKim0pJ_yR3-muGnJQxvpcN8w,4786
 angr/analyses/decompiler/presets/__init__.py,sha256=FfnTqgY3oINacW7JFPIxx3r9dwpgI0Pu8yygBCN9d68,375
-angr/analyses/decompiler/presets/basic.py,sha256=xL7UjuuRnZFoG2j8C-qB1F8xwC3tA189PmVdQO_1tCU,737
-angr/analyses/decompiler/presets/fast.py,sha256=vaHnlv39xQwilXVtdkAEFUKKDQIwQQOTw6Synvse6rI,1469
-angr/analyses/decompiler/presets/full.py,sha256=sFFP4ZUqPlrEnSfwDJ5Owh-wlqnuW459qY2AAXoof2s,1642
+angr/analyses/decompiler/presets/basic.py,sha256=KDHlMq_XWonN2-JIYYVIhbI6FbfzXttmkgXFrwi5MiA,803
+angr/analyses/decompiler/presets/fast.py,sha256=7C6-7Enha_ZRP-z_1tD3y3tG-FFqFPdp97rCTro0I6o,1535
+angr/analyses/decompiler/presets/full.py,sha256=OJU5vmih0QPzoHWfy4Umwek7RHh6TV7fuUTi5VolDTo,1708
 angr/analyses/decompiler/presets/preset.py,sha256=sTK5fJfx_Cdx0Gjn7y4bOrDp-2eFPeg1e1d5Eyc9uXk,1256
 angr/analyses/decompiler/region_simplifiers/__init__.py,sha256=BSD9osrReTEdapOMmyI1kFiN7AmE1EeJGLBV7i0u-Uc,117
 angr/analyses/decompiler/region_simplifiers/cascading_cond_transformer.py,sha256=qLs1LxEYHdPrh5c33IdkHJqtjBU7z4Sz6fxOK4Fn0Oc,3816
@@ -250,10 +252,10 @@ angr/analyses/decompiler/structured_codegen/dummy.py,sha256=JZLeovXE-8C-unp2hbej
 angr/analyses/decompiler/structured_codegen/dwarf_import.py,sha256=J6V40RuIyKXN7r6ESftIYfoREgmgFavnUL5m3lyTzlM,7072
 angr/analyses/decompiler/structuring/__init__.py,sha256=u2SGBezMdqQF_2ixo8wr66vCMedAMY-cSjQyq2m-nR8,711
 angr/analyses/decompiler/structuring/dream.py,sha256=mPNNsNvNb-LoDcoU_HjUejRytIFY_ZyCAbK4tNq_5lM,48254
-angr/analyses/decompiler/structuring/phoenix.py,sha256=uJ6V7DMoc7DOH2b_NfnuRPvyKvB31eUIUOmuWmC7Sz4,120632
-angr/analyses/decompiler/structuring/recursive_structurer.py,sha256=HRUpZiD8xlpJjHWL8WHORakuBw_ip7h8K9ichyLX1j8,7075
+angr/analyses/decompiler/structuring/phoenix.py,sha256=-DkejyxETWXqGGdDw2-HBqlMgNUkVpApyyMpPforhSA,125114
+angr/analyses/decompiler/structuring/recursive_structurer.py,sha256=wxMiixVpmao1Rpuo3wN-gxkPh2YrgTTW4usgtdjdY9E,7150
 angr/analyses/decompiler/structuring/sailr.py,sha256=6lM9cK3iU1kQ_eki7v1Z2VxTiX5OwQzIRF_BbEsw67Q,5721
-angr/analyses/decompiler/structuring/structurer_base.py,sha256=ql8HoTn9SG6snNmgEx1xQVeIHAlvdkASQpDwNR04YKw,41547
+angr/analyses/decompiler/structuring/structurer_base.py,sha256=b2fGaDOYy_XdgbOHsKIalJWVTXEt4zDK7w3IO-ZgIjI,43276
 angr/analyses/decompiler/structuring/structurer_nodes.py,sha256=a916imPog4YCCtWtzcnHIQMPLEC73C5t-zSvx9mnvGk,12081
 angr/analyses/deobfuscator/__init__.py,sha256=dkmq-mm3V6kiuchwUZCXr3bDRAEB1-zsPHeEt54tlUE,648
 angr/analyses/deobfuscator/api_obf_finder.py,sha256=WWl55WESeAwcJMrJPX0LqGKN0druzWz--PsG79IliQA,13241
@@ -1351,9 +1353,9 @@ angr/utils/timing.py,sha256=ELuRPzdRSHzOATgtAzTFByMlVr021ypMrsvtpopreLg,1481
 angr/utils/ssa/__init__.py,sha256=Sz9zQVnvtmCbJJYeTG_k2JxcZtgxvIxap-KqzvRnIFQ,8015
 angr/utils/ssa/tmp_uses_collector.py,sha256=rSpvMxBHzg-tmvhsfjn3iLyPEKzaZN-xpQrdslMq3J4,793
 angr/utils/ssa/vvar_uses_collector.py,sha256=8gfAWdRMz73Deh-ZshDM3GPAot9Lf-rHzCiaCil0hlE,1342
-angr-9.2.127.dist-info/LICENSE,sha256=cgL_ho5B1NH8UxwtBuqThRWdjear8b7hktycaS1sz6g,1327
-angr-9.2.127.dist-info/METADATA,sha256=ShqPxcNeKaZBhxu__-FOBkH4XxlaufXprp4jtO5F_yg,4762
-angr-9.2.127.dist-info/WHEEL,sha256=uEDBtbrkGAvMsG1z7kIl7b5DYNNKZ110KP7bgdmmbH0,109
-angr-9.2.127.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
-angr-9.2.127.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
-angr-9.2.127.dist-info/RECORD,,
+angr-9.2.129.dist-info/LICENSE,sha256=cgL_ho5B1NH8UxwtBuqThRWdjear8b7hktycaS1sz6g,1327
+angr-9.2.129.dist-info/METADATA,sha256=WOdMRFoJxdkUHH8TILuVOxyo2fJZ2amFBMlZdEZpkbg,4762
+angr-9.2.129.dist-info/WHEEL,sha256=4Gyx0AkwVnkmVh7urC5vYOQGgSc_AOR8LpgZGh-WWPI,109
+angr-9.2.129.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
+angr-9.2.129.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
+angr-9.2.129.dist-info/RECORD,,

{angr-9.2.127.dist-info → angr-9.2.129.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.5.0)
 Root-Is-Purelib: true
 Tag: py3-none-manylinux2014_aarch64