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

angr/knowledge_plugins/functions/function.py

@@ -39,51 +39,51 @@ class Function(Serializable):
     """
 
     __slots__ = (
-        "transition_graph",
-        "_local_transition_graph",
-        "normalized",
-        "_ret_sites",
-        "_jumpout_sites",
+        "_addr_to_block_node",
+        "_argument_registers",
+        "_argument_stack_variables",
+        "_block_cache",
+        "_block_sizes",
+        "_call_sites",
         "_callout_sites",
+        "_cyclomatic_complexity",
         "_endpoints",
-        "_call_sites",
-        "_retout_sites",
-        "addr",
         "_function_manager",
-        "is_syscall",
+        "_jumpout_sites",
+        "_local_block_addrs",
+        "_local_blocks",
+        "_local_transition_graph",
+        "_name",
         "_project",
-        "is_plt",
+        "_ret_sites",
+        "_retout_sites",
+        "_returning",
+        "addr",
         "addr",
-        "is_simprocedure",
-        "_name",
-        "previous_names",
-        "is_default_name",
-        "from_signature",
         "binary_name",
-        "_argument_registers",
-        "_argument_stack_variables",
         "bp_on_stack",
-        "retaddr_on_stack",
-        "sp_delta",
         "calling_convention",
-        "prototype",
-        "prototype_libname",
-        "_returning",
+        "from_signature",
+        "info",
+        "is_alignment",
+        "is_default_name",
+        "is_plt",
+        "is_prototype_guessed",
+        "is_simprocedure",
+        "is_syscall",
+        "normalized",
         "prepared_registers",
         "prepared_stack_variables",
+        "previous_names",
+        "prototype",
+        "prototype_libname",
+        "ran_cca",
         "registers_read_afterwards",
+        "retaddr_on_stack",
+        "sp_delta",
         "startpoint",
-        "_addr_to_block_node",
-        "_block_sizes",
-        "_block_cache",
-        "_local_blocks",
-        "_local_block_addrs",
-        "info",
         "tags",
-        "is_alignment",
-        "is_prototype_guessed",
-        "ran_cca",
-        "_cyclomatic_complexity",
+        "transition_graph",
     )
 
     def __init__(
@@ -586,17 +586,18 @@ class Function(Serializable):
         return False
 
     def __str__(self):
-        s = f"Function {self.name} [{self.addr:#x}]\n"
-        s += f"  Syscall: {self.is_syscall}\n"
-        s += "  SP difference: %d\n" % self.sp_delta
-        s += f"  Has return: {self.has_return}\n"
-        s += "  Returning: %s\n" % ("Unknown" if self.returning is None else self.returning)
-        s += f"  Alignment: {self.alignment}\n"
-        s += f"  Arguments: reg: {self._argument_registers}, stack: {self._argument_stack_variables}\n"
-        s += "  Blocks: [{}]\n".format(", ".join([f"{i:#x}" for i in self.block_addrs]))
-        s += f"  Cyclomatic Complexity: {self.cyclomatic_complexity}\n"
-        s += f"  Calling convention: {self.calling_convention}"
-        return s
+        return (
+            f"Function {self.name} [{self.addr:#x}]\n"
+            f"  Syscall: {self.is_syscall}\n"
+            f"  SP difference: {self.sp_delta}\n"
+            f"  Has return: {self.has_return}\n"
+            f"  Returning: {'Unknown' if self.returning is None else self.returning}\n"
+            f"  Alignment: {self.alignment}\n"
+            f"  Arguments: reg: {self._argument_registers}, stack: {self._argument_stack_variables}\n"
+            f"  Blocks: [{', '.join(f'{i:#x}' for i in self.block_addrs)}]\n"
+            f"  Cyclomatic Complexity: {self.cyclomatic_complexity}\n"
+            f"  Calling convention: {self.calling_convention}"
+        )
 
     def __repr__(self):
         if self.is_syscall:
@@ -1093,10 +1094,8 @@ class Function(Serializable):
             g.add_node(block)
         for src, dst, data in self.transition_graph.edges(data=True):
             if "type" in data and (
-                data["type"] in ("transition", "exception")
-                and ("outside" not in data or data["outside"] is False)
-                or data["type"] == "fake_return"
-                and ("outside" not in data or data["outside"] is False)
+                (data["type"] in ("transition", "exception") and ("outside" not in data or data["outside"] is False))
+                or (data["type"] == "fake_return" and ("outside" not in data or data["outside"] is False))
             ):
                 g.add_edge(src, dst, **data)
 
@@ -1268,11 +1267,8 @@ class Function(Serializable):
             if b.addr <= addr < b.addr + b.size:
                 # found it
                 for i, instr_addr in enumerate(b.instruction_addrs):
-                    if (
-                        i < len(b.instruction_addrs) - 1
-                        and instr_addr <= addr < b.instruction_addrs[i + 1]
-                        or i == len(b.instruction_addrs) - 1
-                        and instr_addr <= addr
+                    if (i < len(b.instruction_addrs) - 1 and instr_addr <= addr < b.instruction_addrs[i + 1]) or (
+                        i == len(b.instruction_addrs) - 1 and instr_addr <= addr
                     ):
                         return instr_addr
                 # Not covered by any instruction... why?

angr/knowledge_plugins/functions/function_parser.py

@@ -153,10 +153,10 @@ class FunctionParser:
             dst = None
             dst_addr = edge_cmsg.dst_ea
             if (
-                dst_addr not in blocks
-                and edge_type == "call"  # call has to go to either a HookNode or a function
-                or (all_func_addrs is not None and dst_addr in all_func_addrs)  # jumps to another function
-            ):
+                dst_addr not in blocks and edge_type == "call"
+            ) or (  # call has to go to either a HookNode or a function
+                all_func_addrs is not None and dst_addr in all_func_addrs
+            ):  # jumps to another function
                 if function_manager is not None:
                     # get a function
                     dst = FunctionParser._get_func(dst_addr, function_manager)

angr/knowledge_plugins/key_definitions/__init__.py

@@ -7,11 +7,11 @@ from .definition import Definition
 from . import atoms
 
 __all__ = (
-    "ReachingDefinitionsModel",
+    "Definition",
+    "DerefSize",
     "KeyDefinitionManager",
     "LiveDefinitions",
-    "DerefSize",
+    "ReachingDefinitionsModel",
     "Uses",
     "atoms",
-    "Definition",
 )

angr/knowledge_plugins/key_definitions/atoms.py

@@ -197,7 +197,7 @@ class Tmp(Atom):
         self.tmp_idx = tmp_idx
 
     def __repr__(self):
-        return "<Tmp %d>" % self.tmp_idx
+        return f"<Tmp {self.tmp_idx}>"
 
     def _identity(self):
         return hash(("tmp", self.tmp_idx))
@@ -216,8 +216,8 @@ class Register(Atom):
     """
 
     __slots__ = (
-        "reg_offset",
         "arch",
+        "reg_offset",
     )
 
     def __init__(self, reg_offset: RegisterOffset | int, size: int, arch: Arch | None = None):
@@ -227,7 +227,7 @@ class Register(Atom):
         self.arch = arch
 
     def __repr__(self):
-        return "<Reg %s<%d>>" % (self.name, self.size)
+        return f"<Reg {self.name}<{self.size}>>"
 
     def _identity(self):
         return (self.reg_offset, self.size)
@@ -245,9 +245,9 @@ class VirtualVariable(Atom):
     """
 
     __slots__ = (
-        "varid",
         "category",
         "oident",
+        "varid",
     )
 
     def __init__(
@@ -260,7 +260,7 @@ class VirtualVariable(Atom):
         self.oident = oident
 
     def __repr__(self):
-        return "<VVar %d<%d>>" % (self.varid, self.size)
+        return f"<VVar {self.varid}<{self.size}>>"
 
     def _identity(self):
         return self.varid, self.size
@@ -323,7 +323,7 @@ class MemoryLocation(Atom):
     def __repr__(self):
         address_format = hex(self.addr) if type(self.addr) is int else self.addr
         stack_format = " (stack)" if self.is_on_stack else ""
-        size = "%d" % self.size if isinstance(self.size, int) else self.size
+        size = f"{self.size}" if isinstance(self.size, int) else self.size
 
         return f"<Mem {address_format}<{size}>{stack_format}>"
 

angr/knowledge_plugins/key_definitions/definition.py

@@ -151,11 +151,11 @@ class Definition(Generic[A]):
     """
 
     __slots__ = (
+        "_hash",
         "atom",
         "codeloc",
         "dummy",
         "tags",
-        "_hash",
     )
 
     def __init__(self, atom: A, codeloc: CodeLocation, dummy: bool = False, tags: set[Tag] | None = None):

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -52,7 +52,7 @@ class DefinitionAnnotation(Annotation):
     An annotation that attaches a `Definition` to an AST.
     """
 
-    __slots__ = ("definition", "_hash")
+    __slots__ = ("_hash", "definition")
 
     def __init__(self, definition):
         super().__init__()
@@ -91,24 +91,24 @@ class LiveDefinitions:
     _tops = {}
 
     __slots__ = (
-        "project",
+        "__weakref__",
+        "_canonical_size",
         "arch",
-        "track_tmps",
-        "registers",
-        "stack",
         "heap",
+        "heap_uses",
         "memory",
-        "tmps",
-        "others",
+        "memory_uses",
         "other_uses",
+        "others",
+        "project",
         "register_uses",
+        "registers",
+        "stack",
         "stack_uses",
-        "heap_uses",
-        "memory_uses",
-        "uses_by_codeloc",
         "tmp_uses",
-        "_canonical_size",
-        "__weakref__",
+        "tmps",
+        "track_tmps",
+        "uses_by_codeloc",
     )
 
     def __init__(
@@ -230,7 +230,7 @@ class LiveDefinitions:
     def __repr__(self):
         ctnt = "LiveDefs"
         if self.tmps:
-            ctnt += ", %d tmpdefs" % len(self.tmps)
+            ctnt += f", {len(self.tmps)} tmpdefs"
         return f"<{ctnt}>"
 
     def copy(self, discard_tmpdefs=False) -> LiveDefinitions:
@@ -445,7 +445,7 @@ class LiveDefinitions:
             base_v = self.INITIAL_SP_64BIT
             mask = 0xFFFF_FFFF_FFFF_FFFF
         else:
-            raise ValueError("Unsupported architecture word size %d" % self.arch.bits)
+            raise ValueError(f"Unsupported architecture word size {self.arch.bits}")
         return (base_v + offset) & mask
 
     def merge(self, *others: LiveDefinitions) -> tuple[LiveDefinitions, bool]:

angr/knowledge_plugins/labels.py

@@ -101,7 +101,7 @@ class Labels(KnowledgeBasePlugin):
         # use it as the prefix
         i = 1
         while True:
-            new_label = "%s_%d" % (label, i)
+            new_label = f"{label}_{i}"
             if new_label not in self._labels:
                 return new_label
             i += 1

angr/knowledge_plugins/propagations/__init__.py

@@ -5,6 +5,6 @@ from .propagation_manager import PropagationManager
 
 
 __all__ = (
-    "PropagationModel",
     "PropagationManager",
+    "PropagationModel",
 )

angr/knowledge_plugins/propagations/prop_value.py

@@ -17,7 +17,7 @@ class Detail:
                     or the current function.
     """
 
-    __slots__ = ("size", "expr", "def_at")
+    __slots__ = ("def_at", "expr", "size")
 
     def __init__(self, size: int, expr: ailment.Expression | None, def_at: CodeLocation | None):
         self.size = size
@@ -37,8 +37,8 @@ class PropValue:
     """
 
     __slots__ = (
-        "value",
         "offset_and_details",
+        "value",
     )
 
     def __init__(self, value: claripy.ast.Bits, offset_and_details: dict[int, Detail] | None = None):

angr/knowledge_plugins/propagations/propagation_model.py

@@ -15,17 +15,16 @@ class PropagationModel(Serializable):
     """
 
     __slots__ = (
-        "key",
-        "node_iterations",
-        "states",
-        "input_states",
+        "_function",
+        "_initial_state",
         "block_initial_reg_values",
-        "replacements",
         "equivalence",
-        # internals of the function graph visitor
         "graph_visitor",
-        "_initial_state",
-        "_function",
+        "input_states",
+        "key",
+        "node_iterations",
+        "replacements",
+        "states",
     )
 
     def __init__(

angr/knowledge_plugins/propagations/states.py

@@ -65,20 +65,20 @@ class PropagatorState:
     """
 
     __slots__ = (
-        "arch",
-        "gpr_size",
+        "__weakref__",
+        "_artificial_reg_offsets",
+        "_equivalence",
         "_expr_used_locs",
+        "_gp",
+        "_max_prop_expr_occurrence",
         "_only_consts",
         "_replacements",
-        "_equivalence",
-        "project",
-        "rda",
         "_store_tops",
-        "_gp",
-        "_max_prop_expr_occurrence",
+        "arch",
+        "gpr_size",
         "model",
-        "_artificial_reg_offsets",
-        "__weakref__",
+        "project",
+        "rda",
     )
 
     _tops = {}
@@ -237,11 +237,10 @@ class PropagatorState:
                                 or isinstance(repl, claripy.ast.Base)
                             )
                             and replacements_0[loc][var] is not repl
-                            or (
-                                not isinstance(replacements_0[loc][var], claripy.ast.Base)
-                                and not isinstance(repl, claripy.ast.Base)
-                                and replacements_0[loc][var] != repl
-                            )
+                        ) or (
+                            not isinstance(replacements_0[loc][var], claripy.ast.Base)
+                            and not isinstance(repl, claripy.ast.Base)
+                            and replacements_0[loc][var] != repl
                         ):
                             replacements_0[loc][var] = repl
                             merge_occurred = True
@@ -371,8 +370,8 @@ class PropagatorVEXState(PropagatorState):
     __slots__ = (
         "_registers",
         "_stack_variables",
-        "do_binops",
         "block_initial_reg_values",
+        "do_binops",
     )
 
     def __init__(
@@ -551,9 +550,9 @@ class Equivalence:
     """
 
     __slots__ = (
-        "codeloc",
         "atom0",
         "atom1",
+        "codeloc",
     )
 
     def __init__(self, codeloc, atom0, atom1):
@@ -583,14 +582,14 @@ class PropagatorAILState(PropagatorState):
 
     __slots__ = (
         "_registers",
+        "_sp_adjusted",
         "_stack_variables",
         "_tmps",
-        "temp_expressions",
-        "register_expressions",
-        "last_stack_store",
-        "global_stores",
         "block_initial_reg_values",
-        "_sp_adjusted",
+        "global_stores",
+        "last_stack_store",
+        "register_expressions",
+        "temp_expressions",
     )
 
     def __init__(
@@ -917,10 +916,8 @@ class PropagatorAILState(PropagatorState):
         replaced = False
         # count-based propagation rule only matters when we are performing a full-function copy propagation
         if self._max_prop_expr_occurrence == 0:
-            if (
-                isinstance(old, ailment.Expr.Tmp)
-                or isinstance(old, ailment.Expr.Register)
-                and self.should_replace_reg(old.reg_offset, bp_as_gpr, new)
+            if isinstance(old, ailment.Expr.Tmp) or (
+                isinstance(old, ailment.Expr.Register) and self.should_replace_reg(old.reg_offset, bp_as_gpr, new)
             ):
                 self._replacements[codeloc][old] = (
                     new if stmt_to_remove is None else {"expr": new, "stmt_to_remove": stmt_to_remove}
@@ -963,8 +960,7 @@ class PropagatorAILState(PropagatorState):
                 force_replace
                 or prop_count <= self._max_prop_expr_occurrence
                 or isinstance(new, ailment.Expr.StackBaseOffset)
-                or isinstance(new, ailment.Expr.Convert)
-                and isinstance(new.operand, ailment.Expr.StackBaseOffset)
+                or (isinstance(new, ailment.Expr.Convert) and isinstance(new.operand, ailment.Expr.StackBaseOffset))
                 or (
                     isinstance(old, ailment.Expr.Register)
                     and self.arch.is_artificial_register(old.reg_offset, old.size)
@@ -1020,10 +1016,14 @@ class PropagatorAILState(PropagatorState):
             isinstance(expr, ailment.Expr.BinaryOp)
             and expr.op in {"Add", "Sub"}
             and (
-                isinstance(expr.operands[0], ailment.Expr.Register)
-                and PropagatorAILState.is_global_variable_load(expr.operands[1])
-                or isinstance(expr.operands[1], ailment.Expr.Register)
-                and PropagatorAILState.is_global_variable_load(expr.operands[0])
+                (
+                    isinstance(expr.operands[0], ailment.Expr.Register)
+                    and PropagatorAILState.is_global_variable_load(expr.operands[1])
+                )
+                or (
+                    isinstance(expr.operands[1], ailment.Expr.Register)
+                    and PropagatorAILState.is_global_variable_load(expr.operands[0])
+                )
             )
         )
 

angr/knowledge_plugins/variables/variable_access.py

@@ -26,11 +26,11 @@ class VariableAccess(Serializable):
     """
 
     __slots__ = (
-        "variable",
         "access_type",
+        "atom_hash",
         "location",
         "offset",
-        "atom_hash",
+        "variable",
     )
 
     def __init__(self, variable, access_type, location, offset, atom_hash=None):

angr/knowledge_plugins/variables/variable_manager.py

@@ -390,7 +390,7 @@ class VariableManagerInternal(Serializable):
         else:
             prefix = "m"
 
-        return "i%s_%d" % (prefix, next(self._variable_counters[sort]))
+        return f"i{prefix}_{next(self._variable_counters[sort])}"
 
     def add_variable(self, sort, start, variable: SimVariable):
         if sort == "stack":

angr/knowledge_plugins/xrefs/xref.py

@@ -10,13 +10,13 @@ class XRef(Serializable):
     """
 
     __slots__ = (
-        "ins_addr",
         "block_addr",
-        "stmt_idx",
+        "dst",
+        "ins_addr",
         "insn_op_idx",
         "insn_op_type",
         "memory_data",
-        "dst",
+        "stmt_idx",
         "type",
     )
 
@@ -58,11 +58,8 @@ class XRef(Serializable):
             dst_str = hex(self.memory_data.addr)
         else:
             dst_str = "unknown"
-        return "<XRef {}: {}->{}>".format(
-            self.type_string,
-            f"{self.ins_addr:#x}" if self.ins_addr is not None else "%#x[%d]" % (self.block_addr, self.stmt_idx),
-            dst_str,
-        )
+        ins_addr_str = f"{self.ins_addr:#x}" if self.ins_addr is not None else f"{self.block_addr:#x}[{self.stmt_idx}]"
+        return f"<XRef {self.type_string}: {ins_addr_str}->{dst_str}>"
 
     def __eq__(self, other):
         return (

angr/misc/__init__.py

@@ -9,11 +9,11 @@ from .picklable_lock import PicklableLock
 
 
 __all__ = (
-    "ux",
-    "autoimport",
+    "HookSet",
     "Loggers",
+    "PicklableLock",
     "PluginHub",
     "PluginPreset",
-    "HookSet",
-    "PicklableLock",
+    "autoimport",
+    "ux",
 )

angr/misc/hookset.py

@@ -85,11 +85,10 @@ class HookedMethod:
         self.pending = []
 
     def __repr__(self):
-        return "<HookedMethod(%s.%s, %d pending)>" % (
-            self.func.__self__.__class__.__name__,
-            self.func.__name__,
-            len(self.pending),
-        )
+        class_name = self.func.__self__.__class__.__name__
+        func_name = self.func.__name__
+        pending_count = len(self.pending)
+        return f"<HookedMethod({class_name}.{func_name}, {pending_count} pending)>"
 
     def __call__(self, *args, **kwargs):
         if self.pending:

angr/misc/loggers.py

@@ -15,10 +15,10 @@ class Loggers:
     """
 
     __slots__ = (
-        "default_level",
         "_loggers",
-        "profiling_enabled",
+        "default_level",
         "handler",
+        "profiling_enabled",
     )
 
     def __init__(self, default_level=logging.WARNING):

angr/misc/telemetry.py

@@ -47,7 +47,7 @@ except ImportError:
 
 from angr import __version__
 
-__all__ = ["get_tracer", "get_current_span", "Status", "StatusCode"]
+__all__ = ["Status", "StatusCode", "get_current_span", "get_tracer"]
 
 
 def get_tracer(name: str) -> Tracer:

angr/procedures/__init__.py

@@ -5,8 +5,8 @@ from .definitions import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
 
 
 __all__ = (
-    "SIM_PROCEDURES",
     "SIM_LIBRARIES",
+    "SIM_PROCEDURES",
     "SIM_TYPE_COLLECTIONS",
     "SimProcedures",
 )

angr/procedures/cgc/fdwait.py

@@ -23,7 +23,7 @@ class fdwait(angr.SimProcedure):
                     sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
-                        "fdwait_read_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "read_ready")
+                        f"fdwait_read_{run_count}_{fd}", 1, key=("syscall", "fdwait", fd, "read_ready")
                     )
                 fd = claripy.BVV(fd, self.state.arch.bits)
                 sym_newbit = claripy.If(claripy.ULT(fd, nfds), sym_bit, 0)
@@ -40,7 +40,7 @@ class fdwait(angr.SimProcedure):
                     sym_bit = claripy.BVV(1, 1)
                 else:
                     sym_bit = self.state.solver.Unconstrained(
-                        "fdwait_write_%d_%d" % (run_count, fd), 1, key=("syscall", "fdwait", fd, "write_ready")
+                        f"fdwait_write_{run_count}_{fd}", 1, key=("syscall", "fdwait", fd, "write_ready")
                     )
 
                 fd = claripy.BVV(fd, self.state.arch.bits)

angr/procedures/definitions/__init__.py

@@ -5,7 +5,7 @@ import os
 import logging
 import inspect
 from collections import defaultdict
-from typing import Optional, Dict, Type, List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import itanium_demangler
 
@@ -569,7 +569,7 @@ class SimSyscallLibrary(SimLibrary):
             mapping = self.syscall_number_mapping[abi]
             if number in mapping:
                 return mapping[number], arch, abi
-        return "sys_%d" % number, arch, None
+        return f"sys_{number}", arch, None
 
     def _apply_numerical_metadata(self, proc, number, arch, abi):
         proc.syscall_number = number