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

angr/analyses/decompiler/return_maker.py

@@ -1,4 +1,3 @@
-from typing import Optional
 import logging
 
 import ailment
@@ -28,7 +27,7 @@ class ReturnMaker(AILGraphWalker):
         return self.ail_manager.next_atom()
 
     def _handle_Return(
-        self, stmt_idx: int, stmt: ailment.Stmt.Return, block: Optional[ailment.Block]
+        self, stmt_idx: int, stmt: ailment.Stmt.Return, block: ailment.Block | None
     ):  # pylint:disable=unused-argument
         if (
             block is not None

angr/analyses/decompiler/structured_codegen/base.py

@@ -1,4 +1,3 @@
-from typing import Dict, Optional, Set, Union
 from sortedcontainers import SortedDict
 
 from ....sim_variable import SimVariable
@@ -29,7 +28,7 @@ class PositionMapping:
     DUPLICATION_CHECK = True
 
     def __init__(self):
-        self._posmap: Union[SortedDict, Dict[int, PositionMappingElement]] = SortedDict()
+        self._posmap: SortedDict | dict[int, PositionMappingElement] = SortedDict()
 
     def items(self):
         return self._posmap.items()
@@ -56,7 +55,7 @@ class PositionMapping:
             return None
         return element.obj
 
-    def get_element(self, pos: int) -> Optional[PositionMappingElement]:
+    def get_element(self, pos: int) -> PositionMappingElement | None:
         try:
             pre = next(self._posmap.irange(maximum=pos, reverse=True))
         except StopIteration:
@@ -86,7 +85,7 @@ class InstructionMapping:
     __slots__ = ("_insmap",)
 
     def __init__(self):
-        self._insmap: Union[SortedDict, Dict[int, InstructionMappingElement]] = SortedDict()
+        self._insmap: SortedDict | dict[int, InstructionMappingElement] = SortedDict()
 
     def items(self):
         return self._insmap.items()
@@ -98,7 +97,7 @@ class InstructionMapping:
         else:
             self._insmap[ins_addr] = InstructionMappingElement(ins_addr, posmap_pos)
 
-    def get_nearest_pos(self, ins_addr: int) -> Optional[int]:
+    def get_nearest_pos(self, ins_addr: int) -> int | None:
         try:
             pre_max = next(self._insmap.irange(maximum=ins_addr, reverse=True))
             pre_min = next(self._insmap.irange(minimum=ins_addr, reverse=True))
@@ -121,7 +120,7 @@ class BaseStructuredCodeGenerator:
         self.map_pos_to_node = None
         self.map_pos_to_addr = None
         self.map_addr_to_pos = None
-        self.map_ast_to_pos: Optional[Dict[SimVariable, Set[PositionMappingElement]]] = None
+        self.map_ast_to_pos: dict[SimVariable, set[PositionMappingElement]] | None = None
 
     def reapply_options(self, options):
         pass

angr/analyses/decompiler/structured_codegen/c.py

@@ -1,5 +1,6 @@
 # pylint:disable=missing-class-docstring,too-many-boolean-expressions,unused-argument,no-self-use
-from typing import Optional, Dict, List, Tuple, Set, Any, Union, TYPE_CHECKING, Callable
+from typing import Optional, Any, TYPE_CHECKING
+from collections.abc import Callable
 from collections import defaultdict
 import logging
 import struct
@@ -72,13 +73,13 @@ def unpack_typeref(ty):
     return ty
 
 
-def unpack_pointer(ty) -> Optional[SimType]:
+def unpack_pointer(ty) -> SimType | None:
     if isinstance(ty, SimTypePointer):
         return ty.pts_to
     return None
 
 
-def unpack_array(ty) -> Optional[SimType]:
+def unpack_array(ty) -> SimType | None:
     if isinstance(ty, SimTypeArray):
         return ty.elem_type
     if isinstance(ty, SimTypeFixedSizeArray):
@@ -119,7 +120,7 @@ def qualifies_for_implicit_cast(ty1, ty2):
     return ty1.size <= ty2.size
 
 
-def extract_terms(expr: "CExpression") -> Tuple[int, List[Tuple[int, "CExpression"]]]:
+def extract_terms(expr: "CExpression") -> tuple[int, list[tuple[int, "CExpression"]]]:
     # handle unnecessary type casts
     if isinstance(expr, CTypeCast):
         expr = MakeTypecastsImplicit.collapse(expr.dst_type, expr.expr)
@@ -166,7 +167,7 @@ def is_machine_word_size_type(type_: SimType, arch: "archinfo.Arch") -> bool:
     return isinstance(type_, SimTypeReg) and type_.size == arch.bits
 
 
-def guess_value_type(value: int, project: "angr.Project") -> Optional[SimType]:
+def guess_value_type(value: int, project: "angr.Project") -> SimType | None:
     if project.kb.functions.contains_addr(value):
         # might be a function pointer
         return SimTypePointer(SimTypeBottom(label="void")).with_arch(project.arch)
@@ -399,7 +400,7 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
         addr,
         name,
         functy: SimTypeFunction,
-        arg_list: List["CVariable"],
+        arg_list: list["CVariable"],
         statements,
         variables_in_use,
         variable_manager,
@@ -418,14 +419,14 @@ class CFunction(CConstruct):  # pylint:disable=abstract-method
         self.variables_in_use = variables_in_use
         self.variable_manager: "VariableManagerInternal" = variable_manager
         self.demangled_name = demangled_name
-        self.unified_local_vars: Dict[SimVariable, Set[Tuple[CVariable, SimType]]] = self.get_unified_local_vars()
+        self.unified_local_vars: dict[SimVariable, set[tuple[CVariable, SimType]]] = self.get_unified_local_vars()
         self.show_demangled_name = show_demangled_name
         self.omit_header = omit_header
 
-    def get_unified_local_vars(self) -> Dict[SimVariable, Set[Tuple["CVariable", SimType]]]:
-        unified_to_var_and_types: Dict[SimVariable, Set[Tuple[CVariable, SimType]]] = defaultdict(set)
+    def get_unified_local_vars(self) -> dict[SimVariable, set[tuple["CVariable", SimType]]]:
+        unified_to_var_and_types: dict[SimVariable, set[tuple[CVariable, SimType]]] = defaultdict(set)
 
-        arg_set: Set[SimVariable] = set()
+        arg_set: set[SimVariable] = set()
         for arg in self.arg_list:
             # TODO: Handle CIndexedVariable
             if isinstance(arg, CVariable):
@@ -882,7 +883,7 @@ class CIfElse(CStatement):
 
     def __init__(
         self,
-        condition_and_nodes: List[Tuple[CExpression, Optional[CStatement]]],
+        condition_and_nodes: list[tuple[CExpression, CStatement | None]],
         else_node=None,
         simplify_else_scope=False,
         cstyle_ifs=True,
@@ -1091,7 +1092,7 @@ class CSwitchCase(CStatement):
         super().__init__(**kwargs)
 
         self.switch = switch
-        self.cases: List[Tuple[Union[int, Tuple[int]], CStatements]] = cases
+        self.cases: list[tuple[int | tuple[int], CStatements]] = cases
         self.default = default
         self.tags = tags
 
@@ -1241,7 +1242,7 @@ class CFunctionCall(CStatement, CExpression):
         self.show_disambiguated_name = show_disambiguated_name
 
     @property
-    def prototype(self) -> Optional[SimTypeFunction]:  # TODO there should be a prototype for each callsite!
+    def prototype(self) -> SimTypeFunction | None:  # TODO there should be a prototype for each callsite!
         if self.callee_func is not None and self.callee_func.prototype is not None:
             proto = self.callee_func.prototype
             if self.callee_func.prototype_libname is not None:
@@ -1361,7 +1362,7 @@ class CGoto(CStatement):
             # unpack target
             target = target.value
 
-        self.target: Union[int, CExpression] = target
+        self.target: int | CExpression = target
         self.target_idx = target_idx
         self.tags = tags
 
@@ -1440,7 +1441,7 @@ class CLabel(CStatement):
         "tags",
     )
 
-    def __init__(self, name: str, ins_addr: int, block_idx: Optional[int], tags=None, **kwargs):
+    def __init__(self, name: str, ins_addr: int, block_idx: int | None, tags=None, **kwargs):
         super().__init__(**kwargs)
         self.name = name
         self.ins_addr = ins_addr
@@ -1521,7 +1522,7 @@ class CVariable(CExpression):
         super().__init__(**kwargs)
 
         self.variable: SimVariable = variable
-        self.unified_variable: Optional[SimVariable] = unified_variable
+        self.unified_variable: SimVariable | None = unified_variable
         self.variable_type: SimType = variable_type.with_arch(self.codegen.project.arch)
         self.tags = tags
 
@@ -1726,7 +1727,7 @@ class CBinaryOp(CExpression):
 
     __slots__ = ("op", "lhs", "rhs", "tags", "common_type", "_cstyle_null_cmp")
 
-    def __init__(self, op, lhs, rhs, tags: Optional[dict] = None, **kwargs):
+    def __init__(self, op, lhs, rhs, tags: dict | None = None, **kwargs):
         super().__init__(**kwargs)
 
         self.op = op
@@ -2005,7 +2006,7 @@ class CTypeCast(CExpression):
         "tags",
     )
 
-    def __init__(self, src_type: Optional[SimType], dst_type: SimType, expr: CExpression, tags=None, **kwargs):
+    def __init__(self, src_type: SimType | None, dst_type: SimType, expr: CExpression, tags=None, **kwargs):
         super().__init__(**kwargs)
 
         self.src_type = (src_type or expr.type).with_arch(self.codegen.project.arch)
@@ -2046,7 +2047,7 @@ class CConstant(CExpression):
         "tags",
     )
 
-    def __init__(self, value, type_: SimType, reference_values=None, tags: Optional[Dict] = None, **kwargs):
+    def __init__(self, value, type_: SimType, reference_values=None, tags: dict | None = None, **kwargs):
         super().__init__(**kwargs)
 
         self.value = value
@@ -2391,7 +2392,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         indent=0,
         cfg=None,
         variable_kb=None,
-        func_args: Optional[List[SimVariable]] = None,
+        func_args: list[SimVariable] | None = None,
         binop_depth_cutoff: int = 16,
         show_casts=True,
         braces_on_own_lines=True,
@@ -2457,11 +2458,11 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         self._variable_kb = variable_kb if variable_kb is not None else self.kb
         self.binop_depth_cutoff = binop_depth_cutoff
 
-        self._variables_in_use: Optional[Dict] = None
-        self._inlined_strings: Set[SimMemoryVariable] = set()
-        self._function_pointers: Set[SimMemoryVariable] = set()
-        self.ailexpr2cnode: Optional[Dict[Tuple[Expr.Expression, bool], CExpression]] = None
-        self.cnode2ailexpr: Optional[Dict[CExpression, Expr.Expression]] = None
+        self._variables_in_use: dict | None = None
+        self._inlined_strings: set[SimMemoryVariable] = set()
+        self._function_pointers: set[SimMemoryVariable] = set()
+        self.ailexpr2cnode: dict[tuple[Expr.Expression, bool], CExpression] | None = None
+        self.cnode2ailexpr: dict[CExpression, Expr.Expression] | None = None
         self._indent = indent
         self.show_casts = show_casts
         self.comment_gotos = comment_gotos
@@ -2469,9 +2470,9 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         self.use_compound_assignments = use_compound_assignments
         self.show_local_types = show_local_types
         self.cstyle_null_cmp = cstyle_null_cmp
-        self.expr_comments: Dict[int, str] = expr_comments if expr_comments is not None else {}
-        self.stmt_comments: Dict[int, str] = stmt_comments if stmt_comments is not None else {}
-        self.const_formats: Dict[Any, Dict[str, Any]] = const_formats if const_formats is not None else {}
+        self.expr_comments: dict[int, str] = expr_comments if expr_comments is not None else {}
+        self.stmt_comments: dict[int, str] = stmt_comments if stmt_comments is not None else {}
+        self.const_formats: dict[Any, dict[str, Any]] = const_formats if const_formats is not None else {}
         self.externs = externs or set()
         self.show_externs = show_externs
         self.show_demangled_name = show_demangled_name
@@ -2484,10 +2485,10 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         self.map_pos_to_node = None
         self.map_pos_to_addr = None
         self.map_addr_to_pos = None
-        self.map_ast_to_pos: Optional[Dict[SimVariable, Set[PositionMappingElement]]] = None
-        self.map_addr_to_label: Dict[Tuple[int, Optional[int]], CLabel] = {}
-        self.cfunc: Optional[CFunction] = None
-        self.cexterns: Optional[Set[CVariable]] = None
+        self.map_ast_to_pos: dict[SimVariable, set[PositionMappingElement]] | None = None
+        self.map_addr_to_label: dict[tuple[int, int | None], CLabel] = {}
+        self.cfunc: CFunction | None = None
+        self.cexterns: set[CVariable] | None = None
 
         self._analyze()
 
@@ -2581,7 +2582,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             self.map_ast_to_pos,
         ) = self.render_text(self.cfunc)
 
-    RENDER_TYPE = Tuple[str, PositionMapping, PositionMapping, InstructionMapping, Dict[Any, Set[Any]]]
+    RENDER_TYPE = tuple[str, PositionMapping, PositionMapping, InstructionMapping, dict[Any, set[Any]]]
 
     def render_text(self, cfunc: CFunction) -> RENDER_TYPE:
         pos_to_node = PositionMapping()
@@ -2622,7 +2623,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         else:
             return self._variable_kb.variables[self._func.addr].get_variable_type(var)
 
-    def _get_derefed_type(self, ty: SimType) -> Optional[SimType]:
+    def _get_derefed_type(self, ty: SimType) -> SimType | None:
         if ty is None:
             return None
         ty = unpack_typeref(ty)
@@ -2669,7 +2670,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
             return _mapping.get(n)(signed=signed).with_arch(self.project.arch)
         return SimTypeNum(n * self.project.arch.byte_width, signed=signed).with_arch(self.project.arch)
 
-    def _variable(self, variable: SimVariable, fallback_type_size: Optional[int]) -> CVariable:
+    def _variable(self, variable: SimVariable, fallback_type_size: int | None) -> CVariable:
         # TODO: we need to fucking make sure that variable recovery and type inference actually generates a size
         # TODO: for each variable it links into the fucking ail. then we can remove fallback_type_size.
         unified = self._variable_kb.variables[self._func.addr].unified_variable(variable)
@@ -2707,7 +2708,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         return result
 
     def _access_constant_offset_reference(
-        self, expr: CExpression, offset: int, data_type: Optional[SimType]
+        self, expr: CExpression, offset: int, data_type: SimType | None
     ) -> CExpression:
         result = self._access_constant_offset(expr, offset, data_type or SimTypeBottom(), True)
         if isinstance(result, CTypeCast) and data_type is None:
@@ -3048,7 +3049,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
         if (node, is_expr) in self.ailexpr2cnode:
             return self.ailexpr2cnode[(node, is_expr)]
 
-        handler: Optional[Callable] = self._handlers.get(node.__class__, None)
+        handler: Callable | None = self._handlers.get(node.__class__, None)
         if handler is not None:
             if isinstance(node, Stmt.Call):
                 # special case for Call
@@ -3494,7 +3495,7 @@ class CStructuredCodeGenerator(BaseStructuredCodeGenerator, Analysis):
     def _handle_Expr_Convert(self, expr: Expr.Convert, **kwargs):
         # width of converted type is easy
         if 64 >= expr.to_bits > 32:
-            dst_type: Union[SimTypeInt, SimTypeChar] = SimTypeLongLong()
+            dst_type: SimTypeInt | SimTypeChar = SimTypeLongLong()
         elif 32 >= expr.to_bits > 16:
             dst_type = SimTypeInt()
         elif 16 >= expr.to_bits > 8:

angr/analyses/decompiler/structuring/__init__.py

@@ -11,5 +11,5 @@ STRUCTURER_CLASSES = {
 }
 
 
-def structurer_class_from_name(name: str) -> Optional[Type]:
+def structurer_class_from_name(name: str) -> type | None:
     return STRUCTURER_CLASSES.get(name.lower(), None)

angr/analyses/decompiler/structuring/dream.py

@@ -1,5 +1,6 @@
 # pylint:disable=multiple-statements,line-too-long,consider-using-enumerate
-from typing import Dict, Set, Optional, Any, List, Union, Tuple, OrderedDict as ODict, TYPE_CHECKING
+from typing import Optional, Any, TYPE_CHECKING
+from collections import OrderedDict as ODict
 import logging
 from collections import defaultdict, OrderedDict
 
@@ -68,7 +69,7 @@ class DreamStructurer(StructurerBase):
         parent_map=None,
         condition_processor=None,
         func: Optional["Function"] = None,
-        case_entry_to_switch_head: Optional[Dict[int, int]] = None,
+        case_entry_to_switch_head: dict[int, int] | None = None,
         parent_region=None,
         **kwargs,
     ):
@@ -488,7 +489,7 @@ class DreamStructurer(StructurerBase):
 
         jump_tables = self.kb.cfgs["CFGFast"].jump_tables
 
-        addr2nodes: Dict[int, Set[CodeNode]] = defaultdict(set)
+        addr2nodes: dict[int, set[CodeNode]] = defaultdict(set)
         for node in seq.nodes:
             addr2nodes[node.addr].add(node)
 
@@ -513,7 +514,7 @@ class DreamStructurer(StructurerBase):
                 break
 
     def _make_switch_cases_address_loaded_from_memory(
-        self, seq, i, node, addr2nodes: Dict[int, Set[CodeNode]], jump_tables: Dict[int, IndirectJump]
+        self, seq, i, node, addr2nodes: dict[int, set[CodeNode]], jump_tables: dict[int, IndirectJump]
     ) -> bool:
         """
         A typical jump table involves multiple nodes, which look like the following:
@@ -596,7 +597,7 @@ class DreamStructurer(StructurerBase):
         return True
 
     def _make_switch_cases_address_computed(
-        self, seq, i, node, addr2nodes: Dict[int, Set[CodeNode]], jump_tables: Dict[int, IndirectJump]
+        self, seq, i, node, addr2nodes: dict[int, set[CodeNode]], jump_tables: dict[int, IndirectJump]
     ) -> bool:
         if node.addr not in jump_tables:
             return False
@@ -696,8 +697,8 @@ class DreamStructurer(StructurerBase):
         rewriter.walk(seq)  # update SequenceNodes in-place
 
     def _switch_unpack_sequence_node(
-        self, seq: SequenceNode, node_a, node_b_addr: int, jumptable, addr2nodes: Dict[int, Set[CodeNode]]
-    ) -> Tuple[bool, Optional[CodeNode]]:
+        self, seq: SequenceNode, node_a, node_b_addr: int, jumptable, addr2nodes: dict[int, set[CodeNode]]
+    ) -> tuple[bool, CodeNode | None]:
         """
         We might have already structured the actual body of the switch-case structure into a single Sequence node (node
         A). If that is the case, we un-structure the sequence node in this method.
@@ -752,7 +753,7 @@ class DreamStructurer(StructurerBase):
         # should have been handling it when dealing with multi-exit regions. ignore it here.
         return True, node_a
 
-    def _switch_unpack_condition_node(self, cond_node: ConditionNode, jumptable) -> Optional[CodeNode]:
+    def _switch_unpack_condition_node(self, cond_node: ConditionNode, jumptable) -> CodeNode | None:
         """
         Unpack condition nodes by only removing one condition in the form of
         <Bool jump_table_402020 == 0x402ac4>.
@@ -818,8 +819,8 @@ class DreamStructurer(StructurerBase):
     def _switch_check_existence_of_jumptable_entries(
         self,
         jumptable_entries,
-        node_a_block_addrs: Set[int],
-        known_node_addrs: Set[int],
+        node_a_block_addrs: set[int],
+        known_node_addrs: set[int],
         node_a_addr: int,
         node_b_addr: int,
     ) -> bool:
@@ -862,7 +863,7 @@ class DreamStructurer(StructurerBase):
         # not sure what is going on...
         return False
 
-    def _switch_find_jumptable_entry_node(self, entry_addr: int, addr2nodes: Dict[int, Set[CodeNode]]) -> Optional[Any]:
+    def _switch_find_jumptable_entry_node(self, entry_addr: int, addr2nodes: dict[int, set[CodeNode]]) -> Any | None:
         """
         Find the correct node for a given jump table entry address in addr2nodes.
 
@@ -904,11 +905,11 @@ class DreamStructurer(StructurerBase):
         self,
         seq: SequenceNode,
         cmp_lb: int,
-        jumptable_entries: List[int],
+        jumptable_entries: list[int],
         head_node_idx: int,
         node_b_addr: int,
-        addr2nodes: Dict[int, Set[CodeNode]],
-    ) -> Tuple[ODict, Any, Any]:
+        addr2nodes: dict[int, set[CodeNode]],
+    ) -> tuple[ODict, Any, Any]:
         """
         Discover all cases for the switch-case structure and build the switch-cases dict.
 
@@ -921,14 +922,14 @@ class DreamStructurer(StructurerBase):
         :return:                    A tuple of (dict of cases, the default node if exists, nodes to remove).
         """
 
-        cases: ODict[Union[int, Tuple[int, ...]], SequenceNode] = OrderedDict()
+        cases: ODict[int | tuple[int, ...], SequenceNode] = OrderedDict()
         to_remove = set()
         node_default = addr2nodes.get(node_b_addr, None)
         if node_default is not None:
             node_default = next(iter(node_default))
 
         entry_addrs_set = set(jumptable_entries)
-        converted_nodes: Dict[int, Any] = {}
+        converted_nodes: dict[int, Any] = {}
         entry_addr_to_ids = defaultdict(set)
 
         for j, entry_addr in enumerate(jumptable_entries):