angr 9.2.76__py3-none-win_amd64.whl → 9.2.77__py3-none-win_amd64.whl

angr/knowledge_plugins/key_definitions/live_definitions.py

@@ -370,6 +370,14 @@ class LiveDefinitions:
             if isinstance(anno, DefinitionAnnotation):
                 yield anno.definition
 
+    @staticmethod
+    def extract_defs_from_annotations(annos: Iterable["Annotation"]) -> Set[Definition]:
+        defs = set()
+        for anno in annos:
+            if isinstance(anno, DefinitionAnnotation):
+                defs.add(anno.definition)
+        return defs
+
     @staticmethod
     def extract_defs_from_mv(mv: MultiValues) -> Generator[Definition, None, None]:
         for vs in mv.values():
@@ -614,64 +622,60 @@ class LiveDefinitions:
 
     def get_definitions(
         self, thing: Union[Atom, Definition[Atom], Iterable[Atom], Iterable[Definition[Atom]], MultiValues]
-    ) -> Iterable[Definition[Atom]]:
+    ) -> Set[Definition[Atom]]:
         if isinstance(thing, MultiValues):
+            defs = set()
             for vs in thing.values():
                 for v in vs:
-                    for anno in v.annotations:
-                        if isinstance(anno, DefinitionAnnotation):
-                            yield anno.definition
-            return
+                    defs.update(LiveDefinitions.extract_defs_from_annotations(v.annotations))
+            return defs
         elif isinstance(thing, Atom):
             pass
         elif isinstance(thing, Definition):
             thing = thing.atom
         else:
+            defs = set()
             for atom2 in thing:
-                yield from self.get_definitions(atom2)
-            return
+                defs |= self.get_definitions(atom2)
+            return defs
 
         if isinstance(thing, Register):
-            yield from self.get_register_definitions(thing.reg_offset, thing.size)
+            return self.get_register_definitions(thing.reg_offset, thing.size)
         elif isinstance(thing, MemoryLocation):
             if isinstance(thing.addr, SpOffset):
-                yield from self.get_stack_definitions(thing.addr.offset, thing.size, thing.endness)
+                return self.get_stack_definitions(thing.addr.offset, thing.size)
             elif isinstance(thing.addr, HeapAddress):
-                yield from self.get_heap_definitions(thing.addr.value, size=thing.size, endness=thing.endness)
+                return self.get_heap_definitions(thing.addr.value, size=thing.size)
             elif isinstance(thing.addr, int):
-                yield from self.get_memory_definitions(thing.addr, thing.size, thing.endness)
+                return self.get_memory_definitions(thing.addr, thing.size)
             else:
-                return
+                return set()
         elif isinstance(thing, Tmp):
-            yield from self.get_tmp_definitions(thing.tmp_idx)
+            return self.get_tmp_definitions(thing.tmp_idx)
         else:
+            defs = set()
             for mvs in self.others.get(thing, {}).values():
                 for mv in mvs:
-                    yield from self.get_definitions(mv)
+                    defs |= self.get_definitions(mv)
+            return defs
 
-    def get_tmp_definitions(self, tmp_idx: int) -> Iterable[Definition]:
+    def get_tmp_definitions(self, tmp_idx: int) -> Set[Definition]:
         if tmp_idx in self.tmps:
-            yield from self.tmps[tmp_idx]
+            return self.tmps[tmp_idx]
         else:
-            return
+            return set()
 
-    def get_register_definitions(self, reg_offset: int, size: int, endness=None) -> Iterable[Definition]:
+    def get_register_definitions(self, reg_offset: int, size: int) -> Set[Definition]:
         try:
-            values: MultiValues = self.registers.load(
-                reg_offset,
-                size=size,
-                endness=endness,
-            )
+            annotations = self.registers.load_annotations(reg_offset, size)
         except SimMemoryMissingError as ex:
-            # load values and stop at the missing location
             if ex.missing_addr > reg_offset:
-                values: MultiValues = self.registers.load(
-                    reg_offset, size=ex.missing_addr - reg_offset, endness=endness
-                )
+                annotations = self.registers.load_annotations(reg_offset, ex.missing_addr - reg_offset)
             else:
                 # nothing we can do
-                return
-        yield from LiveDefinitions.extract_defs_from_mv(values)
+                return set()
+
+        return LiveDefinitions.extract_defs_from_annotations(annotations)
 
     def get_stack_values(self, stack_offset: int, size: int, endness: str) -> Optional[MultiValues]:
         stack_addr = self.stack_offset_to_stack_addr(stack_offset)
@@ -680,31 +684,36 @@ class LiveDefinitions:
         except SimMemoryMissingError:
             return None
 
-    def get_stack_definitions(self, stack_offset: int, size: int, endness) -> Iterable[Definition]:
-        mv = self.get_stack_values(stack_offset, size, endness)
-        if not mv:
-            return
-        yield from LiveDefinitions.extract_defs_from_mv(mv)
+    def get_stack_definitions(self, stack_offset: int, size: int) -> Set[Definition]:
+        try:
+            stack_addr = self.stack_offset_to_stack_addr(stack_offset)
+            annotations = self.stack.load_annotations(stack_addr, size)
+        except SimMemoryMissingError:
+            return set()
 
-    def get_heap_definitions(self, heap_addr: int, size: int, endness) -> Iterable[Definition]:
+        return LiveDefinitions.extract_defs_from_annotations(annotations)
+
+    def get_heap_definitions(self, heap_addr: int, size: int) -> Set[Definition]:
         try:
-            mv: MultiValues = self.heap.load(heap_addr, size=size, endness=endness)
+            annotations = self.heap.load_annotations(heap_addr, size)
         except SimMemoryMissingError:
-            return
-        yield from LiveDefinitions.extract_defs_from_mv(mv)
+            return set()
+
+        return LiveDefinitions.extract_defs_from_annotations(annotations)
 
-    def get_memory_definitions(self, addr: int, size: int, endness) -> Iterable[Definition]:
+    def get_memory_definitions(self, addr: int, size: int) -> Set[Definition]:
         try:
-            values = self.memory.load(addr, size=size, endness=endness)
+            annotations = self.memory.load_annotations(addr, size)
         except SimMemoryMissingError:
-            return
-        yield from LiveDefinitions.extract_defs_from_mv(values)
+            return set()
+
+        return LiveDefinitions.extract_defs_from_annotations(annotations)
 
     @deprecated("get_definitions")
     def get_definitions_from_atoms(self, atoms: Iterable[Atom]) -> Iterable[Definition]:
         result = set()
         for atom in atoms:
-            result |= set(self.get_definitions(atom))
+            result |= self.get_definitions(atom)
         return result
 
     @deprecated("get_values")
@@ -905,7 +914,7 @@ class LiveDefinitions:
 
     def add_memory_use(self, atom: MemoryLocation, code_loc: CodeLocation, expr: Optional[Any] = None) -> None:
         # get all current definitions
-        current_defs: Iterable[Definition] = self.get_definitions(atom)
+        current_defs: Set[Definition] = self.get_definitions(atom)
 
         for current_def in current_defs:
             self.add_memory_use_by_def(current_def, code_loc, expr=expr)

angr/knowledge_plugins/key_definitions/liveness.py

@@ -1,7 +1,9 @@
-from typing import DefaultDict, Optional, List, Set, Tuple, TYPE_CHECKING
+from typing import DefaultDict, Optional, List, Set, Tuple, Dict, TYPE_CHECKING
 
 from collections import defaultdict
+from itertools import chain
 
+from angr.utils.constants import DEFAULT_STATEMENT
 from angr.knowledge_plugins.key_definitions.atoms import Tmp
 
 from .constants import ObservationPointType, OP_BEFORE, OP_AFTER
@@ -15,6 +17,7 @@ LocationType = Tuple[int, Optional[int], Optional[int]]  # block addr, block ID,
 LocationWithPosType = Tuple[
     int, Optional[int], Optional[int], ObservationPointType
 ]  # block addr, block ID, stmt ID, before/after
+BlockAddrType = Tuple[int, Optional[int]]  # block addr, block ID
 
 
 class Liveness:
@@ -25,30 +28,37 @@ class Liveness:
     def __init__(self):
         self.curr_live_defs: Set["Definition"] = set()
         self.curr_loc: Optional[LocationType] = None
-        self.def_to_liveness: DefaultDict["Definition", Set[LocationType]] = defaultdict(set)
-        self.loc_to_defs: DefaultDict[LocationWithPosType, Set["Definition"]] = defaultdict(set)
-        self._node_max_stmt_id: DefaultDict[Tuple[int, Optional[int]], int] = defaultdict(int)
-
-    def add_def(self, d: "Definition", code_loc: "CodeLocation") -> None:
-        loc = (code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx)
+        self.curr_block: Optional[BlockAddrType] = None
+        self.curr_stmt_idx: Optional[int] = None
+        self.blockstart_to_defs: DefaultDict[BlockAddrType, Set["Definition"]] = defaultdict(set)
+        self.blockend_to_defs: DefaultDict[BlockAddrType, Set["Definition"]] = defaultdict(set)
+        self.loc_to_killed_defs: DefaultDict[BlockAddrType, Dict[int, Set["Definition"]]] = defaultdict(dict)
+        self.loc_to_added_defs: DefaultDict[BlockAddrType, Dict[int, Set["Definition"]]] = defaultdict(dict)
+        self._node_max_stmt_id: DefaultDict[BlockAddrType, int] = defaultdict(int)
+
+    def add_def(self, d: "Definition") -> None:
         self.curr_live_defs.add(d)
-        self.def_to_liveness[d].add(loc)
+        if self.curr_stmt_idx not in self.loc_to_added_defs[self.curr_block]:
+            self.loc_to_added_defs[self.curr_block][self.curr_stmt_idx] = set()
+        self.loc_to_added_defs[self.curr_block][self.curr_stmt_idx].add(d)
 
     def kill_def(self, d: "Definition") -> None:
         self.curr_live_defs.discard(d)
+        if self.curr_stmt_idx not in self.loc_to_killed_defs[self.curr_block]:
+            self.loc_to_killed_defs[self.curr_block][self.curr_stmt_idx] = set()
+        self.loc_to_killed_defs[self.curr_block][self.curr_stmt_idx].add(d)
 
-    def complete_loc(self) -> None:
-        if self.curr_loc is not None:
-            for live_def in self.curr_live_defs:
-                self.def_to_liveness[live_def].add(self.curr_loc)
-            self.loc_to_defs[self.curr_loc + (OP_AFTER,)] |= self.curr_live_defs
+    def make_liveness_snapshot(self) -> None:
+        if self.curr_block is not None:
+            self.blockend_to_defs[self.curr_block] |= self.curr_live_defs
 
     def at_new_stmt(self, code_loc: "CodeLocation") -> None:
         """
         Only support moving from a statement to the next statement within one basic block.
         """
-        self.complete_loc()
         self.curr_loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx
+        self.curr_block = code_loc.block_addr, code_loc.block_idx
+        self.curr_stmt_idx = code_loc.stmt_idx
         if (
             code_loc.stmt_idx is not None
             and code_loc.stmt_idx > self._node_max_stmt_id[(code_loc.block_addr, code_loc.block_idx)]
@@ -59,44 +69,102 @@ class Liveness:
         """
         Only support moving to a new block from one or more blocks.
         """
+        self.make_liveness_snapshot()
+
         loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx
-        key = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, OP_BEFORE
+        key = code_loc.block_addr, code_loc.block_idx
         for pred_codeloc in pred_codelocs:
-            if pred_codeloc.stmt_idx is None:
-                # external code location
-                pred_max_stmt_id = None
-            else:
-                pred_max_stmt_id = self._node_max_stmt_id[(pred_codeloc.block_addr, pred_codeloc.block_idx)]
-            pred_key = pred_codeloc.block_addr, pred_codeloc.block_idx, pred_max_stmt_id, OP_AFTER
-            all_pred_defs = self.loc_to_defs[pred_key]
+            all_pred_defs = self.blockend_to_defs[pred_codeloc.block_addr, pred_codeloc.block_idx]
 
             # remove tmp defs
             pred_defs = set()
             for pred_def in all_pred_defs:
                 if not isinstance(pred_def.atom, Tmp):
                     pred_defs.add(pred_def)
-            for pred_def in pred_defs:
-                self.def_to_liveness[pred_def].add(loc)
-            self.loc_to_defs[key] |= pred_defs
+            self.blockstart_to_defs[key] |= pred_defs
 
-        self.curr_live_defs = set(self.loc_to_defs[key])
+        self.curr_live_defs = self.blockstart_to_defs[key].copy()
         self.curr_loc = loc
+        self.curr_stmt_idx = 0
 
     def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
-        if op == OP_BEFORE:
-            if code_loc.stmt_idx != 0:
-                loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx - 1, OP_AFTER
+        return self.find_defs_at_raw(code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, op=op)
+
+    def find_defs_at_raw(
+        self, block_addr: int, block_idx: Optional[int], stmt_idx: Optional[int], op: int = OP_BEFORE
+    ) -> Set["Definition"]:
+        block: BlockAddrType = block_addr, block_idx
+        if block not in self.blockstart_to_defs:
+            defs = set()
+        else:
+            defs = self.blockstart_to_defs[block].copy()
+
+        if stmt_idx is None:
+            return defs
+
+        added_defs = self.loc_to_added_defs[block] if block in self.loc_to_added_defs else None
+        killed_defs = self.loc_to_killed_defs[block] if block in self.loc_to_added_defs else None
+
+        if stmt_idx == DEFAULT_STATEMENT:
+            end_stmt_idx = self._node_max_stmt_id[block] + 1
+        else:
+            if op == OP_BEFORE:
+                end_stmt_idx = stmt_idx
             else:
-                loc = code_loc.block_addr, code_loc.block_idx, 0, OP_BEFORE
+                end_stmt_idx = stmt_idx + 1
+
+        if added_defs is not None and killed_defs is not None:
+            indices = chain(added_defs, killed_defs)
+        elif added_defs is None and killed_defs is not None:
+            indices = killed_defs
+        elif added_defs is not None and killed_defs is None:
+            indices = added_defs
         else:
-            loc = code_loc.block_addr, code_loc.block_idx, code_loc.stmt_idx, OP_AFTER
-        return set() if loc not in self.loc_to_defs else self.loc_to_defs[loc]
+            indices = []
+
+        tmp_indices = []
+        if killed_defs is not None and None in killed_defs:
+            # External codeloc
+            defs.difference_update(killed_defs[None])
+            for idx in indices:
+                if idx is not None:
+                    tmp_indices.append(idx)
+            indices = tmp_indices
+
+        tmp_indices = []
+        if added_defs is not None and None in added_defs:
+            # External codeloc
+            defs.update(added_defs[None])
+            for idx in indices:
+                if idx is not None:
+                    tmp_indices.append(idx)
+            indices = tmp_indices
+
+        for idx in sorted(indices):
+            if idx >= end_stmt_idx:
+                break
+            if killed_defs is not None and idx in killed_defs:
+                defs.difference_update(killed_defs[idx])
+            if added_defs is not None and idx in added_defs:
+                defs.update(added_defs[idx])
+
+        if stmt_idx == DEFAULT_STATEMENT and op == OP_AFTER:
+            if killed_defs is not None and DEFAULT_STATEMENT in killed_defs:
+                defs.difference_update(killed_defs[DEFAULT_STATEMENT])
+            if added_defs is not None and DEFAULT_STATEMENT in added_defs:
+                defs.update(added_defs[DEFAULT_STATEMENT])
+
+        return defs
 
     def copy(self) -> "Liveness":
         o = Liveness()
         o.curr_live_defs = self.curr_live_defs.copy()
         o.curr_loc = self.curr_loc
-        o.def_to_liveness = self.def_to_liveness.copy()
-        o.loc_to_defs = self.loc_to_defs.copy()
+        o.curr_block = self.curr_block
+        o.curr_stmt_idx = self.curr_stmt_idx
+        o.blockstart_to_defs = self.blockstart_to_defs.copy()
+        o.blockend_to_defs = self.blockend_to_defs.copy()
+        o.loc_to_added_defs = self.loc_to_added_defs.copy()
+        o.loc_to_killed_defs = self.loc_to_killed_defs.copy()
         o._node_max_stmt_id = self._node_max_stmt_id.copy()
         return o

angr/knowledge_plugins/key_definitions/rd_model.py

@@ -32,9 +32,9 @@ class ReachingDefinitionsModel:
             len(self.observed_results),
         )
 
-    def add_def(self, d: "Definition", codeloc: "CodeLocation") -> None:
+    def add_def(self, d: "Definition") -> None:
         if self.liveness is not None:
-            self.liveness.add_def(d, codeloc)
+            self.liveness.add_def(d)
 
     def kill_def(self, d: "Definition") -> None:
         if self.liveness is not None:
@@ -48,9 +48,9 @@ class ReachingDefinitionsModel:
         if self.liveness is not None:
             self.liveness.at_new_block(code_loc, pred_codelocs)
 
-    def complete_loc(self) -> None:
+    def make_liveness_snapshot(self) -> None:
         if self.liveness is not None:
-            self.liveness.complete_loc()
+            self.liveness.make_liveness_snapshot()
 
     def find_defs_at(self, code_loc: "CodeLocation", op: int = OP_BEFORE) -> Set["Definition"]:
         return self.liveness.find_defs_at(code_loc, op=op)

angr/knowledge_plugins/propagations/states.py

@@ -808,7 +808,9 @@ class PropagatorAILState(PropagatorState):
                 or isinstance(old, ailment.Expr.Register)
                 and (old.reg_offset == self.arch.sp_offset or (not bp_as_gpr and old.reg_offset == self.arch.bp_offset))
             ):
-                self._replacements[codeloc][old] = new
+                self._replacements[codeloc][old] = (
+                    new if stmt_to_remove is None else {"expr": new, "stmt_to_remove": stmt_to_remove}
+                )
                 replaced = True
         else:
             prop_count = 0

angr/knowledge_plugins/variables/variable_manager.py

@@ -90,6 +90,7 @@ class VariableManagerInternal(Serializable):
         self._atom_to_variable: Dict[
             Union[Tuple[int, int], Tuple[int, int, int]], Dict[int, Set[Tuple[SimVariable, int]]]
         ] = defaultdict(_defaultdict_set)
+        self._ident_to_variable: Dict[str, SimVariable] = {}
         self._variable_counters = {
             "register": count(),
             "stack": count(),
@@ -109,6 +110,9 @@ class VariableManagerInternal(Serializable):
         self.variable_to_types: Dict[SimVariable, SimType] = {}
         self.variables_with_manual_types = set()
 
+        # optimization
+        self._variables_without_writes = set()
+
         self.ret_val_size = None
 
     #
@@ -241,6 +245,7 @@ class VariableManagerInternal(Serializable):
                 model._phi_variables[var] = set()
             else:
                 model._variables.add(var)
+                model._ident_to_variable[var.ident] = var
 
         # variable accesses
         for varaccess_pb2 in cmsg.accesses:
@@ -314,6 +319,8 @@ class VariableManagerInternal(Serializable):
 
             region.add_variable(offset, var)
 
+        model._variables_without_writes = model.get_variables_without_writes()
+
         return model
 
     #
@@ -338,7 +345,7 @@ class VariableManagerInternal(Serializable):
         ident = "i%s_%d" % (prefix, next(self._variable_counters[sort]))
         return ident
 
-    def add_variable(self, sort, start, variable):
+    def add_variable(self, sort, start, variable: SimVariable):
         if sort == "stack":
             region = self._stack_region
         elif sort == "register":
@@ -347,17 +354,17 @@ class VariableManagerInternal(Serializable):
             region = self._global_region
         else:
             raise ValueError("Unsupported sort %s in add_variable()." % sort)
-        existing = [x for x in region.get_variables_by_offset(start) if x.ident == variable.ident]
-        if len(existing) == 1:
-            var = existing[0]
-            if var.name is not None and not variable.renamed:
-                variable.name = var.name
-                variable.renamed = var.renamed
-        else:
-            # implicitly overwrite or add I guess
-            pass
+
+        # 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]
+            if existing_var.name is not None and not variable.renamed:
+                variable.name = existing_var.name
+                variable.renamed = existing_var.renamed
+        self._ident_to_variable[variable.ident] = variable
         region.add_variable(start, variable)
         self._variables.add(variable)
+        self._variables_without_writes.add(variable)
 
     def set_variable(self, sort, start, variable: SimVariable):
         if sort == "stack":
@@ -368,17 +375,15 @@ class VariableManagerInternal(Serializable):
             region = self._global_region
         else:
             raise ValueError("Unsupported sort %s in set_variable()." % sort)
-        existing = [x for x in region.get_variables_by_offset(start) if x.ident == variable.ident]
-        if len(existing) == 1:
-            var = existing[0]
-            if var.name is not None and not variable.renamed:
-                variable.name = var.name
-                variable.renamed = var.renamed
-        else:
-            # implicitly overwrite or add I guess
-            pass
+        # 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]
+            if existing_var.name is not None and not variable.renamed:
+                variable.name = existing_var.name
+                variable.renamed = existing_var.renamed
         region.set_variable(start, variable)
         self._variables.add(variable)
+        self._variables_without_writes.add(variable)
 
     def write_to(self, variable, offset, location, overwrite=False, atom=None):
         self._record_variable_access(
@@ -404,17 +409,19 @@ class VariableManagerInternal(Serializable):
         overwrite=False,
         atom=None,
     ):
-        # TODO can this line be removed, should we be only adding to _variables in add_variable?
-        self._variables.add(variable)
         atom_hash = (hash(atom) & 0xFFFF_FFFF) if atom is not None else None
         if overwrite:
             self._variable_accesses[variable] = {VariableAccess(variable, sort, location, offset, atom_hash=atom_hash)}
         else:
             self._variable_accesses[variable].add(VariableAccess(variable, sort, location, offset, atom_hash=atom_hash))
         self.record_variable(location, variable, offset, overwrite=overwrite, atom=atom)
+        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):
-        self._variables.add(variable)
+        if variable.ident not in self._ident_to_variable:
+            self._ident_to_variable[variable.ident] = variable
+            self._variables.add(variable)
         var_and_offset = variable, offset
         atom_hash = (hash(atom) & 0xFFFF_FFFF) if atom is not None else None
         key = (
@@ -693,7 +700,7 @@ class VariableManagerInternal(Serializable):
             variables[phi] = self._phi_variables[phi]
         return variables
 
-    def input_variables(self, exclude_specials=True):
+    def get_variables_without_writes(self) -> List[SimVariable]:
         """
         Get all variables that have never been written to.
 
@@ -703,16 +710,35 @@ class VariableManagerInternal(Serializable):
         def has_write_access(accesses):
             return any(acc for acc in accesses if acc.access_type == VariableAccessSort.WRITE)
 
+        input_variables = []
+
+        for variable, accesses in self._variable_accesses.items():
+            if variable in self._phi_variables:
+                # a phi variable is definitely not an input variable
+                continue
+            if not has_write_access(accesses):
+                input_variables.append(variable)
+
+        return input_variables
+
+    def input_variables(self, exclude_specials: bool = True):
+        """
+        Get all variables that have never been written to.
+
+        :return: A list of variables that are never written to.
+        """
+
         def has_read_access(accesses):
             return any(acc for acc in accesses if acc.access_type == VariableAccessSort.READ)
 
         input_variables = []
 
-        for variable, accesses in self._variable_accesses.items():
+        for variable in self._variables_without_writes:
             if variable in self._phi_variables:
                 # a phi variable is definitely not an input variable
                 continue
-            if not has_write_access(accesses) and has_read_access(accesses):
+            accesses = self._variable_accesses[variable]
+            if has_read_access(accesses):
                 if not exclude_specials or not variable.category:
                     input_variables.append(variable)
 

angr/misc/bug_report.py

@@ -1,4 +1,4 @@
-import imp
+import importlib
 import os
 import sys
 import datetime
@@ -41,7 +41,7 @@ def print_versions():
     for m in angr_modules:
         print("######## %s #########" % m)
         try:
-            _, python_filename, _ = imp.find_module(m)
+            python_filename = importlib.util.find_spec(m).origin
         except ImportError:
             print("Python could not find " + m)
             continue

angr/storage/memory_mixins/__init__.py

@@ -1,4 +1,4 @@
-# pylint:disable=abstract-method
+# pylint:disable=abstract-method,wrong-import-position,unused-argument,missing-class-docstring,arguments-differ
 from typing import Iterable, Tuple, Dict, Any, Optional
 
 import claripy
@@ -114,7 +114,6 @@ class MemoryMixin(SimStatePlugin):
 
         The ``inspect``, ``events``, and ``key`` parameters are for ``state.solver.Unconstrained``, if it is used.
         """
-        pass
 
     def _merge_values(self, values: Iterable[Tuple[Any, Any]], merged_size: int, **kwargs) -> Optional[Any]:
         """
@@ -187,6 +186,7 @@ from .paged_memory.paged_memory_mixin import (
 )
 from .paged_memory.privileged_mixin import PrivilegedPagingMixin
 from .paged_memory.stack_allocation_mixin import StackAllocationMixin
+from .paged_memory.paged_memory_multivalue_mixin import PagedMemoryMultiValueMixin
 from .paged_memory.pages import *
 
 from .slotted_memory import SlottedMemoryMixin
@@ -353,6 +353,7 @@ class MultiValuedMemory(
     DefaultFillerMixin,
     MultiValueMergerMixin,
     PagedMemoryMixin,
+    PagedMemoryMultiValueMixin,
 ):
     def _default_value(self, addr, size, **kwargs):
         # TODO: Make _default_value() a separate Mixin

angr/storage/memory_mixins/paged_memory/paged_memory_multivalue_mixin.py

@@ -0,0 +1,63 @@
+from .. import MemoryMixin
+
+
+class PagedMemoryMultiValueMixin(MemoryMixin):
+    """
+    Implement optimizations and fast accessors for the MultiValues-variant of Paged Memory.
+    """
+
+    def load_annotations(self, addr: int, size: int, **kwargs):
+        if not isinstance(size, int):
+            raise TypeError("Need size to be resolved to an int by this point")
+
+        if not isinstance(addr, int):
+            raise TypeError("Need addr to be resolved to an int by this point")
+
+        pageno, pageoff = self._divide_addr(addr)
+
+        annotations = set()
+
+        # fasttrack basic case
+        if pageoff + size <= self.page_size:
+            page = self._get_page(pageno, False, **kwargs)
+            loaded = page.load(
+                pageoff,
+                size=size,
+                page_addr=pageno * self.page_size,
+                memory=self,
+                cooperate=True,
+                **kwargs,
+            )
+            for _, mos in loaded:
+                if isinstance(mos, set):
+                    for mo in mos:
+                        annotations.update(mo.object.annotations)
+                else:
+                    annotations.update(mos.object.annotations)
+
+        else:
+            max_pageno = (1 << self.state.arch.bits) // self.page_size
+            bytes_done = 0
+            while bytes_done < size:
+                page = self._get_page(pageno, False, **kwargs)
+                sub_size = min(self.page_size - pageoff, size - bytes_done)
+                loaded = page.load(
+                    pageoff,
+                    size=sub_size,
+                    page_addr=pageno * self.page_size,
+                    memory=self,
+                    cooperate=True,
+                    **kwargs,
+                )
+                for _, mos in loaded:
+                    if isinstance(mos, set):
+                        for mo in mos:
+                            annotations.update(mo.object.annotations)
+                    else:
+                        annotations.update(mos.object.annotations)
+
+                bytes_done += sub_size
+                pageno = (pageno + 1) % max_pageno
+                pageoff = 0
+
+        return annotations