angr 9.2.117__py3-none-macosx_11_0_arm64.whl → 9.2.119__py3-none-macosx_11_0_arm64.whl

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,
@@ -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 = claripy.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,12 +416,11 @@ 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)
 
     @staticmethod
     def _apply_condition_to_symbolic_addr(addr, condition):
@@ -432,7 +430,7 @@ class RegionedMemoryMixin(MemoryMixin):
         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).
 
@@ -441,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
@@ -37,12 +38,11 @@ class SimpleInterfaceMixin(MemoryMixin):
     def _translate_data(self, d, size):
         if type(d) in (bytes, bytearray):
             return claripy.BVV(d)
-        elif type(d) is int:
+        if type(d) is int:
             return claripy.BVV(d, size * self.state.arch.byte_width)
-        elif isinstance(d, claripy.ast.Base):
+        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,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 import claripy
@@ -20,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]
@@ -112,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
@@ -135,7 +136,7 @@ class SizeConcretizationMixin(MemoryMixin):
             conc_sizes = [min(cs, self._max_symbolic_size) for cs in conc_sizes]
 
         if condition is None:
-            condition = claripy.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
@@ -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 = claripy.true
+            condition = claripy.true()
         chunk = None
         chunk_progress = chunk_size
 
@@ -138,7 +139,7 @@ class SmartFindMixin(MemoryMixin):
 
     def _find_condition(self, target_addr):  # pylint:disable=unused-argument,no-self-use
         # TODO: fill this in in order to make each load have the correct condition associated with it
-        return claripy.true
+        return claripy.true()
 
     def _find_compare(self, element, target):
         comparison = element == target

angr/storage/memory_mixins/symbolic_merger_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections.abc import Iterable
 from typing import Any
 

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)

angr/storage/memory_mixins/underconstrained_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 import logging
 
@@ -36,7 +37,7 @@ class UnderconstrainedMixin(MemoryMixin):
                 uc_alloc_depth = 0
 
             if name is None:
-                name = "mem_%x" % addr
+                name = f"mem_{addr:x}"
 
             bits = size * self.state.arch.byte_width
             return self.state.solver.Unconstrained(
@@ -50,18 +51,15 @@ class UnderconstrainedMixin(MemoryMixin):
             o.UNDER_CONSTRAINED_SYMEXEC in self.state.options
             and isinstance(addr, claripy.ast.Base)
             and addr.uninitialized
-            and addr.uc_alloc_depth is not None
+            and self.state.uc_manager.get_alloc_depth(addr) is not None
+        ) and (
+            not self.state.uc_manager.is_bounded(addr)
+            or self.state.solver.max_int(addr) - self.state.solver.min_int(addr) >= self._unconstrained_range
         ):
-            if (
-                not self.state.uc_manager.is_bounded(addr)
-                or self.state.solver.max_int(addr) - self.state.solver.min_int(addr) >= self._unconstrained_range
-            ):
-                # in under-constrained symbolic execution, we'll assign a new memory region for this address
-                mem_region = self.state.uc_manager.assign(addr)
+            # in under-constrained symbolic execution, we'll assign a new memory region for this address
+            mem_region = self.state.uc_manager.assign(addr)
 
-                # ... but only if it's not already been constrained to something!
-                if self.state.solver.solution(addr, mem_region):
-                    self.state.add_constraints(addr == mem_region)
-                l.debug(
-                    "Under-constrained symbolic execution: assigned a new memory region @ %s to %s", mem_region, addr
-                )
+            # ... but only if it's not already been constrained to something!
+            if self.state.solver.solution(addr, mem_region):
+                self.state.add_constraints(addr == mem_region)
+            l.debug("Under-constrained symbolic execution: assigned a new memory region @ %s to %s", mem_region, addr)

angr/storage/memory_mixins/unwrapper_mixin.py

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

angr/storage/memory_object.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from ..errors import SimMemoryError
@@ -10,6 +11,7 @@ def obj_bit_size(o):
 
 
 # TODO: get rid of is_bytes and have the bytes-backed objects be a separate class
+# pylint: disable=too-many-positional-arguments
 
 
 class SimMemoryObject:
@@ -55,10 +57,6 @@ class SimMemoryObject:
     def variables(self):
         return self.object.variables
 
-    @property
-    def cache_key(self):
-        return self.object.cache_key
-
     @property
     def symbolic(self):
         return self.object.symbolic
@@ -68,9 +66,13 @@ class SimMemoryObject:
         return self.base + self.length - 1
 
     def concrete_bytes(self, offset: int, size: int) -> bytes | None:
-        if self._concrete_bytes is None:
-            if isinstance(self.object, claripy.ast.Bits) and self.object.op == "BVV" and not self.object.annotations:
-                self._concrete_bytes = self.object.concrete_value.to_bytes(len(self.object) // self._byte_width, "big")
+        if (
+            self._concrete_bytes is None
+            and isinstance(self.object, claripy.ast.Bits)
+            and self.object.op == "BVV"
+            and not self.object.annotations
+        ):
+            self._concrete_bytes = self.object.concrete_value.to_bytes(len(self.object) // self._byte_width, "big")
 
         if self._concrete_bytes is None:
             return None
@@ -83,7 +85,7 @@ class SimMemoryObject:
     def bytes_at(self, addr, length, allow_concrete=False, endness="Iend_BE"):
         rev = endness != self.endness
         if allow_concrete and rev:
-            raise Exception("allow_concrete must be used with the stored endness")
+            raise ValueError("allow_concrete must be used with the stored endness")
 
         if self.is_bytes:
             if addr == self.base and length == self.length:
@@ -95,25 +97,24 @@ class SimMemoryObject:
 
             return o if allow_concrete else claripy.BVV(o)
 
-        else:
-            offset = addr - self.base
-            try:
-                thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
-            except claripy.ClaripyOperationError:
-                # hacks to handle address space wrapping
-                if offset >= 0:
-                    raise
-                if offset + 2**32 >= 0:
-                    offset += 2**32
-                elif offset + 2**64 >= 0:
-                    offset += 2**64
-                else:
-                    raise
-                thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
-
-            if self.endness != endness:
-                thing = thing.reversed
-            return thing
+        offset = addr - self.base
+        try:
+            thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
+        except claripy.ClaripyOperationError:
+            # hacks to handle address space wrapping
+            if offset >= 0:
+                raise
+            if offset + 2**32 >= 0:
+                offset += 2**32
+            elif offset + 2**64 >= 0:
+                offset += 2**64
+            else:
+                raise
+            thing = bv_slice(self.object, offset, length, self.endness == "Iend_LE", self._byte_width)
+
+        if self.endness != endness:
+            thing = thing.reversed
+        return thing
 
     def _object_equals(self, other):
         if self.is_bytes != other.is_bytes:
@@ -121,17 +122,15 @@ class SimMemoryObject:
 
         if self.is_bytes:
             return self.object == other.object
-        else:
-            return self.object.cache_key == other.object.cache_key
+        return self.object.hash() == other.object.hash()
 
     def _length_equals(self, other):
-        if type(self.length) is not type(other.length):  # noqa: E721
+        if type(self.length) is not type(other.length):
             return False
 
         if isinstance(self.length, int):
             return self.length == other.length
-        else:
-            return self.length.cache_key == other.length.cache_key
+        return self.length.hash() == other.length.hash()
 
     def __eq__(self, other):
         if self is other:
@@ -143,17 +142,18 @@ class SimMemoryObject:
         return self.base == other.base and self._object_equals(other) and self._length_equals(other)
 
     def __hash__(self):
-        obj_hash = hash(self.object) if self.is_bytes else self.object.cache_key
-        return hash((obj_hash, self.base, hash(self.length)))
+        return hash((self.object, self.base, self.length))
 
     def __ne__(self, other):
         return not self == other
 
     def __repr__(self):
-        return "MO(%s)" % self.object
+        return f"MO({self.object})"
 
 
 class SimLabeledMemoryObject(SimMemoryObject):
+    """SimLabeledMemoryObject is a SimMemoryObject with a label"""
+
     __slots__ = ("label",)
 
     def __init__(self, obj, base, endness, length=None, byte_width=8, label=None):

angr/storage/pcap.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import socket
 import logging
 
@@ -19,8 +20,8 @@ class PCAP:
             self.initialize(self.path)
 
     def initialize(self, path):
-        f = open(path)
-        pcap = dpkt.pcap.Reader(f)
+        with open(path) as f:
+            pcap = dpkt.pcap.Reader(f)
         for _, buf in pcap:
             ip = dpkt.ethernet.Ethernet(buf).ip
             tcp = ip.data
@@ -29,7 +30,6 @@ class PCAP:
                 self.out_streams.append((len(tcp.data), tcp.data))
             elif len(tcp.data) != 0:
                 self.in_streams.append((len(tcp.data), tcp.data))
-        f.close()
 
     def recv(self, length):
         temp = 0

angr/tablespecs.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 

angr/utils/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from .timing import timethis
 from . import graph
 from . import constants

angr/utils/ail.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from ailment import AILBlockWalkerBase
+from ailment.block import Block
+from ailment.expression import Expression, VirtualVariable, Phi
+from ailment.statement import Assignment, Statement
+
+
+def is_phi_assignment(stmt: Statement) -> bool:
+    return isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable) and isinstance(stmt.src, Phi)
+
+
+class HasExprWalker(AILBlockWalkerBase):
+    """
+    Test if any expressions in exprs_to_check is used in another AIL expression.
+    """
+
+    def __init__(self, exprs_to_check: set[Expression]) -> None:
+        super().__init__()
+
+        self.exprs_to_check: set[Expression] = exprs_to_check
+        self.contains_exprs: bool = False
+
+    def _handle_expr(
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
+    ) -> None:
+        if expr in self.exprs_to_check:
+            self.contains_exprs = True
+        if not self.contains_exprs:
+            super()._handle_expr(expr_idx, expr, stmt_idx, stmt, block)

angr/utils/algo.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 from collections.abc import Callable
 

angr/utils/bits.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+
+def truncate_bits(value: int, nbits: int) -> int:
+    """
+    Truncate `value` to `nbits`.
+
+    For example: truncate_bits(0x1234, 8) -> 0x34
+    """
+    if nbits < 0:
+        raise ValueError("nbits must not be negative")
+    return value & (2**nbits - 1)

angr/utils/constants.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 DEFAULT_STATEMENT = -2
 SWITCH_MISSING_DEFAULT_NODE_ADDR = 0xFFFF_FFFE
 MAX_POINTSTO_BITS = -1330 * 8