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

angr/storage/memory_mixins/paged_memory/page_backer_mixins.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from mmap import mmap
 from typing import Union
 from collections.abc import Generator
@@ -93,9 +94,9 @@ class ClemoryBackerMixin(PagedMemoryMixin):
         # initialize the page
         if isinstance(backer, (bytes, bytearray, mmap)):
             return self._data_from_bytes_backer(addr, backer, backer_start, backer_iter)
-        elif isinstance(backer, list):
+        if isinstance(backer, list):
             return self._data_from_lists_backer(addr, backer, backer_start, backer_iter)
-        raise TypeError("Unsupported backer type %s." % type(backer))
+        raise TypeError(f"Unsupported backer type {type(backer)}.")
 
     def _calc_page_starts(self, addr: int, backer_start: int, backer_length: int) -> tuple[int, int, int]:
         # lord help me. why do I keep having to write code that looks like this
@@ -118,7 +119,7 @@ class ClemoryBackerMixin(PagedMemoryMixin):
         addr: int,
         backer: bytes | bytearray,
         backer_start: int,
-        backer_iter: Generator[tuple[int, bytes | bytearray], None, None],
+        backer_iter: Generator[tuple[int, bytes | bytearray]],
     ) -> claripy.ast.BV:
         if backer_start <= addr and backer_start + len(backer) >= addr + self.page_size:
             # fast case
@@ -145,7 +146,7 @@ class ClemoryBackerMixin(PagedMemoryMixin):
         return data
 
     def _data_from_lists_backer(
-        self, addr: int, backer: list[int], backer_start: int, backer_iter: Generator[tuple[int, list[int]], None, None]
+        self, addr: int, backer: list[int], backer_start: int, backer_iter: Generator[tuple[int, list[int]]]
     ) -> claripy.ast.BV:
         page_data = [0] * self.page_size
         while backer_start < addr + self.page_size:
@@ -161,8 +162,7 @@ class ClemoryBackerMixin(PagedMemoryMixin):
             except StopIteration:
                 break
 
-        data = claripy.Concat(*map(lambda v: claripy.BVV(v, self.state.arch.byte_width), page_data))
-        return data
+        return claripy.Concat(*(claripy.BVV(v, self.state.arch.byte_width) for v in page_data))
 
     def _cle_permissions_lookup(self, addr):
         if self._cle_loader is None:

angr/storage/memory_mixins/paged_memory/paged_memory_mixin.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import cffi
 from typing import Any
 from collections.abc import Iterable
@@ -109,7 +110,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, endness=None, **kwargs):
+    def load(self, addr: int, size: int | None = None, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -163,7 +164,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, endness=None, **kwargs):
+    def store(self, addr: int, data, size: int | None = None, endness=None, **kwargs):
         if endness is None:
             endness = self.endness
 
@@ -252,7 +253,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: Iterable[PagedMemoryMixin], merge_conditions, common_ancestor=None) -> bool:
         changed_pages_and_offsets: dict[int, set[int] | None] = {}
         for o in others:
             for changed_page, changed_offsets in self.changed_pages(o).items():
@@ -295,7 +296,7 @@ class PagedMemoryMixin(MemoryMixin):
 
         return bool(merged_bytes)
 
-    def compare(self, other: "PagedMemoryMixin") -> bool:
+    def compare(self, other: PagedMemoryMixin) -> bool:
         changed_pages_and_offsets: dict[int, set[int] | None] = dict(self.changed_pages(other))
 
         for page_no in sorted(changed_pages_and_offsets):
@@ -320,7 +321,7 @@ class PagedMemoryMixin(MemoryMixin):
         try:
             page = self._get_page(pageno, permissions is not None, allow_default=False, **kwargs)
         except SimMemoryError as e:
-            raise SimMemoryError("%#x is not mapped" % addr) from e
+            raise SimMemoryError(f"{addr:#x} is not mapped") from e
 
         if type(permissions) is int:
             permissions = claripy.BVV(permissions, 3)
@@ -403,9 +404,8 @@ class PagedMemoryMixin(MemoryMixin):
         if result.op == "BVV":
             if with_bitmap:
                 return memoryview(result.args[0].to_bytes(size, "big")), memoryview(bytes(size))
-            else:
-                return memoryview(result.args[0].to_bytes(size, "big"))
-        elif result.op == "Concat":
+            return memoryview(result.args[0].to_bytes(size, "big"))
+        if result.op == "Concat":
             bytes_out = bytearray(size)
             bitmap_out = bytearray(size)
             bit_idx = 0
@@ -423,18 +423,12 @@ class PagedMemoryMixin(MemoryMixin):
                     bitmap_out[byte_idx] = 1
                     continue
 
-                if bit_idx % byte_width != 0:
-                    # if the current element has at least byte_width bits, the top `hi_chop` bits should be removed
-                    hi_chop = byte_width - (bit_idx % byte_width)
-                else:
-                    hi_chop = 0
+                # if the current element has at least byte_width bits, the top `hi_chop` bits should be removed
+                hi_chop = byte_width - bit_idx % byte_width if bit_idx % byte_width != 0 else 0
 
-                if (bit_idx + len(element)) % byte_width != 0:
-                    # if the current element does not have enough bits to extend to the next byte boundary, the
-                    # bottom `lo_chop` bits should be removed
-                    lo_chop = (bit_idx + len(element)) % byte_width
-                else:
-                    lo_chop = 0
+                # if the current element does not have enough bits to extend to the next byte boundary, the
+                # bottom `lo_chop` bits should be removed
+                lo_chop = (bit_idx + len(element)) % byte_width if (bit_idx + len(element)) % byte_width != 0 else 0
 
                 if hi_chop + lo_chop == len(element):
                     # the entire element will be removed
@@ -470,13 +464,10 @@ class PagedMemoryMixin(MemoryMixin):
                     bitmap_out[bit_idx // byte_width] = 1
             if with_bitmap:
                 return memoryview(bytes(bytes_out)), memoryview(bytes(bitmap_out))
-            else:
-                return memoryview(bytes(bytes_out))
-        else:
-            if with_bitmap:
-                return memoryview(bytes(size)), memoryview(b"\x01" * size)
-            else:
-                return memoryview(b"")
+            return memoryview(bytes(bytes_out))
+        if with_bitmap:
+            return memoryview(bytes(size)), memoryview(b"\x01" * size)
+        return memoryview(b"")
 
     def concrete_load(self, addr, size, writing=False, with_bitmap=False, **kwargs):
         pageno, offset = self._divide_addr(addr)
@@ -486,8 +477,7 @@ class PagedMemoryMixin(MemoryMixin):
         except SimMemoryError:
             if with_bitmap:
                 return memoryview(b""), memoryview(b"")
-            else:
-                return memoryview(b"")
+            return memoryview(b"")
 
         if not page.SUPPORTS_CONCRETE_LOAD:
             # the page does not support concrete_load
@@ -572,9 +562,7 @@ class PagedMemoryMixin(MemoryMixin):
 
             if (my_page is None) ^ (other_page is None):
                 changes.update(range(pageno * self.page_size, (pageno + 1) * self.page_size))
-            elif my_page is None:
-                pass
-            elif my_page is other_page:
+            elif my_page is None or my_page is other_page:
                 pass
             else:
                 changes.update(
@@ -597,9 +585,7 @@ class PagedMemoryMixin(MemoryMixin):
 
             if (my_page is None) ^ (other_page is None):
                 changes[pageno] = None
-            elif my_page is None:
-                pass
-            elif my_page is other_page:
+            elif my_page is None or my_page is other_page:
                 pass
             else:
                 changed_offsets = my_page.changed_bytes(other_page, page_addr=pageno * self.page_size)
@@ -657,7 +643,7 @@ class PagedMemoryMixin(MemoryMixin):
 
 class LabeledPagesMixin(PagedMemoryMixin):
     def load_with_labels(
-        self, addr: int, size: int = None, endness=None, **kwargs
+        self, addr: int, size: int | None = None, endness=None, **kwargs
     ) -> tuple[claripy.ast.Base, tuple[tuple[int, int, int, Any]]]:
         if endness is None:
             endness = self.endness
@@ -726,7 +712,7 @@ class MVListPagesMixin(PagedMemoryMixin):
         self.skip_missing_values_during_merging = skip_missing_values_during_merging
 
     @MemoryMixin.memo
-    def copy(self, memo) -> "MVListPagesMixin":
+    def copy(self, memo) -> MVListPagesMixin:
         r = super().copy(memo)
         r.skip_missing_values_during_merging = self.skip_missing_values_during_merging
         return r

angr/storage/memory_mixins/paged_memory/paged_memory_multivalue_mixin.py

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

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import typing
 
 from angr.storage.memory_mixins import MemoryMixin
@@ -23,8 +24,6 @@ class PageBase(HistoryTrackingMixin, RefcountMixin, CooperationBase, ISPOMixin,
     Read the docstrings for each of the constituent classes to understand the nuances of their functionalities
     """
 
-    pass
-
 
 PageType = typing.TypeVar("PageType", bound=PageBase)
 

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import Any
 
 import claripy
@@ -207,13 +208,13 @@ class MemoryObjectSetMixin(CooperationBase):
             return MultiValues(offset_to_values={0: elements[0]})
 
         if endness == "Iend_LE":
-            elements = list(reversed(elements))
+            elements.reverse()
 
         mv = MultiValues()
         offset = 0
         start_offset = 0
         prev_value = ...
-        for i, value_set in enumerate(elements):
+        for value_set in elements:
             if len(value_set) == 1:
                 if prev_value is ...:
                     prev_value = next(iter(value_set))
@@ -258,7 +259,7 @@ class MemoryObjectSetMixin(CooperationBase):
                         )
                     )
 
-            sorted_offsets = list(sorted(offset_to_mos.keys()))
+            sorted_offsets = sorted(offset_to_mos.keys())
             pos = 0
             while pos < len(sorted_offsets):
                 mos = set(offset_to_mos[sorted_offsets[pos]])

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

@@ -1,4 +1,5 @@
 # pylint:disable=arguments-differ,unused-argument,no-member
+from __future__ import annotations
 
 from angr.storage.memory_mixins import MemoryMixin
 from angr.utils.segment_list import SegmentList
@@ -26,8 +27,7 @@ class HistoryTrackingMixin(RefcountMixin, MemoryMixin):
         return super().store(addr, data, **kwargs)
 
     def copy(self, memo):
-        o = super().copy(memo)
-        return o
+        return super().copy(memo)
 
     def acquire_unique(self):
         page = super().acquire_unique()
@@ -52,8 +52,8 @@ class HistoryTrackingMixin(RefcountMixin, MemoryMixin):
     def changed_bytes(self, other, **kwargs) -> set[int] | None:
         candidates: set[int] = set()
 
-        self_history_list = [self] + list(self.parents())
-        other_history_list = [other] + list(other.parents())
+        self_history_list = [self, *list(self.parents())]
+        other_history_list = [other, *list(other.parents())]
         if self_history_list and other_history_list and self_history_list[-1] is other_history_list[-1]:
             # two pages have the same root. we can get a list of candidate offsets this way
 

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

@@ -1,4 +1,5 @@
 # pylint:disable=arguments-differ
+from __future__ import annotations
 from angr.storage.memory_mixins import MemoryMixin
 
 

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

@@ -1,4 +1,5 @@
 # pylint:disable=abstract-method,arguments-differ
+from __future__ import annotations
 import logging
 
 import claripy
@@ -24,9 +25,8 @@ class ListPage(MemoryObjectMixin, PageBase):
             DynamicDictList(max_size=memory.page_size, content=content) if content is not None else None
         )
         self.stored_offset = set()
-        if self.content is None:
-            if memory is not None:
-                self.content: DynamicDictList[SimMemoryObject | None] = DynamicDictList(max_size=memory.page_size)
+        if self.content is None and memory is not None:
+            self.content: DynamicDictList[SimMemoryObject | None] = DynamicDictList(max_size=memory.page_size)
         self._mo_cmp = mo_cmp
 
         self.sinkhole: SimMemoryObject | None = sinkhole
@@ -113,10 +113,10 @@ class ListPage(MemoryObjectMixin, PageBase):
 
     def merge(
         self,
-        others: list["ListPage"],
+        others: list[ListPage],
         merge_conditions,
         common_ancestor=None,
-        page_addr: int = None,
+        page_addr: int | None = None,
         memory=None,
         changed_offsets: set[int] | None = None,
     ):
@@ -125,7 +125,7 @@ class ListPage(MemoryObjectMixin, PageBase):
             for other in others:
                 changed_offsets |= self.changed_bytes(other, page_addr)
 
-        all_pages: list["ListPage"] = [self] + others
+        all_pages: list[ListPage] = [self, *others]
         if merge_conditions is None:
             merge_conditions = [None] * len(all_pages)
 
@@ -165,7 +165,7 @@ class ListPage(MemoryObjectMixin, PageBase):
                 to_merge = [(mo.object, fv) for mo, fv in memory_objects]
 
                 # Update `merged_to`
-                mo_base = list(mo_bases)[0]
+                mo_base = next(iter(mo_bases))
                 mo_length = memory_objects[0][0].length
                 size = mo_length - (page_addr + b - mo_base)
                 merged_to = b + size
@@ -202,7 +202,7 @@ class ListPage(MemoryObjectMixin, PageBase):
                     if min_size is None or mo_size < min_size:
                         min_size = mo_size
                 for um, _ in unconstrained_in:
-                    for i in range(0, min_size):
+                    for i in range(min_size):
                         if um._contains(b + i, page_addr):
                             min_size = i
                             break
@@ -240,7 +240,7 @@ class ListPage(MemoryObjectMixin, PageBase):
         self.stored_offset |= merged_offsets
         return merged_offsets
 
-    def changed_bytes(self, other: "ListPage", page_addr: int = None):
+    def changed_bytes(self, other: ListPage, page_addr: int | None = None):
         candidates = super().changed_bytes(other)
         if candidates is None:
             candidates: set[int] = set()
@@ -263,16 +263,11 @@ class ListPage(MemoryObjectMixin, PageBase):
         for c in candidates:
             s_contains = self._contains(c, page_addr)
             o_contains = other._contains(c, page_addr)
-            if not s_contains and o_contains:
-                differences.add(c)
-            elif s_contains and not o_contains:
+            if not s_contains and o_contains or s_contains and not o_contains:
                 differences.add(c)
             else:
                 if self.content[c] is None:
-                    if self.sinkhole is None:
-                        v = claripy.BVV(0, 8)
-                    else:
-                        v = (self.sinkhole.bytes_at(page_addr + c, 1),)
+                    v = claripy.BVV(0, 8) if self.sinkhole is None else (self.sinkhole.bytes_at(page_addr + c, 1),)
                     self.content[c] = SimMemoryObject(
                         v,
                         page_addr + c,
@@ -280,10 +275,7 @@ class ListPage(MemoryObjectMixin, PageBase):
                         endness="Iend_BE",
                     )
                 if other.content[c] is None:
-                    if other.sinkhole is None:
-                        v = claripy.BVV(0, 8)
-                    else:
-                        v = (other.sinkhole.bytes_at(page_addr + c, 1),)
+                    v = claripy.BVV(0, 8) if other.sinkhole is None else (other.sinkhole.bytes_at(page_addr + c, 1),)
                     other.content[c] = SimMemoryObject(
                         v,
                         page_addr + c,

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

@@ -1,4 +1,4 @@
-from typing import Union
+from __future__ import annotations
 from collections.abc import Iterator
 import archinfo
 
@@ -25,7 +25,7 @@ class MultiValues:
 
     def __init__(
         self,
-        v: Union[claripy.ast.Bits, "MultiValues", None, dict[int, set[claripy.ast.Bits]]] = None,
+        v: claripy.ast.Bits | MultiValues | None | dict[int, set[claripy.ast.Bits]] = None,
         offset_to_values=None,
     ):
         if v is not None and offset_to_values is not None:
@@ -46,10 +46,9 @@ class MultiValues:
             self._values = {}
 
         # if only one value is passed in, assign it to self._single_value
-        if self._values:
-            if len(self._values) == 1 and 0 in self._values and len(self._values[0]) == 1:
-                self._single_value = next(iter(self._values[0]))
-                self._values = None
+        if self._values and len(self._values) == 1 and 0 in self._values and len(self._values[0]) == 1:
+            self._single_value = next(iter(self._values[0]))
+            self._values = None
 
         if self._values:
             # sanity check
@@ -156,7 +155,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) -> MultiValues:
         new_values = {k: set(v) for k, v in self.items()}
         for off, vs in mv.items():
             if off not in new_values:
@@ -178,10 +177,7 @@ class MultiValues:
         assert other._values is not None
         if set(self._values.keys()) != set(other._values.keys()):
             return False
-        for k in self._values.keys():
-            if self._values[k] != other._values[k]:
-                return False
-        return True
+        return all(self._values[k] == other._values[k] for k in self._values)
 
     def __repr__(self):
         if self._single_value is not None:
@@ -197,9 +193,9 @@ class MultiValues:
         if self._single_value is not None:
             if offset == 0:
                 return {self._single_value}
-            raise KeyError()
-        elif not self._values:
-            raise KeyError()
+            raise KeyError
+        if not self._values:
+            raise KeyError
         return self._values[offset]
 
     def keys(self) -> set[int]:
@@ -231,7 +227,7 @@ class MultiValues:
             return 0
         return len(self._values)
 
-    def extract(self, offset: int, length: int, endness: str) -> "MultiValues":
+    def extract(self, offset: int, length: int, endness: str) -> MultiValues:
         end = offset + length
         result = MultiValues(claripy.BVV(b""))
         for obj_offset, values in self.items():
@@ -250,7 +246,7 @@ class MultiValues:
 
         return result
 
-    def concat(self, other: Union["MultiValues", claripy.ast.Bits, bytes]) -> "MultiValues":
+    def concat(self, other: MultiValues | claripy.ast.Bits | bytes) -> MultiValues:
         if isinstance(other, bytes):
             other = claripy.BVV(other)
         if isinstance(other, claripy.ast.Bits):
@@ -276,14 +272,13 @@ class MultiValues:
         :return:        The adjacent offset as requested. If the requested adjacent offset does not exist, return None.
         """
 
-        sorted_offsets = list(sorted(self._values.keys())) if self._values is not None else [0]
+        sorted_offsets = sorted(self._values.keys()) if self._values is not None else [0]
 
         for i, off in enumerate(sorted_offsets):
             if off == offset:
                 if before:
                     return sorted_offsets[i - 1] if i > 0 else None
-                else:
-                    return sorted_offsets[i + 1] if i + 1 < len(sorted_offsets) else None
+                return sorted_offsets[i + 1] if i + 1 < len(sorted_offsets) else None
             if off > offset:
                 # we missed it...
                 return None

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

@@ -1,4 +1,5 @@
 # pylint:disable=abstract-method,arguments-differ,assignment-from-no-return
+from __future__ import annotations
 import logging
 from typing import Union, Any
 from collections.abc import Callable
@@ -35,15 +36,12 @@ class MVListPage(
         self.stored_offset = set()
         self._mo_cmp: Callable | None = mo_cmp
 
-        if self.content is None:
-            if memory is not None:
-                self.content: DynamicDictList[_MOTYPE | set[_MOTYPE] | None] = DynamicDictList(
-                    max_size=memory.page_size
-                )
+        if self.content is None and memory is not None:
+            self.content: DynamicDictList[_MOTYPE | set[_MOTYPE] | None] = DynamicDictList(max_size=memory.page_size)
 
         self.sinkhole: _MOTYPE | None = sinkhole
 
-    def copy(self, memo) -> "MVListPage":
+    def copy(self, memo) -> MVListPage:
         o = super().copy(memo)
         o.content = DynamicDictList(max_size=self.content.max_size, content=self.content)
         o.sinkhole = self.sinkhole
@@ -142,10 +140,10 @@ class MVListPage(
 
     def merge(
         self,
-        others: list["MVListPage"],
+        others: list[MVListPage],
         merge_conditions,
         common_ancestor=None,
-        page_addr: int = None,
+        page_addr: int | None = None,
         memory=None,
         changed_offsets: set[int] | None = None,
     ):
@@ -154,7 +152,7 @@ class MVListPage(
             for other in others:
                 changed_offsets |= self.changed_bytes(other, page_addr)
 
-        all_pages: list["MVListPage"] = [self] + others
+        all_pages: list[MVListPage] = [self, *others]
         if merge_conditions is None:
             merge_conditions = [None] * len(all_pages)
 
@@ -217,7 +215,7 @@ class MVListPage(
                         to_merge.append((mo.object, fv))
 
                 # Update `merged_to`
-                mo_base = list(mo_bases)[0]
+                mo_base = next(iter(mo_bases))
                 mo_length = next(iter(mo_lengths))
                 size = min(mo_length - (page_addr + b - mo_base), len(self.content) - b)
                 merged_to = b + size
@@ -245,7 +243,7 @@ class MVListPage(
                     for mo in mo_set:
                         min_size = min(min_size, mo.length - ((b + page_addr - mo.base) & mask))
                 for um, _ in unconstrained_in:
-                    for i in range(0, min_size):
+                    for i in range(min_size):
                         if um._contains(b + i, page_addr):
                             min_size = i
                             break
@@ -280,7 +278,7 @@ class MVListPage(
         return merged_offsets
 
     def compare(
-        self, other: "MVListPage", page_addr: int = None, memory=None, changed_offsets=None
+        self, other: MVListPage, page_addr: int | None = None, memory=None, changed_offsets=None
     ) -> bool:  # pylint: disable=unused-argument
         compared_to = None
         for b in sorted(changed_offsets):
@@ -312,7 +310,7 @@ class MVListPage(
 
         return True
 
-    def changed_bytes(self, other: "MVListPage", page_addr: int = None):
+    def changed_bytes(self, other: MVListPage, page_addr: int | None = None):
         candidates: set[int] = super().changed_bytes(other)
         if candidates is not None:
             # using the result from the history tracking mixin as an approximation
@@ -341,27 +339,23 @@ class MVListPage(
         for c in candidates:
             s_contains = self._contains(c, page_addr)
             o_contains = other._contains(c, page_addr)
-            if not s_contains and o_contains:
-                differences.add(c)
-            elif s_contains and not o_contains:
+            if not s_contains and o_contains or s_contains and not o_contains:
                 differences.add(c)
             else:
-                if self.content[c] is None:
-                    if self.sinkhole is not None:
-                        self.content[c] = SimMemoryObject(
-                            self.sinkhole.bytes_at(page_addr + c, 1),
-                            page_addr + c,
-                            byte_width=byte_width,
-                            endness="Iend_BE",
-                        )
-                if other.content[c] is None:
-                    if other.sinkhole is not None:
-                        other.content[c] = SimMemoryObject(
-                            other.sinkhole.bytes_at(page_addr + c, 1),
-                            page_addr + c,
-                            byte_width=byte_width,
-                            endness="Iend_BE",
-                        )
+                if self.content[c] is None and self.sinkhole is not None:
+                    self.content[c] = SimMemoryObject(
+                        self.sinkhole.bytes_at(page_addr + c, 1),
+                        page_addr + c,
+                        byte_width=byte_width,
+                        endness="Iend_BE",
+                    )
+                if other.content[c] is None and other.sinkhole is not None:
+                    other.content[c] = SimMemoryObject(
+                        other.sinkhole.bytes_at(page_addr + c, 1),
+                        page_addr + c,
+                        byte_width=byte_width,
+                        endness="Iend_BE",
+                    )
                 if s_contains and self.content[c] != other.content[c]:
                     same = None
                     if self._mo_cmp is not None:

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import claripy
 
 from angr.storage.memory_mixins import MemoryMixin

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

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from angr.storage.memory_mixins import MemoryMixin
 from angr.misc import PicklableLock
 
@@ -29,8 +30,7 @@ class RefcountMixin(MemoryMixin):
         with self.lock:
             if self.refcount == 1:
                 return self
-            else:
-                self.refcount -= 1
+            self.refcount -= 1
         return self.copy(
             {}
         )  # TODO: evaluate if it's worth making the lock a reentrant lock (RLock) so this can go in the else arm