angr 9.2.117__py3-none-win_amd64.whl → 9.2.119__py3-none-win_amd64.whl

angr/analyses/decompiler/structuring/phoenix.py

@@ -1,5 +1,6 @@
 # pylint:disable=line-too-long,import-outside-toplevel,import-error,multiple-statements,too-many-boolean-expressions
-from typing import Any, DefaultDict, Optional, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 from collections import defaultdict, OrderedDict
 from enum import Enum
 import logging
@@ -12,6 +13,7 @@ from ailment.statement import Statement, ConditionalJump, Jump, Label, Return
 from ailment.expression import Const, UnaryOp, MultiStatementExpression
 
 from angr.utils.graph import GraphUtils
+from angr.utils.ail import is_phi_assignment
 from ....knowledge_plugins.cfg import IndirectJumpType
 from ....utils.constants import SWITCH_MISSING_DEFAULT_NODE_ADDR
 from ....utils.graph import dominates, to_acyclic_graph, dfs_back_edges
@@ -21,10 +23,10 @@ from ..utils import (
     extract_jump_targets,
     switch_extract_cmp_bounds,
     is_empty_or_label_only_node,
-    has_nonlabel_statements,
-    first_nonlabel_statement,
+    has_nonlabel_nonphi_statements,
+    first_nonlabel_nonphi_statement,
 )
-from ..call_counter import AILCallCounter
+from ..counters.call_counter import AILCallCounter
 from .structurer_nodes import (
     ConditionNode,
     SequenceNode,
@@ -79,7 +81,7 @@ class PhoenixStructurer(StructurerBase):
         region,
         parent_map=None,
         condition_processor=None,
-        func: Optional["Function"] = None,
+        func: Function | None = None,
         case_entry_to_switch_head: dict[int, int] | None = None,
         parent_region=None,
         improve_algorithm=False,
@@ -299,10 +301,10 @@ class PhoenixStructurer(StructurerBase):
                     and head_block.nodes
                     and isinstance(head_block.nodes[0], Block)
                     and head_block.nodes[0].statements
-                    and isinstance(first_nonlabel_statement(head_block.nodes[0]), ConditionalJump)
+                    and isinstance(first_nonlabel_nonphi_statement(head_block.nodes[0]), ConditionalJump)
                     or isinstance(head_block, Block)
                     and head_block.statements
-                    and isinstance(first_nonlabel_statement(head_block), ConditionalJump)
+                    and isinstance(first_nonlabel_nonphi_statement(head_block), ConditionalJump)
                 ):
                     # it's a while loop if the conditional jump (or the head block) is at the beginning of node
                     loop_type = "while" if head_block_idx == 0 else "do-while"
@@ -355,19 +357,42 @@ class PhoenixStructurer(StructurerBase):
                             self._remove_edges_except(full_graph, loop_node, right)
 
                             return True, loop_node, right
-                        else:
-                            # we generate a while-true loop instead
-                            last_stmt = self._remove_last_statement_if_jump(head_block)
-                            cond_jump = Jump(
-                                None,
-                                Const(None, None, right.addr, self.project.arch.bits),
-                                None,
-                                ins_addr=last_stmt.ins_addr,
-                            )
-                            jump_node = Block(last_stmt.ins_addr, None, statements=[cond_jump])
-                            cond_jump_node = ConditionNode(last_stmt.ins_addr, None, edge_cond_right, jump_node)
-                            new_node = SequenceNode(node.addr, nodes=[node, cond_jump_node, left])
-                            loop_node = LoopNode("while", claripy.true, new_node, addr=node.addr)
+                        # we generate a while-true loop instead
+                        last_stmt = self._remove_last_statement_if_jump(head_block)
+                        cond_jump = Jump(
+                            None,
+                            Const(None, None, right.addr, self.project.arch.bits),
+                            None,
+                            ins_addr=last_stmt.ins_addr,
+                        )
+                        jump_node = Block(last_stmt.ins_addr, None, statements=[cond_jump])
+                        cond_jump_node = ConditionNode(last_stmt.ins_addr, None, edge_cond_right, jump_node)
+                        new_node = SequenceNode(node.addr, nodes=[node, cond_jump_node, left])
+                        loop_node = LoopNode("while", claripy.true(), new_node, addr=node.addr)
+
+                        # on the original graph
+                        self.replace_nodes(graph, node, loop_node, old_node_1=left, self_loop=False)
+                        # on the graph with successors
+                        self.replace_nodes(full_graph, node, loop_node, old_node_1=left, self_loop=False)
+
+                        # ensure the loop has only one successor: the right node
+                        self._remove_edges_except(graph, loop_node, right)
+                        self._remove_edges_except(full_graph, loop_node, right)
+
+                        return True, loop_node, right
+
+                if self._improve_algorithm and full_graph.out_degree[node] == 1:
+                    # while (true) { ...; if (...) break; }
+                    _, _, head_block = self._find_node_going_to_dst(node, left, condjump_only=True)
+                    if head_block is not None:
+                        edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, head_block, left)
+                        edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, head_block, right)
+                        if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
+                            # c = !c
+                            self._remove_last_statement_if_jump(head_block)
+                            cond_break = ConditionalBreakNode(node.addr, edge_cond_right, right.addr)
+                            new_node = SequenceNode(node.addr, nodes=[node, cond_break, left])
+                            loop_node = LoopNode("while", claripy.true(), new_node, addr=node.addr)
 
                             # on the original graph
                             self.replace_nodes(graph, node, loop_node, old_node_1=left, self_loop=False)
@@ -380,31 +405,6 @@ class PhoenixStructurer(StructurerBase):
 
                             return True, loop_node, right
 
-                if self._improve_algorithm:
-                    if full_graph.out_degree[node] == 1:
-                        # while (true) { ...; if (...) break; }
-                        _, _, head_block = self._find_node_going_to_dst(node, left, condjump_only=True)
-                        if head_block is not None:
-                            edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, head_block, left)
-                            edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, head_block, right)
-                            if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
-                                # c = !c
-                                self._remove_last_statement_if_jump(head_block)
-                                cond_break = ConditionalBreakNode(node.addr, edge_cond_right, right.addr)
-                                new_node = SequenceNode(node.addr, nodes=[node, cond_break, left])
-                                loop_node = LoopNode("while", claripy.true, new_node, addr=node.addr)
-
-                                # on the original graph
-                                self.replace_nodes(graph, node, loop_node, old_node_1=left, self_loop=False)
-                                # on the graph with successors
-                                self.replace_nodes(full_graph, node, loop_node, old_node_1=left, self_loop=False)
-
-                                # ensure the loop has only one successor: the right node
-                                self._remove_edges_except(graph, loop_node, right)
-                                self._remove_edges_except(full_graph, loop_node, right)
-
-                                return True, loop_node, right
-
         return False, None, None
 
     def _match_cyclic_while_with_single_successor(
@@ -423,6 +423,9 @@ class PhoenixStructurer(StructurerBase):
             isinstance(node, SequenceNode)
             and node.nodes
             and isinstance(node.nodes[-1], ConditionNode)
+            # must ensure the nodes before the condition node are empty. otherwise the condition may use variables that
+            # are updated in these nodes leading up to the condition node.
+            and all(not self.has_nonlabel_nonphi_statements(nn) for nn in node.nodes[:-1])
             and node.nodes[-1].true_node is not None
             and node.nodes[-1].false_node is not None
         ):
@@ -499,19 +502,22 @@ class PhoenixStructurer(StructurerBase):
                             self._remove_last_statement_if_jump(succ)
                             drop_succ = False
 
-                            if self._improve_algorithm:
-                                # absorb the entire succ block if possible
-                                if self._is_sequential_statement_block(succ) and self._should_use_multistmtexprs(succ):
-                                    stmts = self._build_multistatementexpr_statements(succ)
-                                    assert stmts is not None
-                                    if stmts:
-                                        edge_cond_succhead = MultiStatementExpression(
-                                            None,
-                                            stmts,
-                                            self.cond_proc.convert_claripy_bool_ast(edge_cond_succhead),
-                                            ins_addr=succ.addr,
-                                        )
-                                    drop_succ = True
+                            # absorb the entire succ block if possible
+                            if (
+                                self._improve_algorithm
+                                and self._is_sequential_statement_block(succ)
+                                and self._should_use_multistmtexprs(succ)
+                            ):
+                                stmts = self._build_multistatementexpr_statements(succ)
+                                assert stmts is not None
+                                if stmts:
+                                    edge_cond_succhead = MultiStatementExpression(
+                                        None,
+                                        stmts,
+                                        self.cond_proc.convert_claripy_bool_ast(edge_cond_succhead),
+                                        ins_addr=succ.addr,
+                                    )
+                                drop_succ = True
 
                             new_node = SequenceNode(node.addr, nodes=[node] if drop_succ else [node, succ])
                             loop_node = LoopNode("do-while", edge_cond_succhead, new_node, addr=node.addr)
@@ -566,7 +572,7 @@ class PhoenixStructurer(StructurerBase):
             seen_nodes.add(next_node)
             seq_node.nodes.append(next_node)
 
-        loop_node = LoopNode("while", claripy.true, seq_node, addr=node.addr)
+        loop_node = LoopNode("while", claripy.true(), seq_node, addr=node.addr)
 
         # on the original graph
         for node_ in seq_node.nodes:
@@ -613,22 +619,21 @@ class PhoenixStructurer(StructurerBase):
         continue_edges: list[tuple[BaseNode, BaseNode]] = []
         outgoing_edges: list = []
 
-        if is_while and is_dowhile:
-            # gotta pick one!
-            # for now, we handle the most common case: both successors exist in the graph of the parent region, and
-            # one successor has a path to the other successor
-            if self._parent_region is not None:
-                succ_while = result_while[-1]
-                succ_dowhile = result_dowhile[-1]
-                if succ_while in self._parent_region.graph and succ_dowhile in self._parent_region.graph:
-                    sorted_nodes = GraphUtils.quasi_topological_sort_nodes(
-                        self._parent_region.graph, loop_heads=[self._parent_region.head]
-                    )
-                    succ_while_idx = sorted_nodes.index(succ_while)
-                    succ_dowhile_idx = sorted_nodes.index(succ_dowhile)
-                    if succ_dowhile_idx < succ_while_idx:
-                        # pick do-while
-                        is_while = False
+        # gotta pick one!
+        # for now, we handle the most common case: both successors exist in the graph of the parent region, and
+        # one successor has a path to the other successor
+        if is_while and is_dowhile and self._parent_region is not None:
+            succ_while = result_while[-1]
+            succ_dowhile = result_dowhile[-1]
+            if succ_while in self._parent_region.graph and succ_dowhile in self._parent_region.graph:
+                sorted_nodes = GraphUtils.quasi_topological_sort_nodes(
+                    self._parent_region.graph, loop_heads=[self._parent_region.head]
+                )
+                succ_while_idx = sorted_nodes.index(succ_while)
+                succ_dowhile_idx = sorted_nodes.index(succ_dowhile)
+                if succ_dowhile_idx < succ_while_idx:
+                    # pick do-while
+                    is_while = False
 
         if is_while:
             loop_type = "while"
@@ -648,7 +653,7 @@ class PhoenixStructurer(StructurerBase):
                     if loop_head is succ:
                         continue_edges.append((node, succ))
             if successor_candidates:
-                successor_candidates = list(sorted(successor_candidates, key=lambda x: x.addr))
+                successor_candidates = sorted(successor_candidates, key=lambda x: x.addr)
                 successor = successor_candidates[0]
                 # virtualize all other edges
                 for succ in successor_candidates:
@@ -820,7 +825,7 @@ class PhoenixStructurer(StructurerBase):
                     # cont_block is not found. but it's ok. one possibility is that src is a jump table head with one
                     # case being the loop head. in such cases, we can just remove the edge.
                     if src.addr not in self.kb.cfgs["CFGFast"].jump_tables:
-                        l.warning(
+                        l.debug(
                             "_refine_cyclic_core: Cannot find the block going to loop head for edge %r -> %r. "
                             "Remove the edge anyway.",
                             src,
@@ -1031,8 +1036,7 @@ class PhoenixStructurer(StructurerBase):
         r = self._match_acyclic_switch_cases_address_computed(node, graph, full_graph, jump_tables)
         if r:
             return r
-        r = self._match_acyclic_incomplete_switch_cases(node, graph, full_graph, jump_tables)
-        return r
+        return self._match_acyclic_incomplete_switch_cases(node, graph, full_graph, jump_tables)
 
     def _match_acyclic_switch_cases_incomplete_switch_head(self, node, graph, full_graph) -> bool:
         try:
@@ -1151,7 +1155,7 @@ class PhoenixStructurer(StructurerBase):
         # sanity check: case nodes are successors to node_a. all case nodes must have at most common one successor
         node_pred = None
         if graph.in_degree[node] == 1:
-            node_pred = list(graph.predecessors(node))[0]
+            node_pred = next(iter(graph.predecessors(node)))
 
         case_nodes = list(graph.successors(node_a))
         case_node_successors = set()
@@ -1333,7 +1337,7 @@ class PhoenixStructurer(StructurerBase):
 
         # entry_addrs_set = set(jumptable_entries)
         converted_nodes: dict[tuple[int, int | None], Any] = {}
-        entry_addr_to_ids: DefaultDict[tuple[int, int | None], set[int]] = defaultdict(set)
+        entry_addr_to_ids: defaultdict[tuple[int, int | None], set[int]] = defaultdict(set)
 
         # the default node might get duplicated (e.g., by EagerReturns). we detect if a duplicate of the default node
         # (node b) is a successor node of node a. we only skip those entries going to the default node if no duplicate
@@ -1478,7 +1482,7 @@ class PhoenixStructurer(StructurerBase):
                     all_case_nodes = list(cases.values())
                     if node_default is not None:
                         all_case_nodes.append(node_default)
-                    case_node: SequenceNode = [nn for nn in all_case_nodes if nn.addr == out_src.addr][0]
+                    case_node: SequenceNode = next(nn for nn in all_case_nodes if nn.addr == out_src.addr)
                     case_node_last_stmt = self.cond_proc.get_last_statement(case_node)
                     if not isinstance(case_node_last_stmt, Jump):
                         jump_stmt = Jump(
@@ -1486,8 +1490,6 @@ class PhoenixStructurer(StructurerBase):
                         )
                         jump_node = Block(out_src.addr, 0, statements=[jump_stmt])
                         case_node.nodes.append(jump_node)
-                    graph.add_edge(scnode, head)
-                    full_graph.add_edge(scnode, head)
 
             out_edges = [edge for edge in out_edges if edge[1] is not head]
             if out_edges:
@@ -1639,82 +1641,91 @@ class PhoenixStructurer(StructurerBase):
                 # swap them
                 left, right = right, left
                 left_succs, right_succs = right_succs, left_succs
-            if left in graph and len(left_succs) == 1 and left_succs[0] == right:
-                # potentially If-Then
-                if full_graph.in_degree[left] == 1 and full_graph.in_degree[right] >= 2:
-                    edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, start_node, left)
-                    edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, start_node, right)
-                    if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
-                        # c = !c
-                        last_if_jump = self._remove_last_statement_if_jump(start_node)
-                        new_cond_node = ConditionNode(
-                            last_if_jump.ins_addr if last_if_jump is not None else start_node.addr,
-                            None,
-                            edge_cond_left,
-                            left,
-                            false_node=None,
-                        )
-                        new_node = SequenceNode(start_node.addr, nodes=[start_node, new_cond_node])
+            # potentially If-Then
+            if (
+                left in graph
+                and len(left_succs) == 1
+                and left_succs[0] == right
+                and full_graph.in_degree[left] == 1
+                and full_graph.in_degree[right] >= 2
+            ):
+                edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, start_node, left)
+                edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, start_node, right)
+                if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
+                    # c = !c
+                    last_if_jump = self._remove_last_statement_if_jump(start_node)
+                    new_cond_node = ConditionNode(
+                        last_if_jump.ins_addr if last_if_jump is not None else start_node.addr,
+                        None,
+                        edge_cond_left,
+                        left,
+                        false_node=None,
+                    )
+                    new_node = SequenceNode(start_node.addr, nodes=[start_node, new_cond_node])
 
-                        # on the original graph
-                        self.replace_nodes(graph, start_node, new_node, old_node_1=left)
-                        # on the graph with successors
-                        self.replace_nodes(full_graph, start_node, new_node, old_node_1=left)
+                    # on the original graph
+                    self.replace_nodes(graph, start_node, new_node, old_node_1=left)
+                    # on the graph with successors
+                    self.replace_nodes(full_graph, start_node, new_node, old_node_1=left)
 
-                        return True
+                    return True
 
             if right in graph and left not in graph:
                 # swap them
                 left, right = right, left
                 left_succs, right_succs = right_succs, left_succs  # pylint:disable=unused-variable
-            if left in graph and right not in graph:
-                # potentially If-then
-                if full_graph.in_degree[left] == 1 and (
+            # potentially If-then
+            if (
+                left in graph
+                and right not in graph
+                and full_graph.in_degree[left] == 1
+                and (
                     full_graph.in_degree[right] == 2
                     and left_succs == [right]
                     or full_graph.in_degree[right] == 1
                     and not left_succs
-                ):
-                    edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, start_node, left)
-                    edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, start_node, right)
-                    if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
-                        # c = !c
-                        try:
-                            last_stmt = self.cond_proc.get_last_statement(start_node)
-                        except EmptyBlockNotice:
-                            last_stmt = None
-                        new_cond_node = ConditionNode(
-                            last_stmt.ins_addr if last_stmt is not None else start_node.addr,
-                            None,
-                            edge_cond_left,
-                            left,
-                            false_node=None,
+                )
+            ):
+                edge_cond_left = self.cond_proc.recover_edge_condition(full_graph, start_node, left)
+                edge_cond_right = self.cond_proc.recover_edge_condition(full_graph, start_node, right)
+                if claripy.is_true(claripy.Not(edge_cond_left) == edge_cond_right):
+                    # c = !c
+                    try:
+                        last_stmt = self.cond_proc.get_last_statement(start_node)
+                    except EmptyBlockNotice:
+                        last_stmt = None
+                    new_cond_node = ConditionNode(
+                        last_stmt.ins_addr if last_stmt is not None else start_node.addr,
+                        None,
+                        edge_cond_left,
+                        left,
+                        false_node=None,
+                    )
+                    new_nodes = [start_node, new_cond_node]
+                    if full_graph.in_degree[right] == 1:
+                        # only remove the if statement when it will no longer be used later
+                        self._remove_last_statement_if_jump(start_node)
+                        # add a goto node at the end
+                        new_jump_node = Block(
+                            new_cond_node.addr,
+                            0,
+                            statements=[
+                                Jump(
+                                    None,
+                                    Const(None, None, right.addr, self.project.arch.bits),
+                                    ins_addr=new_cond_node.addr,
+                                )
+                            ],
                         )
-                        new_nodes = [start_node, new_cond_node]
-                        if full_graph.in_degree[right] == 1:
-                            # only remove the if statement when it will no longer be used later
-                            self._remove_last_statement_if_jump(start_node)
-                            # add a goto node at the end
-                            new_jump_node = Block(
-                                new_cond_node.addr,
-                                0,
-                                statements=[
-                                    Jump(
-                                        None,
-                                        Const(None, None, right.addr, self.project.arch.bits),
-                                        ins_addr=new_cond_node.addr,
-                                    )
-                                ],
-                            )
-                            new_nodes.append(new_jump_node)
-                        new_node = SequenceNode(start_node.addr, nodes=new_nodes)
+                        new_nodes.append(new_jump_node)
+                    new_node = SequenceNode(start_node.addr, nodes=new_nodes)
 
-                        # on the original graph
-                        self.replace_nodes(graph, start_node, new_node, old_node_1=left)
-                        # on the graph with successors
-                        self.replace_nodes(full_graph, start_node, new_node, old_node_1=left)
+                    # on the original graph
+                    self.replace_nodes(graph, start_node, new_node, old_node_1=left)
+                    # on the graph with successors
+                    self.replace_nodes(full_graph, start_node, new_node, old_node_1=left)
 
-                        return True
+                    return True
 
         return False
 
@@ -2234,7 +2245,7 @@ class PhoenixStructurer(StructurerBase):
         The original Phoenix algorithm had no support for multi-stmt expressions, such as the following:
         if ((x = y) && z) { ... }
 
-        There are multiple levels at which multi-stmt expressions can be used. If the Phoenix algorith is not not
+        There are multiple levels at which multi-stmt expressions can be used. If the Phoenix algorithm is not not
         set to be in improved mode, then we should not use multi-stmt expressions at all.
         """
         if not self._improve_algorithm:
@@ -2270,35 +2281,36 @@ class PhoenixStructurer(StructurerBase):
         dst_idx = dst.idx if isinstance(dst, Block) else ...
 
         def _check(last_stmt):
-            if (
-                not condjump_only
-                and isinstance(last_stmt, Jump)
-                and isinstance(last_stmt.target, Const)
-                and last_stmt.target.value == dst_addr
-                and (dst_idx is ... or last_stmt.target_idx == dst_idx)
-            ):
-                return True
-            elif isinstance(last_stmt, ConditionalJump):
-                if (
-                    isinstance(last_stmt.true_target, Const)
-                    and last_stmt.true_target.value == dst_addr
-                    and (dst_idx is ... or last_stmt.true_target_idx == dst_idx)
-                ):
-                    return True
-                elif (
-                    isinstance(last_stmt.false_target, Const)
-                    and last_stmt.false_target.value == dst_addr
-                    and (dst_idx is ... or last_stmt.false_target_idx == dst_idx)
-                ):
-                    return True
-            elif isinstance(last_stmt, IncompleteSwitchCaseHeadStatement):
-                if any(case_addr == dst_addr for _, _, _, case_addr in last_stmt.case_addrs):
-                    return True
-            return False
+            return (
+                (
+                    not condjump_only
+                    and isinstance(last_stmt, Jump)
+                    and isinstance(last_stmt.target, Const)
+                    and last_stmt.target.value == dst_addr
+                    and (dst_idx is ... or last_stmt.target_idx == dst_idx)
+                )
+                or isinstance(last_stmt, ConditionalJump)
+                and (
+                    (
+                        isinstance(last_stmt.true_target, Const)
+                        and last_stmt.true_target.value == dst_addr
+                        and (dst_idx is ... or last_stmt.true_target_idx == dst_idx)
+                    )
+                    or (
+                        isinstance(last_stmt.false_target, Const)
+                        and last_stmt.false_target.value == dst_addr
+                        and (dst_idx is ... or last_stmt.false_target_idx == dst_idx)
+                    )
+                )
+                or (
+                    isinstance(last_stmt, IncompleteSwitchCaseHeadStatement)
+                    and any(case_addr == dst_addr for _, _, _, _, case_addr in last_stmt.case_addrs)
+                )
+            )
 
         def _handle_Block(block: Block, parent=None, **kwargs):  # pylint:disable=unused-argument
             if block.statements:
-                first_stmt = first_nonlabel_statement(block)
+                first_stmt = first_nonlabel_nonphi_statement(block)
                 if first_stmt is not None:
                     # this block has content. increment the block ID counter
                     walker.block_id += 1
@@ -2307,9 +2319,7 @@ class PhoenixStructurer(StructurerBase):
                     walker.parent_and_block.append((walker.block_id, parent, block))
                 elif len(block.statements) > 1:
                     last_stmt = block.statements[-1]
-                    if _check(last_stmt):
-                        walker.parent_and_block.append((walker.block_id, parent, block))
-                    elif (
+                    if _check(last_stmt) or (
                         not isinstance(last_stmt, (Jump, ConditionalJump))
                         and block.addr + block.original_size == dst_addr
                     ):
@@ -2317,7 +2327,7 @@ class PhoenixStructurer(StructurerBase):
 
         def _handle_MultiNode(block: MultiNode, parent=None, **kwargs):  # pylint:disable=unused-argument
             if block.nodes and isinstance(block.nodes[-1], Block) and block.nodes[-1].statements:
-                first_stmt = first_nonlabel_statement(block)
+                first_stmt = first_nonlabel_nonphi_statement(block)
                 if first_stmt is not None:
                     # this block has content. increment the block ID counter
                     walker.block_id += 1
@@ -2348,10 +2358,9 @@ class PhoenixStructurer(StructurerBase):
         walker.walk(node)
         if not walker.parent_and_block:
             return None, None, None
-        else:
-            if last:
-                return walker.parent_and_block[-1]
-            return walker.parent_and_block[0]
+        if last:
+            return walker.parent_and_block[-1]
+        return walker.parent_and_block[0]
 
     @staticmethod
     def _unpack_sequencenode_head(graph: networkx.DiGraph, seq: SequenceNode, new_seq=None):
@@ -2395,10 +2404,8 @@ class PhoenixStructurer(StructurerBase):
     @staticmethod
     def _count_statements(node: BaseNode | Block) -> int:
         if isinstance(node, Block):
-            return sum(1 for stmt in node.statements if not isinstance(stmt, Label))
-        elif isinstance(node, MultiNode):
-            return sum(PhoenixStructurer._count_statements(nn) for nn in node.nodes)
-        elif isinstance(node, SequenceNode):
+            return sum(1 for stmt in node.statements if not isinstance(stmt, Label) and not is_phi_assignment(stmt))
+        if isinstance(node, (MultiNode, SequenceNode)):
             return sum(PhoenixStructurer._count_statements(nn) for nn in node.nodes)
         return 1
 
@@ -2418,16 +2425,7 @@ class PhoenixStructurer(StructurerBase):
         def _is_sequential_statement_list(stmts: list[Statement]) -> bool:
             if not stmts:
                 return True
-            for stmt in stmts[:-1]:
-                if isinstance(
-                    stmt,
-                    (
-                        ConditionalJump,
-                        Jump,
-                    ),
-                ):
-                    return False
-            return True
+            return all(not isinstance(stmt, (ConditionalJump, Jump)) for stmt in stmts[:-1])
 
         def _to_statement_list(node: Block | MultiNode | SequenceNode) -> list[Statement]:
             if isinstance(node, Block):
@@ -2461,10 +2459,12 @@ class PhoenixStructurer(StructurerBase):
                     return None
                 stmts += stmts_
             return stmts
-        elif isinstance(block, Block):
+        if isinstance(block, Block):
             for idx, stmt in enumerate(block.statements):
                 if isinstance(stmt, Label):
                     continue
+                if is_phi_assignment(stmt):
+                    continue
                 if isinstance(stmt, ConditionalJump):
                     if idx == len(block.statements) - 1:
                         continue
@@ -2487,7 +2487,7 @@ class PhoenixStructurer(StructurerBase):
             if node.statements:
                 idx = 0
                 first_stmt = node.statements[idx]
-                while isinstance(first_stmt, Label):
+                while isinstance(first_stmt, Label) or is_phi_assignment(first_stmt):
                     idx += 1
                     if idx >= len(node.statements):
                         first_stmt = None
@@ -2504,7 +2504,7 @@ class PhoenixStructurer(StructurerBase):
         if isinstance(node, MultiNode):
             for nn in node.nodes:
                 if isinstance(nn, Block):
-                    if not has_nonlabel_statements(nn):
+                    if not has_nonlabel_nonphi_statements(nn):
                         continue
                     return PhoenixStructurer._remove_first_statement_if_jump(nn)
                 break
@@ -2532,7 +2532,7 @@ class PhoenixStructurer(StructurerBase):
             src_out_degree = graph.out_degree[src]
             return -node_seq.get(dst), dst_in_degree, src_out_degree, -src.addr, -dst.addr
 
-        return list(sorted(edges, key=_sort_edge, reverse=True))
+        return sorted(edges, key=_sort_edge, reverse=True)
 
     @staticmethod
     def _replace_node_in_edge_list(edge_list: list[tuple], old_node, new_node) -> None:
@@ -2554,9 +2554,9 @@ class PhoenixStructurer(StructurerBase):
         graph_with_str = networkx.DiGraph()
 
         for node in graph:
-            graph_with_str.add_node(f'"{repr(node)}"')
+            graph_with_str.add_node(f'"{node!r}"')
 
         for src, dst in graph.edges:
-            graph_with_str.add_edge(f'"{repr(src)}"', f'"{repr(dst)}"')
+            graph_with_str.add_edge(f'"{src!r}"', f'"{dst!r}"')
 
         networkx.drawing.nx_pydot.write_dot(graph_with_str, path)