angr 9.2.101__py3-none-manylinux2014_x86_64.whl → 9.2.103__py3-none-manylinux2014_x86_64.whl

angr/analyses/data_dep/data_dependency_analysis.py

@@ -2,7 +2,7 @@
 
 import logging
 import math
-from typing import Optional, List, Union, Dict, Set, Tuple, TYPE_CHECKING
+from typing import Optional, Union, TYPE_CHECKING
 
 from networkx import DiGraph
 
@@ -54,9 +54,9 @@ class DataDependencyGraphAnalysis(Analysis):
     def __init__(
         self,
         end_state: "SimState",
-        start_from: Optional[int] = None,
-        end_at: Optional[int] = None,
-        block_addrs: Optional[List[int]] = None,
+        start_from: int | None = None,
+        end_at: int | None = None,
+        block_addrs: list[int] | None = None,
     ):
         """
         :param end_state: Simulation state used to extract all SimActionData
@@ -64,9 +64,9 @@ class DataDependencyGraphAnalysis(Analysis):
         :param end_at: An address or None, Specifies where to end generation of DDG
         :param iterable or None block_addrs: List of block addresses that the DDG analysis should be run on
         """
-        self._graph: Optional[DiGraph] = None
-        self._simplified_graph: Optional[DiGraph] = None
-        self._sub_graph: Optional[DiGraph] = None
+        self._graph: DiGraph | None = None
+        self._simplified_graph: DiGraph | None = None
+        self._sub_graph: DiGraph | None = None
 
         self._end_state = end_state
         self._start_from = start_from if start_from else self.project.entry
@@ -77,12 +77,12 @@ class DataDependencyGraphAnalysis(Analysis):
         self._register_file.set_state(self._end_state)
         self._memory_map = DefaultMemory(memory_id="mem")  # Tracks the current state of all parsed memory addresses
         self._memory_map.set_state(self._end_state)
-        self._tmp_nodes: Dict[str, TmpDepNode] = {}  # Per-block: Maps temp name to its current node
-        self._constant_nodes: Dict[int, ConstantDepNode] = {}  # Per program: Maps values to their ConstantDepNodes
-        self._actions: List["SimActionData"] = []
+        self._tmp_nodes: dict[str, TmpDepNode] = {}  # Per-block: Maps temp name to its current node
+        self._constant_nodes: dict[int, ConstantDepNode] = {}  # Per program: Maps values to their ConstantDepNodes
+        self._actions: list["SimActionData"] = []
 
         # Used by parser to track instruction addresses processed
-        self._parsed_ins_addrs: List[ParsedInstruction] = []  # Instruction address, min stmt_idx, max stmt_idx
+        self._parsed_ins_addrs: list[ParsedInstruction] = []  # Instruction address, min stmt_idx, max stmt_idx
 
         # Parameter sanity check
         if self._block_addrs and self._end_at:
@@ -91,15 +91,15 @@ class DataDependencyGraphAnalysis(Analysis):
         self._work()
 
     @property
-    def graph(self) -> Optional[DiGraph]:
+    def graph(self) -> DiGraph | None:
         return self._graph
 
     @property
-    def simplified_graph(self) -> Optional[DiGraph]:
+    def simplified_graph(self) -> DiGraph | None:
         return self._simplified_graph
 
     @property
-    def sub_graph(self) -> Optional[DiGraph]:
+    def sub_graph(self) -> DiGraph | None:
         return self._sub_graph
 
     def _pop(self) -> Optional["SimActionData"]:
@@ -171,7 +171,7 @@ class DataDependencyGraphAnalysis(Analysis):
         self,
         type_: int,
         sim_act: "SimActionData",
-        val: Tuple["BV", int],
+        val: tuple["BV", int],
         *constructor_params,
     ) -> "BaseDepNode":
         """
@@ -213,7 +213,7 @@ class DataDependencyGraphAnalysis(Analysis):
         return ret_node
 
     def _get_dep_node(
-        self, dep_type: int, sim_act: SimActionData, var_src: Union[int, "BV"], val: Union[int, BV]
+        self, dep_type: int, sim_act: SimActionData, var_src: Union[int, "BV"], val: int | BV
     ) -> "BaseDepNode":
         if isinstance(var_src, BV):
             var_src = self._end_state.solver.eval(var_src)
@@ -287,7 +287,7 @@ class DataDependencyGraphAnalysis(Analysis):
     def _parse_action(self) -> "BaseDepNode":
         return self._get_generic_node(self._pop())
 
-    def _parse_read_statement(self, read_nodes: Optional[Dict[int, List["BaseDepNode"]]] = None) -> "BaseDepNode":
+    def _parse_read_statement(self, read_nodes: dict[int, list["BaseDepNode"]] | None = None) -> "BaseDepNode":
         act = self._peek()
         read_node = self._parse_action()
         ancestor_node = self._get_active_node(read_node)
@@ -310,7 +310,7 @@ class DataDependencyGraphAnalysis(Analysis):
 
         return read_node
 
-    def _create_dep_edges(self, act, write_node, read_nodes: Dict[int, List["BaseDepNode"]]) -> bool:
+    def _create_dep_edges(self, act, write_node, read_nodes: dict[int, list["BaseDepNode"]]) -> bool:
         """Last resort for linking dependencies"""
         # Check tmp and reg deps
         var_read_nodes = []
@@ -337,7 +337,7 @@ class DataDependencyGraphAnalysis(Analysis):
 
         return dep_found
 
-    def _parse_var_statement(self, read_nodes: Optional[Dict[int, List["BaseDepNode"]]] = None) -> SimActLocation:
+    def _parse_var_statement(self, read_nodes: dict[int, list["BaseDepNode"]] | None = None) -> SimActLocation:
         act = self._peek()
         act_loc = SimActLocation(act.bbl_addr, act.ins_addr, act.stmt_idx)
 
@@ -383,7 +383,7 @@ class DataDependencyGraphAnalysis(Analysis):
                 self._parse_statement(read_nodes) if self._peek() and act.stmt_idx == self._peek().stmt_idx else act_loc
             )
 
-    def _parse_mem_statement(self, read_nodes: Optional[Dict[int, List["BaseDepNode"]]] = None) -> SimActLocation:
+    def _parse_mem_statement(self, read_nodes: dict[int, list["BaseDepNode"]] | None = None) -> SimActLocation:
         act = self._peek()
         act_loc = SimActLocation(act.bbl_addr, act.ins_addr, act.stmt_idx)
 
@@ -416,7 +416,7 @@ class DataDependencyGraphAnalysis(Analysis):
 
         return ret_val if ret_val else self._parse_statement(read_nodes)
 
-    def _parse_statement(self, read_nodes: Optional[Dict[int, List["BaseDepNode"]]] = None) -> SimActLocation:
+    def _parse_statement(self, read_nodes: dict[int, list["BaseDepNode"]] | None = None) -> SimActLocation:
         """
         statement -> write_var | write_mem
         statement -> read_var | write_mem statement
@@ -493,7 +493,7 @@ class DataDependencyGraphAnalysis(Analysis):
             self._parse_block()
             self._parse_blocks()
 
-    def _filter_sim_actions(self) -> List[SimActionData]:
+    def _filter_sim_actions(self) -> list[SimActionData]:
         """
         Using the user's start/end address OR block address list parameters,
         filters the actions down to those that are relevant
@@ -574,7 +574,7 @@ class DataDependencyGraphAnalysis(Analysis):
         return g0
 
     @staticmethod
-    def _get_related_nodes(G: DiGraph, curr_node: "BaseDepNode", nodes: Set["BaseDepNode"], get_ancestors: bool):
+    def _get_related_nodes(G: DiGraph, curr_node: "BaseDepNode", nodes: set["BaseDepNode"], get_ancestors: bool):
         nodes.add(curr_node)
 
         next_nodes = G.predecessors(curr_node) if get_ancestors else G.successors(curr_node)
@@ -587,7 +587,7 @@ class DataDependencyGraphAnalysis(Analysis):
         else:
             return
 
-    def get_data_dep(self, g_node: "BaseDepNode", include_tmp_nodes: bool, backwards: bool) -> Optional[DiGraph]:
+    def get_data_dep(self, g_node: "BaseDepNode", include_tmp_nodes: bool, backwards: bool) -> DiGraph | None:
         # We have a matching node and can proceed to build a subgraph
         if g_node in self._graph:
             relevant_nodes = set()

angr/analyses/data_dep/dep_nodes.py

@@ -1,4 +1,4 @@
-from typing import Optional, Tuple, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from claripy.ast.bv import BV
@@ -27,10 +27,10 @@ class BaseDepNode:
         self.ins_addr = sim_act.ins_addr
         self.stmt_idx = sim_act.stmt_idx
         self.action_id: int = sim_act.id
-        self.value: Optional[int] = None
+        self.value: int | None = None
         self._value_ast: Optional["BV"] = None
 
-    def value_tuple(self) -> Tuple["BV", int]:
+    def value_tuple(self) -> tuple["BV", int]:
         """
         :return: A tuple containing the node's value as a BV and as an evaluated integer
         """

angr/analyses/ddg.py

@@ -1,6 +1,5 @@
 import logging
 from collections import defaultdict
-from typing import List
 
 import networkx
 import pyvex
@@ -425,7 +424,7 @@ class DDGViewInstruction:
             return DDGViewItem(self._ddg, pv, simplified=self._simplified)
 
     @property
-    def definitions(self) -> List[DDGViewItem]:
+    def definitions(self) -> list[DDGViewItem]:
         """
         Get all definitions located at the current instruction address.
 

angr/analyses/decompiler/ail_simplifier.py

@@ -1,5 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
-from typing import Set, Dict, List, Tuple, Any, Optional, TYPE_CHECKING
+from typing import Any, Optional, TYPE_CHECKING
 from collections import defaultdict
 import logging
 
@@ -74,14 +74,15 @@ class AILSimplifier(Analysis):
         func,
         func_graph=None,
         remove_dead_memdefs=False,
-        stack_arg_offsets: Optional[Set[Tuple[int, int]]] = None,
+        stack_arg_offsets: set[tuple[int, int]] | None = None,
         unify_variables=False,
         ail_manager: Optional["Manager"] = None,
-        gp: Optional[int] = None,
+        gp: int | None = None,
         narrow_expressions=False,
         only_consts=False,
         fold_callexprs_into_conditions=False,
         use_callee_saved_regs_at_return=True,
+        rewrite_ccalls=True,
     ):
         self.func = func
         self.func_graph = func_graph if func_graph is not None else func.graph
@@ -97,9 +98,10 @@ class AILSimplifier(Analysis):
         self._only_consts = only_consts
         self._fold_callexprs_into_conditions = fold_callexprs_into_conditions
         self._use_callee_saved_regs_at_return = use_callee_saved_regs_at_return
+        self._should_rewrite_ccalls = rewrite_ccalls
 
-        self._calls_to_remove: Set[CodeLocation] = set()
-        self._assignments_to_remove: Set[CodeLocation] = set()
+        self._calls_to_remove: set[CodeLocation] = set()
+        self._assignments_to_remove: set[CodeLocation] = set()
         self.blocks = {}  # Mapping nodes to simplified blocks
 
         self.simplified: bool = False
@@ -127,13 +129,14 @@ class AILSimplifier(Analysis):
         if self._only_consts:
             return
 
-        _l.debug("Rewriting ccalls")
-        ccalls_rewritten = self._rewrite_ccalls()
-        self.simplified |= ccalls_rewritten
-        if ccalls_rewritten:
-            _l.debug("... ccalls rewritten")
-            self._rebuild_func_graph()
-            self._clear_cache()
+        if self._should_rewrite_ccalls:
+            _l.debug("Rewriting ccalls")
+            ccalls_rewritten = self._rewrite_ccalls()
+            self.simplified |= ccalls_rewritten
+            if ccalls_rewritten:
+                _l.debug("... ccalls rewritten")
+                self._rebuild_func_graph()
+                self._clear_cache()
 
         if self._unify_vars:
             _l.debug("Removing dead assignments")
@@ -227,7 +230,7 @@ class AILSimplifier(Analysis):
 
         narrowed = False
 
-        addr_and_idx_to_block: Dict[Tuple[int, int], Block] = {}
+        addr_and_idx_to_block: dict[tuple[int, int], Block] = {}
         for block in self.func_graph.nodes():
             addr_and_idx_to_block[(block.addr, block.idx)] = block
 
@@ -457,13 +460,13 @@ class AILSimplifier(Analysis):
 
     def _narrowing_needed(
         self, def_, rd, addr_and_idx_to_block
-    ) -> Tuple[bool, Optional[int], Optional[List[Tuple[CodeLocation, Tuple[str, Tuple[Expression, ...]]]]]]:
+    ) -> tuple[bool, int | None, list[tuple[CodeLocation, tuple[str, tuple[Expression, ...]]]] | None]:
         def_size = def_.size
         # find its uses
         use_and_exprs = rd.all_uses.get_uses_with_expr(def_)
 
         all_used_sizes = set()
-        used_by: List[Tuple[CodeLocation, Tuple[str, Tuple[Expression, ...]]]] = []
+        used_by: list[tuple[CodeLocation, tuple[str, tuple[Expression, ...]]]] = []
 
         for loc, expr in use_and_exprs:
             old_block = addr_and_idx_to_block.get((loc.block_addr, loc.block_idx), None)
@@ -492,7 +495,7 @@ class AILSimplifier(Analysis):
 
     def _extract_expression_effective_size(
         self, statement, expr
-    ) -> Tuple[Optional[int], Optional[Tuple[str, Tuple[Expression, ...]]]]:
+    ) -> tuple[int | None, tuple[str, tuple[Expression, ...]] | None]:
         """
         Determine the effective size of an expression when it's used.
         """
@@ -603,11 +606,11 @@ class AILSimplifier(Analysis):
         if not prop.model.equivalence:
             return simplified
 
-        addr_and_idx_to_block: Dict[Tuple[int, int], Block] = {}
+        addr_and_idx_to_block: dict[tuple[int, int], Block] = {}
         for block in self.func_graph.nodes():
             addr_and_idx_to_block[(block.addr, block.idx)] = block
 
-        equivalences: Dict[Any, Set[Equivalence]] = defaultdict(set)
+        equivalences: dict[Any, set[Equivalence]] = defaultdict(set)
         atom_by_loc = set()
         for eq in prop.model.equivalence:
             equivalences[eq.atom1].add(eq)
@@ -735,7 +738,7 @@ class AILSimplifier(Analysis):
                             continue
 
                         # find all its uses
-                        all_arg_copy_var_uses: Set[Tuple[CodeLocation, Any]] = set(
+                        all_arg_copy_var_uses: set[tuple[CodeLocation, Any]] = set(
                             rd.all_uses.get_uses_with_expr(arg_copy_def)
                         )
                         all_uses_with_def = set()
@@ -816,7 +819,7 @@ class AILSimplifier(Analysis):
 
                 # find all uses of this definition
                 # we make a copy of the set since we may touch the set (uses) when replacing expressions
-                all_uses: Set[Tuple[CodeLocation, Any]] = set(rd.all_uses.get_uses_with_expr(to_replace_def))
+                all_uses: set[tuple[CodeLocation, Any]] = set(rd.all_uses.get_uses_with_expr(to_replace_def))
                 # make sure none of these uses are phi nodes (depends on more than one def)
                 all_uses_with_unique_def = set()
                 for use_and_expr in all_uses:
@@ -943,7 +946,7 @@ class AILSimplifier(Analysis):
         return simplified
 
     @staticmethod
-    def _find_atom_def_at(atom, rd, codeloc: CodeLocation) -> Optional[Definition]:
+    def _find_atom_def_at(atom, rd, codeloc: CodeLocation) -> Definition | None:
         if isinstance(atom, Register):
             defs = rd.get_defs(atom, codeloc, OP_BEFORE)
             return next(iter(defs)) if len(defs) == 1 else None
@@ -1007,18 +1010,18 @@ class AILSimplifier(Analysis):
         if not prop.model.equivalence:
             return simplified
 
-        addr_and_idx_to_block: Dict[Tuple[int, int], Block] = {}
+        addr_and_idx_to_block: dict[tuple[int, int], Block] = {}
         for block in self.func_graph.nodes():
             addr_and_idx_to_block[(block.addr, block.idx)] = block
 
-        def_locations_to_remove: Set[CodeLocation] = set()
-        updated_use_locations: Set[CodeLocation] = set()
+        def_locations_to_remove: set[CodeLocation] = set()
+        updated_use_locations: set[CodeLocation] = set()
 
         eq: Equivalence
         for eq in prop.model.equivalence:
             # register variable == Call
             if isinstance(eq.atom0, Register):
-                call_addr: Optional[int]
+                call_addr: int | None
                 if isinstance(eq.atom1, Call):
                     # register variable = Call
                     call: Expression = eq.atom1
@@ -1052,7 +1055,7 @@ class AILSimplifier(Analysis):
                 the_def: Definition = defs[0]
 
                 # find all uses of this definition
-                all_uses: Set[Tuple[CodeLocation, Any]] = set(rd.all_uses.get_uses_with_expr(the_def))
+                all_uses: set[tuple[CodeLocation, Any]] = set(rd.all_uses.get_uses_with_expr(the_def))
 
                 if len(all_uses) != 1:
                     continue
@@ -1156,8 +1159,8 @@ class AILSimplifier(Analysis):
         # no need to clear the cache at the end of this method
         return simplified
 
-    def _get_super_node_blocks(self, start_node: Block) -> List[Block]:
-        lst: List[Block] = [start_node]
+    def _get_super_node_blocks(self, start_node: Block) -> list[Block]:
+        lst: list[Block] = [start_node]
         while True:
             b = lst[-1]
             successors = list(self.func_graph.successors(b))
@@ -1178,7 +1181,7 @@ class AILSimplifier(Analysis):
 
     def _replace_expr_and_update_block(
         self, block, stmt_idx, stmt, the_def, codeloc, src_expr, dst_expr
-    ) -> Tuple[bool, Optional[Block]]:
+    ) -> tuple[bool, Block | None]:
         replaced, new_stmt = stmt.replace(src_expr, dst_expr)
         if replaced:
             new_block = block.copy()
@@ -1193,7 +1196,7 @@ class AILSimplifier(Analysis):
         return False, None
 
     def _remove_dead_assignments(self) -> bool:
-        stmts_to_remove_per_block: Dict[Tuple[int, int], Set[int]] = defaultdict(set)
+        stmts_to_remove_per_block: dict[tuple[int, int], set[int]] = defaultdict(set)
 
         # Find all statements that should be removed
         mask = (1 << self.project.arch.bits) - 1
@@ -1325,9 +1328,7 @@ class AILSimplifier(Analysis):
 
             v = False
 
-        def _handle_expr(
-            expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement, block
-        ) -> Optional[Expression]:
+        def _handle_expr(expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement, block) -> Expression | None:
             if isinstance(expr, DirtyExpression) and isinstance(expr.dirty_expr, VEXCCallExpression):
                 rewriter = rewriter_cls(expr.dirty_expr, self.project.arch)
                 if rewriter.result is not None:
@@ -1383,7 +1384,7 @@ class AILSimplifier(Analysis):
         return False
 
     @staticmethod
-    def _count_calls_in_supernodeblocks(blocks: List[Block], start: CodeLocation, end: CodeLocation) -> int:
+    def _count_calls_in_supernodeblocks(blocks: list[Block], start: CodeLocation, end: CodeLocation) -> int:
         """
         Count the number of call statements in a list of blocks for a single super block between two given code
         locations (exclusive).

angr/analyses/decompiler/block_io_finder.py

@@ -1,5 +1,5 @@
 from collections import defaultdict
-from typing import Any, Optional, Union, List
+from typing import Any
 
 from ailment import Block
 from ailment.statement import Call, Statement, ConditionalJump, Assignment, Store, Return, Jump
@@ -26,7 +26,7 @@ class BlockIOFinder(AILBlockWalkerBase):
     I/O locations can be a Register, MemoryLocation, or SpOffset (wrapped in a Memory Location).
     """
 
-    def __init__(self, ail_obj: Union[Block, List[Statement]], project, as_atom=True):
+    def __init__(self, ail_obj: Block | list[Statement], project, as_atom=True):
         super().__init__()
         self.expr_handlers[StackBaseOffset] = self._handle_StackBaseOffset
         self._as_atom = as_atom
@@ -86,7 +86,7 @@ class BlockIOFinder(AILBlockWalkerBase):
         other_input = self.inputs_by_stmt[other_idx]
         return target_output.intersection(other_input)
 
-    def can_swap(self, stmt, ail_obj: Union[Block, List[Statement]], offset: int):
+    def can_swap(self, stmt, ail_obj: Block | list[Statement], offset: int):
         all_stmts = (ail_obj.statements or []) if isinstance(ail_obj, Block) else ail_obj
         if stmt not in all_stmts:
             raise RuntimeError("Statement not in block, and we can't compute moving a stmt to a new block!")
@@ -123,14 +123,14 @@ class BlockIOFinder(AILBlockWalkerBase):
     # Statements (all with side effects)
     #
 
-    def _handle_Assignment(self, stmt_idx: int, stmt: Assignment, block: Optional[Block]):
+    def _handle_Assignment(self, stmt_idx: int, stmt: Assignment, block: Block | None):
         output_loc = self._handle_expr(0, stmt.dst, stmt_idx, stmt, block)
         self._add_or_update_dict(self.outputs_by_stmt, stmt_idx, output_loc)
 
         input_loc = self._handle_expr(1, stmt.src, stmt_idx, stmt, block)
         self._add_or_update_dict(self.inputs_by_stmt, stmt_idx, input_loc)
 
-    def _handle_Call(self, stmt_idx: int, stmt: Call, block: Optional[Block]):
+    def _handle_Call(self, stmt_idx: int, stmt: Call, block: Block | None):
         if stmt.args:
             for i, arg in enumerate(stmt.args):
                 input_loc = self._handle_expr(i, arg, stmt_idx, stmt, block)
@@ -139,14 +139,14 @@ class BlockIOFinder(AILBlockWalkerBase):
         out_loc = self._handle_expr(0, stmt.ret_expr, stmt_idx, stmt, block)
         self._add_or_update_dict(self.outputs_by_stmt, stmt_idx, out_loc)
 
-    def _handle_Store(self, stmt_idx: int, stmt: Store, block: Optional[Block]):
+    def _handle_Store(self, stmt_idx: int, stmt: Store, block: Block | None):
         out_loc = self._handle_expr(0, stmt.addr, stmt_idx, stmt, block, is_memory=True)
         self._add_or_update_dict(self.outputs_by_stmt, stmt_idx, out_loc)
 
         input_loc = self._handle_expr(1, stmt.data, stmt_idx, stmt, block)
         self._add_or_update_dict(self.inputs_by_stmt, stmt_idx, input_loc)
 
-    def _handle_ConditionalJump(self, stmt_idx: int, stmt: ConditionalJump, block: Optional[Block]):
+    def _handle_ConditionalJump(self, stmt_idx: int, stmt: ConditionalJump, block: Block | None):
         input1 = self._handle_expr(0, stmt.condition, stmt_idx, stmt, block)
         input2 = self._handle_expr(1, stmt.true_target, stmt_idx, stmt, block)
         input3 = self._handle_expr(2, stmt.false_target, stmt_idx, stmt, block)
@@ -154,7 +154,7 @@ class BlockIOFinder(AILBlockWalkerBase):
         self._add_or_update_dict(self.inputs_by_stmt, stmt_idx, input2)
         self._add_or_update_dict(self.inputs_by_stmt, stmt_idx, input3)
 
-    def _handle_Return(self, stmt_idx: int, stmt: Return, block: Optional[Block]):
+    def _handle_Return(self, stmt_idx: int, stmt: Return, block: Block | None):
         if stmt.ret_exprs:
             for i, ret_expr in enumerate(stmt.ret_exprs):
                 loc = self._handle_expr(i, ret_expr, stmt_idx, stmt, block)
@@ -170,8 +170,8 @@ class BlockIOFinder(AILBlockWalkerBase):
         expr_idx: int,
         expr: Expression,
         stmt_idx: int,
-        stmt: Optional[Statement],
-        block: Optional[Block],
+        stmt: Statement | None,
+        block: Block | None,
         is_memory=False,
     ) -> Any:
         try:
@@ -185,14 +185,14 @@ class BlockIOFinder(AILBlockWalkerBase):
 
     # pylint: disable=unused-argument
     def _handle_Load(
-        self, expr_idx: int, expr: Load, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=True
+        self, expr_idx: int, expr: Load, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=True
     ):
         load_loc = self._handle_expr(0, expr.addr, stmt_idx, stmt, block, is_memory=True)
         self._add_or_update_dict(self.derefed_at, stmt_idx, load_loc)
         return load_loc
 
     def _handle_CallExpr(
-        self, expr_idx: int, expr: Call, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: Call, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         args = set()
         if expr.args:
@@ -202,7 +202,7 @@ class BlockIOFinder(AILBlockWalkerBase):
         return args
 
     def _handle_BinaryOp(
-        self, expr_idx: int, expr: BinaryOp, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: BinaryOp, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         input_locs = set()
         self._add_or_update_set(
@@ -215,17 +215,17 @@ class BlockIOFinder(AILBlockWalkerBase):
         return input_locs
 
     def _handle_UnaryOp(
-        self, expr_idx: int, expr: UnaryOp, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: UnaryOp, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         return self._handle_expr(0, expr.operand, stmt_idx, stmt, block, is_memory=is_memory)
 
     def _handle_Convert(
-        self, expr_idx: int, expr: Convert, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: Convert, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         return self._handle_expr(expr_idx, expr.operand, stmt_idx, stmt, block, is_memory=is_memory)
 
     def _handle_ITE(
-        self, expr_idx: int, expr: ITE, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: ITE, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         input_locs = set()
         self._add_or_update_set(
@@ -249,7 +249,7 @@ class BlockIOFinder(AILBlockWalkerBase):
 
     # pylint: disable=unused-argument
     def _handle_Tmp(
-        self, expr_idx: int, expr: Tmp, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: Tmp, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         if self._as_atom:
             return None
@@ -258,7 +258,7 @@ class BlockIOFinder(AILBlockWalkerBase):
 
     # pylint: disable=unused-argument
     def _handle_Register(
-        self, expr_idx: int, expr: Register, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: Register, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         if self._as_atom:
             return Register(expr.reg_offset, expr.size)
@@ -266,7 +266,7 @@ class BlockIOFinder(AILBlockWalkerBase):
             return expr
 
     def _handle_Const(
-        self, expr_idx: int, expr: Const, stmt_idx: int, stmt: Statement, block: Optional[Block], is_memory=False
+        self, expr_idx: int, expr: Const, stmt_idx: int, stmt: Statement, block: Block | None, is_memory=False
     ):
         if self._as_atom:
             return MemoryLocation(expr.value, expr.size) if is_memory else ConstantSrc(expr.value, expr.size)
@@ -283,7 +283,7 @@ class BlockIOFinder(AILBlockWalkerBase):
         expr: StackBaseOffset,
         stmt_idx: int,
         stmt: Statement,
-        block: Optional[Block],
+        block: Block | None,
         is_memory=False,
     ):
         if self._as_atom:

angr/analyses/decompiler/block_similarity.py

@@ -1,5 +1,3 @@
-from typing import Union, Optional, List, Tuple
-
 import networkx as nx
 from ailment.block import Block
 from ailment.statement import Statement, ConditionalJump
@@ -19,7 +17,7 @@ def has_similar_stmt(blk1: Block, blk2: Block):
 
 
 def is_similar(
-    ail_obj1: Union[Block, Statement], ail_obj2: Union[Block, Statement], graph: nx.DiGraph = None, partial: bool = True
+    ail_obj1: Block | Statement, ail_obj2: Block | Statement, graph: nx.DiGraph = None, partial: bool = True
 ):
     """
     Returns True if the two AIL objects are similar, False otherwise.
@@ -128,7 +126,7 @@ def _kmp_search_ail_obj(search_pattern, stmt_seq, graph=None, partial=True):
             yield start_pos
 
 
-def index_of_similar_stmts(search_stmts, other_stmts, graph=None, all_positions=False) -> Optional[int]:
+def index_of_similar_stmts(search_stmts, other_stmts, graph=None, all_positions=False) -> int | None:
     """
     Returns the index of the first occurrence of the search_stmts (a list of Statement) in other_stmts (a list of
     Statement). If all_positions is True, returns a list of all positions.
@@ -157,8 +155,8 @@ def in_other(stmts, other, graph=None):
 
 
 def longest_ail_subseq(
-    stmts_list: List[List[Statement]], graph=None
-) -> Tuple[Optional[List[Statement]], Optional[List[int]]]:
+    stmts_list: list[list[Statement]], graph=None
+) -> tuple[list[Statement] | None, list[int] | None]:
     """
     Given a list of List[Statement], it returns the longest List[Statement] that is a subsequence of all the lists.
     The common List[Statement] most all be in the same order and adjacent to each other. If no common subsequence is

angr/analyses/decompiler/block_simplifier.py

@@ -1,6 +1,7 @@
 # pylint:disable=too-many-boolean-expressions
 import logging
-from typing import Optional, Union, Type, Iterable, Tuple, Set, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
+from collections.abc import Iterable
 
 from ailment.statement import Statement, Assignment, Call, Store, Jump
 from ailment.expression import Tmp, Load, Const, Register, Convert
@@ -60,13 +61,13 @@ class BlockSimplifier(Analysis):
     def __init__(
         self,
         block: Optional["Block"],
-        func_addr: Optional[int] = None,
+        func_addr: int | None = None,
         remove_dead_memdefs=False,
         stack_pointer_tracker=None,
-        peephole_optimizations: Optional[
-            Iterable[Union[Type[PeepholeOptimizationStmtBase], Type[PeepholeOptimizationExprBase]]]
-        ] = None,
-        stack_arg_offsets: Optional[Set[Tuple[int, int]]] = None,
+        peephole_optimizations: None | (
+            Iterable[type[PeepholeOptimizationStmtBase] | type[PeepholeOptimizationExprBase]]
+        ) = None,
+        stack_arg_offsets: set[tuple[int, int]] | None = None,
         cached_reaching_definitions=None,
         cached_propagator=None,
     ):
@@ -194,14 +195,14 @@ class BlockSimplifier(Analysis):
         # propagator
         if nonconstant_stmts >= 2 and has_propagatable_assignments:
             propagator = self._compute_propagation(block)
-            prop_state = list(propagator.model.states.values())[0]
-            replacements = prop_state._replacements
-            if replacements:
-                _, new_block = self._replace_and_build(block, replacements, replace_registers=True)
-                new_block = self._eliminate_self_assignments(new_block)
-                self._clear_cache()
-            else:
-                new_block = block
+            new_block = block
+            if propagator.model.states:
+                prop_state = list(propagator.model.states.values())[0]
+                replacements = prop_state._replacements
+                if replacements:
+                    _, new_block = self._replace_and_build(block, replacements, replace_registers=True)
+                    new_block = self._eliminate_self_assignments(new_block)
+                    self._clear_cache()
         else:
             # Skipped calling Propagator
             new_block = block
@@ -218,9 +219,9 @@ class BlockSimplifier(Analysis):
         replacements,
         replace_assignment_dsts: bool = False,
         replace_loads: bool = False,
-        gp: Optional[int] = None,
+        gp: int | None = None,
         replace_registers: bool = True,
-    ) -> Tuple[bool, "Block"]:
+    ) -> tuple[bool, "Block"]:
         new_statements = block.statements[::]
         replaced = False