angr 9.2.132__py3-none-manylinux2014_x86_64.whl → 9.2.134__py3-none-manylinux2014_x86_64.whl

angr/blade.py

@@ -144,13 +144,13 @@ class Blade:
                 else:
                     stmt_str = str(stmt)
 
-                block_str += "%02s %02d | %s\n" % ("+" if i in included_stmts else " ", i, stmt_str)
+                block_str += f"{'+' if i in included_stmts else ' '} {i:02d} | {stmt_str}\n"
 
             block_str += " + " if default_exit_included else "   "
             if isinstance(block.next, pyvex.IRExpr.Const):
                 block_str += f"Next: {block.next.con.value:#x}\n"
             elif isinstance(block.next, pyvex.IRExpr.RdTmp):
-                block_str += "Next: t%d\n" % block.next.tmp
+                block_str += f"Next: t{block.next.tmp}\n"
             else:
                 block_str += f"Next: {block.next!s}\n"
 

angr/block.py

@@ -23,7 +23,7 @@ class DisassemblerBlock:
     instructions
     """
 
-    __slots__ = ["addr", "insns", "thumb", "arch"]
+    __slots__ = ["addr", "arch", "insns", "thumb"]
 
     def __init__(self, addr, insns, thumb, arch):
         self.addr = addr
@@ -122,25 +122,25 @@ class Block(Serializable):
     BLOCK_MAX_SIZE = 4096
 
     __slots__ = [
-        "_project",
         "_bytes",
-        "_vex",
-        "thumb",
-        "_disassembly",
         "_capstone",
-        "addr",
-        "size",
-        "arch",
-        "_instructions",
-        "_instruction_addrs",
-        "_opt_level",
-        "_vex_nostmt",
         "_collect_data_refs",
-        "_strict_block_end",
-        "_cross_insn_opt",
-        "_load_from_ro_regions",
         "_const_prop",
+        "_cross_insn_opt",
+        "_disassembly",
         "_initial_regs",
+        "_instruction_addrs",
+        "_instructions",
+        "_load_from_ro_regions",
+        "_opt_level",
+        "_project",
+        "_strict_block_end",
+        "_vex",
+        "_vex_nostmt",
+        "addr",
+        "arch",
+        "size",
+        "thumb",
     ]
 
     def __init__(
@@ -277,7 +277,7 @@ class Block(Serializable):
             self.size = vex_block.size
 
     def __repr__(self):
-        return "<Block for %#x, %d bytes>" % (self.addr, self.size)
+        return f"<Block for {self.addr:#x}, {self.size} bytes>"
 
     def __getstate__(self):
         return {k: getattr(self, k) for k in self.__slots__ if k not in {"_capstone", "_disassembly", "_project"}}

angr/calling_conventions.py

@@ -243,12 +243,12 @@ class SimFunctionArgument:
         if not isinstance(value, claripy.ast.Base) and self.size is None:
             raise TypeError("Only claripy objects may be stored through SimFunctionArgument when size is not provided")
         if self.size is not None and isinstance(value, claripy.ast.Base) and self.size * arch.byte_width < value.length:
-            raise TypeError("%s doesn't fit in an argument of size %d" % (value, self.size))
+            raise TypeError(f"{value} doesn't fit in an argument of size {self.size}")
         if isinstance(value, int):
             value = claripy.BVV(value, self.size * arch.byte_width)
         if isinstance(value, float):
             if self.size not in (4, 8):
-                raise ValueError("What do I do with a float %d bytes long" % self.size)
+                raise ValueError(f"What do I do with a float {self.size} bytes long")
             value = claripy.FPV(value, claripy.FSORT_FLOAT if self.size == 4 else claripy.FSORT_DOUBLE)
         return value.raw_to_bv()
 
@@ -468,7 +468,7 @@ class SimArrayArg(SimFunctionArgument):
 
     def set_value(self, state, value, **kwargs):
         if len(value) != len(self.locs):
-            raise TypeError("Expected %d elements, got %d" % (len(self.locs), len(value)))
+            raise TypeError(f"Expected {len(self.locs)} elements, got {len(value)}")
         for subvalue, setter in zip(value, self.locs):
             setter.set_value(state, subvalue, **kwargs)
 
@@ -505,10 +505,10 @@ class ArgSession:
     """
 
     __slots__ = (
+        "both_iter",
         "cc",
         "fp_iter",
         "int_iter",
-        "both_iter",
     )
 
     def __init__(self, cc):
@@ -1027,7 +1027,7 @@ class SimCC:
                 raise TypeError(f"Type mismatch: Expected {ty}, got {type(arg)} (i.e. struct)")
             if type(arg) is not SimStructValue:
                 if len(arg) != len(ty.fields):
-                    raise TypeError("Wrong number of fields in struct, expected %d got %d" % (len(ty.fields), len(arg)))
+                    raise TypeError(f"Wrong number of fields in struct, expected {len(ty.fields)} got {len(arg)}")
                 arg = SimStructValue(ty, arg)
             return SimStructValue(
                 ty, [SimCC._standardize_value(arg[field], ty.fields[field], state, alloc) for field in ty.fields]
@@ -1063,7 +1063,7 @@ class SimCC:
                 if len(arg) != ty.size:
                     if arg.concrete:
                         return claripy.BVV(arg.concrete_value, ty.size)
-                    raise TypeError("Type mismatch of symbolic data: expected %s, got %d bits" % (ty, len(arg)))
+                    raise TypeError(f"Type mismatch of symbolic data: expected {ty}, got {len(arg)} bits")
                 return arg
             if isinstance(ty, (SimTypeFloat)):
                 raise TypeError(
@@ -2272,7 +2272,7 @@ def default_cc(  # pylint:disable=unused-argument
     platform: str | None = "Linux",
     language: str | None = None,
     syscall: bool = False,
-    **kwargs,
+    default: type[SimCC] | None = None,
 ) -> type[SimCC] | None:
     """
     Return the default calling convention for a given architecture, platform, and language combination.
@@ -2281,19 +2281,19 @@ def default_cc(  # pylint:disable=unused-argument
     :param platform:    The platform name (e.g., "Linux" or "Win32").
     :param language:    The programming language name (e.g., "go").
     :param syscall:     Return syscall convention (True), or normal calling convention (False, default).
+    :param default:     The default calling convention to return if nothing fits.
     :return:            A default calling convention class if we can find one for the architecture, platform, and
-                        language combination, or None if nothing fits.
+                        language combination, or the default if nothing fits.
     """
 
     if platform is None:
         platform = "Linux"
 
-    default = kwargs.get("default", ...)
     cc_map = SYSCALL_CC if syscall else DEFAULT_CC
 
     if arch in cc_map:
         if platform not in cc_map[arch]:
-            if default is not ...:
+            if default is not None:
                 return default
             if "Linux" in cc_map[arch]:
                 return cc_map[arch]["Linux"]
@@ -2301,9 +2301,7 @@ def default_cc(  # pylint:disable=unused-argument
 
     alias = unify_arch_name(arch)
     if alias not in cc_map or platform not in cc_map[alias]:
-        if default is not ...:
-            return default
-        return None
+        return default
     return cc_map[alias][platform]
 
 

angr/code_location.py

@@ -9,14 +9,14 @@ class CodeLocation:
     """
 
     __slots__ = (
+        "_hash",
         "block_addr",
-        "stmt_idx",
-        "sim_procedure",
-        "ins_addr",
+        "block_idx",
         "context",
         "info",
-        "block_idx",
-        "_hash",
+        "ins_addr",
+        "sim_procedure",
+        "stmt_idx",
     )
 
     def __init__(
@@ -65,11 +65,7 @@ class CodeLocation:
                 self.block_addr,
             )
         else:
-            s = "<%s%#x[%d]" % (
-                (f"{self.ins_addr:#x} id=") if self.ins_addr else "",
-                self.block_addr,
-                self.stmt_idx,
-            )
+            s = f"<{(f'{self.ins_addr:#x} id=') if self.ins_addr else ''}{self.block_addr:#x}[{self.stmt_idx}]"
 
         if self.context is None:
             s += " contextless"

angr/codenode.py

@@ -11,7 +11,7 @@ def repr_addr(addr):
 
 
 class CodeNode:
-    __slots__ = ["addr", "size", "_graph", "thumb", "_hash"]
+    __slots__ = ["_graph", "_hash", "addr", "size", "thumb"]
 
     def __init__(self, addr: int, size: int, graph=None, thumb=False):
         self.addr: int = addr
@@ -75,7 +75,7 @@ class BlockNode(CodeNode):
         self.bytestr = bytestr
 
     def __repr__(self):
-        return "<BlockNode at %s (size %d)>" % (repr_addr(self.addr), self.size)
+        return f"<BlockNode at {repr_addr(self.addr)} (size {self.size})>"
 
     def __getstate__(self):
         return (self.addr, self.size, self.bytestr, self.thumb)
@@ -94,7 +94,7 @@ class SootBlockNode(BlockNode):
         assert (stmts is None and size == 0) or (size == len(stmts))
 
     def __repr__(self):
-        return "<SootBlockNode at %s (%d statements)>" % (repr_addr(self.addr), self.size)
+        return f"<SootBlockNode at {repr_addr(self.addr)} ({self.size} statements)>"
 
     def __getstate__(self):
         return self.addr, self.size, self.stmts

angr/engines/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from .successors import SimSuccessors
-from .engine import SimEngine, SuccessorsMixin, TLSMixin
+from .engine import SimEngine, SuccessorsMixin
 
 from .vex import HeavyVEXMixin, TrackActionsMixin, SimInspectMixin, HeavyResilienceMixin, SuperFastpathMixin
 from .procedure import ProcedureMixin, ProcedureEngine
@@ -26,29 +26,27 @@ class UberEngine(
     HeavyResilienceMixin,
     SootMixin,
     HeavyVEXMixin,
-    TLSMixin,
 ):
     pass
 
 
 __all__ = [
-    "SimSuccessors",
-    "SimEngine",
-    "SuccessorsMixin",
-    "TLSMixin",
-    "HeavyVEXMixin",
-    "TrackActionsMixin",
-    "SimInspectMixin",
     "HeavyResilienceMixin",
-    "SuperFastpathMixin",
-    "ProcedureMixin",
+    "HeavyVEXMixin",
+    "HooksMixin",
     "ProcedureEngine",
-    "SimEngineUnicorn",
+    "ProcedureMixin",
+    "SimEngine",
+    "SimEngineConcrete",
     "SimEngineFailure",
     "SimEngineSyscall",
-    "SimEngineConcrete",
-    "HooksMixin",
+    "SimEngineUnicorn",
+    "SimInspectMixin",
+    "SimSuccessors",
     "SootMixin",
+    "SuccessorsMixin",
+    "SuperFastpathMixin",
+    "TrackActionsMixin",
     "UberEngine",
 ]
 

angr/engines/engine.py

@@ -3,11 +3,9 @@ from __future__ import annotations
 from typing import Generic, TypeVar
 import abc
 import logging
-import threading
 
-
-from archinfo.arch_soot import SootAddressDescriptor
 import claripy
+from archinfo.arch_soot import SootAddressDescriptor
 
 import angr
 from angr.sim_state import SimState
@@ -40,8 +38,6 @@ class SimEngineBase(Generic[StateType]):
         self.project = project
         self.arch = self.project.arch
 
-    __tls = ("state",)
-
     def __getstate__(self):
         return (self.project,)
 
@@ -64,53 +60,6 @@ class SimEngine(Generic[StateType, ResultType], SimEngineBase[StateType], metacl
         """
 
 
-class TLSMixin:
-    """
-    Mix this class into any class that defines __tls to make all of the attributes named in that list into
-    thread-local properties.
-
-    MAGIC MAGIC MAGIC
-    """
-
-    __local: threading.local  # pylint: disable=unused-private-member
-
-    def __new__(cls, *args, **kwargs):  # pylint:disable=unused-argument
-        obj = super().__new__(cls)
-        obj.__local = threading.local()
-        return obj
-
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-
-        for subcls in cls.mro():
-            for attr in subcls.__dict__.get(f"_{subcls.__name__}__tls", ()):
-                if attr.startswith("__"):
-                    attr = f"_{subcls.__name__}{attr}"
-
-                if hasattr(cls, attr):
-                    assert (
-                        type(getattr(cls, attr, None)) is TLSProperty
-                    ), f"Programming error: {attr} is both in __tls and __class__"
-                else:
-                    setattr(cls, attr, TLSProperty(attr))
-
-
-class TLSProperty:  # pylint:disable=missing-class-docstring
-    def __init__(self, name):
-        self.name = name
-
-    def __get__(self, instance, owner):
-        if instance is None:
-            return self
-        return getattr(instance._TLSMixin__local, self.name)
-
-    def __set__(self, instance, value):
-        setattr(instance._TLSMixin__local, self.name, value)
-
-    def __delete__(self, instance):
-        delattr(instance._TLSMixin__local, self.name)
-
-
 class SuccessorsMixin(SimEngine[HeavyState, SimSuccessors]):
     """
     A mixin for SimEngine which implements ``process`` to perform common operations related to symbolic execution
@@ -122,8 +71,6 @@ class SuccessorsMixin(SimEngine[HeavyState, SimSuccessors]):
 
         self.successors: SimSuccessors | None = None
 
-    __tls = ("successors",)
-
     def process(self, state: HeavyState, **kwargs) -> SimSuccessors:  # pylint:disable=unused-argument
         """
         Perform execution with a state.

angr/engines/light/__init__.py

@@ -12,12 +12,12 @@ from .engine import (
 
 __all__ = (
     "ArithmeticExpression",
-    "SpOffset",
     "RegisterOffset",
     "SimEngineLight",
-    "SimEngineLightVEX",
     "SimEngineLightAIL",
-    "SimEngineNostmtVEX",
-    "SimEngineNostmtAIL",
+    "SimEngineLightVEX",
     "SimEngineNoexprAIL",
+    "SimEngineNostmtAIL",
+    "SimEngineNostmtVEX",
+    "SpOffset",
 )

angr/engines/light/data.py

@@ -332,8 +332,8 @@ class ArithmeticExpression:
 class RegisterOffset:
     __slots__ = (
         "_bits",
-        "reg",
         "offset",
+        "reg",
     )
 
     def __init__(self, bits, reg, offset):

angr/engines/pcode/__init__.py

@@ -4,6 +4,6 @@ from .cc import register_pcode_arch_default_cc
 from .engine import HeavyPcodeMixin
 
 __all__ = (
-    "register_pcode_arch_default_cc",
     "HeavyPcodeMixin",
+    "register_pcode_arch_default_cc",
 )

angr/engines/pcode/behavior.py

@@ -35,7 +35,7 @@ class OpBehavior:
     Base class for all operation behaviors.
     """
 
-    __slots__ = ("opcode", "is_unary", "is_special")
+    __slots__ = ("is_special", "is_unary", "opcode")
     opcode: int
     is_unary: bool
     is_special: bool

angr/engines/pcode/lifter.py

@@ -112,17 +112,17 @@ class IRSB:
 
     __slots__ = (
         "_direct_next",
+        "_disassembly",
         "_exit_statements",
         "_instruction_addresses",
         "_ops",
         "_size",
         "_statements",
-        "_disassembly",
         "addr",
         "arch",
         "behaviors",
-        "data_refs",
         "const_vals",
+        "data_refs",
         "default_exit_target",
         "jumpkind",
         "next",
@@ -521,19 +521,19 @@ class Lifter:
     REQUIRE_DATA_PY = False
 
     __slots__ = (
-        "data",
-        "bytes_offset",
-        "opt_level",
-        "traceflags",
+        "addr",
         "allow_arch_optimizations",
-        "strict_block_end",
+        "arch",
+        "bytes_offset",
         "collect_data_refs",
-        "max_inst",
+        "data",
+        "irsb",
         "max_bytes",
+        "max_inst",
+        "opt_level",
         "skip_stmts",
-        "irsb",
-        "arch",
-        "addr",
+        "strict_block_end",
+        "traceflags",
     )
 
     data: str | bytes | None
@@ -1377,10 +1377,8 @@ class PcodeLifterEngineMixin(SimEngineBase):
 
     def __is_stop_point(self, addr: int, extra_stop_points: Sequence[int] | None = None) -> bool:
         return bool(
-            self.project is not None
-            and addr in self.project._sim_procedures
-            or extra_stop_points is not None
-            and addr in extra_stop_points
+            (self.project is not None and addr in self.project._sim_procedures)
+            or (extra_stop_points is not None and addr in extra_stop_points)
         )
 
     def __getstate__(self):

angr/engines/soot/expressions/__init__.py

@@ -59,32 +59,32 @@ from .instanceOf import SimSootExpr_InstanceOf
 
 
 __all__ = (
-    "translate_expr",
     "SimSootExpr_ArrayRef",
     "SimSootExpr_Binop",
     "SimSootExpr_Cast",
+    "SimSootExpr_ClassConstant",
     "SimSootExpr_Condition",
-    "SimSootExpr_IntConstant",
-    "SimSootExpr_LongConstant",
-    "SimSootExpr_FloatConstant",
     "SimSootExpr_DoubleConstant",
-    "SimSootExpr_StringConstant",
-    "SimSootExpr_ClassConstant",
-    "SimSootExpr_NullConstant",
+    "SimSootExpr_FloatConstant",
     "SimSootExpr_InstanceFieldRef",
-    "SimSootExpr_SpecialInvoke",
-    "SimSootExpr_StaticInvoke",
-    "SimSootExpr_VirtualInvoke",
+    "SimSootExpr_InstanceOf",
+    "SimSootExpr_IntConstant",
     "SimSootExpr_InterfaceInvoke",
     "SimSootExpr_Length",
     "SimSootExpr_Local",
+    "SimSootExpr_LongConstant",
     "SimSootExpr_New",
     "SimSootExpr_NewArray",
     "SimSootExpr_NewMultiArray",
+    "SimSootExpr_NullConstant",
+    "SimSootExpr_ParamRef",
     "SimSootExpr_Phi",
+    "SimSootExpr_SpecialInvoke",
     "SimSootExpr_StaticFieldRef",
+    "SimSootExpr_StaticInvoke",
+    "SimSootExpr_StringConstant",
     "SimSootExpr_ThisRef",
-    "SimSootExpr_ParamRef",
     "SimSootExpr_Unsupported",
-    "SimSootExpr_InstanceOf",
+    "SimSootExpr_VirtualInvoke",
+    "translate_expr",
 )

angr/engines/soot/statements/__init__.py

@@ -32,15 +32,15 @@ from .throw import SimSootStmt_Throw
 
 
 __all__ = (
-    "translate_stmt",
     "SimSootStmt_Assign",
-    "SimSootStmt_Return",
-    "SimSootStmt_ReturnVoid",
-    "SimSootStmt_Identity",
     "SimSootStmt_Goto",
-    "SimSootStmt_Invoke",
+    "SimSootStmt_Identity",
     "SimSootStmt_If",
-    "SimSootStmt_TableSwitch",
+    "SimSootStmt_Invoke",
     "SimSootStmt_LookupSwitch",
+    "SimSootStmt_Return",
+    "SimSootStmt_ReturnVoid",
+    "SimSootStmt_TableSwitch",
     "SimSootStmt_Throw",
+    "translate_stmt",
 )

angr/engines/soot/values/__init__.py

@@ -27,14 +27,14 @@ from .strref import SimSootValue_StringRef
 
 
 __all__ = (
-    "translate_value",
-    "SimSootValue_Local",
-    "SimSootValue_ParamRef",
-    "SimSootValue_ArrayRef",
     "SimSootValue_ArrayBaseRef",
-    "SimSootValue_ThisRef",
-    "SimSootValue_StaticFieldRef",
+    "SimSootValue_ArrayRef",
     "SimSootValue_InstanceFieldRef",
     "SimSootValue_IntConstant",
+    "SimSootValue_Local",
+    "SimSootValue_ParamRef",
+    "SimSootValue_StaticFieldRef",
     "SimSootValue_StringRef",
+    "SimSootValue_ThisRef",
+    "translate_value",
 )

angr/engines/soot/values/arrayref.py

@@ -12,7 +12,7 @@ l = logging.getLogger("angr.engines.soot.values.arrayref")
 
 
 class SimSootValue_ArrayBaseRef(SimSootValue):
-    __slots__ = ["id", "element_type", "size", "_default_value_generator", "type"]
+    __slots__ = ["_default_value_generator", "element_type", "id", "size", "type"]
 
     def __init__(self, heap_alloc_id, element_type, size, default_value_generator=None):
         self.id = f"{heap_alloc_id}.array_{element_type}"
@@ -48,7 +48,7 @@ class SimSootValue_ArrayBaseRef(SimSootValue):
 
 
 class SimSootValue_ArrayRef(SimSootValue):
-    __slots__ = ["id", "base", "index"]
+    __slots__ = ["base", "id", "index"]
 
     def __init__(self, base, index):
         self.id = f"{base.id}[{index}]"

angr/engines/soot/values/constants.py

@@ -3,7 +3,7 @@ from .base import SimSootValue
 
 
 class SimSootValue_IntConstant(SimSootValue):
-    __slots__ = ["value", "type"]
+    __slots__ = ["type", "value"]
 
     def __init__(self, value, type_):
         super().__init__()

angr/engines/soot/values/instancefieldref.py

@@ -5,7 +5,7 @@ from angr.engines.soot.field_dispatcher import resolve_field
 
 
 class SimSootValue_InstanceFieldRef(SimSootValue):
-    __slots__ = ["id", "class_name", "field_name", "type"]
+    __slots__ = ["class_name", "field_name", "id", "type"]
 
     def __init__(self, heap_alloc_id, class_name, field_name, type_):
         self.id = f"{heap_alloc_id}.{class_name}.{field_name}"

angr/engines/soot/values/paramref.py

@@ -6,7 +6,7 @@ class SimSootValue_ParamRef(SimSootValue):
     __slots__ = ["id", "index", "type"]
 
     def __init__(self, index, type_):
-        self.id = "param_%d" % index
+        self.id = f"param_{index}"
         self.index = index
         self.type = type_
 

angr/engines/soot/values/staticfieldref.py

@@ -4,7 +4,7 @@ from angr.engines.soot.field_dispatcher import resolve_field
 
 
 class SimSootValue_StaticFieldRef(SimSootValue):
-    __slots__ = ["id", "class_name", "field_name", "type"]
+    __slots__ = ["class_name", "field_name", "id", "type"]
 
     def __init__(self, class_name, field_name, type_):
         self.id = f"{class_name}.{field_name}"

angr/engines/successors.py

@@ -268,11 +268,8 @@ class SimSuccessors:
             if o.VALIDATE_APPROXIMATIONS in state.options and state.solver.satisfiable():
                 raise Exception("WTF")
             self.unsat_successors.append(state)
-        elif (
-            not state.scratch.guard.symbolic
-            and state.solver.is_false(state.scratch.guard)
-            or o.LAZY_SOLVES not in state.options
-            and not state.satisfiable()
+        elif (not state.scratch.guard.symbolic and state.solver.is_false(state.scratch.guard)) or (
+            o.LAZY_SOLVES not in state.options and not state.satisfiable()
         ):
             self.unsat_successors.append(state)
         elif o.NO_SYMBOLIC_JUMP_RESOLUTION in state.options and state.solver.symbolic(target):

angr/engines/vex/__init__.py

@@ -8,13 +8,13 @@ from .lifter import VEXLifter
 
 __all__ = (
     "ClaripyDataMixin",
-    "VEXMixin",
-    "VEXResilienceMixin",
-    "VEXSlicingMixin",
-    "TrackActionsMixin",
+    "HeavyResilienceMixin",
     "HeavyVEXMixin",
     "SimInspectMixin",
-    "HeavyResilienceMixin",
     "SuperFastpathMixin",
+    "TrackActionsMixin",
     "VEXLifter",
+    "VEXMixin",
+    "VEXResilienceMixin",
+    "VEXSlicingMixin",
 )