angr 9.2.116__py3-none-manylinux2014_aarch64.whl → 9.2.118__py3-none-manylinux2014_aarch64.whl

angr/knowledge_plugins/structured_code/manager.py

@@ -1,5 +1,6 @@
 # pylint:disable=import-outside-toplevel
-from typing import Any, Union, TYPE_CHECKING
+from __future__ import annotations
+from typing import Any, TYPE_CHECKING
 
 from .. import KnowledgeBasePlugin
 
@@ -11,7 +12,7 @@ if TYPE_CHECKING:
 class StructuredCodeManager(KnowledgeBasePlugin):
     def __init__(self, kb):
         super().__init__(kb=kb)
-        self.cached: dict[Any, "DecompilationCache"] = {}
+        self.cached: dict[Any, DecompilationCache] = {}
 
     def _normalize_key(self, item):
         if type(item) is not tuple:
@@ -20,10 +21,10 @@ class StructuredCodeManager(KnowledgeBasePlugin):
             item = (self._kb.labels.lookup(item[0]), *item[1:])
         return item
 
-    def __getitem__(self, item) -> "DecompilationCache":
+    def __getitem__(self, item) -> DecompilationCache:
         return self.cached[self._normalize_key(item)]
 
-    def __setitem__(self, key, value: Union["DecompilationCache", "BaseStructuredCodeGenerator"]):
+    def __setitem__(self, key, value: DecompilationCache | BaseStructuredCodeGenerator):
         from ...analyses.decompiler.structured_codegen import BaseStructuredCodeGenerator
         from ...analyses.decompiler.decompilation_cache import DecompilationCache
 

angr/knowledge_plugins/sync/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .sync_controller import SyncController

angr/knowledge_plugins/sync/sync_controller.py

@@ -1,6 +1,6 @@
 # pylint:disable=import-outside-toplevel
+from __future__ import annotations
 from functools import wraps
-from typing import Optional
 
 from ... import knowledge_plugins
 from ...knowledge_plugins.plugin import KnowledgeBasePlugin
@@ -41,10 +41,8 @@ def make_state(f):
             r = f(self, *args, **kwargs)
             state.save()
             return r
-        else:
-            kwargs["state"] = state
-            r = f(self, *args, **kwargs)
-            return r
+        kwargs["state"] = state
+        return f(self, *args, **kwargs)
 
     return state_check
 
@@ -91,7 +89,7 @@ class SyncController(KnowledgeBasePlugin):
 
         super().__init__(kb=kb)
 
-        self.client: Optional["binsync.client.Client"] = None
+        self.client: binsync.client.Client | None = None
 
     #
     # Public methods
@@ -172,7 +170,7 @@ class SyncController(KnowledgeBasePlugin):
     @init_checker
     @make_state
     # pylint:disable=unused-argument,no-self-use
-    def push_comments(self, comments: list["binsync.data.Comment"], user=None, state=None):
+    def push_comments(self, comments: list[binsync.data.Comment], user=None, state=None):
         """
         Push a bunch of comments upwards.
 
@@ -226,7 +224,7 @@ class SyncController(KnowledgeBasePlugin):
     @init_checker
     @make_ro_state
     # pylint:disable=unused-argument
-    def pull_function(self, addr, user=None, state=None) -> Optional["binsync.data.Function"]:
+    def pull_function(self, addr, user=None, state=None) -> binsync.data.Function | None:
         """
         Pull a function downwards.
 
@@ -237,15 +235,14 @@ class SyncController(KnowledgeBasePlugin):
 
         func_addr = self.get_func_addr_from_addr(addr)
         try:
-            func = state.get_function(func_addr)
-            return func
+            return state.get_function(func_addr)
         except KeyError:
             return None
 
     @init_checker
     @make_ro_state
     # pylint:disable=unused-argument
-    def pull_comment(self, addr, user=None, state=None) -> Optional["binsync.data.Comment"]:
+    def pull_comment(self, addr, user=None, state=None) -> binsync.data.Comment | None:
         """
         Pull a comment downwards.
 
@@ -256,8 +253,7 @@ class SyncController(KnowledgeBasePlugin):
 
         func_addr = self.get_func_addr_from_addr(addr)
         try:
-            comment = state.get_comment(func_addr, addr)
-            return comment
+            return state.get_comment(func_addr, addr)
         except KeyError:
             return None
 
@@ -274,8 +270,7 @@ class SyncController(KnowledgeBasePlugin):
         :rtype:                 Iterable
         """
         try:
-            comments = state.get_comments(func_addr)
-            return comments
+            return state.get_comments(func_addr)
         except KeyError:
             return {}
 

angr/knowledge_plugins/types.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import random
 from collections import UserDict
 

angr/knowledge_plugins/variables/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .variable_manager import VariableManager, VariableType

angr/knowledge_plugins/variables/variable_access.py

@@ -1,4 +1,5 @@
 # pylint:disable=arguments-differ,no-member
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ...code_location import CodeLocation
@@ -33,7 +34,7 @@ class VariableAccess(Serializable):
     )
 
     def __init__(self, variable, access_type, location, offset, atom_hash=None):
-        self.variable: "SimVariable" = variable
+        self.variable: SimVariable = variable
         self.access_type: int = access_type
         self.location: CodeLocation = location
         self.offset: int | None = offset
@@ -71,9 +72,8 @@ class VariableAccess(Serializable):
         cmsg.block_addr = self.location.block_addr
         cmsg.stmt_idx = self.location.stmt_idx
         cmsg.ins_addr = self.location.ins_addr
-        if self.offset is not None:
-            if isinstance(self.offset, int):
-                cmsg.offset = self.offset
+        if self.offset is not None and isinstance(self.offset, int):
+            cmsg.offset = self.offset
         if self.atom_hash is not None:
             cmsg.atom_hash = self.atom_hash
 
@@ -84,14 +84,14 @@ class VariableAccess(Serializable):
         elif self.access_type == VariableAccessSort.REFERENCE:
             cmsg.access_type = variables_pb2.VariableAccess.REFERENCE
         else:
-            raise NotImplementedError()
+            raise NotImplementedError
 
         return cmsg
 
     @classmethod
     def parse_from_cmessage(
-        cls, cmsg, variable_by_ident: dict[str, "SimVariable"] | None = None, **kwargs
-    ) -> "VariableAccess":
+        cls, cmsg, variable_by_ident: dict[str, SimVariable] | None = None, **kwargs
+    ) -> VariableAccess:
         assert variable_by_ident is not None
 
         variable = variable_by_ident[cmsg.ident]
@@ -103,12 +103,11 @@ class VariableAccess(Serializable):
         elif cmsg.access_type == variables_pb2.VariableAccess.REFERENCE:
             access_type = VariableAccessSort.REFERENCE
         else:
-            raise NotImplementedError()
-        model = VariableAccess(
+            raise NotImplementedError
+        return VariableAccess(
             variable,
             access_type,
             location,
             cmsg.offset if cmsg.HasField("offset") else None,
             atom_hash=cmsg.atom_hash if cmsg.HasField("atom_hash") else None,
         )
-        return model

angr/knowledge_plugins/variables/variable_manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Literal, TYPE_CHECKING
 import logging
 from collections import defaultdict
@@ -5,10 +6,12 @@ from itertools import count, chain
 
 import networkx
 
+import ailment
 from cle.backends.elf.compilation_unit import CompilationUnit
 from cle.backends.elf.variable import Variable
 
 from angr.utils.orderedset import OrderedSet
+from angr.utils.ail import is_phi_assignment
 from ...protos import variables_pb2
 from ...serializable import Serializable
 from ...sim_variable import SimVariable, SimStackVariable, SimMemoryVariable, SimRegisterVariable
@@ -70,7 +73,7 @@ class VariableManagerInternal(Serializable):
     """
 
     def __init__(self, manager, func_addr=None):
-        self.manager: "VariableManager" = manager
+        self.manager: VariableManager = manager
 
         self.func_addr = func_addr
 
@@ -154,7 +157,7 @@ class VariableManagerInternal(Serializable):
         d["types"].kb = None
         return d
 
-    def set_manager(self, manager: "VariableManager"):
+    def set_manager(self, manager: VariableManager):
         self.manager = manager
         self.types.kb = manager._kb
 
@@ -180,7 +183,7 @@ class VariableManagerInternal(Serializable):
             elif isinstance(variable, SimMemoryVariable):
                 memory_variables.append(vc)
             else:
-                raise NotImplementedError()
+                raise NotImplementedError
         for variable in self._phi_variables:
             vc = variable.serialize_to_cmessage()
             vc.base.is_phi = True
@@ -191,7 +194,7 @@ class VariableManagerInternal(Serializable):
             elif isinstance(variable, SimMemoryVariable):
                 memory_variables.append(vc)
             else:
-                raise NotImplementedError()
+                raise NotImplementedError
 
         cmsg.regvars.extend(register_variables)
         cmsg.stackvars.extend(stack_variables)
@@ -219,7 +222,7 @@ class VariableManagerInternal(Serializable):
             elif isinstance(variable, SimMemoryVariable):
                 unified_memory_variables.append(variable.serialize_to_cmessage())
             else:
-                raise NotImplementedError()
+                raise NotImplementedError
 
         cmsg.unified_regvars.extend(unified_register_variables)
         cmsg.unified_stackvars.extend(unified_stack_variables)
@@ -261,7 +264,7 @@ class VariableManagerInternal(Serializable):
     @classmethod
     def parse_from_cmessage(
         cls, cmsg, variable_manager=None, func_addr=None, **kwargs
-    ) -> "VariableManagerInternal":  # pylint:disable=arguments-differ
+    ) -> VariableManagerInternal:  # pylint:disable=arguments-differ
         model = VariableManagerInternal(variable_manager, func_addr=func_addr)
 
         variable_by_ident = {}
@@ -358,7 +361,7 @@ class VariableManagerInternal(Serializable):
                 region = model._global_region
                 offset = var.addr
             else:
-                raise ValueError("Unsupported sort %s in parse_from_cmessage()." % type(var))
+                raise ValueError(f"Unsupported sort {type(var)} in parse_from_cmessage().")
 
             region.add_variable(offset, var)
 
@@ -372,7 +375,7 @@ class VariableManagerInternal(Serializable):
 
     def next_variable_ident(self, sort):
         if sort not in self._variable_counters:
-            raise ValueError("Unsupported variable sort %s" % sort)
+            raise ValueError(f"Unsupported variable sort {sort}")
 
         if sort == "register":
             prefix = "r"
@@ -385,8 +388,7 @@ class VariableManagerInternal(Serializable):
         else:
             prefix = "m"
 
-        ident = "i%s_%d" % (prefix, next(self._variable_counters[sort]))
-        return ident
+        return "i%s_%d" % (prefix, next(self._variable_counters[sort]))
 
     def add_variable(self, sort, start, variable: SimVariable):
         if sort == "stack":
@@ -396,7 +398,7 @@ class VariableManagerInternal(Serializable):
         elif sort == "global":
             region = self._global_region
         else:
-            raise ValueError("Unsupported sort %s in add_variable()." % sort)
+            raise ValueError(f"Unsupported sort {sort} in add_variable().")
 
         # find if there is already an existing variable with the same identifier
         if variable.ident in self._ident_to_variable:
@@ -417,7 +419,7 @@ class VariableManagerInternal(Serializable):
         elif sort == "global":
             region = self._global_region
         else:
-            raise ValueError("Unsupported sort %s in set_variable()." % sort)
+            raise ValueError(f"Unsupported sort {sort} in set_variable().")
         # find if there is already an existing variable with the same identifier
         if variable.ident in self._ident_to_variable:
             existing_var = self._ident_to_variable[variable.ident]
@@ -448,7 +450,7 @@ class VariableManagerInternal(Serializable):
         sort: int,
         variable,
         offset,
-        location: "CodeLocation",
+        location: CodeLocation,
         overwrite=False,
         atom=None,
     ):
@@ -461,7 +463,7 @@ class VariableManagerInternal(Serializable):
         if sort == VariableAccessSort.WRITE and variable in self._variables_without_writes:
             self._variables_without_writes.discard(variable)
 
-    def record_variable(self, location: "CodeLocation", variable, offset, overwrite=False, atom=None):
+    def record_variable(self, location: CodeLocation, variable, offset, overwrite=False, atom=None):
         if variable.ident not in self._ident_to_variable:
             self._ident_to_variable[variable.ident] = variable
             self._variables.add(variable)
@@ -485,7 +487,7 @@ class VariableManagerInternal(Serializable):
             if atom_hash is not None:
                 self._atom_to_variable[key][atom_hash].add(var_and_offset)
 
-    def remove_variable_by_atom(self, location: "CodeLocation", variable: SimVariable, atom):
+    def remove_variable_by_atom(self, location: CodeLocation, variable: SimVariable, atom):
         key = (
             (location.block_addr, location.stmt_idx)
             if location.block_idx is None
@@ -552,7 +554,7 @@ class VariableManagerInternal(Serializable):
             ident_sort = "stack"
             a = SimStackVariable(repre.offset, repre_size, ident=self.next_variable_ident(ident_sort))
         else:
-            raise TypeError('make_phi_node(): Unsupported variable type "%s".' % type(repre))
+            raise TypeError(f'make_phi_node(): Unsupported variable type "{type(repre)}".')
 
         # Keep a record of all phi variables
         self._phi_variables[a] = set(variables)
@@ -607,15 +609,15 @@ class VariableManagerInternal(Serializable):
             return []
 
         if sort == "memory":
-            var_and_offsets = list(
+            var_and_offsets = [
                 (var, offset)
                 for var, offset in self._stmt_to_variable[key]
                 if isinstance(var, (SimStackVariable, SimMemoryVariable))
-            )
+            ]
         elif sort == "register":
-            var_and_offsets = list(
+            var_and_offsets = [
                 (var, offset) for var, offset in self._stmt_to_variable[key] if isinstance(var, SimRegisterVariable)
-            )
+            ]
         else:
             l.error('find_variables_by_stmt(): Unsupported variable sort "%s".', sort)
             return []
@@ -628,10 +630,7 @@ class VariableManagerInternal(Serializable):
     def find_variables_by_atom(
         self, block_addr, stmt_idx, atom, block_idx: int | None = None
     ) -> set[tuple[SimVariable, int]]:
-        if block_idx is None:
-            key = block_addr, stmt_idx
-        else:
-            key = block_addr, block_idx, stmt_idx
+        key = (block_addr, stmt_idx) if block_idx is None else (block_addr, block_idx, stmt_idx)
 
         if key not in self._atom_to_variable:
             return set()
@@ -661,7 +660,7 @@ class VariableManagerInternal(Serializable):
 
         vars_list = []
 
-        for var in self._variable_accesses.keys():
+        for var in self._variable_accesses:
             if variable.name == var.name:
                 vars_list.append(var)
 
@@ -685,7 +684,7 @@ class VariableManagerInternal(Serializable):
         variables = []
 
         if collapse_same_ident:
-            raise NotImplementedError()
+            raise NotImplementedError
 
         for var in self._variables:
             if sort == "stack" and not isinstance(var, SimStackVariable):
@@ -805,9 +804,8 @@ class VariableManagerInternal(Serializable):
                 continue
             if variable in self._variable_accesses:
                 accesses = self._variable_accesses[variable]
-                if has_read_access(accesses):
-                    if not exclude_specials or not variable.category:
-                        input_variables.append(variable)
+                if has_read_access(accesses) and (not exclude_specials or not variable.category):
+                    input_variables.append(variable)
 
         return input_variables
 
@@ -824,7 +822,7 @@ class VariableManagerInternal(Serializable):
                 if var.name is not None:
                     continue
                 if var.ident.startswith("iarg"):
-                    var.name = "arg_%x" % var.offset
+                    var.name = f"arg_{var.offset:x}"
                 else:
                     var.name = "s_%x" % (-var.offset)
                     # var.name = var.ident
@@ -840,21 +838,28 @@ class VariableManagerInternal(Serializable):
                     if "@@" in var.name:
                         var.name = var.name[: var.name.index("@@")]
                 elif isinstance(var.addr, int):
-                    var.name = "g_%x" % var.addr
+                    var.name = f"g_{var.addr:x}"
                 elif var.ident is not None:
                     var.name = var.ident
                 else:
-                    var.name = "g_%s" % var.addr
+                    var.name = f"g_{var.addr}"
 
     def assign_unified_variable_names(
-        self, labels=None, arg_names: list[str] | None = None, reset: bool = False
+        self,
+        labels=None,
+        arg_names: list[str] | None = None,
+        reset: bool = False,
+        func_blocks: list[ailment.Block] | None = None,
     ) -> None:
         """
-        Assign default names to all unified variables.
+        Assign default names to all unified variables. If `func_blocks` is provided, we will find out variables that
+        are only ever written to in Phi assignments and never used elsewhere, and put these variables at the end of
+        the sorted list. These variables are likely completely removed during the dephication process.
 
         :param labels:    Known labels in the binary.
         :param arg_names: Known argument names.
         :param reset:     Reset all variable names or not.
+        :param func_blocks: A list of function blocks of the function where these variables are accessed.
         """
 
         def _id_from_varident(ident: str) -> int:
@@ -899,13 +904,24 @@ class VariableManagerInternal(Serializable):
         sorted_stack_variables = sorted(sorted_stack_variables, key=lambda v: v.offset)
         sorted_reg_variables = sorted(sorted_reg_variables, key=lambda v: _id_from_varident(v.ident))
 
-        for var in chain(sorted_stack_variables, sorted_reg_variables):
+        # find variables that are likely only used by phi assignments
+        phi_only_vars = []
+        if func_blocks:
+            func_block_by_addr = {(block.addr, block.idx): block for block in func_blocks}
+            for var in list(sorted_stack_variables):
+                if self._is_variable_only_used_by_phi_stmt(var, func_block_by_addr):
+                    sorted_stack_variables.remove(var)
+                    phi_only_vars.append(var)
+            for var in list(sorted_reg_variables):
+                if self._is_variable_only_used_by_phi_stmt(var, func_block_by_addr):
+                    sorted_reg_variables.remove(var)
+                    phi_only_vars.append(var)
+
+        for var in chain(sorted_stack_variables, sorted_reg_variables, phi_only_vars):
             idx = next(var_ctr)
             if var.name is not None and not reset:
                 continue
-            if isinstance(var, SimStackVariable):
-                var.name = f"v{idx}"
-            elif isinstance(var, SimRegisterVariable):
+            if isinstance(var, (SimStackVariable, SimRegisterVariable)):
                 var.name = f"v{idx}"
             # clear the hash cache
             var._hash = None
@@ -940,17 +956,16 @@ class VariableManagerInternal(Serializable):
         all_unified: bool = False,
         mark_manual: bool = False,
     ) -> None:
-        if isinstance(ty, SimTypeBottom) and override_bot:
-            # we fall back to assigning a default unsigned integer type for the variable
-            if var.size is not None:
-                size_to_type = {
-                    1: SimTypeChar,
-                    2: SimTypeShort,
-                    4: SimTypeInt,
-                    8: SimTypeLong,
-                }
-                if var.size in size_to_type:
-                    ty = size_to_type[var.size](signed=False, label=ty.label).with_arch(self.manager._kb._project.arch)
+        # we fall back to assigning a default unsigned integer type for the variable
+        if isinstance(ty, SimTypeBottom) and override_bot and var.size is not None:
+            size_to_type = {
+                1: SimTypeChar,
+                2: SimTypeShort,
+                4: SimTypeInt,
+                8: SimTypeLong,
+            }
+            if var.size in size_to_type:
+                ty = size_to_type[var.size](signed=False, label=ty.label).with_arch(self.manager._kb._project.arch)
 
         if name:
             if name not in self.types:
@@ -1051,7 +1066,7 @@ class VariableManagerInternal(Serializable):
             if len(nodes) <= 1:
                 continue
             # side effect of sorting: arg_x variables are always in the front of the list
-            nodes = list(sorted(nodes, key=lambda x: x.ident))
+            nodes = sorted(nodes, key=lambda x: x.ident)
             unified = nodes[0].copy()
             for v in nodes:
                 self.set_unified_variable(v, unified)
@@ -1089,6 +1104,21 @@ class VariableManagerInternal(Serializable):
 
         return self._variables_to_unified_variables.get(variable, None)
 
+    def _is_variable_only_used_by_phi_stmt(
+        self, var: SimVariable, func_block_by_addr: dict[tuple[int, int | None], ailment.Block]
+    ) -> bool:
+        accesses = self.get_variable_accesses(var)
+        if not accesses:
+            # not used at all?
+            return False
+        for acc in accesses:
+            block = func_block_by_addr.get((acc.location.block_addr, acc.location.block_idx), None)
+            if block is not None:
+                stmt = block.statements[acc.location.stmt_idx]
+                if not is_phi_assignment(stmt):
+                    return False
+        return True
+
 
 class VariableManager(KnowledgeBasePlugin):
     """
@@ -1117,9 +1147,8 @@ class VariableManager(KnowledgeBasePlugin):
         if key == "global":  # pylint:disable=no-else-return
             return self.global_manager
 
-        else:
-            # key refers to a function address
-            return self.get_function_manager(key)
+        # key refers to a function address
+        return self.get_function_manager(key)
 
     def __delitem__(self, key) -> None:
         """
@@ -1167,7 +1196,7 @@ class VariableManager(KnowledgeBasePlugin):
         if variable.region == "global":
             return self.global_manager.get_variable_accesses(variable, same_name=same_name)
 
-        elif variable.region in self.function_managers:
+        if variable.region in self.function_managers:
             return self.function_managers[variable.region].get_variable_accesses(variable, same_name=same_name)
 
         l.warning("get_variable_accesses(): Region %s is not found.", variable.region)
@@ -1195,7 +1224,7 @@ class VariableManager(KnowledgeBasePlugin):
             simv.name = v.name
             manager.add_variable(v.sort, v.addr, simv)
 
-    def load_from_dwarf(self, cu_list: list[CompilationUnit] = None):
+    def load_from_dwarf(self, cu_list: list[CompilationUnit] | None = None):
         cu_list = cu_list or self._kb._project.loader.main_object.compilation_units
         if cu_list is None:
             l.warning("no CompilationUnit found")

angr/knowledge_plugins/xrefs/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .xref_types import XRefType
 from .xref import XRef
 from .xref_manager import XRefManager

angr/knowledge_plugins/xrefs/xref.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ...serializable import Serializable
 from ...protos import primitives_pb2
 from .xref_types import XRefType
@@ -30,7 +31,7 @@ class XRef(Serializable):
         xref_type=None,
     ):
         if dst is not None and not isinstance(dst, int):
-            raise TypeError("XRefs must be pointing to a constant target. Target %r is not supported." % dst)
+            raise TypeError(f"XRefs must be pointing to a constant target. Target {dst!r} is not supported.")
 
         # src
         self.ins_addr: int | None = ins_addr
@@ -52,17 +53,14 @@ class XRef(Serializable):
 
     def __repr__(self):
         if self.dst is not None:
-            if isinstance(self.dst, int):
-                dst_str = hex(self.dst)
-            else:
-                dst_str = str(self.dst)
+            dst_str = hex(self.dst) if isinstance(self.dst, int) else str(self.dst)
         elif self.memory_data is not None:
             dst_str = hex(self.memory_data.addr)
         else:
             dst_str = "unknown"
         return "<XRef {}: {}->{}>".format(
             self.type_string,
-            "%#x" % self.ins_addr if self.ins_addr is not None else "%#x[%d]" % (self.block_addr, self.stmt_idx),
+            f"{self.ins_addr:#x}" if self.ins_addr is not None else "%#x[%d]" % (self.block_addr, self.stmt_idx),
             dst_str,
         )
 
@@ -131,18 +129,17 @@ class XRef(Serializable):
         else:
             dst = cmsg.data_ea
 
-        cr = XRef(
+        return XRef(
             ins_addr=cmsg.ea,
             block_addr=cmsg.block_ea,
             stmt_idx=cmsg.stmt_idx,
-            insn_op_idx=None if cmsg.operand_idx == -1 else cmsg.opearnd_idx,
+            insn_op_idx=None if cmsg.operand_idx == -1 else cmsg.operand_idx,
             dst=dst,
             xref_type=cmsg.ref_type,
         )
-        return cr
 
     def copy(self):
-        cr = XRef(
+        return XRef(
             ins_addr=self.ins_addr,
             block_addr=self.block_addr,
             stmt_idx=self.stmt_idx,
@@ -151,7 +148,6 @@ class XRef(Serializable):
             dst=self.dst,
             xref_type=self.type,
         )
-        return cr
 
 
 from ..cfg.memory_data import MemoryDataSort

angr/knowledge_plugins/xrefs/xref_manager.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 from collections import defaultdict
 

angr/knowledge_plugins/xrefs/xref_types.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class XRefType:
     Offset = 0
     Read = 1

angr/misc/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from . import ux
 from . import autoimport
 from . import weakpatch

angr/misc/ansi.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from enum import Enum, unique
 
 

angr/misc/autoimport.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import importlib
 import importlib.machinery
@@ -23,7 +24,7 @@ def auto_import_packages(base_module, base_path, ignore_dirs=(), ignore_files=()
         l.debug("Loading %s.%s", base_module, lib_module_name)
 
         try:
-            package = importlib.import_module(".%s" % lib_module_name, base_module)
+            package = importlib.import_module(f".{lib_module_name}", base_module)
         except ImportError:
             l.warning("Unable to autoimport package %s.%s", base_module, lib_module_name, exc_info=True)
         else:
@@ -47,7 +48,7 @@ def auto_import_modules(base_module, base_path, ignore_files=(), filter_func: Ca
             continue
 
         try:
-            proc_module = importlib.import_module(".%s" % proc_module_name, base_module)
+            proc_module = importlib.import_module(f".{proc_module_name}", base_module)
         except ImportError:
             l.warning("Unable to autoimport module %s.%s", base_module, proc_module_name, exc_info=True)
             continue