angr 9.2.102__py3-none-manylinux2014_x86_64.whl → 9.2.104__py3-none-manylinux2014_x86_64.whl

angr/project.py

@@ -6,7 +6,7 @@ import pickle
 import string
 from collections import defaultdict
 from pathlib import Path
-from typing import Dict, Any, Optional, Union, cast
+from typing import Any, cast
 
 import archinfo
 from archinfo.arch_soot import SootAddressDescriptor, ArchSoot
@@ -19,7 +19,7 @@ from .errors import AngrNoPluginError
 l = logging.getLogger(name=__name__)
 
 
-def load_shellcode(shellcode: Union[bytes, str], arch, start_offset=0, load_address=0, thumb=False, **kwargs):
+def load_shellcode(shellcode: bytes | str, arch, start_offset=0, load_address=0, thumb=False, **kwargs):
     """
     Load a new project based on a snippet of assembly or bytecode.
 
@@ -107,10 +107,10 @@ class Project:
         arch=None,
         simos=None,
         engine=None,
-        load_options: Optional[Dict[str, Any]] = None,
+        load_options: dict[str, Any] | None = None,
         translation_cache=True,
         selfmodifying_code: bool = False,
-        support_selfmodifying_code: Optional[bool] = None,  # deprecated. use selfmodifying_code instead
+        support_selfmodifying_code: bool | None = None,  # deprecated. use selfmodifying_code instead
         store_function=None,
         load_function=None,
         analyses_preset=None,
@@ -461,7 +461,7 @@ class Project:
     #
 
     # pylint: disable=inconsistent-return-statements
-    def hook(self, addr, hook=None, length=0, kwargs=None, replace: Optional[bool] = False):
+    def hook(self, addr, hook=None, length=0, kwargs=None, replace: bool | None = False):
         """
         Hook a section of code with a custom function. This is used internally to provide symbolic
         summaries of library functions, and can be used to instrument execution or to modify
@@ -491,7 +491,7 @@ class Project:
         """
         if hook is None:
             # if we haven't been passed a thing to hook with, assume we're being used as a decorator
-            return self._hook_decorator(addr, length=length, kwargs=kwargs)
+            return self._hook_decorator(addr, length=length, kwargs=kwargs, replace=replace)
 
         if kwargs is None:
             kwargs = {}
@@ -534,7 +534,7 @@ class Project:
         """
         return addr in self._sim_procedures
 
-    def hooked_by(self, addr) -> Optional[SimProcedure]:
+    def hooked_by(self, addr) -> SimProcedure | None:
         """
         Returns the current hook for `addr`.
 
@@ -561,7 +561,7 @@ class Project:
 
         del self._sim_procedures[addr]
 
-    def hook_symbol(self, symbol_name, simproc, kwargs=None, replace: Optional[bool] = None):
+    def hook_symbol(self, symbol_name, simproc, kwargs=None, replace: bool | None = None):
         """
         Resolve a dependency in a binary. Looks up the address of the given symbol, and then hooks that
         address. If the symbol was not available in the loaded libraries, this address may be provided
@@ -612,7 +612,7 @@ class Project:
         self.hook(hook_addr, simproc, kwargs=kwargs, replace=replace)
         return hook_addr
 
-    def symbol_hooked_by(self, symbol_name) -> Optional[SimProcedure]:
+    def symbol_hooked_by(self, symbol_name) -> SimProcedure | None:
         """
         Return the SimProcedure, if it exists, for the given symbol name.
 
@@ -625,6 +625,8 @@ class Project:
             l.warning("Could not find symbol %s", symbol_name)
             return None
         hook_addr, _ = self.simos.prepare_function_symbol(symbol_name, basic_addr=sym.rebased_addr)
+        if not self.is_hooked(hook_addr):
+            return None
         return self.hooked_by(hook_addr)
 
     def is_symbol_hooked(self, symbol_name):
@@ -726,7 +728,7 @@ class Project:
     # Private methods related to hooking
     #
 
-    def _hook_decorator(self, addr, length=0, kwargs=None):
+    def _hook_decorator(self, addr, length=0, kwargs=None, replace=False):
         """
         Return a function decorator that allows easy hooking. Please refer to hook() for its usage.
 
@@ -734,7 +736,7 @@ class Project:
         """
 
         def hook_decorator(func):
-            self.hook(addr, func, length=length, kwargs=kwargs)
+            self.hook(addr, func, length=length, kwargs=kwargs, replace=replace)
             return func
 
         return hook_decorator

angr/sim_manager.py

@@ -2,7 +2,7 @@ import sys
 import itertools
 import types
 from collections import defaultdict
-from typing import List, Tuple, DefaultDict
+from typing import DefaultDict
 import logging
 
 import claripy
@@ -65,7 +65,7 @@ class SimulationManager:
     ALL = "_ALL"
     DROP = "_DROP"
 
-    _integral_stashes: Tuple[str] = ("active", "stashed", "pruned", "unsat", "errored", "deadended", "unconstrained")
+    _integral_stashes: tuple[str] = ("active", "stashed", "pruned", "unsat", "errored", "deadended", "unconstrained")
 
     def __init__(
         self,
@@ -91,7 +91,7 @@ class SimulationManager:
 
         if stashes is None:
             stashes = self._create_integral_stashes()
-        self._stashes: DefaultDict[str, List["SimState"]] = stashes
+        self._stashes: DefaultDict[str, list["SimState"]] = stashes
         self._hierarchy = StateHierarchy() if hierarchy is None else hierarchy
         self._save_unsat = save_unsat
         self._auto_drop = {
@@ -164,13 +164,13 @@ class SimulationManager:
         except AttributeError:
             return SimulationManager._fetch_states(self, stash=item)
 
-    active: List[SimState]
-    stashed: List[SimState]
-    pruned: List[SimState]
-    unsat: List[SimState]
-    deadended: List[SimState]
-    unconstrained: List[SimState]
-    found: List[SimState]
+    active: list[SimState]
+    stashed: list[SimState]
+    pruned: list[SimState]
+    unsat: list[SimState]
+    deadended: list[SimState]
+    unconstrained: list[SimState]
+    found: list[SimState]
     one_active: SimState
     one_stashed: SimState
     one_pruned: SimState
@@ -193,7 +193,7 @@ class SimulationManager:
         return self._errored
 
     @property
-    def stashes(self) -> DefaultDict[str, List["SimState"]]:
+    def stashes(self) -> DefaultDict[str, list["SimState"]]:
         return self._stashes
 
     def mulpyplex(self, *stashes):
@@ -894,7 +894,7 @@ class SimulationManager:
     #   ...
     #
 
-    def _create_integral_stashes(self) -> DefaultDict[str, List["SimState"]]:
+    def _create_integral_stashes(self) -> DefaultDict[str, list["SimState"]]:
         stashes = defaultdict(list)
         stashes.update({name: [] for name in self._integral_stashes})
         return stashes

angr/sim_procedure.py

@@ -2,7 +2,7 @@ import inspect
 import copy
 import itertools
 import logging
-from typing import TYPE_CHECKING, Union, Tuple
+from typing import TYPE_CHECKING
 
 import claripy
 from cle import SymbolType
@@ -165,7 +165,7 @@ class SimProcedure:
         self.ret_expr = None
         self.call_ret_expr = None
         self.inhibit_autoret = None
-        self.arg_session: Union[None, ArgSession, int] = None
+        self.arg_session: None | ArgSession | int = None
 
     def __repr__(self):
         return "<SimProcedure %s%s%s%s%s>" % self._describe_me()
@@ -321,7 +321,7 @@ class SimProcedure:
     IS_FUNCTION = True
     ARGS_MISMATCH = False
     ALT_NAMES = None  # alternative names
-    local_vars: Tuple[str, ...] = ()
+    local_vars: tuple[str, ...] = ()
 
     def run(self, *args, **kwargs):  # pylint: disable=unused-argument
         """
@@ -520,6 +520,10 @@ class SimProcedure:
 
         self._exit_action(call_state, addr)
         self.successors.add_successor(call_state, addr, call_state.solver.true, jumpkind)
+        if jumpkind != "Ijk_Call":
+            call_state.callstack.call(
+                self.state.addr, addr, retn_target=ret_addr, stack_pointer=call_state.regs.sp.concrete_value
+            )
 
         if o.DO_RET_EMULATION in self.state.options:
             # we need to set up the call because the continuation will try to tear it down

angr/sim_state.py

@@ -5,7 +5,7 @@ import weakref
 
 import logging
 
-from typing import Type, TypeVar, TYPE_CHECKING
+from typing import TypeVar, TYPE_CHECKING
 
 from archinfo import Arch
 
@@ -429,7 +429,7 @@ class SimState(PluginHub):
         self._set_plugin_state(plugin, inhibit_init=inhibit_init)
         return super().register_plugin(name, plugin)
 
-    def _init_plugin(self, plugin_cls: Type[SimStatePlugin]) -> SimStatePlugin:
+    def _init_plugin(self, plugin_cls: type[SimStatePlugin]) -> SimStatePlugin:
         plugin = plugin_cls()
         self._set_plugin_state(plugin)
         return plugin

angr/sim_type.py

@@ -1,8 +1,10 @@
 # pylint:disable=abstract-method,line-too-long,missing-class-docstring
+from __future__ import annotations
+
 from collections import OrderedDict, defaultdict, ChainMap
 import copy
 import re
-from typing import Optional, Dict, Any, Tuple, List, Union, Type, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING
 import logging
 
 try:
@@ -50,6 +52,14 @@ class SimType:
         """
         self.label = label
 
+    @staticmethod
+    def _simtype_eq(self_type: SimType, other: SimType, avoid: dict[str, set[SimType]] | None) -> bool:
+        if self_type is other:
+            return True
+        if avoid is not None and self_type in avoid["self"] and other in avoid["other"]:
+            return True
+        return self_type.__eq__(other, avoid=avoid)  # pylint:disable=unnecessary-dunder-call
+
     def __eq__(self, other, avoid=None):
         if type(self) != type(other):
             return False
@@ -60,12 +70,18 @@ class SimType:
             attr_self = getattr(self, attr)
             attr_other = getattr(other, attr)
             if isinstance(attr_self, SimType):
-                if attr_other is attr_self:
-                    return True
-                if avoid is not None and attr_self in avoid["self"] and attr_other in avoid["other"]:
-                    continue
-                if not attr_self.__eq__(attr_other, avoid=avoid):
+                if not SimType._simtype_eq(attr_self, attr_other, avoid):
+                    return False
+            elif isinstance(attr_self, (list, tuple)) and isinstance(attr_other, (list, tuple)):
+                if len(attr_self) != len(attr_other):
                     return False
+                for a, b in zip(attr_self, attr_other):
+                    if isinstance(a, SimType) and isinstance(b, SimType):
+                        if SimType._simtype_eq(a, b, avoid) is False:
+                            return False
+                    else:
+                        if a != b:
+                            return False
             else:
                 if attr_self != attr_other:
                     return False
@@ -125,7 +141,7 @@ class SimType:
     def _init_str(self):
         return f"NotImplemented({self.__class__.__name__})"
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(self, name=None, full=0, memo=None, indent=0):  # pylint:disable=unused-argument
         if name is None:
             return repr(self)
         else:
@@ -210,7 +226,7 @@ class NamedTypeMixin:
     unqualified name of the type.
     """
 
-    def __init__(self, *args, name: Optional[str] = None, **kwargs):
+    def __init__(self, *args, name: str | None = None, **kwargs):
         super().__init__(*args, **kwargs)
         self._name = name
 
@@ -239,9 +255,6 @@ class SimTypeBottom(SimType):
 
     _base_name = "bot"
 
-    def __init__(self, label=None):
-        super().__init__(label)
-
     def __repr__(self):
         return self.label or "BOT"
 
@@ -413,8 +426,8 @@ class SimTypeInt(SimTypeReg):
             raise ValueError("Can't tell my size without an arch!")
         try:
             return self._arch.sizeof[self._base_name]
-        except KeyError:
-            raise ValueError(f"Arch {self._arch.name} doesn't have its {self._base_name} type defined!")
+        except KeyError as ex:
+            raise ValueError(f"Arch {self._arch.name} doesn't have its {self._base_name} type defined!") from ex
 
     def extract(self, state, addr, concrete=False):
         out = state.memory.load(addr, self.size // state.arch.byte_width, endness=state.arch.memory_endness)
@@ -723,7 +736,7 @@ class SimTypeArray(SimType):
         """
         super().__init__(label=label)
         self.elem_type: SimType = elem_type
-        self.length: Optional[int] = length
+        self.length: int | None = length
 
     def __repr__(self):
         return "{}[{}]".format(self.elem_type, "" if self.length is None else self.length)
@@ -790,7 +803,7 @@ class SimTypeString(NamedTypeMixin, SimTypeArray):
 
     _fields = SimTypeArray._fields + ("length",)
 
-    def __init__(self, length=None, label=None, name: Optional[str] = None):
+    def __init__(self, length=None, label=None, name: str | None = None):
         """
         :param label:   The type label.
         :param length:  An expression of the length of the string, if known.
@@ -800,7 +813,7 @@ class SimTypeString(NamedTypeMixin, SimTypeArray):
     def __repr__(self):
         return "string_t"
 
-    def extract(self, state: "SimState", addr, concrete=False):
+    def extract(self, state: SimState, addr, concrete=False):
         if self.length is None:
             out = None
             last_byte = state.memory.load(addr, size=1)
@@ -848,7 +861,7 @@ class SimTypeWString(NamedTypeMixin, SimTypeArray):
 
     _fields = SimTypeArray._fields + ("length",)
 
-    def __init__(self, length=None, label=None, name: Optional[str] = None):
+    def __init__(self, length=None, label=None, name: str | None = None):
         super().__init__(SimTypeNum(16, False), label=label, length=length, name=name)
 
     def __repr__(self):
@@ -909,7 +922,7 @@ class SimTypeFunction(SimType):
     _fields = ("args", "returnty")
     base = False
 
-    def __init__(self, args: List[SimType], returnty: Optional[SimType], label=None, arg_names=None, variadic=False):
+    def __init__(self, args: list[SimType], returnty: SimType | None, label=None, arg_names=None, variadic=False):
         """
         :param label:    The type label
         :param args:     A tuple of types representing the arguments to the function
@@ -917,8 +930,8 @@ class SimTypeFunction(SimType):
         :param variadic: Whether the function accepts varargs
         """
         super().__init__(label=label)
-        self.args: List[SimType] = args
-        self.returnty: Optional[SimType] = returnty
+        self.args: list[SimType] = args
+        self.returnty: SimType | None = returnty
         self.arg_names = arg_names if arg_names else ()
         self.variadic = variadic
 
@@ -931,14 +944,18 @@ class SimTypeFunction(SimType):
             argstrs.append("...")
         return "({}) -> {}".format(", ".join(argstrs), self.returnty)
 
-    def c_repr(self, name=None, full=0, memo=None, indent=0):
+    def c_repr(self, name=None, full=0, memo=None, indent=0, name_parens: bool = True):
         formatted_args = [
             a.c_repr(n, full - 1, memo, indent)
             for a, n in zip(self.args, self.arg_names if self.arg_names and full else (None,) * len(self.args))
         ]
         if self.variadic:
             formatted_args.append("...")
-        proto = f"({name or ''})({', '.join(formatted_args)})"
+        if name_parens:
+            name_str = f"({name or ''})"
+        else:
+            name_str = name or ""
+        proto = f"{name_str}({', '.join(formatted_args)})"
         return f"void {proto}" if self.returnty is None else self.returnty.c_repr(proto, full, memo, indent)
 
     @property
@@ -988,7 +1005,7 @@ class SimTypeCppFunction(SimTypeFunction):
     """
 
     def __init__(
-        self, args, returnty, label=None, arg_names: Tuple[str] = None, ctor: bool = False, dtor: bool = False
+        self, args, returnty, label=None, arg_names: tuple[str] = None, ctor: bool = False, dtor: bool = False
     ):
         super().__init__(args, returnty, label=label, arg_names=arg_names, variadic=False)
         self.ctor = ctor
@@ -1121,7 +1138,7 @@ class SimTypeDouble(SimTypeFloat):
 class SimStruct(NamedTypeMixin, SimType):
     _fields = ("name", "fields")
 
-    def __init__(self, fields: Union[Dict[str, SimType], OrderedDict], name=None, pack=False, align=None):
+    def __init__(self, fields: dict[str, SimType] | OrderedDict, name=None, pack=False, align=None):
         super().__init__(None, name="<anon>" if name is None else name)
 
         self._pack = pack
@@ -1135,7 +1152,7 @@ class SimStruct(NamedTypeMixin, SimType):
         return self._pack
 
     @property
-    def offsets(self) -> Dict[str, int]:
+    def offsets(self) -> dict[str, int]:
         offsets = {}
         offset_so_far = 0
         for name, ty in self.fields.items():
@@ -1273,7 +1290,7 @@ class SimStruct(NamedTypeMixin, SimType):
     def copy(self):
         return SimStruct(dict(self.fields), name=self.name, pack=self._pack, align=self._align)
 
-    def __eq__(self, other, avoid=None):
+    def __eq__(self, other, avoid: dict[str, set[SimType]] | None = None):
         if not isinstance(other, SimStruct):
             return False
         if not (
@@ -1298,6 +1315,8 @@ class SimStruct(NamedTypeMixin, SimType):
             field_other = other.fields[key]
             if field_self in avoid["self"] and field_other in avoid["other"]:
                 continue
+            avoid["self"].add(field_self)
+            avoid["other"].add(field_other)
             if not field_self.__eq__(field_other, avoid=avoid):
                 return False
         return True
@@ -1352,8 +1371,7 @@ class SimStructValue:
                         return f[k]
                     except KeyError:
                         continue
-            else:
-                return self._values[k]
+            return self._values[k]
 
         return self._values[k]
 
@@ -1490,10 +1508,10 @@ class SimUnionValue:
 class SimCppClass(SimStruct):
     def __init__(
         self,
-        members: Optional[Dict[str, SimType]] = None,
-        function_members: Optional[Dict[str, SimTypeCppFunction]] = None,
+        members: dict[str, SimType] | None = None,
+        function_members: dict[str, SimTypeCppFunction] | None = None,
         vtable_ptrs=None,
-        name: Optional[str] = None,
+        name: str | None = None,
         pack: bool = False,
         align=None,
     ):
@@ -1606,10 +1624,7 @@ class SimTypeNumOffset(SimTypeNum):
         super().__init__(size, signed, label)
         self.offset = offset
 
-    def __repr__(self):
-        return super().__repr__()
-
-    def extract(self, state: "SimState", addr, concrete=False):
+    def extract(self, state: SimState, addr, concrete=False):
         if state.arch.memory_endness != Endness.LE:
             raise NotImplementedError("This has only been implemented and tested with Little Endian arches so far")
         minimum_load_size = self.offset + self.size  # because we start from a byte aligned offset _before_ the value
@@ -1639,7 +1654,7 @@ class SimTypeRef(SimType):
     SimTypeRef is not SimTypeReference.
     """
 
-    def __init__(self, name, original_type: Type[SimStruct]):
+    def __init__(self, name, original_type: type[SimStruct]):
         super().__init__(label=name)
         self.original_type = original_type
 
@@ -2812,7 +2827,7 @@ def parse_types(defn, preprocess=True, predefined_types=None, arch=None):
 _include_re = re.compile(r"^\s*#include")
 
 
-def parse_file(defn, preprocess=True, predefined_types: Optional[Dict[Any, SimType]] = None, arch=None):
+def parse_file(defn, preprocess=True, predefined_types: dict[Any, SimType] | None = None, arch=None):
     """
     Parse a series of C definitions, returns a tuple of two type mappings, one for variable
     definitions and one for type definitions.
@@ -2862,7 +2877,7 @@ def parse_file(defn, preprocess=True, predefined_types: Optional[Dict[Any, SimTy
 _type_parser_singleton = None
 
 
-def type_parser_singleton() -> Optional[pycparser.CParser]:
+def type_parser_singleton() -> pycparser.CParser | None:
     global _type_parser_singleton  # pylint:disable=global-statement
     if pycparser is not None:
         if _type_parser_singleton is None:
@@ -2887,7 +2902,7 @@ def parse_type(defn, preprocess=True, predefined_types=None, arch=None):  # pyli
 
 
 def parse_type_with_name(
-    defn, preprocess=True, predefined_types: Optional[Dict[Any, SimType]] = None, arch=None
+    defn, preprocess=True, predefined_types: dict[Any, SimType] | None = None, arch=None
 ):  # pylint:disable=unused-argument
     """
     Parse a simple type expression into a SimType, returning a tuple of the type object and any associated name
@@ -3119,7 +3134,7 @@ def _parse_const(c, arch=None, extra_types=None):
         raise ValueError(c)
 
 
-def _cpp_decl_to_type(decl: Any, extra_types: Dict[str, SimType], opaque_classes=True):
+def _cpp_decl_to_type(decl: Any, extra_types: dict[str, SimType], opaque_classes=True):
     if isinstance(decl, CppHeaderParser.CppMethod):
         the_func = decl
         func_name = the_func["name"]
@@ -3131,7 +3146,7 @@ def _cpp_decl_to_type(decl: Any, extra_types: Dict[str, SimType], opaque_classes
             the_func["destructor"] = True
         # translate parameters
         args = []
-        arg_names: List[str] = []
+        arg_names: list[str] = []
         for param in the_func["parameters"]:
             arg_type = param["type"]
             args.append(_cpp_decl_to_type(arg_type, extra_types, opaque_classes=opaque_classes))
@@ -3139,7 +3154,7 @@ def _cpp_decl_to_type(decl: Any, extra_types: Dict[str, SimType], opaque_classes
             arg_names.append(arg_name)
 
         args = tuple(args)
-        arg_names: Tuple[str] = tuple(arg_names)
+        arg_names: tuple[str] = tuple(arg_names)
         # returns
         if not the_func["returns"].strip():
             returnty = SimTypeBottom()
@@ -3252,10 +3267,10 @@ def parse_cpp_file(cpp_decl, with_param_names: bool = False):
     if not h.functions:
         return None, None
 
-    func_decls: Dict[str, SimTypeCppFunction] = {}
+    func_decls: dict[str, SimTypeCppFunction] = {}
     for the_func in h.functions:
         # FIXME: We always assume that there is a "this" pointer but it is not the case for static methods.
-        proto: Optional[SimTypeCppFunction] = _cpp_decl_to_type(the_func, {}, opaque_classes=True)
+        proto: SimTypeCppFunction | None = _cpp_decl_to_type(the_func, {}, opaque_classes=True)
         if proto is not None and the_func["class"]:
             func_name = the_func["class"] + "::" + the_func["name"]
             proto.args = (
@@ -3270,7 +3285,7 @@ def parse_cpp_file(cpp_decl, with_param_names: bool = False):
 
 
 def dereference_simtype(
-    t: SimType, type_collections: List["SimTypeCollection"], memo: Optional[Dict[str, SimType]] = None
+    t: SimType, type_collections: list[SimTypeCollection], memo: dict[str, SimType] | None = None
 ) -> SimType:
     if memo is None:
         memo = {}

angr/sim_variable.py

@@ -1,6 +1,6 @@
 import collections.abc
 import claripy
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from .protos import variables_pb2 as pb2
 from .serializable import Serializable
@@ -20,15 +20,15 @@ class SimVariable(Serializable):
         "size",
     ]
 
-    def __init__(self, ident=None, name=None, region: Optional[int] = None, category=None, size: Optional[int] = None):
+    def __init__(self, ident=None, name=None, region: int | None = None, category=None, size: int | None = None):
         """
         :param ident: A unique identifier provided by user or the program. Usually a string.
         :param str name: Name of this variable.
         """
         self.ident = ident
         self.name = name
-        self.region: Optional[int] = region
-        self.category: Optional[str] = category
+        self.region: int | None = region
+        self.category: str | None = category
         self.renamed = False
         self.candidate_names = None
         self.size = size
@@ -175,7 +175,7 @@ class SimRegisterVariable(SimVariable):
         SimVariable.__init__(self, ident=ident, name=name, region=region, category=category, size=size)
 
         self.reg: int = reg_offset
-        self._hash: Optional[int] = None
+        self._hash: int | None = None
 
     @property
     def bits(self):

angr/simos/simos.py

@@ -1,6 +1,5 @@
 import logging
 import struct
-from typing import Optional
 
 import angr  # for types
 
@@ -344,7 +343,7 @@ class SimOS:
     def syscall_abi(self, state) -> str:
         return None
 
-    def syscall_cc(self, state) -> Optional[angr.calling_conventions.SimCCSyscall]:
+    def syscall_cc(self, state) -> angr.calling_conventions.SimCCSyscall | None:
         raise NotImplementedError()
 
     def is_syscall_addr(self, addr):

angr/simos/userland.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Dict, Tuple
 
 from ..calling_conventions import SYSCALL_CC, SimCCSyscall
 from ..errors import AngrUnsupportedSyscallError, SimSolverError
@@ -23,7 +22,7 @@ class SimUserland(SimOS):
         self.syscall_addr_alignment = syscall_addr_alignment
         self.kernel_base = None
         self.unknown_syscall_number = None
-        self.syscall_abis: Dict[str, Tuple[int, int, int]] = {}
+        self.syscall_abis: dict[str, tuple[int, int, int]] = {}
         # syscall_abis is a dict of tuples {name: (base_number, min_number, max_number)}
         # min_number and max_number are just cached from SimSyscallLibrary.{min,max}imum_sysall_number
         # base_number is used to map the syscalls into the syscall address space - it's a "base address"

angr/state_plugins/callstack.py

@@ -1,7 +1,8 @@
 import collections
 from itertools import dropwhile
 import logging
-from typing import Iterator, Optional, Tuple, Union
+from typing import Optional
+from collections.abc import Iterator
 
 from .plugin import SimStatePlugin
 from ..errors import AngrError, SimEmptyCallStackError
@@ -327,7 +328,7 @@ class CallStack(SimStatePlugin):
 
         return "\n".join(stack)
 
-    def stack_suffix(self, context_sensitivity_level) -> Tuple[Union[int, None], ...]:
+    def stack_suffix(self, context_sensitivity_level) -> tuple[int | None, ...]:
         """
         Generate the stack suffix. A stack suffix can be used as the key to a SimRun in CFG recovery.
 

angr/state_plugins/history.py

@@ -2,7 +2,6 @@ import operator
 import logging
 import itertools
 import contextlib
-from typing import Optional
 
 import claripy
 from claripy.ast.bv import BV
@@ -40,7 +39,7 @@ class SimStateHistory(SimStatePlugin):
         self.jump_target = None if clone is None else clone.jump_target
         self.jump_source = None if clone is None else clone.jump_source
         self.jump_avoidable = None if clone is None else clone.jump_avoidable
-        self.jump_guard: Optional[BV] = None if clone is None else clone.jump_guard
+        self.jump_guard: BV | None = None if clone is None else clone.jump_guard
         self.jumpkind = None if clone is None else clone.jumpkind
 
         # the execution log for this history