angr 9.2.123__py3-none-manylinux2014_aarch64.whl → 9.2.125__py3-none-manylinux2014_aarch64.whl

angr/storage/memory_mixins/paged_memory/page_backer_mixins.py

@@ -7,8 +7,6 @@ import logging
 import claripy
 import cle
 
-from .paged_memory_mixin import PagedMemoryMixin
-
 l = logging.getLogger(__name__)
 
 BackerType = Union[bytes, bytearray, list[int]]
@@ -29,6 +27,9 @@ class NotMemoryview:
         memoryview(self.obj)[self.offset : self.offset + self.size][k] = v
 
 
+from .paged_memory_mixin import PagedMemoryMixin
+
+
 class ClemoryBackerMixin(PagedMemoryMixin):
     def __init__(self, cle_memory_backer: None | cle.Loader | cle.Clemory = None, **kwargs):
         super().__init__(**kwargs)
@@ -49,9 +50,9 @@ class ClemoryBackerMixin(PagedMemoryMixin):
         o._cle_loader = self._cle_loader
         return o
 
-    def _initialize_page(self, pageno, force_default=False, **kwargs):
+    def _initialize_page(self, pageno, permissions=None, *, force_default=False, **kwargs):
         if self._clemory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         addr = pageno * self.page_size
 
@@ -59,10 +60,10 @@ class ClemoryBackerMixin(PagedMemoryMixin):
             backer_iter: BackerIterType = self._clemory_backer.backers(addr)
             backer_start, backer = next(backer_iter)
         except StopIteration:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if backer_start >= addr + self.page_size:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         # Load data from backere
         data = self._data_from_backer(addr, backer, backer_start, backer_iter)
@@ -184,9 +185,9 @@ class ClemoryBackerMixin(PagedMemoryMixin):
 
 
 class ConcreteBackerMixin(ClemoryBackerMixin):
-    def _initialize_page(self, pageno, force_default=False, **kwargs):
+    def _initialize_page(self, pageno, permissions=None, *, force_default=False, **kwargs):
         if self._clemory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         addr = pageno * self.page_size
 
@@ -194,10 +195,10 @@ class ConcreteBackerMixin(ClemoryBackerMixin):
             backer_iter = self._clemory_backer.backers(addr)
             backer_start, backer = next(backer_iter)
         except StopIteration:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if backer_start >= addr + self.page_size:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         if self.state.project.concrete_target:
             l.debug("Fetching data from concrete target")
@@ -207,7 +208,7 @@ class ConcreteBackerMixin(ClemoryBackerMixin):
             )
         else:
             # the concrete backer only is here to support concrete loading, defer back to the CleMemoryBacker
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         permissions = self._cle_permissions_lookup(addr)
 
@@ -237,11 +238,11 @@ class DictBackerMixin(PagedMemoryMixin):
         o._dict_memory_backer = self._dict_memory_backer
         return o
 
-    def _initialize_page(self, pageno: int, force_default=False, **kwargs):
+    def _initialize_page(self, pageno: int, permissions=None, *, force_default=False, **kwargs):
         page_addr = pageno * self.page_size
 
         if self._dict_memory_backer is None or force_default:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         new_page = None
 
@@ -261,6 +262,6 @@ class DictBackerMixin(PagedMemoryMixin):
                 )
 
         if new_page is None:
-            return super()._initialize_page(pageno, **kwargs)
+            return super()._initialize_page(pageno, permissions=permissions, **kwargs)
 
         return new_page

angr/storage/memory_mixins/paged_memory/paged_memory_mixin.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 import cffi
-from typing import Any
+from typing import Any, Generic, Literal, overload
 from collections.abc import Iterable
 import logging
 from collections import defaultdict
 
 import claripy
 
+from angr.state_plugins.sim_action_object import SimActionObject
 from angr.storage.memory_mixins.memory_mixin import MemoryMixin
 from angr.storage.memory_mixins.paged_memory.pages import PageType, ListPage, UltraPage, MVListPage
 from angr.errors import SimMemoryError
@@ -17,14 +18,17 @@ ffi = cffi.FFI()
 l = logging.getLogger(__name__)
 
 
-class PagedMemoryMixin(MemoryMixin):
+class PagedMemoryMixin(
+    Generic[PageType],
+    MemoryMixin[int | claripy.ast.BV | SimActionObject, claripy.ast.BV, int | claripy.ast.BV | SimActionObject],
+):
     """
     A bottom-level storage mechanism. Dispatches reads to individual pages, the type of which is the PAGE_TYPE class
     variable.
     """
 
     SUPPORTS_CONCRETE_LOAD = True
-    PAGE_TYPE: type[PageType] = None  # must be provided in subclass
+    PAGE_TYPE: type[PageType]  # must be provided in subclass
 
     def __init__(self, page_size=0x1000, default_permissions=3, permissions_map=None, page_kwargs=None, **kwargs):
         super().__init__(**kwargs)
@@ -84,7 +88,7 @@ class PagedMemoryMixin(MemoryMixin):
         kwargs["allow_default"] = True
         return PagedMemoryMixin._initialize_page(self, pageno, permissions=permissions, **kwargs)
 
-    def _initialize_page(self, pageno: int, permissions=None, allow_default=True, **kwargs) -> PageType:
+    def _initialize_page(self, pageno: int, permissions=None, *, allow_default=True, **kwargs) -> PageType:
         if not allow_default:
             raise SimMemoryError("I have been instructed not to create a default page")
 
@@ -110,7 +114,7 @@ class PagedMemoryMixin(MemoryMixin):
     def _divide_addr(self, addr: int) -> tuple[int, int]:
         return divmod(addr, self.page_size)
 
-    def load(self, addr: int, size: int | None = None, endness=None, **kwargs):
+    def load(self, addr: int, size: int | None = None, *, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -164,7 +168,7 @@ class PagedMemoryMixin(MemoryMixin):
         l.debug("%s.load(%#x, %d, %s) = %s", self.id, addr, size, endness, out)
         return out
 
-    def store(self, addr: int, data, size: int | None = None, endness=None, **kwargs):
+    def store(self, addr: int, data, size: int | None = None, *, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -253,7 +257,7 @@ class PagedMemoryMixin(MemoryMixin):
             pageno = (pageno + 1) % max_pageno
             pageoff = 0
 
-    def merge(self, others: Iterable[PagedMemoryMixin], merge_conditions, common_ancestor=None) -> bool:
+    def merge(self, others, merge_conditions, common_ancestor=None):
         changed_pages_and_offsets: dict[int, set[int] | None] = {}
         for o in others:
             for changed_page, changed_offsets in self.changed_pages(o).items():
@@ -315,7 +319,7 @@ class PagedMemoryMixin(MemoryMixin):
         return True
 
     def permissions(self, addr, permissions=None, **kwargs):
-        if type(addr) is not int:
+        if not isinstance(addr, int):
             raise TypeError("addr must be an int in paged memory")
         pageno, _ = self._divide_addr(addr)
         try:
@@ -323,15 +327,15 @@ class PagedMemoryMixin(MemoryMixin):
         except SimMemoryError as e:
             raise SimMemoryError(f"{addr:#x} is not mapped") from e
 
-        if type(permissions) is int:
+        if isinstance(permissions, int):
             permissions = claripy.BVV(permissions, 3)
 
-        result = page.permissions
+        result = page.permission_bits
         if permissions is not None:
-            page.permissions = permissions
+            page.permission_bits = permissions
         return result
 
-    def map_region(self, addr, length, permissions, init_zero=False, **kwargs):
+    def map_region(self, addr, length, permissions, *, init_zero=False, **kwargs):
         if type(addr) is not int:
             raise TypeError("addr must be an int in paged memory")
         pageno, pageoff = self._divide_addr(addr)
@@ -399,6 +403,11 @@ class PagedMemoryMixin(MemoryMixin):
         else:
             return True
 
+    @overload
+    def _load_to_memoryview(self, addr, size, with_bitmap: Literal[True]) -> tuple[memoryview, memoryview]: ...
+    @overload
+    def _load_to_memoryview(self, addr, size, with_bitmap: Literal[False]) -> memoryview: ...
+
     def _load_to_memoryview(self, addr, size, with_bitmap):
         result = self.load(addr, size, endness="Iend_BE")
         if result.op == "BVV":
@@ -469,7 +478,7 @@ class PagedMemoryMixin(MemoryMixin):
             return memoryview(bytes(size)), memoryview(b"\x01" * size)
         return memoryview(b"")
 
-    def concrete_load(self, addr, size, writing=False, with_bitmap=False, **kwargs):
+    def concrete_load(self, addr, size, writing=False, *, with_bitmap: bool = False, **kwargs):
         pageno, offset = self._divide_addr(addr)
         subsize = min(size, self.page_size - offset)
         try:
@@ -481,9 +490,11 @@ class PagedMemoryMixin(MemoryMixin):
 
         if not page.SUPPORTS_CONCRETE_LOAD:
             # the page does not support concrete_load
-            return self._load_to_memoryview(addr, size, with_bitmap)
+            if with_bitmap:
+                return self._load_to_memoryview(addr, size, True)
+            return self._load_to_memoryview(addr, size, False)
 
-        data, bitmap = page.concrete_load(offset, subsize, **kwargs)
+        data, bitmap = page.concrete_load(offset, subsize, with_bitmap=True, **kwargs)
         if with_bitmap:
             return data, bitmap
 
@@ -513,7 +524,7 @@ class PagedMemoryMixin(MemoryMixin):
             except (SimMemoryError, AttributeError):
                 break
             else:
-                newdata, bitmap = concrete_load(offset, subsize, **kwargs)
+                newdata, bitmap = concrete_load(offset, subsize, with_bitmap=True, **kwargs)
                 for i, byte in enumerate(bitmap):
                     if byte != 0:
                         break

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

@@ -1,26 +1,32 @@
 from __future__ import annotations
-from typing import Any
+from abc import abstractmethod
+from typing import Generic, TypeVar
+from collections.abc import Generator
 
 import claripy
 
 from angr.storage.memory_object import SimMemoryObject, SimLabeledMemoryObject
 from .multi_values import MultiValues
 
+T = TypeVar("T")
 
-class CooperationBase:
+
+class CooperationBase(Generic[T]):
     """
     Any given subclass of this class which is not a subclass of MemoryMixin should have the property that any subclass
     it which *is* a subclass of MemoryMixin should all work with the same datatypes
     """
 
     @classmethod
-    def _compose_objects(cls, objects, size, endness, **kwargs):
+    @abstractmethod
+    def _compose_objects(cls, objects: list[list[tuple[int, T]]], size: str, endness: str, **kwargs) -> T:
         """
         Provide this a list of the result of several load calls, and it will compose them into a single result.
         """
 
     @classmethod
-    def _decompose_objects(cls, addr, data, endness, **kwargs) -> tuple[Any, int, int]:
+    @abstractmethod
+    def _decompose_objects(cls, addr, data, endness, **kwargs) -> Generator[tuple[T, int, int], int]:
         """
         A bidirectional generator. No idea if this is overengineered. Usage is that you send it a size to use
         and it yields a tuple of three elements: the object to store for the next n bytes, the base address of the
@@ -28,13 +34,14 @@ class CooperationBase:
         """
 
     @classmethod
-    def _zero_objects(cls, addr, size, **kwargs):
+    @abstractmethod
+    def _zero_objects(cls, addr, size, **kwargs) -> Generator[tuple[T, int, int], int]:
         """
         Like decompose objects, but with a size to zero-fill instead of explicit data
         """
 
     @classmethod
-    def _force_store_cooperation(cls, addr, data, size, endness, **kwargs):
+    def _force_store_cooperation(cls, addr: int, data: T, size: int, endness: str, **kwargs):
         if data is not None:
             sub_gen = cls._decompose_objects(addr, data, endness, **kwargs)
         else:
@@ -50,7 +57,7 @@ class CooperationBase:
         return cls._compose_objects([results], size, endness, **kwargs)
 
 
-class MemoryObjectMixin(CooperationBase):
+class MemoryObjectMixin(CooperationBase[SimMemoryObject]):
     """
     Uses SimMemoryObjects in region storage.
     With this, load will return a list of tuple (address, MO) and store will take a MO.
@@ -123,11 +130,12 @@ class MemoryObjectMixin(CooperationBase):
         else:
             memory_object = SimLabeledMemoryObject(data, cur_addr, endness, byte_width=byte_width, label=label)
 
+        next_elem_size_left = 0
+        next_elem_index = 0
         if data.symbolic and data.op == "Concat":
             next_elem_size_left = data.args[0].size() // 8
-            next_elem_index = 0
 
-        size = yield
+        size = yield NotImplemented, NotImplemented, NotImplemented
         max_size = kwargs.get("max_size", size)
         while True:
             if data.symbolic and data.op == "Concat" and data.size() > max_size:
@@ -235,6 +243,7 @@ class MemoryObjectSetMixin(CooperationBase):
             mv.add_value(start_offset, prev_value)
             prev_value = ...
 
+        assert next(mv.values(), None) is not None, "MultiValues may not be empty"
         return mv
 
     @classmethod

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

@@ -14,7 +14,7 @@ class ISPOMixin(MemoryMixin):
     def set_state(self, state):
         raise Exception("Cannot set state on this stateless object")
 
-    def _default_value(self, *args, memory=None, **kwargs):
+    def _default_value(self, *args, memory, **kwargs):
         try:
             func = memory._default_value
         except AttributeError as e:
@@ -22,7 +22,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _add_constraints(self, *args, memory=None, **kwargs):
+    def _add_constraints(self, *args, memory, **kwargs):
         try:
             func = memory._add_constraints
         except AttributeError as e:
@@ -30,7 +30,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _merge_values(self, *args, memory=None, **kwargs):
+    def _merge_values(self, *args, memory, **kwargs):
         try:
             func = memory._merge_values
         except AttributeError as ex:
@@ -38,7 +38,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _merge_labels(self, *args, memory=None, **kwargs):
+    def _merge_labels(self, *args, memory, **kwargs):
         try:
             func = memory._merge_labels
         except AttributeError as ex:
@@ -46,7 +46,7 @@ class ISPOMixin(MemoryMixin):
         else:
             return func(*args, **kwargs)
 
-    def _update_mappings(self, *args, memory=None, **kwargs):
+    def _update_mappings(self, *args, memory, **kwargs):
         try:
             func = memory._update_mappings
         except AttributeError as ex:

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)