angr 9.2.123__py3-none-macosx_11_0_arm64.whl → 9.2.124__py3-none-macosx_11_0_arm64.whl

angr/storage/memory_mixins/paged_memory/pages/multi_values.py

@@ -1,13 +1,17 @@
 from __future__ import annotations
 from collections.abc import Iterator
+from typing import Any, Generic, TypeGuard, TypeVar, cast
 import archinfo
 
 import claripy
 
+from angr.errors import AngrTypeError
 from angr.storage.memory_object import bv_slice
 
+MVType = TypeVar("MVType", bound=claripy.ast.BV | claripy.ast.FP)
 
-class MultiValues:
+
+class MultiValues(Generic[MVType]):
     """
     Represents a byte vector where each byte can have one or multiple values.
 
@@ -20,27 +24,31 @@ class MultiValues:
         "_single_value",
     )
 
-    _single_value: claripy.ast.Bits | None
-    _values: dict[int, set[claripy.ast.Bits]] | None
+    _single_value: MVType | None
+    _values: dict[int, set[MVType]] | None
 
     def __init__(
         self,
-        v: claripy.ast.Bits | MultiValues | None | dict[int, set[claripy.ast.Bits]] = None,
-        offset_to_values=None,
+        v: MVType | MultiValues[MVType] | None | dict[int, set[MVType]] = None,
+        offset_to_values: dict[int, set[MVType]] | None = None,
     ):
         if v is not None and offset_to_values is not None:
             raise TypeError("You cannot specify v and offset_to_values at the same time!")
 
-        self._single_value = (
-            None
-            if v is None
-            else v if isinstance(v, claripy.ast.Bits) else v._single_value if isinstance(v, MultiValues) else None
-        )
-        self._values = (
-            offset_to_values
-            if offset_to_values is not None
-            else v if isinstance(v, dict) else v._values if isinstance(v, MultiValues) else None
-        )
+        if v is None:
+            self._single_value = None
+            self._values = offset_to_values
+        elif isinstance(v, (claripy.ast.BV, claripy.ast.FP)):
+            self._single_value = v
+            self._values = None
+        elif isinstance(v, MultiValues):
+            self._single_value = v._single_value
+            self._values = v._values
+        elif isinstance(v, dict):
+            self._single_value = None
+            self._values = v
+        else:
+            raise TypeError(type(v))
 
         if self._single_value is None and self._values is None:
             self._values = {}
@@ -56,7 +64,7 @@ class MultiValues:
                 if not isinstance(vs, set):
                     raise TypeError("Each value in offset_to_values must be a set!")
 
-    def add_value(self, offset: int, value: claripy.ast.Bits) -> None:
+    def add_value(self, offset: int, value: MVType) -> None:
         if len(value) == 0:
             return
         if self._single_value is not None:
@@ -80,32 +88,40 @@ class MultiValues:
 
         succ_offset = self._adjacent_offset(offset, before=False)
         if succ_offset is not None:
-            value_end = offset + value.length // 8
+            value_end = offset + value.size() // 8
             if value_end > succ_offset:
+                if isinstance(value, claripy.ast.FP):
+                    raise AngrTypeError("Unsupported case. How do we handle floating point values overlapping?")
                 # value is too long. we need to break value into two
                 mid_value_size = succ_offset - offset
-                remaining_value = value[value.length - mid_value_size * 8 - 1 : 0]
+                remaining_value = cast(MVType, value[value.size() - mid_value_size * 8 - 1 : 0])
                 # update value
-                value = value[value.length - 1 : value.length - mid_value_size * 8]
+                value = cast(MVType, value[value.size() - 1 : value.size() - mid_value_size * 8])
                 self.add_value(succ_offset, remaining_value)
 
         if self._values[offset]:
-            curr_value_size = next(iter(self._values[offset])).length // 8
-            if curr_value_size > value.length // 8:
+            curr_value_size = next(iter(self._values[offset])).size() // 8
+            if curr_value_size > value.size() // 8:
                 # we need to break existing values
                 new_curr_values = set()
                 remaining_values = set()
                 for v in self._values[offset]:
-                    new_curr_values.add(v[v.length - 1 : v.length - value.length])
-                    remaining_values.add(v[v.length - value.length - 1 : 0])
+                    if isinstance(v, claripy.ast.FP):
+                        raise AngrTypeError("Unsupported case. How do we handle floating point values overlapping?")
+
+                    new_curr_values.add(v[v.size() - 1 : v.size() - value.size()])
+                    remaining_values.add(v[v.size() - value.size() - 1 : 0])
                 self._values[offset] = new_curr_values
                 for v in remaining_values:
-                    self.add_value(offset + value.length // 8, v)
-            elif curr_value_size < value.length // 8:
+                    self.add_value(offset + value.size() // 8, v)
+            elif curr_value_size < value.size() // 8:
+                if isinstance(value, claripy.ast.FP):
+                    raise AngrTypeError("Unsupported case. How do we handle floating point values overlapping?")
+
                 # value is too long. we need to break value into two
-                remaining_value = value[value.length - curr_value_size * 8 - 1 : 0]
+                remaining_value = cast(MVType, value[value.size() - curr_value_size * 8 - 1 : 0])
                 # update value
-                value = value[value.length - 1 : value.length - curr_value_size * 8]
+                value = cast(MVType, value[value.size() - 1 : value.size() - curr_value_size * 8])
                 self.add_value(offset + curr_value_size, remaining_value)
 
         self._values[offset].add(value)
@@ -113,26 +129,28 @@ class MultiValues:
         pre_offset = self._adjacent_offset(offset, before=True)
         if pre_offset is not None:
             pre_values = self._values[pre_offset]
-            pre_values_size = next(iter(pre_values)).length // 8
+            pre_values_size = next(iter(pre_values)).size() // 8
             if pre_offset + pre_values_size > offset:
                 # we need to break the preceding values
                 new_pre_value_size = offset - pre_offset
                 new_pre_values = set()
                 remaining_values = set()
                 for v in pre_values:
-                    new_pre_values.add(v[v.length - 1 : v.length - new_pre_value_size * 8])
-                    remaining_values.add(v[v.length - new_pre_value_size * 8 - 1 : 0])
+                    if isinstance(v, claripy.ast.FP):
+                        raise AngrTypeError("Unsupported case. How do we handle floating point values overlapping?")
+                    new_pre_values.add(v[v.size() - 1 : v.size() - new_pre_value_size * 8])
+                    remaining_values.add(v[v.size() - new_pre_value_size * 8 - 1 : 0])
                 self._values[pre_offset] = new_pre_values
                 for v in remaining_values:
                     self.add_value(offset, v)
 
-    def one_value(self, strip_annotations: bool = False) -> claripy.ast.Bits | None:
+    def one_value(self, strip_annotations: bool = False) -> MVType | None:
         if self._single_value is not None:
             return self._single_value
 
         assert self._values is not None
 
-        if len(self._values) == 1 and len(self._values[0]) == 1:
+        if len(self._values) == 1 and 0 in self._values and len(self._values[0]) == 1:
             return next(iter(self._values[0]))
         if strip_annotations:
             all_values_wo_annotations = {
@@ -144,7 +162,7 @@ class MultiValues:
 
     def __len__(self) -> int:
         if self._single_value is not None:
-            return self._single_value.length
+            return self._single_value.size()
 
         assert self._values is not None
 
@@ -155,7 +173,7 @@ class MultiValues:
         max_len = max(x.size() for x in self._values[max_offset])
         return max_offset * 8 + max_len  # FIXME: we are assuming byte_width of 8
 
-    def merge(self, mv: MultiValues) -> MultiValues:
+    def merge(self, mv: MultiValues[MVType]) -> MultiValues[MVType]:
         new_values = {k: set(v) for k, v in self.items()}
         for off, vs in mv.items():
             if off not in new_values:
@@ -187,47 +205,46 @@ class MultiValues:
     def __contains__(self, offset: int) -> bool:
         if self._single_value is not None:
             return offset == 0
-        return False if not self._values else offset in self._values
+        assert self._values is not None
+        return offset in self._values
 
-    def __getitem__(self, offset: int) -> set[claripy.ast.Bits]:
+    def __getitem__(self, offset: int) -> set[MVType]:
         if self._single_value is not None:
             if offset == 0:
                 return {self._single_value}
-            raise KeyError
-        if not self._values:
-            raise KeyError
+            raise KeyError(offset)
+        assert self._values is not None
         return self._values[offset]
 
     def keys(self) -> set[int]:
         if self._single_value is not None:
             return {0}
-        return set() if not self._values else set(self._values.keys())
+        assert self._values is not None
+        return set(self._values.keys())
 
-    def values(self) -> Iterator[set[claripy.ast.Bits]]:
+    def values(self) -> Iterator[set[MVType]]:
         if self._single_value is not None:
             yield {self._single_value}
         else:
-            if self._values is None:
-                return
+            assert self._values is not None
             yield from self._values.values()
 
-    def items(self) -> Iterator[tuple[int, set[claripy.ast.Bits]]]:
+    def items(self) -> Iterator[tuple[int, set[MVType]]]:
         if self._single_value is not None:
             yield 0, {self._single_value}
         else:
-            if self._values is None:
-                yield 0, set()
-            else:
-                yield from self._values.items()
+            assert self._values is not None
+            yield from self._values.items()
 
     def count(self) -> int:
         if self._single_value is not None:
             return 1
-        if self._values is None:
-            return 0
+        assert self._values is not None
         return len(self._values)
 
-    def extract(self, offset: int, length: int, endness: str) -> MultiValues:
+    def extract(
+        self: MultiValues[claripy.ast.BV], offset: int, length: int, endness: str
+    ) -> MultiValues[claripy.ast.BV]:
         end = offset + length
         result = MultiValues(claripy.BVV(b""))
         for obj_offset, values in self.items():
@@ -240,16 +257,19 @@ class MultiValues:
 
                 slice_start = max(0, offset - obj_offset)
                 slice_end = min(obj_length, end - obj_offset)
-                sliced = bv_slice(value, slice_start, slice_end - slice_start, endness == archinfo.Endness.LE, 8)
+                bv_value: claripy.ast.BV = claripy.fpToIEEEBV(value) if isinstance(value, claripy.ast.FP) else value
+                sliced = bv_slice(bv_value, slice_start, slice_end - slice_start, endness == archinfo.Endness.LE, 8)
                 if len(sliced):
                     result.add_value(max(0, obj_offset - offset), sliced)
 
         return result
 
-    def concat(self, other: MultiValues | claripy.ast.Bits | bytes) -> MultiValues:
-        if isinstance(other, bytes):
+    def concat(
+        self: MultiValues[claripy.ast.BV], other: MultiValues[claripy.ast.BV] | claripy.ast.BV | bytes
+    ) -> MultiValues[claripy.ast.BV]:
+        if isinstance(other, (bytes, bytearray, memoryview)):
             other = claripy.BVV(other)
-        if isinstance(other, claripy.ast.Bits):
+        if isinstance(other, claripy.ast.BV):
             other = MultiValues(other)
         offset = len(self) // 8
         result = MultiValues(self)
@@ -283,3 +303,17 @@ class MultiValues:
                 # we missed it...
                 return None
         return None
+
+
+def mv_is_bv(mv: MultiValues[Any]) -> TypeGuard[MultiValues[claripy.ast.BV]]:
+    if mv._single_value is not None:
+        return isinstance(mv._single_value, claripy.ast.BV)
+    assert mv._values is not None
+    return all(isinstance(value, claripy.ast.BV) for valueset in mv._values.values() for value in valueset)
+
+
+def mv_is_fp(mv: MultiValues[Any]) -> TypeGuard[MultiValues[claripy.ast.FP]]:
+    if mv._single_value is not None:
+        return isinstance(mv._single_value, claripy.ast.FP)
+    assert mv._values is not None
+    return all(isinstance(value, claripy.ast.FP) for valueset in mv._values.values() for value in valueset)

angr/storage/memory_mixins/paged_memory/pages/mv_list_page.py

@@ -4,6 +4,7 @@ import logging
 from typing import Union, Any
 from collections.abc import Callable
 
+from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 from angr.utils.dynamic_dictlist import DynamicDictList
 from angr.storage.memory_object import SimMemoryObject, SimLabeledMemoryObject
 from . import PageBase
@@ -20,10 +21,9 @@ class MVListPage(
     PageBase,
 ):
     """
-    MVListPage allows storing multiple values at the same location, thus allowing weak updates.
+    MVListPage allows storing multiple values at the same location.
 
-    Each store() may take a value or multiple values, and a "weak" parameter to specify if this store is a weak update
-    or not.
+    Each store() may take a value or multiple values.
     Each load() returns an iterator of all values stored at that location.
     """
 
@@ -104,8 +104,8 @@ class MVListPage(
             self.stored_offset.add(subaddr)
         result[-1] = (global_start_addr, new_item)
 
-    def store(self, addr, data, size=None, endness=None, memory=None, cooperate=False, weak=False, **kwargs):
-        super().store(addr, data, size=size, endness=endness, memory=memory, cooperate=cooperate, weak=weak, **kwargs)
+    def store(self, addr, data, size=None, endness=None, memory=None, cooperate=False, **kwargs):
+        super().store(addr, data, size=size, endness=endness, memory=memory, cooperate=cooperate, **kwargs)
 
         if not cooperate:
             data = self._force_store_cooperation(addr, data, size, endness, memory=memory, **kwargs)
@@ -117,22 +117,12 @@ class MVListPage(
             self.content = DynamicDictList(max_size=len(self.content))
             self.stored_offset = set()
         else:
-            if not weak:
-                if len(data) == 1:
-                    # unpack
-                    data: _MOTYPE = next(iter(data))
-                for subaddr in range(addr, addr + size):
-                    self.content[subaddr] = data
-                    self.stored_offset.add(subaddr)
-            else:
-                for subaddr in range(addr, addr + size):
-                    if self.content[subaddr] is None:
-                        self.content[subaddr] = data
-                    elif type(self.content[subaddr]) is set:
-                        self.content[subaddr] |= data
-                    else:
-                        self.content[subaddr] = {self.content[subaddr]} | data
-                    self.stored_offset.add(subaddr)
+            if len(data) == 1:
+                # unpack
+                data: _MOTYPE = next(iter(data))
+            for subaddr in range(addr, addr + size):
+                self.content[subaddr] = data
+                self.stored_offset.add(subaddr)
 
     def erase(self, addr, size=None, **kwargs) -> None:
         for off in range(size):
@@ -143,8 +133,9 @@ class MVListPage(
         others: list[MVListPage],
         merge_conditions,
         common_ancestor=None,
-        page_addr: int | None = None,
-        memory=None,
+        *,
+        page_addr: int,
+        memory: MemoryMixin,
         changed_offsets: set[int] | None = None,
     ):
         if changed_offsets is None:
@@ -230,7 +221,7 @@ class MVListPage(
                 # new_object = self._replace_memory_object(our_mo, merged_val, page_addr, memory.page_size)
 
                 new_mos = {SimMemoryObject(v, mo_base, endness=the_endness) for v in merged_val}
-                self.store(b, new_mos, size=size, cooperate=True, weak=False)
+                self.store(b, new_mos, size=size, cooperate=True)
 
                 merged_offsets.add(b)
 
@@ -271,7 +262,7 @@ class MVListPage(
                     continue
 
                 new_mos = {SimMemoryObject(v, page_addr + b, endness="Iend_BE") for v in merged_val}
-                self.store(b, new_mos, size=min_size, cooperate=True, weak=False)
+                self.store(b, new_mos, size=min_size, cooperate=True)
                 merged_offsets.add(b)
 
         self.stored_offset |= merged_offsets

angr/storage/memory_mixins/paged_memory/pages/permissions_mixin.py

@@ -6,29 +6,31 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 class PermissionsMixin(MemoryMixin):
     """
-    This mixin adds a permissions field and properties for extracting the read/write/exec permissions. It does NOT add
-    permissions checking.
+    This mixin adds a permissions_bits field and properties for extracting the read/write/exec permissions. It does NOT
+    add permissions checking.
     """
 
-    def __init__(self, permissions=None, **kwargs):
+    def __init__(self, permissions: int | claripy.ast.BV | None = None, **kwargs):
         super().__init__(**kwargs)
-        if type(permissions) is int:
+        if permissions is None:
+            permissions = 7
+        if isinstance(permissions, int):
             permissions = claripy.BVV(permissions, 3)
-        self.permissions = permissions
+        self.permission_bits = permissions
 
     def copy(self, memo):
         o = super().copy(memo)
-        o.permissions = self.permissions
+        o.permission_bits = self.permission_bits
         return o
 
     @property
     def perm_read(self):
-        return self.permissions & 1
+        return self.permission_bits & 1
 
     @property
     def perm_write(self):
-        return self.permissions & 2
+        return self.permission_bits & 2
 
     @property
     def perm_exec(self):
-        return self.permissions & 4
+        return self.permission_bits & 4

angr/storage/memory_mixins/paged_memory/pages/ultra_page.py

@@ -343,13 +343,26 @@ class UltraPage(MemoryObjectMixin, PageBase):
 
         return merged_offsets
 
-    def concrete_load(self, addr, size, **kwargs):  # pylint: disable=arguments-differ
-        if type(self.concrete_data) is bytearray:
-            return (
-                memoryview(self.concrete_data)[addr : addr + size],
-                memoryview(self.symbolic_bitmap)[addr : addr + size],
-            )
-        return self.concrete_data[addr : addr + size], memoryview(self.symbolic_bitmap)[addr : addr + size]
+    def concrete_load(self, addr, size, writing=False, with_bitmap=False, **kwargs):  # pylint: disable=arguments-differ
+        assert self.concrete_data is not None
+        assert self.symbolic_bitmap is not None
+        mv_data = (
+            self.concrete_data
+            if isinstance(self.concrete_data, (memoryview, NotMemoryview))
+            else memoryview(self.concrete_data)
+        )
+        mv_bitm = (
+            self.symbolic_bitmap
+            if isinstance(self.symbolic_bitmap, (memoryview, NotMemoryview))
+            else memoryview(self.symbolic_bitmap)
+        )
+        result = (
+            mv_data[addr : addr + size],
+            mv_bitm[addr : addr + size],
+        )
+        if with_bitmap:
+            return result
+        return result[0]
 
     def changed_bytes(self, other, page_addr=None) -> set[int]:
         changed_candidates = super().changed_bytes(other)
@@ -489,3 +502,6 @@ class UltraPage(MemoryObjectMixin, PageBase):
                 self._update_mappings(b, old.object, new.object, memory=memory)
 
         return new
+
+
+from angr.storage.memory_mixins.paged_memory.page_backer_mixins import NotMemoryview

angr/storage/memory_mixins/paged_memory/privileged_mixin.py

@@ -26,7 +26,7 @@ class PrivilegedPagingMixin(PagedMemoryMixin):
 
         return page
 
-    def _initialize_page(self, pageno: int, priv: bool = False, **kwargs):
+    def _initialize_page(self, pageno: int, *, priv: bool = False, **kwargs):
         if self.category == "mem" and not priv and o.STRICT_PAGE_ACCESS in self.state.options:
             raise SimSegfaultException(pageno * self.page_size, "unmapped")
 

angr/storage/memory_mixins/regioned_memory/region_meta_mixin.py

@@ -148,7 +148,7 @@ class MemoryRegionMetaMixin(MemoryMixin):
 
     @MemoryMixin.memo
     def copy(self, memo):
-        r: MemoryRegionMetaMixin = super().copy(memo)
+        r = super().copy(memo)
         r.alocs = copy.deepcopy(self.alocs)
         r._related_function_addr = self._related_function_addr
         r._is_stack = self._is_stack
@@ -187,7 +187,7 @@ class MemoryRegionMetaMixin(MemoryMixin):
 
         return ret
 
-    def store(self, addr, data, bbl_addr=None, stmt_id=None, ins_addr=None, endness=None, **kwargs):
+    def store(self, addr, data, size=None, *, bbl_addr=None, stmt_id=None, ins_addr=None, endness=None, **kwargs):
         # It comes from a SimProcedure. We'll use bbl_addr as the aloc_id
         aloc_id = ins_addr if ins_addr is not None else bbl_addr
 
@@ -195,13 +195,13 @@ class MemoryRegionMetaMixin(MemoryMixin):
             self.alocs[aloc_id] = AbstractLocation(
                 bbl_addr, stmt_id, self.id, region_offset=addr, size=len(data) // self.state.arch.byte_width
             )
-            return super().store(addr, data, endness=endness, **kwargs)
+            return super().store(addr, data, size=size, endness=endness, **kwargs)
         if self.alocs[aloc_id].update(addr, len(data) // self.state.arch.byte_width):
-            return super().store(addr, data, endness=endness, **kwargs)
-        return super().store(addr, data, endness=endness, **kwargs)
+            return super().store(addr, data, size=size, endness=endness, **kwargs)
+        return super().store(addr, data, size=size, endness=endness, **kwargs)
 
     def load(
-        self, addr, size=None, bbl_addr=None, stmt_idx=None, ins_addr=None, **kwargs
+        self, addr, size=None, *, bbl_addr=None, stmt_idx=None, ins_addr=None, **kwargs
     ):  # pylint:disable=unused-argument
         # if bbl_addr is not None and stmt_id is not None:
         return super().load(addr, size=size, **kwargs)
@@ -228,9 +228,11 @@ class MemoryRegionMetaMixin(MemoryMixin):
         return r
 
     def widen(self, others):
+        result = False
         for other_region in others:
             self._merge_alocs(other_region)
-            super().widen([other_region.memory])
+            result |= super().widen([other_region.memory])
+        return result
 
     def dbg_print(self, indent=0):
         """

angr/storage/memory_mixins/regioned_memory/regioned_memory_mixin.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import logging
 from itertools import count
 from typing import Optional, TYPE_CHECKING
-from collections.abc import Generator, Iterable
+from collections.abc import Generator
 
 import claripy
 from claripy.annotation import RegionAnnotation
@@ -74,7 +74,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
     @MemoryMixin.memo
     def copy(self, memo):
-        o: RegionedMemoryMixin = super().copy(memo)
+        o = super().copy(memo)
         o._write_targets_limit = self._write_targets_limit
         o._read_targets_limit = self._read_targets_limit
         o._stack_size = self._stack_size
@@ -91,7 +91,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
         return o
 
-    def load(self, addr, size: BV | int | None = None, endness=None, condition: Bool | None = None, **kwargs):
+    def load(self, addr, size: BV | int | None = None, *, endness=None, condition: Bool | None = None, **kwargs):
         if isinstance(size, BV) and size.has_annotation_type(RegionAnnotation):
             _l.critical("load(): size %s is a ValueSet. Something is wrong.", size)
             if self.state.scratch.ins_addr is not None:
@@ -132,7 +132,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
         return val
 
-    def store(self, addr, data, size: int | None = None, endness=None, **kwargs):  # pylint:disable=unused-argument
+    def store(self, addr, data, size: int | None = None, *, endness=None, **kwargs):  # pylint:disable=unused-argument
         regioned_addrs_desc = self._normalize_address(addr)
         if (
             regioned_addrs_desc.cardinality >= self._write_targets_limit
@@ -144,7 +144,7 @@ class RegionedMemoryMixin(MemoryMixin):
         for aw in gen:
             self._region_store(aw.address, data, aw.region, endness, related_function_addr=aw.function_address)
 
-    def merge(self, others: Iterable[RegionedMemoryMixin], merge_conditions, common_ancestor=None) -> bool:
+    def merge(self, others, merge_conditions, common_ancestor=None) -> bool:
         r = False
         for o in others:
             for region_id, region in o._regions.items():
@@ -300,7 +300,7 @@ class RegionedMemoryMixin(MemoryMixin):
                 ),
             )
 
-        return self._regions[key].load(addr, size, bbl_addr, stmt_id, ins_addr, **kwargs)
+        return self._regions[key].load(addr, size, bbl_addr=bbl_addr, stmt_idx=stmt_id, ins_addr=ins_addr, **kwargs)
 
     def _region_store(self, addr, data, key: str, endness, related_function_addr: int | None = None, **kwargs):
         if key not in self._regions:
@@ -320,9 +320,9 @@ class RegionedMemoryMixin(MemoryMixin):
         self._regions[key].store(
             addr,
             data,
-            self.state.scratch.bbl_addr,
-            self.state.scratch.stmt_idx,
-            self.state.scratch.ins_addr,
+            bbl_addr=self.state.scratch.bbl_addr,
+            stmt_id=self.state.scratch.stmt_idx,
+            ins_addr=self.state.scratch.ins_addr,
             endness=endness,
             **kwargs,
         )

angr/storage/memory_mixins/regioned_memory/static_find_mixin.py

@@ -14,6 +14,7 @@ class StaticFindMixin(SmartFindMixin):  # pylint:disable=abstract-method
         addr,
         data,
         max_search,
+        *,
         default=None,
         endness=None,
         chunk_size=None,

angr/storage/memory_mixins/simple_interface_mixin.py

@@ -7,7 +7,7 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 
 class SimpleInterfaceMixin(MemoryMixin):
-    def load(self, addr, size=None, endness=None, condition=None, fallback=None, **kwargs):
+    def load(self, addr, size=None, *, endness=None, condition=None, fallback=None, **kwargs):
         tsize = self._translate_size(size, None)
         return super().load(
             self._translate_addr(addr),
@@ -18,7 +18,7 @@ class SimpleInterfaceMixin(MemoryMixin):
             **kwargs,
         )
 
-    def store(self, addr, data, size=None, endness=None, condition=None, **kwargs):
+    def store(self, addr, data, size=None, *, endness=None, condition=None, **kwargs):
         tsize = self._translate_size(size, data)
         super().store(
             self._translate_addr(addr),

angr/storage/memory_mixins/simplification_mixin.py

@@ -5,11 +5,11 @@ from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 
 
 class SimplificationMixin(MemoryMixin):
-    def store(self, addr, data, **kwargs):
+    def store(self, addr, data, size=None, **kwargs):
         if (self.category == "mem" and options.SIMPLIFY_MEMORY_WRITES in self.state.options) or (
             self.category == "reg" and options.SIMPLIFY_REGISTER_WRITES in self.state.options
         ):
             real_data = self.state.solver.simplify(data)
         else:
             real_data = data
-        super().store(addr, real_data, **kwargs)
+        super().store(addr, real_data, size, **kwargs)

angr/storage/memory_mixins/size_resolution_mixin.py

@@ -96,7 +96,7 @@ class SizeConcretizationMixin(MemoryMixin):
         out_size = self.state.solver.max(size)
         return super().load(addr, size=out_size, **kwargs)
 
-    def store(self, addr, data, size=None, condition=None, **kwargs):
+    def store(self, addr, data, size=None, *, condition=None, **kwargs):
         if getattr(size, "op", "BVV") == "BVV":
             super().store(addr, data, size=size, condition=condition, **kwargs)
             return

angr/storage/memory_mixins/slotted_memory.py

@@ -81,7 +81,7 @@ class SlottedMemoryMixin(MemoryMixin):
         try:
             d = self.contents[addr]
         except KeyError:
-            d = self._default_value(addr, self.width, (*self.variable_key_prefix, addr), **kwargs)
+            d = self._default_value(addr, self.width, key=(*self.variable_key_prefix, addr), **kwargs)
             self.contents[addr] = d
 
         if offset == 0 and size == self.width:
@@ -107,7 +107,7 @@ class SlottedMemoryMixin(MemoryMixin):
             end = cur.get_bytes(offset + size, self.width - offset - size)
             self.contents[addr] = start.concat(data, end)
 
-    def load(self, addr, size=None, endness=None, **kwargs):
+    def load(self, addr, size=None, *, endness=None, **kwargs):
         accesses = self._resolve_access(addr, size)
 
         value = claripy.Concat(*(self._single_load(addr, offset, size) for addr, offset, size in accesses))
@@ -116,7 +116,7 @@ class SlottedMemoryMixin(MemoryMixin):
 
         return value
 
-    def store(self, addr, data, size=None, endness=None, **kwargs):
+    def store(self, addr, data, size=None, *, endness=None, **kwargs):
         if endness != self.endness:
             data = data.reversed