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

angr/analyses/cfg/cfg_fast.py

@@ -4,7 +4,7 @@ import logging
 import math
 import re
 import string
-from typing import DefaultDict, List, Set, Dict, Optional, Tuple
+from typing import DefaultDict
 from collections import defaultdict, OrderedDict
 from enum import Enum, unique
 
@@ -153,7 +153,7 @@ class PendingJobs:
 
     __nonzero__ = __bool__
 
-    def _pop_job(self, func_addr: Optional[int]):
+    def _pop_job(self, func_addr: int | None):
         jobs = self._jobs[func_addr]
         j = jobs.pop(-1)
         if not jobs:
@@ -457,16 +457,16 @@ class CFGJob:
         addr: int,
         func_addr: int,
         jumpkind: str,
-        ret_target: Optional[int] = None,
-        last_addr: Optional[int] = None,
-        src_node: Optional[CFGNode] = None,
-        src_ins_addr: Optional[int] = None,
-        src_stmt_idx: Optional[int] = None,
+        ret_target: int | None = None,
+        last_addr: int | None = None,
+        src_node: CFGNode | None = None,
+        src_ins_addr: int | None = None,
+        src_stmt_idx: int | None = None,
         returning_source=None,
         syscall: bool = False,
-        func_edges: Optional[List] = None,
+        func_edges: list | None = None,
         job_type: CFGJobType = CFGJobType.NORMAL,
-        gp: Optional[int] = None,
+        gp: int | None = None,
     ):
         self.addr = addr
         self.func_addr = func_addr
@@ -615,8 +615,8 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         nodecode_window_size=512,
         nodecode_threshold=0.3,
         nodecode_step=16483,
-        indirect_calls_always_return: Optional[bool] = None,
-        jumptable_resolver_resolves_calls: Optional[bool] = None,
+        indirect_calls_always_return: bool | None = None,
+        jumptable_resolver_resolves_calls: bool | None = None,
         start=None,  # deprecated
         end=None,  # deprecated
         collect_data_references=None,  # deprecated
@@ -808,7 +808,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         self._known_thunks = {}
 
         self._initial_state = None
-        self._next_addr: Optional[int] = None
+        self._next_addr: int | None = None
 
         # Create the segment list
         self._seg_list = SegmentList()
@@ -828,10 +828,10 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         self._traced_addresses = None
         self._function_returns = None
         self._function_exits = None
-        self._gp_value: Optional[int] = None
-        self._ro_region_cdata_cache: Optional[List] = None
+        self._gp_value: int | None = None
+        self._ro_region_cdata_cache: list | None = None
         self._job_ctr = 0
-        self._decoding_assumptions: Dict[int, DecodingAssumption] = {}
+        self._decoding_assumptions: dict[int, DecodingAssumption] = {}
         self._decoding_assumption_relations = None
 
         # A mapping between address and the actual data in memory
@@ -1174,7 +1174,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         return nodecode_bytes / total_bytes
 
-    def _next_code_addr_smart(self) -> Optional[int]:
+    def _next_code_addr_smart(self) -> int | None:
         # in the smart scanning mode, if there are more than N consecutive no-decode cases, we skip an entire window of
         # bytes.
         nodecode_bytes_ratio = (
@@ -1215,7 +1215,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         # Initialize variables used during analysis
         self._pending_jobs: PendingJobs = PendingJobs(self.functions, self._deregister_analysis_job)
-        self._traced_addresses: Set[int] = {a for a, n in self._nodes_by_addr.items() if n}
+        self._traced_addresses: set[int] = {a for a, n in self._nodes_by_addr.items() if n}
         self._function_returns = defaultdict(set)
 
         # Populate known objects in segment tracker
@@ -1230,7 +1230,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         # should record all exits from a single function, and then add
         # necessary calling edges in our call map during the post-processing
         # phase.
-        self._function_exits: DefaultDict[int, Set[int]] = defaultdict(set)
+        self._function_exits: DefaultDict[int, set[int]] = defaultdict(set)
 
         # Create an initial state. Store it to self so we can use it globally.
         self._initial_state = self.project.factory.blank_state(
@@ -1245,7 +1245,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         if self._use_exceptions:
             self._preprocess_exception_handlings()
 
-        starting_points: Set[int] = set()
+        starting_points: set[int] = set()
 
         if self._use_symbols:
             starting_points |= self._function_addresses_from_symbols
@@ -1257,7 +1257,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             starting_points |= set(self._extra_function_starts)
 
         # Sort it
-        sorted_starting_points: List[int] = sorted(list(starting_points), reverse=False)
+        sorted_starting_points: list[int] = sorted(list(starting_points), reverse=False)
 
         if self._start_at_entry and self.project.entry is not None and self._inside_regions(self.project.entry):
             if self.project.entry not in starting_points:
@@ -1281,7 +1281,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             self._remaining_function_prologue_addrs = sorted(self._func_addrs_from_prologues())
 
         # assumption management
-        self._decoding_assumptions: Dict[int, DecodingAssumption] = {}
+        self._decoding_assumptions: dict[int, DecodingAssumption] = {}
         self._decoding_assumption_relations = networkx.DiGraph()
 
         # register read-only regions to PyVEX
@@ -1329,7 +1329,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
     def _intra_analysis(self):
         pass
 
-    def _get_successors(self, job: CFGJob) -> List[CFGJob]:  # type: ignore[override] # pylint:disable=arguments-differ
+    def _get_successors(self, job: CFGJob) -> list[CFGJob]:  # type: ignore[override] # pylint:disable=arguments-differ
         # current_function_addr = job.func_addr
         # addr = job.addr
 
@@ -1412,7 +1412,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             func = self.kb.functions.get_by_addr(func_addr)
             if func.is_plt or func.is_simprocedure or func.is_syscall:
                 return
-            if not (1 <= len(func.block_addrs_set) < 15):
+            if not (9 <= len(func.block_addrs_set) < 12):
                 return
 
             from angr.analyses.decompiler.clinic import ClinicMode  # pylint:disable=wrong-import-position
@@ -1759,7 +1759,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         UPDATE_RATIO = 0.5
 
         all_memory_data = sorted(list(self.model.memory_data.items()), key=lambda x: x[0])  # sorted by addr
-        to_update: Dict[int, bytes] = {}
+        to_update: dict[int, bytes] = {}
         total_string_refs: int = 0
         for i, (addr, md) in enumerate(all_memory_data):
             if not md.sort == MemoryDataSort.String:
@@ -1862,7 +1862,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
     # Basic block scanning
 
-    def _scan_block(self, cfg_job: CFGJob) -> List[CFGJob]:
+    def _scan_block(self, cfg_job: CFGJob) -> list[CFGJob]:
         """
         Scan a basic block starting at a specific address
 
@@ -1889,7 +1889,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         return entries
 
-    def _scan_procedure(self, cfg_job, current_func_addr) -> List[CFGJob]:
+    def _scan_procedure(self, cfg_job, current_func_addr) -> list[CFGJob]:
         """
         Checks the hooking procedure for this address searching for new static
         exit points to add to successors (generating entries for them)
@@ -1945,7 +1945,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             # Mark the address as traced
             self._traced_addresses.add(addr)
 
-        entries: List[CFGJob] = []
+        entries: list[CFGJob] = []
 
         if (
             cfg_job.src_node is not None
@@ -2020,7 +2020,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         return entries
 
-    def _scan_irsb(self, cfg_job, current_func_addr) -> List[CFGJob]:
+    def _scan_irsb(self, cfg_job, current_func_addr) -> list[CFGJob]:
         """
         Generate a list of successors (generating them each as entries) to IRSB.
         Updates previous CFG nodes with edges.
@@ -2161,7 +2161,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
     def _create_jobs(
         self, target, jumpkind, current_function_addr, irsb, addr, cfg_node, ins_addr, stmt_idx
-    ) -> List[CFGJob]:
+    ) -> list[CFGJob]:
         """
         Given a node and details of a successor, makes a list of CFGJobs
         and if it is a call or exit marks it appropriately so in the CFG
@@ -2176,7 +2176,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         :param int stmt_idx:        ID of the source statement.
         :return:                    a list of CFGJobs
         """
-        target_addr: Optional[int]
+        target_addr: int | None
         if type(target) is pyvex.IRExpr.Const:  # pylint: disable=unidiomatic-typecheck
             target_addr = target.con.value
         elif type(target) in (
@@ -2201,7 +2201,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             else:
                 raise AngrCFGError("This shouldn't be possible")
 
-        jobs: List[CFGJob] = []
+        jobs: list[CFGJob] = []
         is_syscall = jumpkind.startswith("Ijk_Sys")
 
         # Special handling:
@@ -2410,10 +2410,10 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         stmt_idx: int,
         ins_addr: int,
         current_function_addr: int,
-        target_addr: Optional[int],
+        target_addr: int | None,
         jumpkind: str,
         is_syscall: bool = False,
-    ) -> List[CFGJob]:
+    ) -> list[CFGJob]:
         """
         Generate a CFGJob for target address, also adding to _pending_entries
         if returning to succeeding position (if irsb arg is populated)
@@ -2430,7 +2430,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         :return:                A list of CFGJobs
         """
 
-        jobs: List[CFGJob] = []
+        jobs: list[CFGJob] = []
 
         if is_syscall:
             # Fix the target_addr for syscalls
@@ -2531,7 +2531,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         if callee_might_return:
             func_edges = []
             if return_site is not None:
-                call_returning: Optional[bool]
+                call_returning: bool | None
                 if callee_function is not None:
                     call_returning = self._is_call_returning(cfg_node, callee_function.addr)
                 else:
@@ -2899,8 +2899,8 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
         stmt_idx: int,
         insn_addr: int,
         data_addr: int,
-        data_size: Optional[int] = None,
-        data_type: Optional[MemoryDataSort] = None,
+        data_size: int | None = None,
+        data_type: MemoryDataSort | None = None,
     ) -> None:
         """
         Checks addresses are in the correct segments and creates or updates
@@ -2995,7 +2995,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         return False
 
-    def _indirect_jump_resolved(self, jump: IndirectJump, jump_addr, resolved_by, targets: List[int]):
+    def _indirect_jump_resolved(self, jump: IndirectJump, jump_addr, resolved_by, targets: list[int]):
         """
         Called when an indirect jump is successfully resolved.
 
@@ -3546,7 +3546,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
                     del self._function_returns[nonreturning_function.addr]
 
-    def _pop_pending_job(self, returning=True) -> Optional[CFGJob]:
+    def _pop_pending_job(self, returning=True) -> CFGJob | None:
         while self._pending_jobs:
             job = self._pending_jobs.pop_job(returning=returning)
             if job is not None and job.job_type == CFGJobType.DATAREF_HINTS and self._seg_list.is_occupied(job.addr):
@@ -3563,7 +3563,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
     #
 
     def _graph_add_edge(
-        self, cfg_node: CFGNode, src_node: Optional[CFGNode], src_jumpkind: str, src_ins_addr: int, src_stmt_idx: int
+        self, cfg_node: CFGNode, src_node: CFGNode | None, src_jumpkind: str, src_ins_addr: int, src_stmt_idx: int
     ):
         """
         Add edge between nodes, or add node if entry point
@@ -4061,7 +4061,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
     # Initial registers
     #
 
-    def _get_initial_registers(self, addr, cfg_job, current_function_addr) -> Optional[List[Tuple[int, int, int]]]:
+    def _get_initial_registers(self, addr, cfg_job, current_function_addr) -> list[tuple[int, int, int]] | None:
         initial_regs = None
         if self.project.arch.name in {"MIPS64", "MIPS32"}:
             initial_regs = [
@@ -4533,7 +4533,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
             return None, None, None, None
 
     def _process_block_arch_specific(
-        self, addr: int, cfg_node: CFGNode, irsb: pyvex.IRSB, func_addr: int, caller_gp: Optional[int] = None
+        self, addr: int, cfg_node: CFGNode, irsb: pyvex.IRSB, func_addr: int, caller_gp: int | None = None
     ) -> None:  # pylint: disable=unused-argument
         """
         According to arch types ['ARMEL', 'ARMHF', 'MIPS32', 'X86'] does different
@@ -4704,7 +4704,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
                 func = self.kb.functions.get_by_addr(func_addr)
                 func.info["bp_as_gpr"] = rbp_as_gpr
 
-    def _extract_node_cluster_by_dependency(self, addr, include_successors=False) -> Set[int]:
+    def _extract_node_cluster_by_dependency(self, addr, include_successors=False) -> set[int]:
         to_remove = {addr}
         queue = [addr]
         while queue:
@@ -4840,7 +4840,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
                 # the ARM node and the THUMB node no longer exist.
                 self._traced_addresses.discard(assumption.addr)
 
-    def _mips_determine_function_gp(self, addr: int, irsb: pyvex.IRSB, func_addr: int) -> Optional[int]:
+    def _mips_determine_function_gp(self, addr: int, irsb: pyvex.IRSB, func_addr: int) -> int | None:
         # check if gp is being written to
         last_gp_setting_insn_id = None
         insn_ctr = 0
@@ -4900,7 +4900,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
 
         return result
 
-    def _x86_gcc_pie_find_pc_register_adjustment(self, addr: int, reg_offset: int) -> Optional[int]:
+    def _x86_gcc_pie_find_pc_register_adjustment(self, addr: int, reg_offset: int) -> int | None:
         """
         Match against a single instruction that adds or subtracts a constant from a specified register.
 
@@ -4958,7 +4958,7 @@ class CFGFast(ForwardAnalysis[CFGNode, CFGNode, CFGJob, int], CFGBase):  # pylin
                         return stmt2.data.args[1].con.value
         return None
 
-    def _is_call_returning(self, callsite_cfgnode: CFGNode, callee_func_addr: int) -> Optional[bool]:
+    def _is_call_returning(self, callsite_cfgnode: CFGNode, callee_func_addr: int) -> bool | None:
         """
         Determine if a function call is returning or not, with a special care for DYNAMIC_RET functions.
 

angr/analyses/cfg/cfg_fast_soot.py

@@ -1,7 +1,6 @@
 import logging
 
 from collections import defaultdict
-from typing import List
 
 from sortedcontainers import SortedDict
 from copy import copy
@@ -380,7 +379,7 @@ class CFGFastSoot(CFGFast):
 
         return stmts_count
 
-    def _scan_block(self, cfg_job) -> List[CFGJob]:
+    def _scan_block(self, cfg_job) -> list[CFGJob]:
         """
         Scan a basic block starting at a specific address
 

angr/analyses/cfg/cfg_job_base.py

@@ -1,5 +1,5 @@
 import logging
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from archinfo.arch_soot import SootAddressDescriptor
 
@@ -131,7 +131,7 @@ class CFGJobBase:
         src_block_id=None,
         src_exit_stmt_idx=None,
         src_ins_addr=None,
-        jumpkind: Optional[str] = None,
+        jumpkind: str | None = None,
         call_stack=None,
         is_narrowing=False,
         skip=False,

angr/analyses/cfg/indirect_jump_resolvers/jumptable.py

@@ -1,6 +1,7 @@
 # pylint:disable=wrong-import-position,wrong-import-order
 import enum
-from typing import Tuple, Optional, Dict, Sequence, Set, List, TYPE_CHECKING
+from typing import TYPE_CHECKING
+from collections.abc import Sequence
 import logging
 import functools
 from collections import defaultdict, OrderedDict
@@ -75,7 +76,7 @@ class AddressTransformation:
     Describe and record an address transformation operation.
     """
 
-    def __init__(self, op: AddressTransformationTypes, operands: List, first_load: bool = False):
+    def __init__(self, op: AddressTransformationTypes, operands: list, first_load: bool = False):
         self.op = op
         self.operands = operands
         self.first_load = first_load
@@ -295,7 +296,7 @@ class JumpTableProcessor(
     not be able to recover all jump targets later in block 0x4051b0.
     """
 
-    def __init__(self, project, indirect_jump_node_pred_addrs: Set[int], bp_sp_diff=0x100):
+    def __init__(self, project, indirect_jump_node_pred_addrs: set[int], bp_sp_diff=0x100):
         super().__init__()
         self.project = project
         self._bp_sp_diff = bp_sp_diff  # bp - sp
@@ -303,7 +304,7 @@ class JumpTableProcessor(
         self._indirect_jump_node_pred_addrs = indirect_jump_node_pred_addrs
 
         self._SPOFFSET_BASE = claripy.BVS("SpOffset", self.project.arch.bits, explicit_name=True)
-        self._REGOFFSET_BASE: Dict[int, claripy.ast.BV] = {}
+        self._REGOFFSET_BASE: dict[int, claripy.ast.BV] = {}
 
     def _top(self, size: int):
         return None
@@ -320,7 +321,7 @@ class JumpTableProcessor(
         return v
 
     @staticmethod
-    def _extract_spoffset_from_expr(expr: claripy.ast.Base) -> Optional[SpOffset]:
+    def _extract_spoffset_from_expr(expr: claripy.ast.Base) -> SpOffset | None:
         if expr.op == "BVS":
             for anno in expr.annotations:
                 if isinstance(anno, RegOffsetAnnotation):
@@ -351,7 +352,7 @@ class JumpTableProcessor(
         return v
 
     @staticmethod
-    def _extract_regoffset_from_expr(expr: claripy.ast.Base) -> Optional[RegisterOffset]:
+    def _extract_regoffset_from_expr(expr: claripy.ast.Base) -> RegisterOffset | None:
         if expr.op == "BVS":
             for anno in expr.annotations:
                 if isinstance(anno, RegOffsetAnnotation):
@@ -902,10 +903,10 @@ class JumpTableResolver(IndirectJumpResolver):
         addr: int,
         func: "Function",
         b: Blade,
-        cv_manager: Optional[ConstantValueManager],
+        cv_manager: ConstantValueManager | None,
         potential_call_table: bool = False,
         func_graph_complete: bool = True,
-    ) -> Tuple[bool, Optional[Sequence[int]]]:
+    ) -> tuple[bool, Sequence[int] | None]:
         """
         Internal method for resolving jump tables.
 
@@ -1173,7 +1174,7 @@ class JumpTableResolver(IndirectJumpResolver):
         # initialization
         load_stmt_loc, load_stmt, load_size = None, None, None
         stmts_to_remove = [stmt_loc]
-        stmts_adding_base_addr: List[JumpTargetBaseAddr] = []
+        stmts_adding_base_addr: list[JumpTargetBaseAddr] = []
         # All temporary variables that hold indirect addresses loaded out of the memory
         # Obviously, load_stmt.tmp must be here
         # if there are additional data transferring statements between the Load statement and the base-address-adding
@@ -1189,7 +1190,7 @@ class JumpTableResolver(IndirectJumpResolver):
         # all_addr_holders will be {(0x4c64c4, 11): (AddressTransferringTypes.SignedExtension, 32, 64,),
         #           (0x4c64c4, 12); (AddressTransferringTypes.Assignment,),
         #           }
-        transformations: Dict[Tuple[int, int], AddressTransformation] = OrderedDict()
+        transformations: dict[tuple[int, int], AddressTransformation] = OrderedDict()
 
         initial_block_addr = stmt_loc[0]
         all_load_stmts = sorted(self._all_qualified_load_stmts_in_slice(b, stmt_loc[0]))
@@ -1480,7 +1481,7 @@ class JumpTableResolver(IndirectJumpResolver):
 
         return load_stmt_loc, load_stmt, load_size, stmts_to_remove, stmts_adding_base_addr, transformations
 
-    def _find_load_pc_ite_statement(self, b: Blade, stmt_loc: Tuple[int, int]):
+    def _find_load_pc_ite_statement(self, b: Blade, stmt_loc: tuple[int, int]):
         """
         Find the location of the final ITE statement that loads indirect jump targets into a tmp.
 
@@ -1658,7 +1659,7 @@ class JumpTableResolver(IndirectJumpResolver):
         load_stmt,
         load_size,
         stmts_adding_base_addr,
-        transformations: Dict[Tuple[int, int], AddressTransformation],
+        transformations: dict[tuple[int, int], AddressTransformation],
         potential_call_table: bool = False,
     ):
         """
@@ -2302,7 +2303,7 @@ class JumpTableResolver(IndirectJumpResolver):
             or self.project.loader.find_section_containing(addr) is not None
         )
 
-    def _all_qualified_load_stmts_in_slice(self, b: Blade, addr: int) -> List[int]:
+    def _all_qualified_load_stmts_in_slice(self, b: Blade, addr: int) -> list[int]:
         """
         Recognize all qualified load statements in a slice. A qualified load statements refers to those that are
         loading jump targets (or jump offsets) from a jump table, or loading jump table offsets from a jump-table

angr/analyses/cfg/indirect_jump_resolvers/mips_elf_fast.py

@@ -1,5 +1,5 @@
 # pylint:disable=too-many-boolean-expressions,global-statement
-from typing import Dict, Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 import logging
 
 import pyvex
@@ -203,7 +203,7 @@ class MipsElfFastResolver(IndirectJumpResolver):
         l.info("Indirect jump at %#x cannot be resolved by %s.", addr, repr(self))
         return False, []
 
-    def _try_handle_simple_case_0(self, gp: int, blade: Blade) -> Optional[int]:
+    def _try_handle_simple_case_0(self, gp: int, blade: Blade) -> int | None:
         # we only attempt to support the following case:
         #  + A | t37 = GET:I32(gp)
         #  + B | t36 = Add32(t37,0xffff8624)
@@ -307,7 +307,7 @@ class MipsElfFastResolver(IndirectJumpResolver):
         except KeyError:
             return None
 
-    def _try_handle_simple_case_1(self, gp: int, blade: Blade) -> Optional[int]:
+    def _try_handle_simple_case_1(self, gp: int, blade: Blade) -> int | None:
         # we only attempt to support the following case:
         #  + A | t22 = GET:I32(gp)
         #  + B | t21 = Add32(t22,0xffff8020)
@@ -456,7 +456,7 @@ class MipsElfFastResolver(IndirectJumpResolver):
             return None
 
     @staticmethod
-    def _previous_node(blade: Blade, curr_node: Tuple[int, int]) -> Optional[Tuple[int, int]]:
+    def _previous_node(blade: Blade, curr_node: tuple[int, int]) -> tuple[int, int] | None:
         if blade.slice.in_degree(curr_node) != 1:
             return None
         nn = next(iter(blade.slice.predecessors(curr_node)))
@@ -493,7 +493,7 @@ class MipsElfFastResolver(IndirectJumpResolver):
     @staticmethod
     def _is_gp_used_on_slice(project, b: Blade) -> bool:
         gp_offset = project.arch.registers["gp"][0]
-        blocks_on_slice: Dict[int, "Block"] = {}
+        blocks_on_slice: dict[int, "Block"] = {}
         for block_addr, block_stmt_idx in b.slice.nodes():
             if block_addr not in blocks_on_slice:
                 blocks_on_slice[block_addr] = project.factory.block(block_addr, cross_insn_opt=False)

angr/analyses/cfg_slice_to_sink/cfg_slice_to_sink.py

@@ -1,4 +1,4 @@
-from typing import Optional, Set, Any, List
+from typing import Any
 from functools import reduce
 
 from .transitions import merge_transitions
@@ -56,7 +56,7 @@ class CFGSliceToSink:
         return set(reduce(lambda acc, destinations: acc + destinations, self._transitions.values(), []))
 
     @property
-    def nodes(self) -> List[int]:
+    def nodes(self) -> list[int]:
         """
         :return: The complete list of addresses present in the slice.
         """
@@ -91,7 +91,7 @@ class CFGSliceToSink:
         """
         return not bool(self._transitions)
 
-    def path_between(self, source: int, destination: int, visited: Optional[Set[Any]] = None) -> bool:
+    def path_between(self, source: int, destination: int, visited: set[Any] | None = None) -> bool:
         """
         Check the existence of a path in the slice between two given node adresses.
 

angr/analyses/complete_calling_conventions.py

@@ -1,5 +1,6 @@
 # pylint:disable=import-outside-toplevel
-from typing import Tuple, Optional, Callable, Iterable, Dict, Set, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
+from collections.abc import Callable, Iterable
 import queue
 import threading
 import time
@@ -40,17 +41,17 @@ class CompleteCallingConventionsAnalysis(Analysis):
         recover_variables=False,
         low_priority=False,
         force=False,
-        cfg: Optional[CFGModel] = None,
+        cfg: CFGModel | None = None,
         analyze_callsites: bool = False,
         skip_signature_matched_functions: bool = False,
-        max_function_blocks: Optional[int] = None,
-        max_function_size: Optional[int] = None,
+        max_function_blocks: int | None = None,
+        max_function_size: int | None = None,
         workers: int = 0,
-        cc_callback: Optional[Callable] = None,
-        prioritize_func_addrs: Optional[Iterable[int]] = None,
+        cc_callback: Callable | None = None,
+        prioritize_func_addrs: Iterable[int] | None = None,
         skip_other_funcs: bool = False,
         auto_start: bool = True,
-        func_graphs: Optional[Dict[int, "networkx.DiGraph"]] = None,
+        func_graphs: dict[int, "networkx.DiGraph"] | None = None,
     ):
         """
 
@@ -84,7 +85,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
         self._auto_start = auto_start
         self._total_funcs = None
         self._func_graphs = {} if not func_graphs else func_graphs
-        self.prototype_libnames: Set[str] = set()
+        self.prototype_libnames: set[str] = set()
 
         self._func_addrs = []  # a list that holds addresses of all functions to be analyzed
         self._results = []
@@ -160,7 +161,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
         self._prioritize_func_addrs = None  # no longer useful
 
     def _set_function_prototype(
-        self, func: "Function", prototype: Optional["SimTypeFunction"], prototype_libname: Optional[str]
+        self, func: "Function", prototype: Optional["SimTypeFunction"], prototype_libname: str | None
     ) -> None:
         if func.prototype is None or func.is_prototype_guessed or self._force:
             func.is_prototype_guessed = True
@@ -294,7 +295,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
                 continue
 
             if callee_info is not None:
-                callee_info: Dict[int, Tuple[Optional["SimCC"], Optional["SimTypeFunction"], Optional[str]]]
+                callee_info: dict[int, tuple[Optional["SimCC"], Optional["SimTypeFunction"], str | None]]
                 for callee, (callee_cc, callee_proto, callee_proto_libname) in callee_info.items():
                     callee_func = self.kb.functions.get_by_addr(callee)
                     callee_func.calling_convention = callee_cc
@@ -315,7 +316,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
 
     def _analyze_core(
         self, func_addr: int
-    ) -> Tuple[Optional["SimCC"], Optional["SimTypeFunction"], Optional["str"], Optional["VariableManagerInternal"]]:
+    ) -> tuple[Optional["SimCC"], Optional["SimTypeFunction"], Optional["str"], Optional["VariableManagerInternal"]]:
         func = self.kb.functions.get_by_addr(func_addr)
         if func.ran_cca:
             return (
@@ -384,7 +385,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
 
     def _get_callees_cc_prototypes(
         self, caller_func_addr: int
-    ) -> Dict[int, Tuple[Optional["SimCC"], Optional["SimTypeFunction"], Optional[str]]]:
+    ) -> dict[int, tuple[Optional["SimCC"], Optional["SimTypeFunction"], str | None]]:
         d = {}
         for callee in self.kb.functions.callgraph.successors(caller_func_addr):
             if callee != caller_func_addr and callee not in d: