angr 9.2.131__py3-none-manylinux2014_aarch64.whl → 9.2.133__py3-none-manylinux2014_aarch64.whl

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/cc.py

@@ -5,6 +5,7 @@ from archinfo import ArchPcode
 
 from angr.calling_conventions import (
     SimCC,
+    SimCCARM,
     SimRegArg,
     SimStackArg,
     DEFAULT_CC,
@@ -98,6 +99,7 @@ def register_pcode_arch_default_cc(arch: ArchPcode):
         # we have a bunch of manually specified mappings
         manual_cc_mapping = {
             "68000:BE:32:default": SimCCM68k,
+            "ARM:LE:32:Cortex": SimCCARM,
             "RISCV:LE:32:RV32G": SimCCRISCV,
             "RISCV:LE:32:RV32GC": SimCCRISCV,
             "RISCV:LE:64:RV64G": SimCCRISCV,

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

@@ -4,10 +4,12 @@ import logging
 
 import claripy
 
-from archinfo.arch_soot import ArchSoot
+from archinfo.arch_soot import ArchSoot, SootAddressDescriptor
+
 
 if TYPE_CHECKING:
     from angr import SimState
+    from angr.engines.engine import HeavyState
 
 
 l = logging.getLogger(name=__name__)
@@ -40,15 +42,15 @@ class SimSuccessors:
     https://docs.angr.io/core-concepts/simulation#simsuccessors
     """
 
-    def __init__(self, addr: int | None, initial_state):
+    def __init__(self, addr: int | SootAddressDescriptor | None, initial_state: HeavyState | None):
         self.addr = addr
-        self.initial_state: SimState = initial_state
+        self.initial_state = initial_state
 
-        self.successors: list[SimState] = []
-        self.all_successors: list[SimState] = []
-        self.flat_successors: list[SimState] = []
-        self.unsat_successors: list[SimState] = []
-        self.unconstrained_successors: list[SimState] = []
+        self.successors: list[HeavyState] = []
+        self.all_successors: list[HeavyState] = []
+        self.flat_successors: list[HeavyState] = []
+        self.unsat_successors: list[HeavyState] = []
+        self.unconstrained_successors: list[HeavyState] = []
 
         # the engine that should process or did process this request
         self.engine = None
@@ -150,6 +152,8 @@ class SimSuccessors:
         :param state: the successor state
         """
 
+        assert self.initial_state is not None
+
         # Next, simplify what needs to be simplified
         if o.SIMPLIFY_EXIT_STATE in state.options:
             state.solver.simplify()
@@ -182,7 +186,7 @@ class SimSuccessors:
         state.options.discard(o.AUTO_REFS)
 
     @staticmethod
-    def _manage_callstack(state):
+    def _manage_callstack(state: SimState[claripy.ast.BV | SootAddressDescriptor, int | SootAddressDescriptor]):
         # condition for call = Ijk_Call
         # condition for ret = stack pointer drops below call point
         if state.history.jumpkind == "Ijk_Call":
@@ -264,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",
 )

angr/engines/vex/claripy/ccall.py

@@ -1701,7 +1701,7 @@ def armg_calculate_condition(state, cond_n_op, cc_dep1, cc_dep2, cc_dep3):
         return flag
 
     l.error("Unrecognized condition %d in armg_calculate_condition", concrete_cond)
-    raise SimCCallError("Unrecognized condition %d in armg_calculate_condition" % concrete_cond)
+    raise SimCCallError(f"Unrecognized condition {concrete_cond} in armg_calculate_condition")
 
 
 ARM64G_CC_SHIFT_N = 31
@@ -1991,7 +1991,7 @@ def arm64g_calculate_condition(state, cond_n_op, cc_dep1, cc_dep2, cc_dep3):
         return flag
 
     l.error("Unrecognized condition %d in arm64g_calculate_condition", concrete_cond)
-    raise SimCCallError("Unrecognized condition %d in arm64g_calculate_condition" % concrete_cond)
+    raise SimCCallError(f"Unrecognized condition {concrete_cond} in arm64g_calculate_condition")
 
 
 #

angr/engines/vex/claripy/datalayer.py

@@ -15,7 +15,7 @@ l = logging.getLogger(__name__)
 zero = claripy.BVV(0, 32)
 
 
-def value(ty, val, size: int | None = None):
+def value(ty: str, val: int | float, size: int | None = None):
     if ty == "Ity_F32":
         return claripy.FPV(float(val), claripy.FSORT_FLOAT)
     if ty == "Ity_F64":

angr/engines/vex/claripy/irop.py

@@ -84,7 +84,7 @@ def op_attrs(p):
 
 
 all_operations = list(pyvex.irop_enums_to_ints.keys())
-operations = {}
+operations: dict[str, SimIROp] = {}
 classified = set()
 unclassified = set()
 unsupported = set()
@@ -134,7 +134,7 @@ for _vec_lanewidth in (8, 16, 32, 64):
             continue
 
         # the regex thinks the I is an integral descriptor
-        explicit_attrs["Iop_InterleaveHI%dx%d" % (_vec_lanewidth, _vec_count)] = {
+        explicit_attrs[f"Iop_InterleaveHI{_vec_lanewidth}x{_vec_count}"] = {
             "generic_name": "InterleaveHI",
             "to_size": _vec_width,
             "vector_size": _vec_lanewidth,
@@ -220,29 +220,29 @@ class SimIROp:
     """
 
     __slots__ = (
-        "name",
-        "op_attrs",
-        "_generic_name",
-        "_from_size",
+        "_calculate",
+        "_conversion",
+        "_float",
         "_from_side",
-        "_from_type",
         "_from_signed",
-        "_to_size",
-        "_to_type",
-        "_to_signed",
+        "_from_size",
+        "_from_type",
+        "_generic_name",
+        "_output_size_bits",
+        "_output_type",
+        "_rounding_mode",
         "_set_side",
         "_set_size",
-        "_conversion",
-        "_vector_size",
+        "_to_signed",
+        "_to_size",
+        "_to_type",
+        "_vector_count",
         "_vector_signed",
+        "_vector_size",
         "_vector_type",
         "_vector_zero",
-        "_vector_count",
-        "_rounding_mode",
-        "_output_type",
-        "_output_size_bits",
-        "_float",
-        "_calculate",
+        "name",
+        "op_attrs",
     )
 
     def __init__(self, name, **attrs):
@@ -567,7 +567,7 @@ class SimIROp:
         """
         arg_num = len(args)
         if arg_num != 1:
-            raise SimOperationError("expect exactly one vector to be duplicated, got %d" % arg_num)
+            raise SimOperationError(f"expect exactly one vector to be duplicated, got {arg_num}")
         # Duplicate the vector for this many times
         vector_count = self._vector_count
         # Keep a copy of the vector to be duplicated

angr/engines/vex/heavy/__init__.py

@@ -8,9 +8,9 @@ from .super_fastpath import SuperFastpathMixin
 
 
 __all__ = (
-    "TrackActionsMixin",
+    "HeavyResilienceMixin",
     "HeavyVEXMixin",
     "SimInspectMixin",
-    "HeavyResilienceMixin",
     "SuperFastpathMixin",
+    "TrackActionsMixin",
 )

angr/engines/vex/heavy/actions.py

@@ -14,8 +14,6 @@ class TrackActionsMixin(HeavyVEXMixin):
 
         self.__tmp_deps = {}
 
-    __tls = ("__tmp_deps",)
-
     def _optimize_guarded_addr(self, addr, guard):
         addr, addr_deps = addr
         guard, _ = guard
@@ -150,7 +148,7 @@ class TrackActionsMixin(HeavyVEXMixin):
 
     # statements
 
-    def _perform_vex_stmt_WrTmp(self, tmp, data_bundle, **kwargs):
+    def _perform_vex_stmt_WrTmp(self, tmp, data_bundle, **kwargs):  # pylint:disable=unused-argument
         data, data_deps = data_bundle
 
         if o.TRACK_TMP_ACTIONS not in self.state.options:

angr/engines/vex/heavy/heavy.py

@@ -285,17 +285,15 @@ class HeavyVEXMixin(SuccessorsMixin, ClaripyDataMixin, SimStateStorageMixin, VEX
         if o.COPY_STATES not in self.state.options:
             # very special logic to try to minimize copies
             # first, check if this branch is impossible
-            if (
-                guard.is_false()
-                or o.LAZY_SOLVES not in self.state.options
+            if guard.is_false() or (
+                o.LAZY_SOLVES not in self.state.options
                 and not self.state.solver.satisfiable(extra_constraints=(guard,))
             ):
                 cont_state = self.state
 
             # then, check if it's impossible to continue from this branch
-            elif (
-                guard.is_true()
-                or o.LAZY_SOLVES not in self.state.options
+            elif guard.is_true() or (
+                o.LAZY_SOLVES not in self.state.options
                 and not self.state.solver.satisfiable(extra_constraints=(claripy.Not(guard),))
             ):
                 exit_state = self.state

angr/engines/vex/lifter.py

@@ -384,10 +384,8 @@ class VEXLifter(SimEngineBase):
 
     def __is_stop_point(self, addr, extra_stop_points=None):
         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/vex/light/light.py

@@ -22,8 +22,6 @@ class VEXMixin(SimEngineBase):
         self.stmt_idx = None
         self.tmps = None
 
-    __tls = ("irsb", "stmt_idx", "tmps")
-
     def __init_handlers(self):
         self._vex_expr_handlers = [None] * pyvex.expr.tag_count
         self._vex_stmt_handlers = [None] * pyvex.stmt.tag_count

angr/engines/vex/light/slicing.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
-from .light import VEXMixin
+
 from angr.utils.constants import DEFAULT_STATEMENT
 
+from .light import VEXMixin
+
 
 class VEXSlicingMixin(VEXMixin):
     def __init__(self, *args, **kwargs):
@@ -12,13 +14,11 @@ class VEXSlicingMixin(VEXMixin):
         self._last_stmt = None
         self._whitelist = None
 
-    __tls = ("__no_exit_sliced", "_skip_stmts", "_last_stmt", "_whitelist")
-
-    def process(self, *args, skip_stmts=0, last_stmt=None, whitelist=None, **kwargs):
+    def process(self, state, block=None, skip_stmts=0, last_stmt=None, whitelist=None, **kwargs):
         self._skip_stmts = skip_stmts
         self._last_stmt = last_stmt
         self._whitelist = whitelist
-        return super().process(*args, **kwargs)
+        return super().process(state, block=block, **kwargs)
 
     def handle_vex_block(self, irsb):
         self.__no_exit_sliced = not self._check_vex_slice(DEFAULT_STATEMENT) and not any(