angr 9.2.116__py3-none-manylinux2014_x86_64.whl → 9.2.118__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/region_identifier.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from itertools import count
 from collections import defaultdict
 import logging
@@ -16,7 +17,7 @@ from .. import Analysis, register_analysis
 from .structuring.structurer_nodes import MultiNode, ConditionNode, IncompleteSwitchCaseHeadStatement
 from .graph_region import GraphRegion
 from .condition_processor import ConditionProcessor
-from .utils import replace_last_statement, first_nonlabel_statement, copy_graph
+from .utils import replace_last_statement, first_nonlabel_nonphi_statement, copy_graph
 
 l = logging.getLogger(name=__name__)
 
@@ -81,11 +82,10 @@ class RegionIdentifier(Analysis):
         """
 
         subgraph = subgraph_between_nodes(graph, node, frontier, include_frontier=include_frontier)
-        if not list(subgraph.nodes):
-            # HACK: FIXME: for infinite loop nodes, this would return an empty set, so we include the loop body itself
-            # Make sure this makes sense (EDG thinks it does)
-            if (node, node) in graph.edges:
-                subgraph.add_edge(node, node)
+        # HACK: FIXME: for infinite loop nodes, this would return an empty set, so we include the loop body itself
+        # Make sure this makes sense (EDG thinks it does)
+        if not list(subgraph.nodes) and (node, node) in graph.edges:
+            subgraph.add_edge(node, node)
         return subgraph
 
     def _analyze(self):
@@ -171,10 +171,7 @@ class RegionIdentifier(Analysis):
                 break
 
         # Flow graph reducibility, Hecht and Ullman
-        if len(graph.nodes) == 1:
-            return True
-
-        return False
+        return len(graph.nodes) == 1
 
     def _make_supergraph(self, graph: networkx.DiGraph):
         while True:
@@ -213,8 +210,7 @@ class RegionIdentifier(Analysis):
             if not updated:
                 break
 
-        nodes = set(loop_subgraph)
-        return nodes
+        return set(loop_subgraph)
 
     def _refine_loop(self, graph: networkx.DiGraph, head, initial_loop_nodes, initial_exit_nodes):
         if len(initial_exit_nodes) <= 1:
@@ -431,12 +427,11 @@ class RegionIdentifier(Analysis):
             head = next(iter(n for n in subgraph.nodes() if n.addr == head.addr))
             region.head = head
 
-        if len(graph.nodes()) == 1 and isinstance(list(graph.nodes())[0], GraphRegion):
-            return list(graph.nodes())[0]
+        if len(graph.nodes()) == 1 and isinstance(next(iter(graph.nodes())), GraphRegion):
+            return next(iter(graph.nodes()))
         # create a large graph region
         new_head = self._get_start_node(graph)
-        region = GraphRegion(new_head, graph, None, None, False, None)
-        return region
+        return GraphRegion(new_head, graph, None, None, False, None)
 
     #
     # Cyclic regions
@@ -482,7 +477,7 @@ class RegionIdentifier(Analysis):
         if len(refined_exit_nodes) > 1:
             # self._get_start_node(graph)
             node_post_order = list(networkx.dfs_postorder_nodes(graph, head))
-            sorted_exit_nodes = sorted(list(refined_exit_nodes), key=node_post_order.index)
+            sorted_exit_nodes = sorted(refined_exit_nodes, key=node_post_order.index)
             normal_exit_node = sorted_exit_nodes[0]
             abnormal_exit_nodes = set(sorted_exit_nodes[1:])
         else:
@@ -692,47 +687,47 @@ class RegionIdentifier(Analysis):
             levels = 0
             postdom_node = postdoms.get(node, None)
             while postdom_node is not None:
-                if (node, postdom_node) not in failed_region_attempts:
-                    if self._check_region(graph_copy, node, postdom_node, doms, df):
-                        frontier = [postdom_node]
-                        region = self._compute_region(
-                            graph_copy, node, frontier, dummy_endnode=dummy_endnode, cyclic_ancestor=cyclic
+                if (node, postdom_node) not in failed_region_attempts and self._check_region(
+                    graph_copy, node, postdom_node, doms, df
+                ):
+                    frontier = [postdom_node]
+                    region = self._compute_region(
+                        graph_copy, node, frontier, dummy_endnode=dummy_endnode, cyclic_ancestor=cyclic
+                    )
+                    if region is not None:
+                        # update region.graph_with_successors
+                        if secondary_graph is not None:
+                            if self._complete_successors:
+                                for nn in list(region.graph_with_successors.nodes):
+                                    original_successors = secondary_graph.successors(nn)
+                                    for succ in original_successors:
+                                        if not region.graph_with_successors.has_edge(nn, succ):
+                                            region.graph_with_successors.add_edge(nn, succ)
+                                            region.successors.add(succ)
+                            else:
+                                for nn in list(region.graph_with_successors.nodes):
+                                    original_successors = secondary_graph.successors(nn)
+                                    for succ in original_successors:
+                                        if succ not in graph_copy:
+                                            # the successor wasn't added to the graph because it does not belong
+                                            # to the frontier. we backpatch the successor graph here.
+                                            region.graph_with_successors.add_edge(nn, succ)
+                                            region.successors.add(succ)
+
+                            # add edges between successors
+                            for succ_0 in region.successors:
+                                for succ_1 in region.successors:
+                                    if succ_0 is not succ_1 and secondary_graph.has_edge(succ_0, succ_1):
+                                        region.graph_with_successors.add_edge(succ_0, succ_1)
+
+                        # l.debug("Walked back %d levels in postdom tree.", levels)
+                        l.debug("Node %r, frontier %r.", node, frontier)
+                        # l.debug("Identified an acyclic region %s.", self._dbg_block_list(region.graph.nodes()))
+                        self._abstract_acyclic_region(
+                            graph, region, frontier, dummy_endnode=dummy_endnode, secondary_graph=secondary_graph
                         )
-                        if region is not None:
-                            # update region.graph_with_successors
-                            if secondary_graph is not None:
-                                if self._complete_successors:
-                                    for nn in list(region.graph_with_successors.nodes):
-                                        original_successors = secondary_graph.successors(nn)
-                                        for succ in original_successors:
-                                            if not region.graph_with_successors.has_edge(nn, succ):
-                                                region.graph_with_successors.add_edge(nn, succ)
-                                                region.successors.add(succ)
-                                else:
-                                    for nn in list(region.graph_with_successors.nodes):
-                                        original_successors = secondary_graph.successors(nn)
-                                        for succ in original_successors:
-                                            if succ not in graph_copy:
-                                                # the successor wasn't added to the graph because it does not belong
-                                                # to the frontier. we backpatch the successor graph here.
-                                                region.graph_with_successors.add_edge(nn, succ)
-                                                region.successors.add(succ)
-
-                                # add edges between successors
-                                for succ_0 in region.successors:
-                                    for succ_1 in region.successors:
-                                        if succ_0 is not succ_1:
-                                            if secondary_graph.has_edge(succ_0, succ_1):
-                                                region.graph_with_successors.add_edge(succ_0, succ_1)
-
-                            # l.debug("Walked back %d levels in postdom tree.", levels)
-                            l.debug("Node %r, frontier %r.", node, frontier)
-                            # l.debug("Identified an acyclic region %s.", self._dbg_block_list(region.graph.nodes()))
-                            self._abstract_acyclic_region(
-                                graph, region, frontier, dummy_endnode=dummy_endnode, secondary_graph=secondary_graph
-                            )
-                            # assert dummy_endnode not in graph
-                            return True
+                        # assert dummy_endnode not in graph
+                        return True
 
                 failed_region_attempts.add((node, postdom_node))
                 if not dominates(doms, node, postdom_node):
@@ -811,11 +806,10 @@ class RegionIdentifier(Analysis):
                 if succ is dummy_endnode:
                     continue
 
-                if succ in frontier:
-                    if not include_frontier:
-                        # skip all frontier nodes
-                        frontier_edges.append((node_, succ, edge_data))
-                        continue
+                if succ in frontier and not include_frontier:
+                    # skip all frontier nodes
+                    frontier_edges.append((node_, succ, edge_data))
+                    continue
                 subgraph.add_edge(node_, succ, **edge_data)
                 if succ in traversed:
                     continue
@@ -834,8 +828,7 @@ class RegionIdentifier(Analysis):
             return GraphRegion(
                 node, subgraph, frontier, subgraph_with_frontier, False, None, cyclic_ancestor=cyclic_ancestor
             )
-        else:
-            return None
+        return None
 
     def _abstract_acyclic_region(
         self, graph: networkx.DiGraph, region, frontier, dummy_endnode=None, secondary_graph=None
@@ -938,9 +931,8 @@ class RegionIdentifier(Analysis):
 
         for succ_0 in region.successors:
             for succ_1 in region.successors:
-                if succ_0 is not succ_1:
-                    if graph.has_edge(succ_0, succ_1):
-                        region.graph_with_successors.add_edge(succ_0, succ_1)
+                if succ_0 is not succ_1 and graph.has_edge(succ_0, succ_1):
+                    region.graph_with_successors.add_edge(succ_0, succ_1)
 
         for node in loop_nodes:
             graph.remove_node(node)
@@ -973,12 +965,8 @@ class RegionIdentifier(Analysis):
         in_edges = [(src, dst, data) for (src, dst, data) in graph.in_edges(node, data=True) if src is not node]
         out_edges = [(src, dst, data) for (src, dst, data) in graph.out_edges(node, data=True) if dst is not node]
 
-        if len(in_edges) <= 1 and len(out_edges) <= 1:
-            # it forms a region by itself :-)
-            new_node = None
-
-        else:
-            new_node = MultiNode([node])
+        # true case: it forms a region by itself :-)
+        new_node = None if len(in_edges) <= 1 and len(out_edges) <= 1 else MultiNode([node])
 
         graph.remove_node(node)
 
@@ -1072,7 +1060,7 @@ class RegionIdentifier(Analysis):
                     )
                 )
             else:
-                if not isinstance(first_nonlabel_statement(node), ConditionalJump) and not isinstance(
+                if not isinstance(first_nonlabel_nonphi_statement(node), ConditionalJump) and not isinstance(
                     node.statements[-1],
                     (
                         Jump,
@@ -1087,9 +1075,8 @@ class RegionIdentifier(Analysis):
                             ins_addr=node.addr,
                         )
                     )
-        elif isinstance(node, MultiNode):
-            if node.nodes:
-                self._ensure_jump_at_loop_exit_ends(node.nodes[-1])
+        elif isinstance(node, MultiNode) and node.nodes:
+            self._ensure_jump_at_loop_exit_ends(node.nodes[-1])
 
     @staticmethod
     def _dbg_block_list(blocks):

angr/analyses/decompiler/region_simplifiers/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .region_simplifier import RegionSimplifier

angr/analyses/decompiler/region_simplifiers/cascading_cond_transformer.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-self-use,arguments-renamed,isinstance-second-argument-not-valid-type
+from __future__ import annotations
 
 import ailment
 import claripy
@@ -84,7 +85,7 @@ class CascadingConditionTransformer(SequenceWalker):
 
         elif isinstance(structured, CascadingConditionNode):
             # merge two nodes
-            cond_and_nodes = [(cond_0, node_0)] + structured.condition_and_nodes
+            cond_and_nodes = [(cond_0, node_0), *structured.condition_and_nodes]
             else_node = structured.else_node
 
         else:

angr/analyses/decompiler/region_simplifiers/cascading_ifs.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 import ailment
 
 from ..sequence_walker import SequenceWalker

angr/analyses/decompiler/region_simplifiers/expr_folding.py

@@ -1,6 +1,7 @@
 # pylint:disable=missing-class-docstring,unused-argument
+from __future__ import annotations
 from collections import defaultdict
-from typing import Optional, Any, DefaultDict, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 from collections.abc import Iterable
 
 import ailment
@@ -8,6 +9,7 @@ from ailment import Expression, Block, AILBlockWalker
 from ailment.expression import ITE
 from ailment.statement import Statement, Assignment, Call
 
+from angr.utils.ail import is_phi_assignment
 from ..sequence_walker import SequenceWalker
 from ..structuring.structurer_nodes import (
     ConditionNode,
@@ -140,7 +142,7 @@ class MultiStatementExpressionAssignmentFinder(AILBlockWalker):
         self._stmt_handler = stmt_handler
 
     def _handle_MultiStatementExpression(
-        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Block | None
+        self, expr_idx, expr: MultiStatementExpression, stmt_idx: int, stmt: Statement, block: Block | None
     ):
         for idx, stmt_ in enumerate(expr.stmts):
             self._stmt_handler(idx, stmt_, block)
@@ -175,13 +177,13 @@ class ExpressionUseFinder(AILBlockWalker):
 
     def __init__(self):
         super().__init__()
-        self.uses: DefaultDict[SimVariable, set[tuple[Expression, ExpressionLocation | None]]] = defaultdict(set)
+        self.uses: defaultdict[SimVariable, set[tuple[Expression, ExpressionLocation | None]]] = defaultdict(set)
         self.has_load = False
 
     def _handle_expr(
         self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
     ) -> Any:
-        if isinstance(expr, ailment.Register) and expr.variable is not None:
+        if isinstance(expr, ailment.Expr.VirtualVariable) and expr.was_reg and expr.variable is not None:
             if not (isinstance(stmt, ailment.Stmt.Assignment) and stmt.dst is expr):
                 if block is not None:
                     self.uses[expr.variable].add((expr, ExpressionLocation(block.addr, block.idx, stmt_idx, expr_idx)))
@@ -212,14 +214,14 @@ class ExpressionCounter(SequenceWalker):
         # each element in the set is a tuple of (source of the assignment statement, a tuple of unified variables that
         # the current assignment depends on, StatementLocation of the assignment statement, a Boolean variable that
         # indicates if ExpressionUseFinder has succeeded or not)
-        self.assignments: DefaultDict[Any, set[tuple]] = defaultdict(set)
+        self.assignments: defaultdict[Any, set[tuple]] = defaultdict(set)
         self.uses: dict[SimVariable, set[tuple[Expression, LocationBase | None]]] = {}
-        self._variable_manager: "VariableManagerInternal" = variable_manager
+        self._variable_manager: VariableManagerInternal = variable_manager
 
         super().__init__(handlers)
         self.walk(node)
 
-    def _u(self, v) -> Optional["SimVariable"]:
+    def _u(self, v) -> SimVariable | None:
         """
         Get unified variable for a given variable.
         """
@@ -228,7 +230,13 @@ class ExpressionCounter(SequenceWalker):
 
     def _handle_Statement(self, idx: int, stmt: ailment.Stmt, node: ailment.Block | LoopNode):
         if isinstance(stmt, ailment.Stmt.Assignment):
-            if isinstance(stmt.dst, ailment.Expr.Register) and stmt.dst.variable is not None:
+            if is_phi_assignment(stmt):
+                return
+            if (
+                isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                and stmt.dst.was_reg
+                and stmt.dst.variable is not None
+            ):
                 u = self._u(stmt.dst.variable)
                 if u is not None:
                     # dependency
@@ -245,7 +253,8 @@ class ExpressionCounter(SequenceWalker):
                     )
         if (
             isinstance(stmt, ailment.Stmt.Call)
-            and isinstance(stmt.ret_expr, ailment.Expr.Register)
+            and isinstance(stmt.ret_expr, ailment.Expr.VirtualVariable)
+            and stmt.ret_expr.was_reg
             and stmt.ret_expr.variable is not None
         ):
             u = self._u(stmt.ret_expr.variable)
@@ -334,29 +343,29 @@ class ExpressionReplacer(AILBlockWalker):
         super().__init__()
         self._assignments = assignments
         self._uses = uses
-        self._variable_manager: "VariableManagerInternal" = variable_manager
+        self._variable_manager: VariableManagerInternal = variable_manager
 
-    def _u(self, v) -> Optional["SimVariable"]:
+    def _u(self, v) -> SimVariable | None:
         """
         Get unified variable for a given variable.
         """
         return self._variable_manager.unified_variable(v)
 
     def _handle_MultiStatementExpression(
-        self, expr_idx, expr: "MultiStatementExpression", stmt_idx: int, stmt: Statement, block: Block | None
+        self, expr_idx, expr: MultiStatementExpression, stmt_idx: int, stmt: Statement, block: Block | None
     ):
         changed = False
         new_statements = []
         for idx, stmt_ in enumerate(expr.stmts):
             if (
                 isinstance(stmt_, Assignment)
-                and isinstance(stmt_.dst, ailment.Expr.Register)
+                and isinstance(stmt_.dst, ailment.Expr.VirtualVariable)
+                and stmt_.dst.was_reg
                 and stmt_.dst.variable is not None
-            ):
-                if stmt_.dst.variable in self._assignments:
-                    # remove this statement
-                    changed = True
-                    continue
+            ) and stmt_.dst.variable in self._assignments:
+                # remove this statement
+                changed = True
+                continue
 
             new_stmt = self._handle_stmt(idx, stmt_, None)
             if new_stmt is not None and new_stmt is not stmt_:
@@ -411,7 +420,7 @@ class ExpressionReplacer(AILBlockWalker):
     def _handle_expr(
         self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
     ) -> Any:
-        if isinstance(expr, ailment.Register) and expr.variable is not None:
+        if isinstance(expr, ailment.Expr.VirtualVariable) and expr.was_reg and expr.variable is not None:
             unified_var = self._u(expr.variable)
             if unified_var in self._uses:
                 replace_with, _ = self._assignments[unified_var]
@@ -434,7 +443,7 @@ class ExpressionFolder(SequenceWalker):
         self._variable_manager = variable_manager
         self.walk(node)
 
-    def _u(self, v) -> Optional["SimVariable"]:
+    def _u(self, v) -> SimVariable | None:
         """
         Get unified variable for a given variable.
         """
@@ -444,15 +453,20 @@ class ExpressionFolder(SequenceWalker):
         # Walk the block to remove each assignment and replace uses of each variable
         new_stmts = []
         for stmt in node.statements:
-            if isinstance(stmt, ailment.Stmt.Assignment):
-                if isinstance(stmt.dst, ailment.Expr.Register) and stmt.dst.variable is not None:
-                    unified_var = self._u(stmt.dst.variable)
-                    if unified_var in self._assignments:
-                        # remove this statement
-                        continue
+            if (
+                isinstance(stmt, ailment.Stmt.Assignment)
+                and isinstance(stmt.dst, ailment.Expr.VirtualVariable)
+                and stmt.dst.was_reg
+                and stmt.dst.variable is not None
+            ):
+                unified_var = self._u(stmt.dst.variable)
+                if unified_var in self._assignments:
+                    # remove this statement
+                    continue
             if (
                 isinstance(stmt, ailment.Stmt.Call)
-                and isinstance(stmt.ret_expr, ailment.Expr.Register)
+                and isinstance(stmt.ret_expr, ailment.Expr.VirtualVariable)
+                and stmt.ret_expr.was_reg
                 and stmt.ret_expr.variable is not None
             ):
                 unified_var = self._u(stmt.ret_expr.variable)
@@ -539,8 +553,8 @@ class StoreStatementFinder(SequenceWalker):
 
         self._intervals = intervals
 
-        self._start_to_ends: DefaultDict[StatementLocation, set[LocationBase]] = defaultdict(set)
-        self._end_to_starts: DefaultDict[LocationBase, set[StatementLocation]] = defaultdict(set)
+        self._start_to_ends: defaultdict[StatementLocation, set[LocationBase]] = defaultdict(set)
+        self._end_to_starts: defaultdict[LocationBase, set[StatementLocation]] = defaultdict(set)
         self.interval_to_hasstore: dict[tuple[StatementLocation, StatementLocation], bool] = {}
         for start, end in intervals:
             self._start_to_ends[start].add(end)

angr/analyses/decompiler/region_simplifiers/goto.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 import logging
 
 import ailment

angr/analyses/decompiler/region_simplifiers/if_.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 import logging
 
 import ailment
@@ -104,39 +105,31 @@ class IfSimplifier(SequenceWalker):
 
         if block.statements and isinstance(block.statements[-1], ailment.Stmt.ConditionalJump):
             cond_stmt = block.statements[-1]  # ailment.Stmt.ConditionalJump
-            if isinstance(successor, ConditionNode):
-                true_cond = False
-                if cond_stmt.true_target is not None and successor.true_node is not None:
-                    # True branch exists. Test if the true target is the address
-                    if (
-                        isinstance(cond_stmt.true_target, ailment.Expr.Const)
-                        and cond_stmt.true_target.value == successor.true_node.addr
-                    ):
-                        true_cond = True
-                if cond_stmt.true_target is not None and successor.false_node is not None:
-                    # True branch exists. Test if the true target is the address
-                    if (
-                        isinstance(cond_stmt.true_target, ailment.Expr.Const)
-                        and cond_stmt.true_target.value == successor.false_node.addr
-                    ):
-                        true_cond = True
-
-                false_cond = False
-                if cond_stmt.false_target is not None and successor.false_node is not None:
-                    # False branch exists. Test if the false target is the address
-                    if (
-                        isinstance(cond_stmt.true_target, ailment.Expr.Const)
-                        and cond_stmt.false_target.value == successor.false_node.addr
-                    ):
-                        false_cond = True
-                if cond_stmt.false_target is not None and successor.true_node is not None:
-                    # True branch exists. Test if the true target is the address
-                    if (
-                        isinstance(cond_stmt.true_target, ailment.Expr.Const)
-                        and cond_stmt.false_target.value == successor.true_node.addr
-                    ):
-                        false_cond = True
-
-                if true_cond or false_cond:
-                    # We can safely remove this statement
-                    block.statements = block.statements[:-1]
+            if (
+                isinstance(successor, ConditionNode)
+                and isinstance(cond_stmt.true_target, ailment.Expr.Const)
+                and (
+                    (
+                        (successor.true_node is not None and cond_stmt.true_target.value == successor.true_node.addr)
+                        or (
+                            successor.false_node is not None
+                            and cond_stmt.true_target.value == successor.false_node.addr
+                        )
+                    )
+                    or (
+                        cond_stmt.false_target is not None
+                        and (
+                            (
+                                successor.false_node is not None
+                                and cond_stmt.false_target.value == successor.false_node.addr
+                            )
+                            or (
+                                successor.true_node is not None
+                                and cond_stmt.false_target.value == successor.true_node.addr
+                            )
+                        )
+                    )
+                )
+            ):
+                # We can safely remove this statement
+                block.statements = block.statements[:-1]

angr/analyses/decompiler/region_simplifiers/ifelse.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 
 from ..sequence_walker import SequenceWalker
 from ..structuring.structurer_nodes import (

angr/analyses/decompiler/region_simplifiers/loop.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 from collections import defaultdict
 
 import ailment
@@ -14,7 +15,7 @@ from ..structuring.structurer_nodes import (
     ContinueNode,
     CascadingConditionNode,
 )
-from ..utils import is_statement_terminating
+from ..utils import is_statement_terminating, has_nonlabel_nonphi_statements
 
 
 class LoopSimplifier(SequenceWalker):
@@ -82,14 +83,15 @@ class LoopSimplifier(SequenceWalker):
 
         # find for-loop iterators
         if (
-            node.sort == "while"
-            and self.continue_preludes[node]
-            and (
-                (node.condition is not None and not isinstance(node.condition, ailment.Expr.Const))
-                or len(self.continue_preludes[node]) > 1
+            (
+                node.sort == "while"
+                and self.continue_preludes[node]
+                and (
+                    (node.condition is not None and not isinstance(node.condition, ailment.Expr.Const))
+                    or len(self.continue_preludes[node]) > 1
+                )
             )
-        ):
-            if (
+            and (
                 all(block.statements for block in self.continue_preludes[node])
                 and all(
                     not self._control_transferring_statement(block.statements[-1])
@@ -99,11 +101,23 @@ class LoopSimplifier(SequenceWalker):
                     block.statements[-1] == self.continue_preludes[node][0].statements[-1]
                     for block in self.continue_preludes[node]
                 )
-            ):
-                node.sort = "for"
-                node.iterator = self.continue_preludes[node][0].statements[-1]
-                for block in self.continue_preludes[node]:
-                    block.statements = block.statements[:-1]
+            )
+            and (
+                all(has_nonlabel_nonphi_statements(block) for block in self.continue_preludes[node])
+                and all(
+                    not self._control_transferring_statement(block.statements[-1])
+                    for block in self.continue_preludes[node]
+                )
+                and all(
+                    block.statements[-1] == self.continue_preludes[node][0].statements[-1]
+                    for block in self.continue_preludes[node]
+                )
+            )
+        ):
+            node.sort = "for"
+            node.iterator = self.continue_preludes[node][0].statements[-1]
+            for block in self.continue_preludes[node]:
+                block.statements = block.statements[:-1]
 
         # find for-loop initializers
         if isinstance(predecessor, MultiNode):

angr/analyses/decompiler/region_simplifiers/node_address_finder.py

@@ -1,4 +1,5 @@
 # pylint:disable=unused-argument,arguments-differ
+from __future__ import annotations
 
 import ailment
 

angr/analyses/decompiler/region_simplifiers/region_simplifier.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import ailment
 
 from ..goto_manager import GotoManager