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

angr/storage/memory_mixins/regioned_memory/region_data.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
 from sortedcontainers import SortedDict
 
+import claripy
+
 from ....errors import SimRegionMapError
 from ....state_plugins import SimStatePlugin
 
@@ -50,7 +53,7 @@ class AddressWrapper:
         :param state: A state
         :return: The converted ValueSet instance
         """
-        return state.solver.VS(state.arch.bits, self.region, self.region_base_addr, self.address)
+        return claripy.VS(state.arch.bits, self.region, self.region_base_addr, self.address)
 
 
 class RegionDescriptor:
@@ -70,9 +73,7 @@ class RegionDescriptor:
         self.related_function_address = related_function_address
 
     def __repr__(self):
-        return "<{} - {:#x}>".format(
-            self.region_id, self.related_function_address if self.related_function_address is not None else 0
-        )
+        return f"<{self.region_id} - {self.related_function_address if self.related_function_address is not None else 0:#x}>"
 
 
 class RegionMap:
@@ -197,7 +198,7 @@ class RegionMap:
             return relative_address
 
         if region_id not in self._region_id_to_address:
-            raise SimRegionMapError('Non-existent region ID "%s"' % region_id)
+            raise SimRegionMapError(f'Non-existent region ID "{region_id}"')
 
         base_address = self._region_id_to_address[region_id].base_address
         return base_address + relative_address
@@ -237,7 +238,7 @@ class RegionMap:
                 return "global", absolute_address, None
 
             if target_region_id not in self._region_id_to_address:
-                raise SimRegionMapError('Trying to relativize to a non-existent region "%s"' % target_region_id)
+                raise SimRegionMapError(f'Trying to relativize to a non-existent region "{target_region_id}"')
 
             descriptor = self._region_id_to_address[target_region_id]
             base_address = descriptor.base_address

angr/storage/memory_mixins/regioned_memory/region_meta_mixin.py

@@ -1,11 +1,132 @@
+from __future__ import annotations
 import copy
 from typing import Any
 
-from claripy.vsa import AbstractLocation
-
 from .. import MemoryMixin
 
 
+class Segment:
+    """Segment represents a continuous memory region."""
+
+    def __init__(self, offset, size=0):
+        self.offset = offset
+        self.size = size
+
+    def __repr__(self):
+        return "Seg (%s [ %d ])" % (hex(self.offset), self.size)
+
+
+class AbstractLocation:
+    """AbstractLocation represents a location in memory."""
+
+    def __init__(self, bbl_key, stmt_id, region_id, segment_list=None, region_offset=None, size=None):
+        self._bbl_key = -1 if bbl_key is None else bbl_key
+        self._stmt_id = -1 if stmt_id is None else stmt_id
+        self._region_id = region_id
+        self._segment_list = [] if not segment_list else segment_list[::]
+
+        if region_offset and size:
+            self._add_segment(region_offset, size)
+
+    def _add_segment(self, offset, size):
+        segment_added = False
+
+        last_pos = 0
+        segment_end = offset + size
+
+        for i, s in enumerate(self._segment_list):
+            # Case 1
+            s_end = s.offset + s.size
+
+            if offset >= s.offset and segment_end <= s_end:
+                # It has been covered
+                return False
+
+            if offset - 1 <= s.offset <= offset + 1:
+                s.offset = min(s.offset, offset)
+                s.size = max(s_end, segment_end) - s.offset
+                segment_added = True
+                break
+
+            # Case 2
+            if segment_end - 1 <= s_end <= segment_end + 1:
+                s.offset = min(s.offset, offset)
+                s.size = max(s_end, segment_end) - s.offset
+                segment_added = True
+                break
+
+            if s.offset < offset:
+                last_pos = i + 1
+
+        if not segment_added:
+            # We create a new segment and add it to the list
+            s = Segment(offset, size)
+            self._segment_list.insert(last_pos, s)
+
+        # Check for possible merges
+        i = 0
+        while i < len(self._segment_list) - 1:
+            s = self._segment_list[i]
+            t = self._segment_list[i + 1]
+
+            if s.offset + s.size >= t.offset:
+                # They should be merged!
+                new_s = Segment(s.offset, max(s.offset + s.size, t.offset + t.size) - s.offset)
+                self._segment_list[i : i + 2] = [new_s]
+
+            else:
+                i += 1
+
+        return True
+
+    @property
+    def basicblock_key(self):
+        return self._bbl_key
+
+    @property
+    def statement_id(self):
+        return self._stmt_id
+
+    @property
+    def region(self):
+        return self._region_id
+
+    @property
+    def segments(self):
+        return self._segment_list
+
+    def update(self, region_offset, size):
+        return self._add_segment(region_offset, size)
+
+    def copy(self):
+        return AbstractLocation(self._bbl_key, self._stmt_id, self._region_id, self._segment_list)
+
+    def merge(self, other):
+        merged = False
+
+        for s in other._segment_list:
+            merged |= self.update(s.offset, s.size)
+
+        return merged
+
+    def __contains__(self, offset):
+        for s in self._segment_list:
+            if s.offset <= offset < s.offset + s.size:
+                return True
+
+            if s.offset > offset:
+                break
+
+        return False
+
+    def __repr__(self):
+        return "(%xh, %d) %s" % (
+            (self.basicblock_key if self.basicblock_key is not None else -1),
+            (self.statement_id if self.statement_id is not None else -1),
+            self._segment_list,
+        )
+
+
 class MemoryRegionMetaMixin(MemoryMixin):
     __slots__ = (
         "_endness",
@@ -27,7 +148,7 @@ class MemoryRegionMetaMixin(MemoryMixin):
 
     @MemoryMixin.memo
     def copy(self, memo):
-        r: "MemoryRegionMetaMixin" = super().copy(memo)
+        r: MemoryRegionMetaMixin = super().copy(memo)
         r.alocs = copy.deepcopy(self.alocs)
         r._related_function_addr = self._related_function_addr
         r._is_stack = self._is_stack
@@ -67,22 +188,17 @@ class MemoryRegionMetaMixin(MemoryMixin):
         return ret
 
     def store(self, addr, data, bbl_addr=None, stmt_id=None, ins_addr=None, endness=None, **kwargs):
-        if ins_addr is not None:
-            aloc_id = ins_addr
-        else:
-            # It comes from a SimProcedure. We'll use bbl_addr as the aloc_id
-            aloc_id = bbl_addr
+        # 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
 
         if aloc_id not in self.alocs:
-            self.alocs[aloc_id] = self.state.solver.AbstractLocation(
+            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)
-        else:
-            if self.alocs[aloc_id].update(addr, len(data) // self.state.arch.byte_width):
-                return super().store(addr, data, endness=endness, **kwargs)
-            else:
-                return super().store(addr, data, 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)
 
     def load(
         self, addr, size=None, bbl_addr=None, stmt_idx=None, ins_addr=None, **kwargs

angr/storage/memory_mixins/regioned_memory/regioned_address_concretization_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections.abc import Generator
 
 import claripy
@@ -96,7 +97,7 @@ class RegionedAddressConcretizationMixin(MemoryMixin):
         original_addr: claripy.ast.Bits,
         is_write: bool = False,
         target_region: str | None = None,
-    ) -> Generator[AddressWrapper, None, None]:
+    ) -> Generator[AddressWrapper]:
         strategies = self.write_strategies if is_write else self.read_strategies
         targets_limit = self._write_targets_limit if is_write else self._read_targets_limit
 

angr/storage/memory_mixins/regioned_memory/regioned_memory_mixin.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
 import logging
 from itertools import count
 from typing import Optional, TYPE_CHECKING
 from collections.abc import Generator, Iterable
 
 import claripy
+from claripy.annotation import RegionAnnotation
 from claripy.ast import Bool, Bits, BV
-from claripy.vsa import StridedInterval, ValueSet, RegionAnnotation
 
 from ....sim_options import (
     AVOID_MULTIVALUED_READS,
@@ -49,7 +50,7 @@ class RegionedMemoryMixin(MemoryMixin):
         stack_region_map: RegionMap | None = None,
         generic_region_map: RegionMap | None = None,
         stack_size: int = 65536,
-        cle_memory_backer: Optional = None,
+        cle_memory_backer: Optional | None = None,
         dict_memory_backer: dict | None = None,
         regioned_memory_cls: type | None = None,
         **kwargs,
@@ -58,7 +59,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
         if regioned_memory_cls is None:
             # delayed import
-            from .. import RegionedMemory
+            from .. import RegionedMemory  # pylint:disable=import-outside-toplevel
 
             regioned_memory_cls = RegionedMemory
 
@@ -78,7 +79,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
     @MemoryMixin.memo
     def copy(self, memo):
-        o: "RegionedMemoryMixin" = super().copy(memo)
+        o: RegionedMemoryMixin = 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,12 +92,12 @@ class RegionedMemoryMixin(MemoryMixin):
 
         o._regions = {}
         for region_id, region in self._regions.items():
-            o._regions[region_id] = region.copy(memo)
+            o._regions[region_id] = region.copy(memo)  # pylint:disable=no-member
 
         return o
 
     def load(self, addr, size: BV | int | None = None, endness=None, condition: Bool | None = None, **kwargs):
-        if isinstance(size, BV) and isinstance(claripy.backends.vsa.convert(size), ValueSet):
+        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:
                 var_name = "invalid_read_%d_%#x" % (next(invalid_read_ctr), self.state.scratch.ins_addr)
@@ -112,8 +113,7 @@ class RegionedMemoryMixin(MemoryMixin):
             regioned_addrs_desc.cardinality >= self._read_targets_limit
             and CONSERVATIVE_READ_STRATEGY in self.state.options
         ):
-            val = self.state.solver.Unconstrained("unconstrained_read", size * self.state.arch.byte_width)
-            return val
+            return self.state.solver.Unconstrained("unconstrained_read", size * self.state.arch.byte_width)
 
         gen = self._concretize_address_descriptor(regioned_addrs_desc, addr, is_write=False)
         for aw in gen:
@@ -143,7 +143,7 @@ class RegionedMemoryMixin(MemoryMixin):
 
         return val
 
-    def store(self, addr, data, size: int | None = None, endness=None, **kwargs):
+    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
@@ -155,7 +155,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: Iterable[RegionedMemoryMixin], merge_conditions, common_ancestor=None) -> bool:
         r = False
         for o in others:
             for region_id, region in o._regions.items():
@@ -172,12 +172,12 @@ class RegionedMemoryMixin(MemoryMixin):
         gen = self._normalize_address_type(addr, self.state.arch.bits)
 
         for region, si in gen:
-            si = claripy.SI(to_conv=si)
             r, s, i = self._regions[region].find(si, data, max_search, **kwargs)
             # Post-process r so that it's still a ValueSet
             region_base_addr = self._region_base(region)
-            r = self.state.solver.ValueSet(r.size(), region, region_base_addr, claripy.backends.vsa.convert(r))
+            r = claripy.ValueSet(r.size(), region, region_base_addr, r)
             return r, s, i
+        return None
 
     def set_state(self, state):
         for region in self._regions.values():
@@ -229,18 +229,17 @@ class RegionedMemoryMixin(MemoryMixin):
         :param function_address: Address of the function.
         :return:                ID of the new memory region.
         """
-        region_id = "stack_%#x" % function_address
+        region_id = f"stack_{function_address:#x}"
 
         # deduplication
         region_ids = self._stack_region_map.region_ids
         if region_id not in region_ids:
             return region_id
-        else:
-            for i in range(0, 2000):
-                new_region_id = region_id + "_%d" % i
-                if new_region_id not in region_ids:
-                    return new_region_id
-            raise SimMemoryError("Cannot allocate region ID for function %#08x - recursion too deep" % function_address)
+        for i in range(2000):
+            new_region_id = region_id + "_%d" % i
+            if new_region_id not in region_ids:
+                return new_region_id
+        raise SimMemoryError(f"Cannot allocate region ID for function {function_address:#08x} - recursion too deep")
 
     def set_stack_size(self, size: int):
         self._stack_size = size
@@ -248,10 +247,10 @@ class RegionedMemoryMixin(MemoryMixin):
     def _create_region(
         self,
         key: str,
-        state: "SimState",
+        state: SimState,
         related_function_addr: int,
         endness,
-        cle_memory_backer: Optional = None,
+        cle_memory_backer: Optional | None = None,
         dict_memory_backer: dict | None = None,
     ):
         """
@@ -349,8 +348,8 @@ class RegionedMemoryMixin(MemoryMixin):
         original_addr: claripy.ast.Bits,
         is_write: bool = False,
         target_region: str | None = None,
-    ) -> Generator[AddressWrapper, None, None]:
-        raise NotImplementedError()
+    ) -> Generator[AddressWrapper]:
+        raise NotImplementedError
 
     def _normalize_address(self, addr: claripy.ast.Bits, condition=None) -> AbstractAddressDescriptor:
         """
@@ -417,21 +416,21 @@ class RegionedMemoryMixin(MemoryMixin):
                 new_region_id, self._region_base(new_region_id), new_relative_address, True, related_function_addr
             )
 
-        else:
-            new_region_id, new_relative_address, related_function_addr = self._generic_region_map.relativize(
-                absolute_address, target_region_id=target_region
-            )
+        new_region_id, new_relative_address, related_function_addr = self._generic_region_map.relativize(
+            absolute_address, target_region_id=target_region
+        )
 
-            return AddressWrapper(new_region_id, self._region_base(new_region_id), new_relative_address, False, None)
+        return AddressWrapper(new_region_id, self._region_base(new_region_id), new_relative_address, False, None)
 
-    def _apply_condition_to_symbolic_addr(self, addr, condition):
-        _, converted = self.state.solver.constraint_to_si(condition)
+    @staticmethod
+    def _apply_condition_to_symbolic_addr(addr, condition):
+        _, converted = claripy.constraint_to_si(condition)
         for original_expr, constrained_expr in converted:
             addr = addr.replace(original_expr, constrained_expr)
         return addr
 
     @staticmethod
-    def _normalize_address_type(addr: int | Bits, bits) -> Generator[tuple[str, StridedInterval], None, None]:
+    def _normalize_address_type(addr: int | Bits, bits) -> Generator[tuple[str, claripy.BV]]:
         """
         Convert address of different types to a list of mapping between region IDs and offsets (strided intervals).
 
@@ -440,23 +439,15 @@ class RegionedMemoryMixin(MemoryMixin):
         :rtype: dict
         """
 
-        if isinstance(addr, int):
-            addr_e = claripy.BVV(addr, bits)
-        else:
-            addr_e = _raw_ast(addr)
-
-        if isinstance(addr_e, (claripy.bv.BVV, claripy.vsa.StridedInterval, claripy.vsa.ValueSet)):
-            raise SimMemoryError("_normalize_address_type() does not take claripy models.")
+        addr_e = claripy.BVV(addr, bits) if isinstance(addr, int) else _raw_ast(addr)
 
         if isinstance(addr_e, claripy.ast.Base):
-            if not isinstance(claripy.backends.vsa.convert(addr_e), ValueSet):
-                # Convert it to a ValueSet first by annotating it
-                addr_e = addr_e.annotate(RegionAnnotation("global", 0, claripy.backends.vsa.convert(addr_e)))
-
-            model_vsa = claripy.backends.vsa.convert(addr_e)
-            if isinstance(model_vsa, ValueSet):
-                yield from model_vsa.items()
+            if region_annotations := addr_e.get_annotations_by_type(RegionAnnotation):
+                region_id = region_annotations[0].region_id
             else:
-                raise SimAbstractMemoryError("Cannot parse address as a VSA ValueSet")
+                region_id = "global"
+
+            yield region_id, addr_e
+
         else:
-            raise SimAbstractMemoryError("Unsupported address type %s" % type(addr_e))
+            raise SimAbstractMemoryError(f"Unsupported address type {type(addr_e)}")

angr/storage/memory_mixins/regioned_memory/static_find_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from ..smart_find_mixin import SmartFindMixin
@@ -39,7 +40,7 @@ class StaticFindMixin(SmartFindMixin):  # pylint:disable=abstract-method
                 addr, char_num, char_size, chunk_size, max_search, endness, condition, max_symbolic_bytes, **kwargs
             )
         ):
-            comparison, concrete_comparison = self._find_compare(element, data, **kwargs)
+            comparison, concrete_comparison = self._find_compare(element, data)
 
             if comparison:
                 match_indices.append(i)
@@ -52,19 +53,16 @@ class StaticFindMixin(SmartFindMixin):  # pylint:disable=abstract-method
             r_union = r_union.union(addr + index)
         return r_union, [], match_indices
 
-    def _find_compare(self, element, target, **kwargs):
-        elem_si = claripy.backends.vsa.convert(element)
-        target_si = claripy.backends.vsa.convert(target)
-
+    def _find_compare(self, element, target):
         comparison, concrete_comparison = False, False
 
         # we only support strided intervals
-        if isinstance(elem_si, claripy.vsa.StridedInterval):
-            comparison = not elem_si.intersection(target_si).is_empty
-            concrete_comparison = elem_si.identical(target_si)
+        if not element.has_annotation_type(claripy.annotation.RegionAnnotation):
+            comparison = not claripy.simplify(element.intersection(target)).identical(claripy.ESI(element.length))
+            concrete_comparison = element.identical(target)
 
         return comparison, concrete_comparison
 
     def _find_are_bytes_symbolic(self, b):
         # we only support strided intervals
-        return not isinstance(claripy.backends.vsa.convert(b), claripy.vsa.StridedInterval)
+        return b.has_annotation_type(claripy.annotation.RegionAnnotation)

angr/storage/memory_mixins/simple_interface_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from . import MemoryMixin
@@ -36,13 +37,12 @@ class SimpleInterfaceMixin(MemoryMixin):
 
     def _translate_data(self, d, size):
         if type(d) in (bytes, bytearray):
-            return self.state.solver.BVV(d)
-        elif type(d) is int:
-            return self.state.solver.BVV(d, size * self.state.arch.byte_width)
-        elif isinstance(d, claripy.ast.Base):
+            return claripy.BVV(d)
+        if type(d) is int:
+            return claripy.BVV(d, size * self.state.arch.byte_width)
+        if isinstance(d, claripy.ast.Base):
             return d
-        else:
-            raise SimMemoryError("data not supported")
+        raise SimMemoryError("data not supported")
 
     def _translate_size(self, s, data):
         if isinstance(s, int):
@@ -52,10 +52,9 @@ class SimpleInterfaceMixin(MemoryMixin):
         if s is None:
             if isinstance(data, claripy.ast.BV):
                 return len(data) // self.state.arch.byte_width
-            elif isinstance(data, (bytes, bytearray)):
+            if isinstance(data, (bytes, bytearray)):
                 return len(data)
-            else:
-                raise SimMemoryError("unknown size")
+            raise SimMemoryError("unknown size")
         return self.state.solver.eval(s)
 
     def _translate_cond(self, c):
@@ -63,11 +62,9 @@ class SimpleInterfaceMixin(MemoryMixin):
             raise SimMemoryError("condition not supported")
         if c is None:
             return True
-        else:
-            return self.state.solver.eval_upto(c, 1)[0]
+        return self.state.solver.eval_upto(c, 1)[0]
 
     def _translate_endness(self, endness):
         if endness is None:
             return self.endness
-        else:
-            return endness
+        return endness

angr/storage/memory_mixins/simplification_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from . import MemoryMixin
 from ... import sim_options as options
 

angr/storage/memory_mixins/size_resolution_mixin.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
 import logging
 
+import claripy
+
 from . import MemoryMixin
 from ...errors import SimMemoryLimitError, SimMemoryError, SimUnsatError
 
@@ -18,7 +21,7 @@ class SizeNormalizationMixin(MemoryMixin):
     def load(self, addr, size=None, **kwargs):
         if size is None:
             raise TypeError("Must provide size to load")
-        elif type(size) is int:
+        if type(size) is int:
             out_size = size
         elif getattr(size, "op", None) == "BVV":
             out_size = size.args[0]
@@ -110,9 +113,9 @@ class SizeConcretizationMixin(MemoryMixin):
                 conc_sizes = list(
                     self.state.solver.eval_upto(size, self._max_concretize_count, extra_constraints=(size <= max_size,))
                 )
-        except SimUnsatError:
+        except SimUnsatError as err:
             # size has to be greater than max_size
-            raise SimMemoryError("Not enough data for store")
+            raise SimMemoryError("Not enough data for store") from err
 
         # filter out all concrete sizes that are greater than max_size
         # Note that the VSA solver (used in static mode) cannot precisely handle extra constraints. As a result, we may
@@ -133,7 +136,7 @@ class SizeConcretizationMixin(MemoryMixin):
             conc_sizes = [min(cs, self._max_symbolic_size) for cs in conc_sizes]
 
         if condition is None:
-            condition = self.state.solver.true
+            condition = claripy.true
         for conc_size in conc_sizes:
             if conc_size == 0:
                 continue

angr/storage/memory_mixins/slotted_memory.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from . import MemoryMixin
@@ -38,7 +39,7 @@ class SlottedMemoryMixin(MemoryMixin):
                 addr,
                 0,
                 self.width,
-                self.state.solver.ite_cases(
+                claripy.ite_cases(
                     zip(merge_conditions[1:], (o._single_load(addr, 0, self.width) for o in others)),
                     self._single_load(addr, 0, self.width),
                 ),
@@ -80,13 +81,12 @@ 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, (*self.variable_key_prefix, addr), **kwargs)
             self.contents[addr] = d
 
         if offset == 0 and size == self.width:
             return d
-        else:
-            return d.get_bytes(offset, size)
+        return d.get_bytes(offset, size)
 
     def _single_store(self, addr, offset, size, data):
         """

angr/storage/memory_mixins/smart_find_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from . import MemoryMixin
@@ -98,7 +99,7 @@ class SmartFindMixin(MemoryMixin):
         able to handle wide characters
         """
         if condition is None:
-            condition = self.state.solver.true
+            condition = claripy.true
         chunk = None
         chunk_progress = chunk_size
 
@@ -155,5 +156,5 @@ class SmartFindMixin(MemoryMixin):
             default = claripy.BVV(0, self.state.arch.bits)
         if cases and cases[-1][0].is_true():
             default = cases.pop(-1)[1]
-        result = self.state.solver.ite_cases(cases, default)
+        result = claripy.ite_cases(cases, default)
         return result, constraints, match_indices

angr/storage/memory_mixins/symbolic_merger_mixin.py

@@ -1,12 +1,15 @@
-from typing import Any
+from __future__ import annotations
 from collections.abc import Iterable
+from typing import Any
+
+import claripy
 
 from . import MemoryMixin
 
 
 class SymbolicMergerMixin(MemoryMixin):
     def _merge_values(self, values: Iterable[tuple[Any, Any]], merged_size: int, **kwargs):
-        merged_val = self.state.solver.BVV(0, merged_size * self.state.arch.byte_width)
+        merged_val = claripy.BVV(0, merged_size * self.state.arch.byte_width)
         for tm, fv in values:
-            merged_val = self.state.solver.If(fv, tm, merged_val)
+            merged_val = claripy.If(fv, tm, merged_val)
         return merged_val

angr/storage/memory_mixins/top_merger_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 from collections.abc import Iterable, Callable
 
@@ -15,8 +16,7 @@ class TopMergerMixin(MemoryMixin):
         super().__init__(*args, **kwargs)
 
     def _merge_values(self, values: Iterable[tuple[Any, Any]], merged_size: int, **kwargs):
-        merged_val = self._top_func(merged_size * self.state.arch.byte_width)
-        return merged_val
+        return self._top_func(merged_size * self.state.arch.byte_width)
 
     def copy(self, memo=None):
         copied = super().copy(memo)