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

angr/analyses/reaching_definitions/function_handler.py

@@ -1,4 +1,5 @@
-from typing import TYPE_CHECKING, Iterable, List, Set, Optional, Union, Callable, cast, Literal
+from typing import TYPE_CHECKING, cast, Literal
+from collections.abc import Iterable, Callable
 from dataclasses import dataclass, field
 import logging
 from functools import wraps
@@ -7,7 +8,7 @@ from cle.backends import ELF
 import claripy
 
 from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from angr.sim_type import SimTypeBottom
+from angr.sim_type import SimTypeBottom, dereference_simtype
 from angr.knowledge_plugins.key_definitions.atoms import Atom, Register, MemoryLocation, SpOffset
 from angr.knowledge_plugins.key_definitions.tag import Tag
 from angr.calling_conventions import SimCC
@@ -17,6 +18,7 @@ from angr.knowledge_plugins.functions import Function
 from angr.analyses.reaching_definitions.dep_graph import FunctionCallRelationships
 from angr.code_location import CodeLocation, ExternalCodeLocation
 from angr.knowledge_plugins.key_definitions.constants import ObservationPointType
+from angr import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
 
 
 if TYPE_CHECKING:
@@ -51,12 +53,12 @@ class FunctionEffect:
     `FunctionCallData.depends` instead.
     """
 
-    dest: Optional[Atom]
-    sources: Set[Atom]
-    value: Optional[MultiValues] = None
-    sources_defns: Optional[Set[Definition]] = None
+    dest: Atom | None
+    sources: set[Atom]
+    value: MultiValues | None = None
+    sources_defns: set[Definition] | None = None
     apply_at_callsite: bool = False
-    tags: Optional[Set[Tag]] = None
+    tags: set[Tag] | None = None
 
 
 @dataclass
@@ -83,21 +85,21 @@ class FunctionCallData:
 
     callsite_codeloc: CodeLocation
     function_codeloc: CodeLocation
-    address_multi: Optional[MultiValues]
-    address: Optional[int] = None
-    symbol: Optional[Symbol] = None
-    function: Optional[Function] = None
-    name: Optional[str] = None
-    cc: Optional[SimCC] = None
-    prototype: Optional[SimTypeFunction] = None
-    args_atoms: Optional[List[Set[Atom]]] = None
-    args_values: Optional[List[MultiValues]] = None
-    ret_atoms: Optional[Set[Atom]] = None
+    address_multi: MultiValues | None
+    address: int | None = None
+    symbol: Symbol | None = None
+    function: Function | None = None
+    name: str | None = None
+    cc: SimCC | None = None
+    prototype: SimTypeFunction | None = None
+    args_atoms: list[set[Atom]] | None = None
+    args_values: list[MultiValues] | None = None
+    ret_atoms: set[Atom] | None = None
     redefine_locals: bool = True
-    visited_blocks: Optional[Set[int]] = None
-    effects: List[FunctionEffect] = field(default_factory=lambda: [])
-    ret_values: Optional[MultiValues] = None
-    ret_values_deps: Optional[Set[Definition]] = None
+    visited_blocks: set[int] | None = None
+    effects: list[FunctionEffect] = field(default_factory=lambda: [])
+    ret_values: MultiValues | None = None
+    ret_values_deps: set[Definition] | None = None
     caller_will_handle_single_ret: bool = False
     guessed_cc: bool = False
     guessed_prototype: bool = False
@@ -135,11 +137,11 @@ class FunctionCallData:
 
     def depends(
         self,
-        dest: Union[Atom, Iterable[Atom], None],
-        *sources: Union[Atom, Iterable[Atom]],
-        value: Union[MultiValues, claripy.ast.BV, bytes, int, None] = None,
+        dest: Atom | Iterable[Atom] | None,
+        *sources: Atom | Iterable[Atom],
+        value: MultiValues | claripy.ast.BV | bytes | int | None = None,
         apply_at_callsite: bool = False,
-        tags: Optional[Set[Tag]] = None,
+        tags: set[Tag] | None = None,
     ):
         """
         Mark a single effect of the current function, including the atom being modified, the input atoms on which that
@@ -186,7 +188,7 @@ class FunctionCallData:
 
     def reset_prototype(
         self, prototype: SimTypeFunction, state: "ReachingDefinitionsState", soft_reset: bool = False
-    ) -> Set[Atom]:
+    ) -> set[Atom]:
         self.prototype = prototype.with_arch(state.arch)
         if not soft_reset:
             self.args_atoms = self.args_values = self.ret_atoms = None
@@ -222,9 +224,9 @@ class FunctionCallDataUnwrapped(FunctionCallData):
     name: str
     cc: SimCC
     prototype: SimTypeFunction
-    args_atoms: List[Set[Atom]]
-    args_values: List[MultiValues]
-    ret_atoms: Set[Atom]
+    args_atoms: list[set[Atom]]
+    args_values: list[MultiValues]
+    ret_atoms: set[Atom]
 
     def __init__(self, inner: FunctionCallData):
         d = dict(inner.__dict__)
@@ -268,7 +270,7 @@ class FunctionHandler:
         return self
 
     def make_function_codeloc(
-        self, target: Union[None, int, MultiValues], callsite: CodeLocation, callsite_func_addr: Optional[int]
+        self, target: None | int | MultiValues, callsite: CodeLocation, callsite_func_addr: int | None
     ):
         """
         The RDA engine will call this function to transform a callsite CodeLocation into a callee CodeLocation.
@@ -329,6 +331,7 @@ class FunctionHandler:
             data.cc = data.function.calling_convention
         if data.prototype is None and data.function is not None:
             data.prototype = data.function.prototype
+        hook_libname = None
         if data.address is not None and (data.cc is None or data.prototype is None):
             hook = (
                 None
@@ -348,6 +351,7 @@ class FunctionHandler:
             if data.prototype is None and hook is not None:
                 data.prototype = hook.prototype.with_arch(state.arch)
                 data.guessed_prototype = hook.guessed_prototype
+                hook_libname = hook.library_name
 
         # fallback to the default calling convention and prototype
         if data.cc is None:
@@ -357,6 +361,19 @@ class FunctionHandler:
             data.prototype = state.analysis.project.factory.function_prototype()
             data.guessed_prototype = True
 
+        if data.prototype is not None and data.function is not None:
+            # make sure the function prototype is resolved.
+            # TODO: Cache resolved function prototypes globally
+            prototype_libname = data.function.prototype_libname or hook_libname
+            type_collections = []
+            if prototype_libname is not None:
+                prototype_lib = SIM_LIBRARIES[prototype_libname]
+                if prototype_lib.type_collection_names:
+                    for typelib_name in prototype_lib.type_collection_names:
+                        type_collections.append(SIM_TYPE_COLLECTIONS[typelib_name])
+            if type_collections:
+                data.prototype = dereference_simtype(data.prototype, type_collections).with_arch(state.arch)
+
         args_atoms_from_values = data.reset_prototype(data.prototype, state, soft_reset=True)
 
         # PROCESS
@@ -512,7 +529,7 @@ class FunctionHandler:
         # get_exit_livedefinitions is currently only using ret_sites, but an argument could be made that it should
         # include jumpout sites as well. In the CFG generation tail call sites seem to be treated as return sites
         # and not as jumpout sites, so we are following that convention here.
-        return_observation_points: List[ObservationPoint] = [
+        return_observation_points: list[ObservationPoint] = [
             (
                 cast(Literal["node"], "node"),  # pycharm doesn't treat a literal string, as Literal[] by default...
                 block.addr,
@@ -540,7 +557,7 @@ class FunctionHandler:
         data.retaddr_popped = True
 
     @staticmethod
-    def c_args_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> List[Set[Atom]]:
+    def c_args_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> list[set[Atom]]:
         if not prototype.variadic:
             sp_value = state.get_one_value(Register(state.arch.sp_offset, state.arch.bytes), strip_annotations=True)
             sp = state.get_stack_offset(sp_value) if sp_value is not None else None
@@ -563,7 +580,7 @@ class FunctionHandler:
         return [{Register(*state.arch.registers[arg_name], arch=state.arch)} for arg_name in cc.ARG_REGS]
 
     @staticmethod
-    def c_return_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> Set[Atom]:
+    def c_return_as_atoms(state: "ReachingDefinitionsState", cc: SimCC, prototype: SimTypeFunction) -> set[Atom]:
         if prototype.returnty is not None and not isinstance(prototype.returnty, SimTypeBottom):
             retval = cc.return_val(prototype.returnty)
             if retval is not None:
@@ -574,7 +591,7 @@ class FunctionHandler:
         return set()
 
     @staticmethod
-    def caller_saved_regs_as_atoms(state: "ReachingDefinitionsState", cc: SimCC) -> Set[Register]:
+    def caller_saved_regs_as_atoms(state: "ReachingDefinitionsState", cc: SimCC) -> set[Register]:
         return (
             {Register(*state.arch.registers[reg], arch=state.arch) for reg in cc.CALLER_SAVED_REGS}
             if cc.CALLER_SAVED_REGS is not None

angr/analyses/reaching_definitions/heap_allocator.py

@@ -1,6 +1,5 @@
 import logging
 
-from typing import Union, List
 
 from ...knowledge_plugins.key_definitions.heap_address import HeapAddress
 from ...knowledge_plugins.key_definitions.unknown_size import UnknownSize
@@ -26,10 +25,10 @@ class HeapAllocator:
         :param canonical_size: The concrete size an <UNKNOWN_SIZE> defaults to.
         """
         self._next_heap_address: HeapAddress = HeapAddress(0)
-        self._allocated_addresses: List[HeapAddress] = [self._next_heap_address]
+        self._allocated_addresses: list[HeapAddress] = [self._next_heap_address]
         self._canonical_size: int = canonical_size
 
-    def allocate(self, size: Union[int, UnknownSize]) -> HeapAddress:
+    def allocate(self, size: int | UnknownSize) -> HeapAddress:
         """
         Gives an address for a new memory chunck of <size> bytes.
 
@@ -45,7 +44,7 @@ class HeapAllocator:
 
         return address
 
-    def free(self, address: Union[Undefined, HeapAddress]):
+    def free(self, address: Undefined | HeapAddress):
         """
         Mark the chunck pointed by <address> as freed.
 

angr/analyses/reaching_definitions/rd_initializer.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Tuple, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import claripy
 from archinfo import Arch
@@ -38,7 +38,7 @@ class RDAStateInitializer:
         self.project = project
 
     def initialize_function_state(
-        self, state: "ReachingDefinitionsState", cc: Optional[SimCC], func_addr: int, rtoc_value: Optional[int] = None
+        self, state: "ReachingDefinitionsState", cc: SimCC | None, func_addr: int, rtoc_value: int | None = None
     ) -> None:
         """
         This is the entry point to the state initialization logic.
@@ -71,8 +71,8 @@ class RDAStateInitializer:
         state: "ReachingDefinitionsState",
         func_addr: int,
         ex_loc: ExternalCodeLocation,
-        cc: Optional[SimCC],
-        prototype: Optional[SimTypeFunction],
+        cc: SimCC | None,
+        prototype: SimTypeFunction | None,
     ) -> None:
         """
         This method handles the setup for _all_ arguments of a function.
@@ -96,7 +96,7 @@ class RDAStateInitializer:
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         argument_location: SimFunctionArgument,
-        argument_type: Optional[SimType] = None,
+        argument_type: SimType | None = None,
     ) -> None:
         """
         This method handles the setup for _one_ argument of a function.
@@ -133,7 +133,7 @@ class RDAStateInitializer:
         state: "ReachingDefinitionsState",
         func_addr: int,
         ex_loc: ExternalCodeLocation,
-        rtoc_value: Optional[int] = None,
+        rtoc_value: int | None = None,
     ) -> None:
         """
         Some architectures require initialization that is specific to that architecture.
@@ -191,7 +191,7 @@ class RDAStateInitializer:
         func_addr: int,
         ex_loc: ExternalCodeLocation,
         arg: SimRegArg,
-        value: Optional[claripy.ast.Base] = None,
+        value: claripy.ast.Base | None = None,
     ):
         # FIXME: implement reg_offset handling in SimRegArg
         reg_offset = self.arch.registers[arg.reg_name][0]
@@ -218,7 +218,7 @@ class RDAStateInitializer:
         state.stack.store(stack_address, ml, endness=self.arch.memory_endness)
 
     @staticmethod
-    def _generate_call_string(subject: Subject, current_address: int) -> Optional[Tuple[int, ...]]:
+    def _generate_call_string(subject: Subject, current_address: int) -> tuple[int, ...] | None:
         if isinstance(subject.content, Function):
             return (subject.content.addr,)
         elif isinstance(subject.content, CallTrace):

angr/analyses/reaching_definitions/rd_state.py

@@ -1,4 +1,5 @@
-from typing import Optional, Iterable, Set, Tuple, Any, TYPE_CHECKING, Iterator, Union, overload, Type
+from typing import Optional, Any, TYPE_CHECKING, overload
+from collections.abc import Iterable, Iterator
 import logging
 
 import archinfo
@@ -84,12 +85,12 @@ class ReachingDefinitionsState:
         track_consts: bool = False,
         analysis: Optional["ReachingDefinitionsAnalysis"] = None,
         rtoc_value=None,
-        live_definitions: Optional[LiveDefinitions] = None,
+        live_definitions: LiveDefinitions | None = None,
         canonical_size: int = 8,
         heap_allocator: HeapAllocator = None,
         environment: Environment = None,
         sp_adjusted: bool = False,
-        all_definitions: Optional[Set[Definition]] = None,
+        all_definitions: set[Definition] | None = None,
         initializer: Optional["RDAStateInitializer"] = None,
         element_limit: int = 5,
     ):
@@ -104,12 +105,12 @@ class ReachingDefinitionsState:
         self._sp_adjusted: bool = sp_adjusted
         self._element_limit: int = element_limit
 
-        self.all_definitions: Set[Definition] = set() if all_definitions is None else all_definitions
+        self.all_definitions: set[Definition] = set() if all_definitions is None else all_definitions
 
         self.heap_allocator = heap_allocator or HeapAllocator(canonical_size)
         self._environment: Environment = environment or Environment()
 
-        self.codeloc_uses: Set[Definition] = set()
+        self.codeloc_uses: set[Definition] = set()
 
         # have we observed an exit statement or not during the analysis of the *last instruction* of a block? we should
         # not perform any sp updates if it is the case. this is for handling conditional returns in ARM binaries.
@@ -149,7 +150,7 @@ class ReachingDefinitionsState:
     def is_top(self, *args):
         return self.live_definitions.is_top(*args)
 
-    def heap_address(self, offset: Union[int, HeapAddress]) -> claripy.ast.BV:
+    def heap_address(self, offset: int | HeapAddress) -> claripy.ast.BV:
         return self.live_definitions.heap_address(offset)
 
     @staticmethod
@@ -157,7 +158,7 @@ class ReachingDefinitionsState:
         return LiveDefinitions.is_heap_address(addr)
 
     @staticmethod
-    def get_heap_offset(addr: claripy.ast.Base) -> Optional[int]:
+    def get_heap_offset(addr: claripy.ast.Base) -> int | None:
         return LiveDefinitions.get_heap_offset(addr)
 
     def stack_address(self, offset: int) -> claripy.ast.BV:
@@ -166,7 +167,7 @@ class ReachingDefinitionsState:
     def is_stack_address(self, addr: claripy.ast.Base) -> bool:
         return self.live_definitions.is_stack_address(addr)
 
-    def get_stack_offset(self, addr: claripy.ast.Base) -> Optional[int]:
+    def get_stack_offset(self, addr: claripy.ast.Base) -> int | None:
         offset = self.live_definitions.get_stack_offset(addr)
         if offset is not None:
             return self._to_signed(offset)
@@ -278,8 +279,8 @@ class ReachingDefinitionsState:
     def _set_initialization_values(
         self,
         subject: Subject,
-        rtoc_value: Optional[int] = None,
-        initializer: Optional[RDAStateInitializer] = None,
+        rtoc_value: int | None = None,
+        initializer: RDAStateInitializer | None = None,
         project=None,
     ):
         if initializer is None:
@@ -321,7 +322,7 @@ class ReachingDefinitionsState:
 
         return rd
 
-    def merge(self, *others) -> Tuple["ReachingDefinitionsState", bool]:
+    def merge(self, *others) -> tuple["ReachingDefinitionsState", bool]:
         state = self.copy()
         others: Iterable["ReachingDefinitionsState"]
 
@@ -358,12 +359,12 @@ class ReachingDefinitionsState:
         atom: Atom,
         data: MultiValues,
         dummy=False,
-        tags: Set[Tag] = None,
+        tags: set[Tag] = None,
         endness=None,  # XXX destroy
         annotated: bool = False,
-        uses: Optional[Set[Definition]] = None,
-        override_codeloc: Optional[CodeLocation] = None,
-    ) -> Tuple[Optional[MultiValues], Set[Definition]]:
+        uses: set[Definition] | None = None,
+        override_codeloc: CodeLocation | None = None,
+    ) -> tuple[MultiValues | None, set[Definition]]:
         codeloc = override_codeloc or self.codeloc
         existing_defs = self.live_definitions.get_definitions(atom)
         mv = self.live_definitions.kill_and_add_definition(
@@ -439,86 +440,84 @@ class ReachingDefinitionsState:
 
         return mv, defs
 
-    def add_use(self, atom: Atom, expr: Optional[Any] = None) -> None:
+    def add_use(self, atom: Atom, expr: Any | None = None) -> None:
         self.codeloc_uses.update(self.get_definitions(atom))
         self.live_definitions.add_use(atom, self.codeloc, expr=expr)
 
-    def add_use_by_def(self, definition: Definition, expr: Optional[Any] = None) -> None:
+    def add_use_by_def(self, definition: Definition, expr: Any | None = None) -> None:
         self.codeloc_uses.add(definition)
         self.live_definitions.add_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_tmp_use(self, tmp: int, expr: Optional[Any] = None) -> None:
+    def add_tmp_use(self, tmp: int, expr: Any | None = None) -> None:
         defs = self.live_definitions.get_tmp_definitions(tmp)
         self.add_tmp_use_by_defs(defs, expr=expr)
 
     def add_tmp_use_by_defs(
-        self, defs: Iterable[Definition], expr: Optional[Any] = None
+        self, defs: Iterable[Definition], expr: Any | None = None
     ) -> None:  # pylint:disable=unused-argument
         for definition in defs:
             self.codeloc_uses.add(definition)
             # if track_tmps is False, definitions may not be Tmp definitions
             self.live_definitions.add_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_register_use(self, reg_offset: int, size: int, expr: Optional[Any] = None) -> None:
+    def add_register_use(self, reg_offset: int, size: int, expr: Any | None = None) -> None:
         defs = self.live_definitions.get_register_definitions(reg_offset, size)
         self.add_register_use_by_defs(defs, expr=expr)
 
-    def add_register_use_by_defs(self, defs: Iterable[Definition], expr: Optional[Any] = None) -> None:
+    def add_register_use_by_defs(self, defs: Iterable[Definition], expr: Any | None = None) -> None:
         for definition in defs:
             self.codeloc_uses.add(definition)
             self.live_definitions.add_register_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_stack_use(self, stack_offset: int, size: int, expr: Optional[Any] = None) -> None:
+    def add_stack_use(self, stack_offset: int, size: int, expr: Any | None = None) -> None:
         defs = self.live_definitions.get_stack_definitions(stack_offset, size)
         self.add_stack_use_by_defs(defs, expr=expr)
 
-    def add_stack_use_by_defs(self, defs: Iterable[Definition], expr: Optional[Any] = None):
+    def add_stack_use_by_defs(self, defs: Iterable[Definition], expr: Any | None = None):
         for definition in defs:
             self.codeloc_uses.add(definition)
             self.live_definitions.add_stack_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_heap_use(self, heap_offset: int, size: int, expr: Optional[Any] = None) -> None:
+    def add_heap_use(self, heap_offset: int, size: int, expr: Any | None = None) -> None:
         defs = self.live_definitions.get_heap_definitions(heap_offset, size)
         self.add_heap_use_by_defs(defs, expr=expr)
 
-    def add_heap_use_by_defs(self, defs: Iterable[Definition], expr: Optional[Any] = None):
+    def add_heap_use_by_defs(self, defs: Iterable[Definition], expr: Any | None = None):
         for definition in defs:
             self.codeloc_uses.add(definition)
             self.live_definitions.add_heap_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_memory_use_by_def(self, definition: Definition, expr: Optional[Any] = None):
+    def add_memory_use_by_def(self, definition: Definition, expr: Any | None = None):
         self.codeloc_uses.add(definition)
         self.live_definitions.add_memory_use_by_def(definition, self.codeloc, expr=expr)
 
-    def add_memory_use_by_defs(self, defs: Iterable[Definition], expr: Optional[Any] = None):
+    def add_memory_use_by_defs(self, defs: Iterable[Definition], expr: Any | None = None):
         for definition in defs:
             self.codeloc_uses.add(definition)
             self.live_definitions.add_memory_use_by_def(definition, self.codeloc, expr=expr)
 
-    def get_definitions(self, atom: Union[Atom, Definition, Iterable[Atom], Iterable[Definition]]) -> Set[Definition]:
+    def get_definitions(self, atom: Atom | Definition | Iterable[Atom] | Iterable[Definition]) -> set[Definition]:
         return self.live_definitions.get_definitions(atom)
 
-    def get_values(self, spec: Union[Atom, Definition, Iterable[Atom]]) -> Optional[MultiValues]:
+    def get_values(self, spec: Atom | Definition | Iterable[Atom]) -> MultiValues | None:
         return self.live_definitions.get_values(spec)
 
-    def get_one_value(
-        self, spec: Union[Atom, Definition], strip_annotations: bool = False
-    ) -> Optional[claripy.ast.bv.BV]:
+    def get_one_value(self, spec: Atom | Definition, strip_annotations: bool = False) -> claripy.ast.bv.BV | None:
         return self.live_definitions.get_one_value(spec, strip_annotations=strip_annotations)
 
     @overload
     def get_concrete_value(
-        self, spec: Union[Atom, Definition[Atom], Iterable[Atom]], cast_to: Type[int] = ...
-    ) -> Optional[int]: ...
+        self, spec: Atom | Definition[Atom] | Iterable[Atom], cast_to: type[int] = ...
+    ) -> int | None: ...
 
     @overload
     def get_concrete_value(
-        self, spec: Union[Atom, Definition[Atom], Iterable[Atom]], cast_to: Type[bytes] = ...
-    ) -> Optional[bytes]: ...
+        self, spec: Atom | Definition[Atom] | Iterable[Atom], cast_to: type[bytes] = ...
+    ) -> bytes | None: ...
 
     def get_concrete_value(
-        self, spec: Union[Atom, Definition[Atom], Iterable[Atom]], cast_to: Union[Type[int], Type[bytes]] = int
-    ) -> Union[int, bytes, None]:
+        self, spec: Atom | Definition[Atom] | Iterable[Atom], cast_to: type[int] | type[bytes] = int
+    ) -> int | bytes | None:
         return self.live_definitions.get_concrete_value(spec, cast_to)
 
     def mark_guard(self, target):
@@ -544,7 +543,7 @@ class ReachingDefinitionsState:
         self.live_definitions.reset_uses()
 
     @deprecated("deref")
-    def pointer_to_atoms(self, pointer: MultiValues, size: int, endness: str) -> Set[MemoryLocation]:
+    def pointer_to_atoms(self, pointer: MultiValues, size: int, endness: str) -> set[MemoryLocation]:
         """
         Given a MultiValues, return the set of atoms that loading or storing to the pointer with that value
         could define or use.
@@ -559,7 +558,7 @@ class ReachingDefinitionsState:
         return result
 
     @deprecated("deref")
-    def pointer_to_atom(self, value: claripy.ast.base.Base, size: int, endness: str) -> Optional[MemoryLocation]:
+    def pointer_to_atom(self, value: claripy.ast.base.Base, size: int, endness: str) -> MemoryLocation | None:
         if self.is_top(value):
             return None
 
@@ -582,33 +581,33 @@ class ReachingDefinitionsState:
     @overload
     def deref(
         self,
-        pointer: Union[int, claripy.ast.bv.BV, HeapAddress, SpOffset],
-        size: Union[int, DerefSize],
+        pointer: int | claripy.ast.bv.BV | HeapAddress | SpOffset,
+        size: int | DerefSize,
         endness: str = ...,
-    ) -> Optional[MemoryLocation]: ...
+    ) -> MemoryLocation | None: ...
 
     @overload
     def deref(
         self,
-        pointer: Union[MultiValues, Atom, Definition, Iterable[Atom], Iterable[Definition]],
-        size: Union[int, DerefSize],
+        pointer: MultiValues | Atom | Definition | Iterable[Atom] | Iterable[Definition],
+        size: int | DerefSize,
         endness: str = ...,
-    ) -> Set[MemoryLocation]: ...
+    ) -> set[MemoryLocation]: ...
 
     def deref(
         self,
-        pointer: Union[
-            MultiValues,
-            Atom,
-            Definition,
-            Iterable[Atom],
-            Iterable[Definition],
-            int,
-            claripy.ast.BV,
-            HeapAddress,
-            SpOffset,
-        ],
-        size: Union[int, DerefSize],
+        pointer: (
+            MultiValues
+            | Atom
+            | Definition
+            | Iterable[Atom]
+            | Iterable[Definition]
+            | int
+            | claripy.ast.BV
+            | HeapAddress
+            | SpOffset
+        ),
+        size: int | DerefSize,
         endness: str = archinfo.Endness.BE,
     ):
         return self.live_definitions.deref(pointer, size, endness)