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

angr/analyses/disassembly.py

@@ -1,6 +1,7 @@
 import logging
 from collections import defaultdict
-from typing import Union, Optional, Sequence, Tuple, Any
+from typing import Union, Any
+from collections.abc import Sequence
 
 import pyvex
 import archinfo
@@ -963,11 +964,11 @@ class Disassembly(Analysis):
 
     def __init__(
         self,
-        function: Optional[Function] = None,
-        ranges: Optional[Sequence[Tuple[int, int]]] = None,
+        function: Function | None = None,
+        ranges: Sequence[tuple[int, int]] | None = None,
         thumb: bool = False,
         include_ir: bool = False,
-        block_bytes: Optional[bytes] = None,
+        block_bytes: bytes | None = None,
     ):
         self.raw_result = []
         self.raw_result_map = {
@@ -1156,7 +1157,7 @@ class Disassembly(Analysis):
         show_edges: bool = True,
         show_addresses: bool = True,
         show_bytes: bool = False,
-        ascii_only: Optional[bool] = None,
+        ascii_only: bool | None = None,
         color: bool = True,
     ) -> str:
         """
@@ -1188,7 +1189,7 @@ class Disassembly(Analysis):
                 "format_callback": lambda item, s: ansi_color(s, formatting["colors"].get(type(item), None)),
             }
 
-        def col(item: Any) -> Optional[str]:
+        def col(item: Any) -> str | None:
             try:
                 return formatting["colors"][item]
             except KeyError:

angr/analyses/flirt.py

@@ -1,4 +1,4 @@
-from typing import Union, List, Dict, Tuple, TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 from functools import partial
 from collections import defaultdict
 import logging
@@ -30,11 +30,11 @@ class FlirtAnalysis(Analysis):
       current binary, and then match all possible signatures for the architecture.
     """
 
-    def __init__(self, sig: Optional[Union[FlirtSignature, str]] = None):
+    def __init__(self, sig: FlirtSignature | str | None = None):
         self._is_arm = is_arm_arch(self.project.arch)
-        self._all_suggestions: Dict[str, Dict[str, Dict[int, str]]] = {}
-        self._suggestions: Dict[int, str] = {}
-        self.matched_suggestions: Dict[str, Tuple[FlirtSignature, Dict[int, str]]] = {}
+        self._all_suggestions: dict[str, dict[str, dict[int, str]]] = {}
+        self._suggestions: dict[int, str] = {}
+        self.matched_suggestions: dict[str, tuple[FlirtSignature, dict[int, str]]] = {}
         self._temporary_sig = False
 
         if sig:
@@ -64,7 +64,7 @@ class FlirtAnalysis(Analysis):
             self.signatures = list(self._find_hits_by_strings(mem_regions))
             _l.debug("Identified %d signatures to apply.", len(self.signatures))
 
-        path_to_sig: Dict[str, FlirtSignature] = {}
+        path_to_sig: dict[str, FlirtSignature] = {}
         for sig_ in self.signatures:
             self._match_all_against_one_signature(sig_)
             if sig_.sig_name not in self._all_suggestions:
@@ -90,8 +90,8 @@ class FlirtAnalysis(Analysis):
                 )
                 self.matched_suggestions[lib] = (sig_, sig_to_suggestions[max_suggestion_sig_path])
 
-    def _find_hits_by_strings(self, regions: List[bytes]) -> List[FlirtSignature]:
-        library_hits: Dict[str, int] = defaultdict(int)
+    def _find_hits_by_strings(self, regions: list[bytes]) -> list[FlirtSignature]:
+        library_hits: dict[str, int] = defaultdict(int)
         for s, libs in STRING_TO_LIBRARIES.items():
             for region in regions:
                 if s.encode("ascii") in region:
@@ -173,7 +173,7 @@ class FlirtAnalysis(Analysis):
                 func_name = f"unknown_function_{func.addr:x}"
             self._suggestions[func.addr] = func_name
 
-    def _apply_changes(self, library_name: Optional[str], suggestion: Dict[int, str]) -> None:
+    def _apply_changes(self, library_name: str | None, suggestion: dict[int, str]) -> None:
         for func_addr, suggested_name in suggestion.items():
             func = self.kb.functions.get_by_addr(func_addr)
             func.name = suggested_name

angr/analyses/forward_analysis/forward_analysis.py

@@ -1,5 +1,6 @@
 from collections import defaultdict
-from typing import Any, Dict, List, Callable, Optional, Generic, Type, TypeVar, Tuple, Set, TYPE_CHECKING, Union
+from typing import Any, Optional, Generic, TypeVar, TYPE_CHECKING
+from collections.abc import Callable
 
 import networkx
 
@@ -41,7 +42,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         order_jobs=False,
         allow_merging=False,
         allow_widening=False,
-        status_callback: Optional[Callable[[Type["ForwardAnalysis"]], Any]] = None,
+        status_callback: Callable[[type["ForwardAnalysis"]], Any] | None = None,
         graph_visitor: "Optional[GraphVisitor[NodeType]]" = None,
     ):
         """
@@ -69,15 +70,15 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         self._should_abort = False
 
         # All remaining jobs
-        self._job_info_queue: List[JobInfo[JobType, JobKey]] = []
+        self._job_info_queue: list[JobInfo[JobType, JobKey]] = []
 
         # A map between job key to job. Jobs with the same key will be merged by calling _merge_jobs()
-        self._job_map: Dict[JobKey, JobInfo[JobType, JobKey]] = {}
+        self._job_map: dict[JobKey, JobInfo[JobType, JobKey]] = {}
 
         # A mapping between node and its input states
-        self._input_states: Dict[NodeType, List[AnalysisState]] = defaultdict(list)
+        self._input_states: dict[NodeType, list[AnalysisState]] = defaultdict(list)
         # A mapping between node and its output state
-        self._output_state: Dict[NodeType, AnalysisState] = {}
+        self._output_state: dict[NodeType, AnalysisState] = {}
 
         # The graph!
         # Analysis results (nodes) are stored here
@@ -149,16 +150,16 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
     def _job_key(self, job: JobType) -> JobKey:
         raise NotImplementedError("_job_key() is not implemented.")
 
-    def _get_successors(self, job: JobType) -> Union[List[SimState], List[JobType]]:
+    def _get_successors(self, job: JobType) -> list[SimState] | list[JobType]:
         raise NotImplementedError("_get_successors() is not implemented.")
 
     def _pre_job_handling(self, job: JobType) -> None:
         raise NotImplementedError("_pre_job_handling() is not implemented.")
 
-    def _post_job_handling(self, job: JobType, new_jobs, successors: List[SimState]) -> None:
+    def _post_job_handling(self, job: JobType, new_jobs, successors: list[SimState]) -> None:
         raise NotImplementedError("_post_job_handling() is not implemented.")
 
-    def _handle_successor(self, job: JobType, successor: SimState, successors: List[SimState]) -> List[JobType]:
+    def _handle_successor(self, job: JobType, successor: SimState, successors: list[SimState]) -> list[JobType]:
         raise NotImplementedError("_handle_successor() is not implemented.")
 
     def _job_queue_empty(self) -> None:
@@ -179,7 +180,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
         """
         return node
 
-    def _run_on_node(self, node: NodeType, state: AnalysisState) -> Tuple[bool, AnalysisState]:
+    def _run_on_node(self, node: NodeType, state: AnalysisState) -> tuple[bool, AnalysisState]:
         """
         The analysis routine that runs on each node in the graph.
 
@@ -197,7 +198,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
 
         raise NotImplementedError("_run_on_node() is not implemented.")
 
-    def _merge_states(self, node: NodeType, *states: AnalysisState) -> Tuple[AnalysisState, bool]:
+    def _merge_states(self, node: NodeType, *states: AnalysisState) -> tuple[AnalysisState, bool]:
         """
         Merge multiple abstract states into one.
 
@@ -311,7 +312,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
                     for succ in successors_to_visit:
                         self._graph_visitor.revisit_node(succ)
 
-    def _add_input_state(self, node: NodeType, input_state: AnalysisState) -> Set[NodeType]:
+    def _add_input_state(self, node: NodeType, input_state: AnalysisState) -> set[NodeType]:
         """
         Add the input state to all successors of the given node.
 
@@ -334,7 +335,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
 
         return successors
 
-    def _get_and_update_input_state(self, node: NodeType) -> Optional[AnalysisState]:
+    def _get_and_update_input_state(self, node: NodeType) -> AnalysisState | None:
         """
         Get the input abstract state for this node, and remove it from the state map.
 
@@ -348,7 +349,7 @@ class ForwardAnalysis(Generic[AnalysisState, NodeType, JobType, JobKey]):
             return input_state
         return None
 
-    def _get_input_state(self, node: NodeType) -> Optional[AnalysisState]:
+    def _get_input_state(self, node: NodeType) -> AnalysisState | None:
         """
         Get the input abstract state for this node.
 

angr/analyses/forward_analysis/visitors/function_graph.py

@@ -1,4 +1,3 @@
-from typing import List, Tuple
 import logging
 
 import networkx
@@ -74,7 +73,7 @@ class FunctionGraphVisitor(GraphVisitor):
 
         return sorted_nodes
 
-    def back_edges(self) -> List[Tuple[NodeType, NodeType]]:
+    def back_edges(self) -> list[tuple[NodeType, NodeType]]:
         start_nodes = [node for node in self.graph if node.addr == self.function.addr]
         if not start_nodes:
             start_nodes = [node for node in self.graph if self.graph.in_degree(node) == 0]

angr/analyses/forward_analysis/visitors/graph.py

@@ -1,4 +1,5 @@
-from typing import TypeVar, Generic, List, Collection, Optional, Iterator, Set, Dict, Tuple
+from typing import TypeVar, Generic
+from collections.abc import Collection, Iterator
 from collections import defaultdict
 
 from ....misc.ux import deprecated
@@ -25,21 +26,21 @@ class GraphVisitor(Generic[NodeType]):
     )
 
     def __init__(self):
-        self._sorted_nodes: List[NodeType] = []  # a list of sorted nodes. do not change until we get a new graph
-        self._worklist: List[NodeType] = []  # a list of nodes that the analysis should work on and finally exhaust
-        self._nodes_set: Set[NodeType] = set()
-        self._node_to_index: Dict[NodeType, int] = {}
-        self._reached_fixedpoint: Set[NodeType] = set()
-        self._back_edges_by_src: Optional[Dict[NodeType, Set[NodeType]]] = None
-        self._back_edges_by_dst: Optional[Dict[NodeType, Set[NodeType]]] = None
+        self._sorted_nodes: list[NodeType] = []  # a list of sorted nodes. do not change until we get a new graph
+        self._worklist: list[NodeType] = []  # a list of nodes that the analysis should work on and finally exhaust
+        self._nodes_set: set[NodeType] = set()
+        self._node_to_index: dict[NodeType, int] = {}
+        self._reached_fixedpoint: set[NodeType] = set()
+        self._back_edges_by_src: dict[NodeType, set[NodeType]] | None = None
+        self._back_edges_by_dst: dict[NodeType, set[NodeType]] | None = None
 
-        self._pending_nodes: Dict[NodeType, Set[NodeType]] = defaultdict(set)
+        self._pending_nodes: dict[NodeType, set[NodeType]] = defaultdict(set)
 
     #
     # Interfaces
     #
 
-    def successors(self, node: NodeType) -> List[NodeType]:
+    def successors(self, node: NodeType) -> list[NodeType]:
         """
         Get successors of a node. The node should be in the graph.
 
@@ -50,7 +51,7 @@ class GraphVisitor(Generic[NodeType]):
 
         raise NotImplementedError()
 
-    def predecessors(self, node: NodeType) -> List[NodeType]:
+    def predecessors(self, node: NodeType) -> list[NodeType]:
         """
         Get predecessors of a node. The node should be in the graph.
 
@@ -60,7 +61,7 @@ class GraphVisitor(Generic[NodeType]):
 
         raise NotImplementedError()
 
-    def sort_nodes(self, nodes: Optional[Collection[NodeType]] = None) -> List[NodeType]:
+    def sort_nodes(self, nodes: Collection[NodeType] | None = None) -> list[NodeType]:
         """
         Get a list of all nodes sorted in an optimal traversal order.
 
@@ -70,7 +71,7 @@ class GraphVisitor(Generic[NodeType]):
 
         raise NotImplementedError()
 
-    def back_edges(self) -> List[Tuple[NodeType, NodeType]]:
+    def back_edges(self) -> list[tuple[NodeType, NodeType]]:
         """
         Get a list of back edges. This function is optional. If not overriden, the traverser cannot achieve an optimal
         graph traversal order.
@@ -122,7 +123,7 @@ class GraphVisitor(Generic[NodeType]):
 
         self._populate_back_edges()
 
-    def next_node(self) -> Optional[NodeType]:
+    def next_node(self) -> NodeType | None:
         """
         Get the next node to visit.
 
@@ -167,7 +168,7 @@ class GraphVisitor(Generic[NodeType]):
 
         return node
 
-    def all_successors(self, node: NodeType, skip_reached_fixedpoint=False) -> Set[NodeType]:
+    def all_successors(self, node: NodeType, skip_reached_fixedpoint=False) -> set[NodeType]:
         """
         Returns all successors to the specific node.
 

angr/analyses/propagator/engine_ail.py

@@ -1,5 +1,5 @@
 # pylint:disable=arguments-differ,arguments-renamed,isinstance-second-argument-not-valid-type
-from typing import Optional, Union, Tuple, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
 import logging
 
 import claripy
@@ -34,12 +34,12 @@ class SimEnginePropagatorAIL(
 
     state: "PropagatorAILState"
 
-    def _is_top(self, expr: Union[claripy.ast.Base, Expr.StackBaseOffset]) -> bool:
+    def _is_top(self, expr: claripy.ast.Base | Expr.StackBaseOffset) -> bool:
         if isinstance(expr, Expr.StackBaseOffset):
             return False
         return super()._is_top(expr)
 
-    def extract_offset_to_sp(self, expr: Union[claripy.ast.Base, Expr.StackBaseOffset]) -> Optional[int]:
+    def extract_offset_to_sp(self, expr: claripy.ast.Base | Expr.StackBaseOffset) -> int | None:
         if isinstance(expr, Expr.StackBaseOffset):
             return expr.offset
         elif isinstance(expr, Expr.Expression):
@@ -288,7 +288,7 @@ class SimEnginePropagatorAIL(
     #
 
     # this method exists so that I can annotate the return type
-    def _expr(self, expr) -> Optional[PropValue]:  # pylint:disable=useless-super-delegation
+    def _expr(self, expr) -> PropValue | None:  # pylint:disable=useless-super-delegation
         return super()._expr(expr)
 
     def _ail_handle_Tmp(self, expr: Expr.Tmp) -> PropValue:
@@ -361,7 +361,7 @@ class SimEnginePropagatorAIL(
 
         return PropValue(self.state.top(expr.size * self.arch.byte_width))
 
-    def _ail_handle_Register(self, expr: Expr.Register) -> Optional[PropValue]:
+    def _ail_handle_Register(self, expr: Expr.Register) -> PropValue | None:
         self.state: "PropagatorAILState"
 
         # Special handling for SP and BP
@@ -527,19 +527,19 @@ class SimEnginePropagatorAIL(
                             bp_as_gpr=self.bp_as_gpr,
                         )
             elif all_subexprs and None not in all_subexprs and len(all_subexprs) == 1:
-                # if the expression has been replaced before, we should remove previous replacements
-                reg_defs = self._reaching_definitions.get_defs(
-                    Register(expr.reg_offset, expr.size), self._codeloc(), OP_BEFORE
-                )
-                if len(reg_defs) == 1:
-                    reg_def = next(iter(reg_defs))
-                else:
-                    reg_def = None
-                updated_codelocs = self.state.revert_past_replacements(
-                    all_subexprs[0], to_replace=expr, to_replace_def=reg_def
-                )
-                # scan through the code locations and recursively remove assignment replacements
                 if self._reaching_definitions is not None:
+                    # if the expression has been replaced before, we should remove previous replacements
+                    reg_defs = self._reaching_definitions.get_defs(
+                        Register(expr.reg_offset, expr.size), self._codeloc(), OP_BEFORE
+                    )
+                    if len(reg_defs) == 1:
+                        reg_def = next(iter(reg_defs))
+                    else:
+                        reg_def = None
+                    updated_codelocs = self.state.revert_past_replacements(
+                        all_subexprs[0], to_replace=expr, to_replace_def=reg_def
+                    )
+                    # scan through the code locations and recursively remove assignment replacements
                     while updated_codelocs:
                         new_updated_codelocs = set()
                         for u_codeloc in updated_codelocs:
@@ -576,7 +576,7 @@ class SimEnginePropagatorAIL(
 
         return PropValue.from_value_and_details(self.state.top(expr.bits), expr.size, expr, self._codeloc())
 
-    def _ail_handle_Load(self, expr: Expr.Load) -> Optional[PropValue]:
+    def _ail_handle_Load(self, expr: Expr.Load) -> PropValue | None:
         self.state: "PropagatorAILState"
 
         addr = self._expr(expr.addr)
@@ -633,6 +633,11 @@ class SimEnginePropagatorAIL(
     def _ail_handle_Convert(self, expr: Expr.Convert) -> PropValue:
         o_value = self._expr(expr.operand)
 
+        if not (expr.from_type == Expr.Convert.TYPE_INT and expr.to_type == Expr.Convert.TYPE_INT):
+            # we do not support floating-point conversions
+            new_value = self.state.top(expr.to_bits)
+            return PropValue.from_value_and_details(new_value, expr.size, expr, self._codeloc())
+
         if o_value is None or self.state.is_top(o_value.value):
             new_value = self.state.top(expr.to_bits)
         else:
@@ -739,16 +744,14 @@ class SimEnginePropagatorAIL(
             v = claripy.BVV(expr.value, expr.bits)
         return PropValue.from_value_and_details(v, expr.size, expr, self._codeloc())
 
-    def _ail_handle_DirtyExpression(
-        self, expr: Expr.DirtyExpression
-    ) -> Optional[PropValue]:  # pylint:disable=no-self-use
+    def _ail_handle_DirtyExpression(self, expr: Expr.DirtyExpression) -> PropValue | None:  # pylint:disable=no-self-use
         if isinstance(expr.dirty_expr, Expr.VEXCCallExpression):
             for operand in expr.dirty_expr.operands:
                 _ = self._expr(operand)
 
         return PropValue.from_value_and_details(self.state.top(expr.bits), expr.size, expr, self._codeloc())
 
-    def _ail_handle_ITE(self, expr: Expr.ITE) -> Optional[PropValue]:
+    def _ail_handle_ITE(self, expr: Expr.ITE) -> PropValue | None:
         # pylint:disable=unused-variable
         self._expr(expr.cond)  # cond
         self._expr(expr.iftrue)  # iftrue
@@ -756,7 +759,7 @@ class SimEnginePropagatorAIL(
 
         return PropValue.from_value_and_details(self.state.top(expr.bits), expr.size, expr, self._codeloc())
 
-    def _ail_handle_Reinterpret(self, expr: Expr.Reinterpret) -> Optional[PropValue]:
+    def _ail_handle_Reinterpret(self, expr: Expr.Reinterpret) -> PropValue | None:
         arg = self._expr(expr.operand)
 
         if self.state.is_top(arg.value):
@@ -768,7 +771,7 @@ class SimEnginePropagatorAIL(
 
         return PropValue.from_value_and_details(arg.value, expr.size, expr, self._codeloc())
 
-    def _ail_handle_CallExpr(self, expr_stmt: Stmt.Call) -> Optional[PropValue]:
+    def _ail_handle_CallExpr(self, expr_stmt: Stmt.Call) -> PropValue | None:
         if isinstance(expr_stmt.target, Expr.Expression):
             _ = self._expr(expr_stmt.target)
 
@@ -847,6 +850,7 @@ class SimEnginePropagatorAIL(
     _ail_handle_CmpGTs = _ail_handle_Cmp
     _ail_handle_CmpEQ = _ail_handle_Cmp
     _ail_handle_CmpNE = _ail_handle_Cmp
+    _ail_handle_CmpORD = _ail_handle_Cmp
 
     def _ail_handle_Add(self, expr: Expr.BinaryOp) -> PropValue:
         o0_value = self._expr(expr.operands[0])
@@ -1492,8 +1496,8 @@ class SimEnginePropagatorAIL(
         expr: Expr.Expression,
         expr_defat: Optional["CodeLocation"],
         current_loc: "CodeLocation",
-        avoid: Optional[Expr.Expression] = None,
-    ) -> Tuple[bool, bool]:
+        avoid: Expr.Expression | None = None,
+    ) -> tuple[bool, bool]:
         if self._reaching_definitions is None:
             l.warning(
                 "Reaching definition information is not provided to propagator. Assume the definition is out-dated."

angr/analyses/propagator/outdated_definition_walker.py

@@ -1,5 +1,6 @@
 # pylint:disable=consider-using-in
-from typing import Optional, Callable, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from collections.abc import Callable
 
 from ailment import Block, Stmt, Expr, AILBlockWalker
 
@@ -25,7 +26,7 @@ class OutdatedDefinitionWalker(AILBlockWalker):
         current_loc: CodeLocation,
         state: "PropagatorAILState",
         arch: "Arch",
-        avoid: Optional[Expr.Expression] = None,
+        avoid: Expr.Expression | None = None,
         extract_offset_to_sp: Callable = None,
         rda: "ReachingDefinitionsModel" = None,
     ):
@@ -46,13 +47,13 @@ class OutdatedDefinitionWalker(AILBlockWalker):
         self.rda = rda
 
     # pylint:disable=unused-argument
-    def _handle_Tmp(self, expr_idx: int, expr: Expr.Tmp, stmt_idx: int, stmt: Stmt.Assignment, block: Optional[Block]):
+    def _handle_Tmp(self, expr_idx: int, expr: Expr.Tmp, stmt_idx: int, stmt: Stmt.Assignment, block: Block | None):
         if self.avoid is not None and expr.likes(self.avoid):
             self.has_avoid = True
 
     # pylint:disable=unused-argument
     def _handle_Register(
-        self, expr_idx: int, expr: Expr.Register, stmt_idx: int, stmt: Stmt.Assignment, block: Optional[Block]
+        self, expr_idx: int, expr: Expr.Register, stmt_idx: int, stmt: Stmt.Assignment, block: Block | None
     ):
         if (
             self.avoid is not None
@@ -70,7 +71,7 @@ class OutdatedDefinitionWalker(AILBlockWalker):
         if not (codelocs_defat and codelocs_currentloc and codelocs_defat == codelocs_currentloc):
             self.out_dated = True
 
-    def _handle_Load(self, expr_idx: int, expr: Expr.Load, stmt_idx: int, stmt: Stmt.Statement, block: Optional[Block]):
+    def _handle_Load(self, expr_idx: int, expr: Expr.Load, stmt_idx: int, stmt: Stmt.Statement, block: Block | None):
         if self.avoid is not None and (expr == self.avoid or expr.addr == self.avoid):
             self.has_avoid = True
 
@@ -131,7 +132,7 @@ class OutdatedDefinitionWalker(AILBlockWalker):
                     self.out_dated = True
 
     def _handle_VEXCCallExpression(
-        self, expr_idx: int, expr: Expr.VEXCCallExpression, stmt_idx: int, stmt: Stmt.Statement, block: Optional[Block]
+        self, expr_idx: int, expr: Expr.VEXCCallExpression, stmt_idx: int, stmt: Stmt.Statement, block: Block | None
     ):
         if self.avoid is not None:
             if any(op == self.avoid for op in expr.operands):
@@ -148,7 +149,7 @@ class OutdatedDefinitionWalker(AILBlockWalker):
         return False
 
     @staticmethod
-    def _check_store_precedes_load(store_defat: Optional[CodeLocation], load_defat: Optional[CodeLocation]) -> bool:
+    def _check_store_precedes_load(store_defat: CodeLocation | None, load_defat: CodeLocation | None) -> bool:
         """
         Check if store precedes load based on their AIL statement IDs.
         """

angr/analyses/propagator/propagator.py

@@ -1,5 +1,5 @@
 # pylint:disable=isinstance-second-argument-not-valid-type
-from typing import Optional, Any, Tuple, Union, Set, TYPE_CHECKING
+from typing import Optional, Any, TYPE_CHECKING
 import logging
 import time
 
@@ -61,10 +61,10 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         do_binops=True,
         store_tops=True,
         vex_cross_insn_opt=False,
-        func_addr: Optional[int] = None,
-        gp: Optional[int] = None,
+        func_addr: int | None = None,
+        gp: int | None = None,
         cache_results: bool = False,
-        key_prefix: Optional[str] = None,
+        key_prefix: str | None = None,
         reaching_definitions: Optional["ReachingDefinitionsModel"] = None,
         immediate_stmt_removal: bool = False,
         profiling: bool = False,
@@ -103,7 +103,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         self._cache_results = cache_results
         self._reaching_definitions = reaching_definitions
         self._initial_codeloc: CodeLocation
-        self.stmts_to_remove: Set[CodeLocation] = set()
+        self.stmts_to_remove: set[CodeLocation] = set()
         if self.flavor == "function":
             self._initial_codeloc = CodeLocation(self._func_addr, stmt_idx=0, ins_addr=self._func_addr)
         else:  # flavor == "block"
@@ -124,11 +124,11 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         else:
             cache_used = True
 
-        graph_visitor: Union[visitors.SingleNodeGraphVisitor, visitors.FunctionGraphVisitor]
+        graph_visitor: visitors.SingleNodeGraphVisitor | visitors.FunctionGraphVisitor
         if self.flavor == "block":
             graph_visitor = None
             if self._cache_results:
-                graph_visitor: Optional[visitors.SingleNodeGraphVisitor] = self.model.graph_visitor
+                graph_visitor: visitors.SingleNodeGraphVisitor | None = self.model.graph_visitor
 
             if graph_visitor is None:
                 graph_visitor = visitors.SingleNodeGraphVisitor(block)
@@ -136,7 +136,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         elif self.flavor == "function":
             graph_visitor = None
             if self._cache_results:
-                graph_visitor: Optional[visitors.FunctionGraphVisitor] = self.model.graph_visitor
+                graph_visitor: visitors.FunctionGraphVisitor | None = self.model.graph_visitor
                 if graph_visitor is not None:
                     # resume
                     resumed = graph_visitor.resume_with_new_graph(func_graph if func_graph is not None else func.graph)
@@ -209,7 +209,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
             _l.warning("  Analyzed statements: %d", self._analyzed_statements)
 
     @property
-    def prop_key(self) -> Tuple[Optional[str], str, int, bool, bool, bool]:
+    def prop_key(self) -> tuple[str | None, str, int, bool, bool, bool]:
         """
         Gets a key that represents the function and the "flavor" of the propagation result.
         """
@@ -228,7 +228,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
     # Main analysis routines
     #
 
-    def _node_key(self, node: Union[ailment.Block, pyvex.IRSB]) -> Any:
+    def _node_key(self, node: ailment.Block | pyvex.IRSB) -> Any:
         if type(node) is ailment.Block:
             return node.addr, node.idx
         elif type(node) is pyvex.IRSB:
@@ -327,9 +327,7 @@ class PropagatorAnalysis(ForwardAnalysis, Analysis):  # pylint:disable=abstract-
         else:
             return False, state
 
-    def _process_input_state_for_successor(
-        self, node, successor, input_state: Union[PropagatorAILState, PropagatorVEXState]
-    ):
+    def _process_input_state_for_successor(self, node, successor, input_state: PropagatorAILState | PropagatorVEXState):
         if self._only_consts:
             if isinstance(input_state, PropagatorAILState):
                 key = node.addr, successor.addr