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

angr/analyses/proximity_graph.py

@@ -1,4 +1,4 @@
-from typing import Optional, Set, List, Tuple, TYPE_CHECKING, Dict
+from typing import Optional, TYPE_CHECKING
 import logging
 
 import networkx
@@ -38,7 +38,7 @@ class BaseProxiNode:
     Base class for all nodes in a proximity graph.
     """
 
-    def __init__(self, type_: int, ref_at: Optional[Set[int]] = None):
+    def __init__(self, type_: int, ref_at: set[int] | None = None):
         self.type_ = type_
         self.ref_at = ref_at
 
@@ -54,7 +54,7 @@ class FunctionProxiNode(BaseProxiNode):
     Proximity node showing current and expanded function calls in graph.
     """
 
-    def __init__(self, func, ref_at: Optional[Set[int]] = None):
+    def __init__(self, func, ref_at: set[int] | None = None):
         super().__init__(ProxiNodeTypes.Function, ref_at=ref_at)
         self.func = func
 
@@ -70,7 +70,7 @@ class VariableProxiNode(BaseProxiNode):
     Variable arg node
     """
 
-    def __init__(self, addr, name, ref_at: Optional[Set[int]] = None):
+    def __init__(self, addr, name, ref_at: set[int] | None = None):
         super().__init__(ProxiNodeTypes.Variable, ref_at=ref_at)
         self.addr = addr
         self.name = name
@@ -87,7 +87,7 @@ class StringProxiNode(BaseProxiNode):
     String arg node
     """
 
-    def __init__(self, addr, content, ref_at: Optional[Set[int]] = None):
+    def __init__(self, addr, content, ref_at: set[int] | None = None):
         super().__init__(ProxiNodeTypes.String, ref_at=ref_at)
         self.addr = addr
         self.content = content
@@ -104,7 +104,7 @@ class CallProxiNode(BaseProxiNode):
     Call node
     """
 
-    def __init__(self, callee, ref_at: Optional[Set[int]] = None, args: Optional[Tuple[BaseProxiNode]] = None):
+    def __init__(self, callee, ref_at: set[int] | None = None, args: tuple[BaseProxiNode] | None = None):
         super().__init__(ProxiNodeTypes.FunctionCall, ref_at=ref_at)
         self.callee = callee
         self.args = args
@@ -127,7 +127,7 @@ class IntegerProxiNode(BaseProxiNode):
     Int arg node
     """
 
-    def __init__(self, value: int, ref_at: Optional[Set[int]] = None):
+    def __init__(self, value: int, ref_at: set[int] | None = None):
         super().__init__(ProxiNodeTypes.Integer, ref_at=ref_at)
         self.value = value
 
@@ -167,7 +167,7 @@ class ProximityGraphAnalysis(Analysis):
         cfg_model: "CFGModel",
         xrefs: "XRefManager",
         decompilation: Optional["Decompiler"] = None,
-        expand_funcs: Optional[Set[int]] = None,
+        expand_funcs: set[int] | None = None,
     ):
         self._function = func
         self._cfg_model = cfg_model
@@ -175,14 +175,14 @@ class ProximityGraphAnalysis(Analysis):
         self._decompilation = decompilation
         self._expand_funcs = expand_funcs.copy() if expand_funcs else None
 
-        self.graph: Optional[networkx.DiGraph] = None
+        self.graph: networkx.DiGraph | None = None
         self.handled_stmts = []
 
         self._work()
 
     def _condense_blank_nodes(self, graph: networkx.DiGraph) -> None:
         nodes = list(graph.nodes)
-        blank_nodes: List[BaseProxiNode] = []
+        blank_nodes: list[BaseProxiNode] = []
 
         for node in nodes:
             if isinstance(node, BaseProxiNode) and node.type_ == ProxiNodeTypes.Empty:
@@ -195,7 +195,7 @@ class ProximityGraphAnalysis(Analysis):
         if blank_nodes:
             self._merge_nodes(graph, blank_nodes)
 
-    def _merge_nodes(self, graph: networkx.DiGraph, nodes: List[BaseProxiNode]) -> None:
+    def _merge_nodes(self, graph: networkx.DiGraph, nodes: list[BaseProxiNode]) -> None:
         for node in nodes:
             predecessors = set(graph.predecessors(node))
             successors = set(graph.successors(node))
@@ -268,10 +268,10 @@ class ProximityGraphAnalysis(Analysis):
                     subgraph.add_edge(end_node, succ)
 
     def _process_function(
-        self, func: "Function", graph: networkx.DiGraph, func_proxi_node: Optional[FunctionProxiNode] = None
-    ) -> List[FunctionProxiNode]:
-        to_expand: List[FunctionProxiNode] = []
-        found_blocks: Dict[BlockNode:BaseProxiNode] = {}
+        self, func: "Function", graph: networkx.DiGraph, func_proxi_node: FunctionProxiNode | None = None
+    ) -> list[FunctionProxiNode]:
+        to_expand: list[FunctionProxiNode] = []
+        found_blocks: dict[BlockNode:BaseProxiNode] = {}
 
         # function calls
         for n_ in func.nodes:
@@ -346,18 +346,18 @@ class ProximityGraphAnalysis(Analysis):
             args.append(UnknownProxiNode("_"))
 
     def _process_decompilation(
-        self, graph: networkx.DiGraph, decompilation: "Decompiler", func_proxi_node: Optional[FunctionProxiNode] = None
-    ) -> List[FunctionProxiNode]:
-        to_expand: List[FunctionProxiNode] = []
+        self, graph: networkx.DiGraph, decompilation: "Decompiler", func_proxi_node: FunctionProxiNode | None = None
+    ) -> list[FunctionProxiNode]:
+        to_expand: list[FunctionProxiNode] = []
 
         # dedup
-        string_refs: Set[int] = set()
+        string_refs: set[int] = set()
 
         # Walk the clinic structure to dump string references and function calls
         ail_graph = decompilation.clinic.cc_graph
 
         def _handle_Call(
-            stmt_idx: int, stmt: ailment.Stmt.Call, block: Optional[ailment.Block]  # pylint:disable=unused-argument
+            stmt_idx: int, stmt: ailment.Stmt.Call, block: ailment.Block | None  # pylint:disable=unused-argument
         ):  # pylint:disable=unused-argument
             func_node = self.kb.functions[stmt.target.value]
             ref_at = {stmt.ins_addr}
@@ -386,7 +386,7 @@ class ProximityGraphAnalysis(Analysis):
             expr: ailment.Stmt.Call,
             stmt_idx: int,  # pylint:disable=unused-argument
             stmt: ailment.Stmt.Statement,  # pylint:disable=unused-argument
-            block: Optional[ailment.Block],
+            block: ailment.Block | None,
         ):  # pylint:disable=unused-argument
             _handle_Call(stmt_idx, expr, block)
 

angr/analyses/reaching_definitions/__init__.py

@@ -42,15 +42,15 @@ __all__ = (
 )
 
 
-def get_all_definitions(region: "MultiValuedMemory") -> Set["Definition"]:
-    all_defs: Set["Definition"] = set()
+def get_all_definitions(region: "MultiValuedMemory") -> set["Definition"]:
+    all_defs: set["Definition"] = set()
 
     # MultiValuedMemory only uses ListPage internally
     for page in region._pages.values():
         page: "MVListPage"
 
         for idx in page.stored_offset:
-            cnt_set: Optional[Union["SimMemoryObject", Set["SimMemoryObject"]]] = page.content[idx]
+            cnt_set: Union["SimMemoryObject", set["SimMemoryObject"]] | None = page.content[idx]
             if cnt_set is None:
                 continue
             if type(cnt_set) is not set:

angr/analyses/reaching_definitions/call_trace.py

@@ -1,6 +1,3 @@
-from typing import List, Optional
-
-
 class CallSite:
     """
     Describes a call site on a CFG.
@@ -12,7 +9,7 @@ class CallSite:
         "callee_func_addr",
     )
 
-    def __init__(self, caller_func_addr: int, block_addr: Optional[int], callee_func_addr: int):
+    def __init__(self, caller_func_addr: int, block_addr: int | None, callee_func_addr: int):
         self.caller_func_addr = caller_func_addr
         self.callee_func_addr = callee_func_addr
         self.block_addr = block_addr
@@ -45,7 +42,7 @@ class CallTrace:
 
     def __init__(self, target: int):
         self.target = target
-        self.callsites: List[CallSite] = []
+        self.callsites: list[CallSite] = []
 
     def __repr__(self):
         return "<Trace with %d callsites>" % len(self.callsites)
@@ -55,7 +52,7 @@ class CallTrace:
             return self.target
         return self.callsites[-1].caller_func_addr
 
-    def step_back(self, caller_func_addr: int, block_addr: Optional[int], callee_func_addr) -> "CallTrace":
+    def step_back(self, caller_func_addr: int, block_addr: int | None, callee_func_addr) -> "CallTrace":
         # create a new CallSite object
         site = CallSite(caller_func_addr, block_addr, callee_func_addr)
         t = self.copy()

angr/analyses/reaching_definitions/dep_graph.py

@@ -1,18 +1,11 @@
 from typing import (
     Optional,
-    Dict,
-    Set,
-    Iterable,
-    Type,
-    Union,
-    List,
     TYPE_CHECKING,
-    Tuple,
     overload,
     Literal,
     Any,
-    Iterator,
 )
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
 
 import networkx
@@ -45,11 +38,11 @@ def _is_definition(node):
 @dataclass
 class FunctionCallRelationships:  # TODO this doesn't belong in this file anymore
     callsite: CodeLocation
-    target: Optional[int]
-    args_defns: List[Set[Definition]]
-    other_input_defns: Set[Definition]
-    ret_defns: Set[Definition]
-    other_output_defns: Set[Definition]
+    target: int | None
+    args_defns: list[set[Definition]]
+    other_input_defns: set[Definition]
+    ret_defns: set[Definition]
+    other_output_defns: set[Definition]
 
 
 class DepGraph:
@@ -64,7 +57,7 @@ class DepGraph:
         :param graph: A graph where nodes are definitions, and edges represent uses.
         """
         # Used for memoization of the `transitive_closure` method.
-        self._transitive_closures: Dict = {}
+        self._transitive_closures: dict = {}
 
         if graph and not all(map(_is_definition, graph.nodes)):
             raise TypeError("In a DepGraph, nodes need to be <%s>s." % Definition.__name__)
@@ -115,7 +108,7 @@ class DepGraph:
             def_: Definition[Atom],
             graph: "networkx.DiGraph[Definition[Atom]]",
             result: "networkx.DiGraph[Definition[Atom]]",
-            visited: Optional[Set[Definition[Atom]]] = None,
+            visited: set[Definition[Atom]] | None = None,
         ):
             """
             Returns a joint graph that comprises the transitive closure of all defs that `def_` depends on and the
@@ -157,7 +150,7 @@ class DepGraph:
         return any(map(lambda definition: definition.atom == atom, self.nodes()))
 
     def add_dependencies_for_concrete_pointers_of(
-        self, values: Iterable[Union[claripy.ast.Base, int]], definition: Definition, cfg: CFGModel, loader: Loader
+        self, values: Iterable[claripy.ast.Base | int], definition: Definition, cfg: CFGModel, loader: Loader
     ):
         """
         When a given definition holds concrete pointers, make sure the <MemoryLocation>s they point to are present in
@@ -170,7 +163,7 @@ class DepGraph:
         """
         assert definition in self.nodes(), "The given Definition must be present in the given graph."
 
-        known_predecessor_addresses: List[Union[int, claripy.ast.Base]] = list(
+        known_predecessor_addresses: list[int | claripy.ast.Base] = list(
             # Needs https://github.com/python/mypy/issues/6847
             map(
                 lambda definition: definition.atom.addr,  # type: ignore
@@ -187,7 +180,7 @@ class DepGraph:
             else:
                 concrete_known_pred_addresses.append(address)
 
-        unknown_concrete_addresses: Set[int] = set()
+        unknown_concrete_addresses: set[int] = set()
         for v in values:
             if isinstance(v, claripy.ast.Base) and v.concrete:
                 v = v.concrete_value
@@ -220,7 +213,7 @@ class DepGraph:
 
             self.graph.add_edge(memory_location_definition, definition)
 
-    def find_definitions(self, **kwargs) -> List[Definition]:
+    def find_definitions(self, **kwargs) -> list[Definition]:
         """
         Filter the definitions present in the graph based on various criteria.
         Parameters can be any valid keyword args to `DefinitionMatchPredicate`
@@ -236,80 +229,80 @@ class DepGraph:
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
-        kind: Type[A],
+        kind: type[A],
         **kwargs: Any,
-    ) -> List[Definition[A]]: ...
+    ) -> list[Definition[A]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
         kind: Literal[AtomKind.REGISTER] = AtomKind.REGISTER,
         **kwargs: Any,
-    ) -> List[Definition[Register]]: ...
+    ) -> list[Definition[Register]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
         kind: Literal[AtomKind.MEMORY] = AtomKind.MEMORY,
         **kwargs: Any,
-    ) -> List[Definition[MemoryLocation]]: ...
+    ) -> list[Definition[MemoryLocation]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
         kind: Literal[AtomKind.TMP] = AtomKind.TMP,
         **kwargs: Any,
-    ) -> List[Definition[Tmp]]: ...
+    ) -> list[Definition[Tmp]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
         kind: Literal[AtomKind.CONSTANT] = AtomKind.CONSTANT,
         **kwargs: Any,
-    ) -> List[Definition[ConstantSrc]]: ...
+    ) -> list[Definition[ConstantSrc]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
         kind: Literal[AtomKind.GUARD] = AtomKind.GUARD,
         **kwargs: Any,
-    ) -> List[Definition[GuardUse]]: ...
+    ) -> list[Definition[GuardUse]]: ...
 
     @overload
     def find_all_predecessors(
         self,
-        starts: Union[Definition[Atom], Iterable[Definition[Atom]]],
+        starts: Definition[Atom] | Iterable[Definition[Atom]],
         *,
-        reg_name: Union[int, str] = ...,
+        reg_name: int | str = ...,
         **kwargs: Any,
-    ) -> List[Definition[Register]]: ...
+    ) -> list[Definition[Register]]: ...
 
     @overload
     def find_all_predecessors(
-        self, starts: Union[Definition[Atom], Iterable[Definition[Atom]]], *, stack_offset: int = ..., **kwargs: Any
-    ) -> List[Definition[MemoryLocation]]: ...
+        self, starts: Definition[Atom] | Iterable[Definition[Atom]], *, stack_offset: int = ..., **kwargs: Any
+    ) -> list[Definition[MemoryLocation]]: ...
 
     @overload
     def find_all_predecessors(
-        self, starts: Union[Definition[Atom], Iterable[Definition[Atom]]], *, const_val: int = ..., **kwargs: Any
-    ) -> List[Definition[ConstantSrc]]: ...
+        self, starts: Definition[Atom] | Iterable[Definition[Atom]], *, const_val: int = ..., **kwargs: Any
+    ) -> list[Definition[ConstantSrc]]: ...
 
     @overload
     def find_all_predecessors(
-        self, starts: Union[Definition[Atom], Iterable[Definition[Atom]]], **kwargs: Any
-    ) -> List[Definition[Atom]]: ...
+        self, starts: Definition[Atom] | Iterable[Definition[Atom]], **kwargs: Any
+    ) -> list[Definition[Atom]]: ...
 
     def find_all_predecessors(self, starts, **kwargs):
         """
@@ -335,7 +328,7 @@ class DepGraph:
                     result.append(pred)
         return result
 
-    def find_all_successors(self, starts: Union[Definition, Iterable[Definition]], **kwargs) -> List[Definition]:
+    def find_all_successors(self, starts: Definition | Iterable[Definition], **kwargs) -> list[Definition]:
         """
         Filter the descendents of the given start node or nodes that match various criteria.
         Parameters can be any valid keyword args to `DefinitionMatchPredicate`
@@ -356,8 +349,8 @@ class DepGraph:
         return result
 
     def find_path(
-        self, starts: Union[Definition, Iterable[Definition]], ends: Union[Definition, Iterable[Definition]], **kwargs
-    ) -> Optional[Tuple[Definition, ...]]:
+        self, starts: Definition | Iterable[Definition], ends: Definition | Iterable[Definition], **kwargs
+    ) -> tuple[Definition, ...] | None:
         """
         Find a path between the given start node or nodes and the given end node or nodes.
         All the intermediate steps in the path must match the criteria given in kwargs.
@@ -369,8 +362,8 @@ class DepGraph:
         return next(self.find_paths(starts, ends, **kwargs), None)
 
     def find_paths(
-        self, starts: Union[Definition, Iterable[Definition]], ends: Union[Definition, Iterable[Definition]], **kwargs
-    ) -> Iterator[Tuple[Definition, ...]]:
+        self, starts: Definition | Iterable[Definition], ends: Definition | Iterable[Definition], **kwargs
+    ) -> Iterator[tuple[Definition, ...]]:
         """
         Find all non-overlapping simple paths between the given start node or nodes and the given end node or nodes.
         All the intermediate steps in the path must match the criteria given in kwargs.
@@ -381,10 +374,10 @@ class DepGraph:
         """
         predicate = DefinitionMatchPredicate.construct(**kwargs)
         ends = {ends} if isinstance(ends, Definition) else set(ends)
-        queue: List[Tuple[Definition, ...]] = (
+        queue: list[tuple[Definition, ...]] = (
             [(starts,)] if isinstance(starts, Definition) else [(start,) for start in starts]
         )
-        seen: Set[Definition] = {starts} if isinstance(starts, Definition) else set(starts)
+        seen: set[Definition] = {starts} if isinstance(starts, Definition) else set(starts)
         while queue:
             path = queue.pop()
             for succ in self.graph.succ[path[-1]]:

angr/analyses/reaching_definitions/engine_ail.py

@@ -1,6 +1,6 @@
 # pylint:disable=missing-class-docstring,too-many-boolean-expressions
 from itertools import chain
-from typing import Iterable, Optional
+from collections.abc import Iterable
 import logging
 
 import archinfo
@@ -34,7 +34,7 @@ class SimEngineRDAIL(
     def __init__(
         self,
         project,
-        function_handler: Optional[FunctionHandler] = None,
+        function_handler: FunctionHandler | None = None,
         stack_pointer_tracker=None,
         use_callee_saved_regs_at_return=True,
         bp_as_gpr: bool = False,
@@ -463,7 +463,7 @@ class SimEngineRDAIL(
             self.state.kill_and_add_definition(reg_atom, value, override_codeloc=extloc)
 
         # extract Definitions
-        defs: Optional[Iterable[Definition]] = None
+        defs: Iterable[Definition] | None = None
         for vs in value.values():
             for v in vs:
                 if defs is None:
@@ -502,7 +502,7 @@ class SimEngineRDAIL(
             self.state.add_memory_use_by_def(def_, expr=expr)
             return MultiValues(top)
 
-        result: Optional[MultiValues] = None
+        result: MultiValues | None = None
         for addr in addrs_v:
             if not isinstance(addr, claripy.ast.Base):
                 continue
@@ -546,7 +546,12 @@ class SimEngineRDAIL(
         bits = expr.to_bits
         size = bits // self.arch.byte_width
 
-        if to_conv.count() == 1 and 0 in to_conv:
+        if (
+            to_conv.count() == 1
+            and 0 in to_conv
+            and expr.from_type == ailment.Expr.Convert.TYPE_INT
+            and expr.to_type == ailment.Expr.Convert.TYPE_INT
+        ):
             values = to_conv[0]
         else:
             top = self.state.top(expr.to_bits)
@@ -1113,6 +1118,7 @@ class SimEngineRDAIL(
     _ail_handle_CmpGEs = _ail_handle_Cmp
     _ail_handle_CmpGT = _ail_handle_Cmp
     _ail_handle_CmpGTs = _ail_handle_Cmp
+    _ail_handle_CmpORD = _ail_handle_Cmp
 
     def _ail_handle_TernaryOp(self, expr) -> MultiValues:
         _ = self._expr(expr.operands[0])

angr/analyses/reaching_definitions/engine_vex.py

@@ -1,5 +1,6 @@
 from itertools import chain
-from typing import Optional, Iterable, Set, Union, TYPE_CHECKING
+from typing import Optional, TYPE_CHECKING
+from collections.abc import Iterable
 import logging
 
 import pyvex
@@ -216,10 +217,10 @@ class SimEngineRDVEX(
 
     def _store_core(
         self,
-        addr: Iterable[Union[int, claripy.ast.bv.BV]],
+        addr: Iterable[int | claripy.ast.bv.BV],
         size: int,
         data: MultiValues,
-        data_old: Optional[MultiValues] = None,
+        data_old: MultiValues | None = None,
         endness=None,
     ):
         if data_old is not None:
@@ -229,7 +230,7 @@ class SimEngineRDVEX(
             if self.state.is_top(a):
                 l.debug("Memory address undefined, ins_addr = %#x.", self.ins_addr)
             else:
-                tags: Optional[Set[Tag]]
+                tags: set[Tag] | None
                 if isinstance(a, int):
                     atom = MemoryLocation(a, size)
                     tags = None
@@ -361,7 +362,7 @@ class SimEngineRDVEX(
             data = MultiValues(top)
         return data
 
-    def _handle_RdTmp(self, expr: pyvex.IRExpr.RdTmp) -> Optional[MultiValues]:
+    def _handle_RdTmp(self, expr: pyvex.IRExpr.RdTmp) -> MultiValues | None:
         tmp: int = expr.tmp
 
         self.state.add_tmp_use(tmp)
@@ -387,7 +388,7 @@ class SimEngineRDVEX(
             # write it to registers
             self.state.kill_and_add_definition(reg_atom, values, override_codeloc=self._external_codeloc())
 
-        current_defs: Optional[Iterable[Definition]] = None
+        current_defs: Iterable[Definition] | None = None
         for vs in values.values():
             for v in vs:
                 if current_defs is None:
@@ -432,7 +433,7 @@ class SimEngineRDVEX(
         return MultiValues(top)
 
     def _load_core(self, addrs: Iterable[claripy.ast.Base], size: int, endness: str) -> MultiValues:
-        result: Optional[MultiValues] = None
+        result: MultiValues | None = None
         # we may get more than one stack addrs with the same value but different annotations (because they are defined
         # at different locations). only load them once.
         loaded_stack_offsets = set()
@@ -1080,7 +1081,7 @@ class SimEngineRDVEX(
     # User defined high level statement handlers
     #
 
-    def _handle_function(self, func_addr: Optional[MultiValues]):
+    def _handle_function(self, func_addr: MultiValues | None):
         if func_addr is None:
             func_addr = self.state.top(self.state.arch.bits)