angr 9.2.176__cp310-abi3-macosx_10_12_x86_64.whl → 9.2.177__cp310-abi3-macosx_10_12_x86_64.whl

angr/__init__.py

@@ -2,7 +2,7 @@
 # pylint: disable=wrong-import-position
 from __future__ import annotations
 
-__version__ = "9.2.176"
+__version__ = "9.2.177"
 
 if bytes is str:
     raise Exception(

angr/analyses/decompiler/ail_simplifier.py

@@ -1426,7 +1426,7 @@ class AILSimplifier(Analysis):
 
         for eq in equivalence:
             # register variable == Call
-            if isinstance(eq.atom0, VirtualVariable) and eq.atom0.was_reg:
+            if isinstance(eq.atom0, VirtualVariable) and (eq.atom0.was_reg or eq.atom0.was_tmp):
                 if isinstance(eq.atom1, Call):
                     # register variable = Call
                     call: Expression = eq.atom1

angr/analyses/decompiler/peephole_optimizations/cas_intrinsics.py

@@ -1,6 +1,7 @@
 # pylint:disable=arguments-differ,too-many-boolean-expressions
 from __future__ import annotations
 
+from angr.ailment import Const
 from angr.ailment.expression import BinaryOp, Load, Expression, Tmp
 from angr.ailment.statement import CAS, ConditionalJump, Statement, Assignment, Call
 
@@ -8,8 +9,22 @@ from .base import PeepholeOptimizationMultiStmtBase
 
 
 _INTRINSICS_NAMES = {
-    "xchg": {"Win32": "InterlockedExchange", "Linux": "atomic_exchange"},
-    "cmpxchg": {"Win32": "InterlockedCompareExchange", "Linux": "atomic_compare_exchange"},
+    "xchg8": {"Win32": "InterlockedExchange8", "Linux": "atomic_exchange"},
+    "xchg16": {"Win32": "InterlockedExchange16", "Linux": "atomic_exchange"},
+    "xchg32": {"Win32": "InterlockedExchange", "Linux": "atomic_exchange"},
+    "xchg64": {"Win32": "InterlockedExchange64", "Linux": "atomic_exchange"},
+    "cmpxchg16": {"Win32": "InterlockedCompareExchange16", "Linux": "atomic_compare_exchange"},
+    "cmpxchg32": {"Win32": "InterlockedCompareExchange", "Linux": "atomic_compare_exchange"},
+    "cmpxchg64": {"Win32": "InterlockedCompareExchange64", "Linux": "atomic_compare_exchange"},
+    "cmpxchg128": {"Win32": "InterlockedCompareExchange128", "Linux": "atomic_compare_exchange"},
+    "lock_inc16": {"Win32": "InterlockedIncrement16", "Linux": "atomic_fetch_add"},
+    "lock_inc32": {"Win32": "InterlockedIncrement", "Linux": "atomic_fetch_add"},
+    "lock_inc64": {"Win32": "InterlockedIncrement64", "Linux": "atomic_fetch_add"},
+    "lock_dec16": {"Win32": "InterlockedDecrement16", "Linux": "atomic_fetch_dec"},
+    "lock_dec32": {"Win32": "InterlockedDecrement", "Linux": "atomic_fetch_dec"},
+    "lock_dec64": {"Win32": "InterlockedDecrement64", "Linux": "atomic_fetch_dec"},
+    "lock_xadd32": {"Win32": "InterlockedExchangeAdd", "Linux": "atomic_exchange_add"},
+    "lock_xadd64": {"Win32": "InterlockedExchangeAdd64", "Linux": "atomic_exchange_add"},
 }
 
 
@@ -72,14 +87,54 @@ class CASIntrinsics(PeepholeOptimizationMultiStmtBase):
             ):
                 # TODO: Support cases where cas_stmt.old_hi is not None
                 # Case 1
-                call_expr = Call(
-                    cas_stmt.idx,
-                    self._get_instrincs_name("xchg"),
-                    args=[addr, cas_stmt.data_lo],
-                    bits=cas_stmt.bits,
-                    ins_addr=cas_stmt.ins_addr,
-                )
-                stmt = Assignment(cas_stmt.idx, cas_stmt.old_lo, call_expr, **cas_stmt.tags)
+
+                call_expr = None
+                if isinstance(cas_stmt.data_lo, BinaryOp):
+                    if cas_stmt.data_lo.op == "Add" and cas_stmt.data_lo.operands[0].likes(cas_stmt.expd_lo):
+                        if isinstance(cas_stmt.data_lo.operands[1], Const) and cas_stmt.data_lo.operands[1].value == 1:
+                            # lock inc
+                            call_expr = Call(
+                                cas_stmt.idx,
+                                self._get_instrincs_name(f"lock_inc{cas_stmt.bits}"),
+                                args=[cas_stmt.addr],
+                                bits=cas_stmt.bits,
+                                ins_addr=cas_stmt.ins_addr,
+                            )
+                        else:
+                            # lock xadd
+                            call_expr = Call(
+                                cas_stmt.idx,
+                                self._get_instrincs_name(f"lock_xadd{cas_stmt.bits}"),
+                                args=[cas_stmt.addr, cas_stmt.data_lo.operands[1]],
+                                bits=cas_stmt.bits,
+                                ins_addr=cas_stmt.ins_addr,
+                            )
+                    elif (
+                        cas_stmt.data_lo.op == "Sub"
+                        and cas_stmt.data_lo.operands[0].likes(cas_stmt.expd_lo)
+                        and isinstance(cas_stmt.data_lo.operands[1], Const)
+                        and cas_stmt.data_lo.operands[1].value == 1
+                    ):
+                        # lock dec
+                        call_expr = Call(
+                            cas_stmt.idx,
+                            self._get_instrincs_name(f"lock_dec{cas_stmt.bits}"),
+                            args=[cas_stmt.addr],
+                            bits=cas_stmt.bits,
+                            ins_addr=cas_stmt.ins_addr,
+                        )
+
+                if call_expr is None:
+                    call_expr = Call(
+                        cas_stmt.idx,
+                        self._get_instrincs_name(f"xchg{cas_stmt.bits}"),
+                        args=[addr, cas_stmt.data_lo],
+                        bits=cas_stmt.bits,
+                        ins_addr=cas_stmt.ins_addr,
+                    )
+
+                assignment_dst = cas_stmt.expd_lo
+                stmt = Assignment(cas_stmt.idx, assignment_dst, call_expr, **cas_stmt.tags)  # type:ignore
                 return [stmt]
 
         if next_stmt.ins_addr <= cas_stmt.ins_addr:
@@ -88,9 +143,10 @@ class CASIntrinsics(PeepholeOptimizationMultiStmtBase):
 
         if cas_stmt.old_hi is None:
             # TODO: Support cases where cas_stmt.old_hi is not None
+            # Case 2
             call_expr = Call(
                 cas_stmt.idx,
-                self._get_instrincs_name("cmpxchg"),
+                self._get_instrincs_name(f"cmpxchg{cas_stmt.bits}"),
                 args=[
                     cas_stmt.addr,
                     cas_stmt.data_lo,
@@ -99,7 +155,8 @@ class CASIntrinsics(PeepholeOptimizationMultiStmtBase):
                 bits=cas_stmt.bits,
                 ins_addr=cas_stmt.ins_addr,
             )
-            stmt = Assignment(cas_stmt.idx, cas_stmt.old_lo, call_expr, **cas_stmt.tags)
+            assignment_dst = cas_stmt.expd_lo
+            stmt = Assignment(cas_stmt.idx, assignment_dst, call_expr, **cas_stmt.tags)  # type:ignore
             return [stmt, next_stmt]
 
         return None

angr/analyses/decompiler/peephole_optimizations/inlined_wcscpy_consolidation.py

@@ -1,13 +1,47 @@
 # pylint:disable=arguments-differ
 from __future__ import annotations
+from typing import TYPE_CHECKING
 
 from angr.ailment.expression import Expression, BinaryOp, Const, Register, StackBaseOffset, UnaryOp, VirtualVariable
-from angr.ailment.statement import Call, Store
+from angr.ailment.statement import Call, Store, Assignment
 
 from angr.sim_type import SimTypePointer, SimTypeWideChar
 from .base import PeepholeOptimizationMultiStmtBase
 from .inlined_wcscpy import InlinedWcscpy
 
+if TYPE_CHECKING:
+    from angr.ailment.statement import Statement
+
+
+def match_statements(stmts: list[Statement], index: int) -> int:
+    ending = index
+    has_wcsncpy = False
+    for i in range(index, len(stmts)):
+        stmt = stmts[i]
+        if isinstance(stmt, Call):
+            if InlinedWcscpy.is_inlined_wcsncpy(stmt):
+                has_wcsncpy = True
+            else:
+                break
+        elif isinstance(stmt, Store):
+            if not isinstance(stmt.data, Const):
+                break
+            _, off = InlinedWcscpyConsolidation._parse_addr(stmt.addr)
+            if off is None:
+                # unsupported offset - bail
+                break
+        elif (
+            isinstance(stmt, Assignment)
+            and isinstance(stmt.dst, VirtualVariable)
+            and stmt.dst.was_stack
+            and isinstance(stmt.src, Const)
+        ):
+            pass
+        else:
+            break
+        ending = i + 1
+    return ending - index if has_wcsncpy and ending - index >= 2 else 0
+
 
 class InlinedWcscpyConsolidation(PeepholeOptimizationMultiStmtBase):
     """
@@ -17,12 +51,141 @@ class InlinedWcscpyConsolidation(PeepholeOptimizationMultiStmtBase):
     __slots__ = ()
 
     NAME = "Consolidate multiple inlined wcsncpy calls"
-    stmt_classes = ((Call, Call), (Call, Store))
+    stmt_classes = (match_statements,)
 
     def optimize(  # type:ignore
-        self, stmts: list[Call], stmt_idx: int | None = None, block=None, **kwargs
+        self, stmts: list[Call | Store | Assignment], stmt_idx: int | None = None, block=None, **kwargs
     ):  # pylint:disable=unused-argument
-        last_stmt, stmt = stmts
+        reordered_stmts = self._reorder_stmts(stmts)
+        if not reordered_stmts or len(reordered_stmts) <= 1:
+            return None
+
+        new_stmts = []
+        optimized = False
+        stop = False
+        while not stop:
+            new_stmts = []
+            stop = True
+            for i, stmt0 in enumerate(reordered_stmts):
+                if i == len(reordered_stmts) - 1:
+                    new_stmts.append(reordered_stmts[i])
+                    break
+                stmt1 = reordered_stmts[i + 1]
+                opt_stmts = self._optimize_pair(stmt0, stmt1)
+                if opt_stmts is None:
+                    new_stmts.append(stmt0)
+                else:
+                    new_stmts += opt_stmts
+                    # start again from the beginning
+                    optimized = True
+                    stop = False
+                    reordered_stmts = new_stmts + reordered_stmts[i + 2 :]
+                    break
+
+        return new_stmts if optimized and new_stmts else None
+
+    def _reorder_stmts(self, stmts: list[Call | Store | Assignment]) -> list[Call | Store] | None:
+        """
+        Order a list of statements based on ascending addresses of their destination buffers.
+        """
+
+        if not all(
+            (
+                InlinedWcscpy.is_inlined_wcsncpy(s)
+                or (isinstance(s, Store) and isinstance(s.data, Const))
+                or (
+                    isinstance(s, Assignment)
+                    and isinstance(s.dst, VirtualVariable)
+                    and s.dst.was_stack
+                    and isinstance(s.src, Const)
+                )
+            )
+            for s in stmts
+        ):
+            return None
+        offset_to_stmt = {}
+        updated_offsets: set[int] = set()
+        known_base = None
+        for stmt in stmts:
+            if isinstance(stmt, Call):
+                assert (
+                    stmt.args is not None
+                    and len(stmt.args) == 3
+                    and stmt.args[0] is not None
+                    and stmt.args[2] is not None
+                )
+                base, off = self._parse_addr(stmt.args[0])
+                store_size = stmt.args[2].value * 2 if isinstance(stmt.args[2], Const) else None
+            elif isinstance(stmt, Store):
+                base, off = self._parse_addr(stmt.addr)
+                store_size = stmt.size
+            elif isinstance(stmt, Assignment):
+                base, off = self._parse_addr(stmt.dst)
+                store_size = stmt.dst.size
+            else:
+                # unexpected!
+                return None
+            if off is None or store_size is None:
+                # bad offset or size - bail
+                return None
+            if known_base is None:
+                known_base = base
+            elif not base.likes(known_base):
+                # bail
+                return None
+            if off in offset_to_stmt:
+                # duplicate offset - bail
+                return None
+            assert isinstance(store_size, int)
+            for i in range(store_size):
+                if off + i in updated_offsets:
+                    # overlapping store - bail
+                    return None
+                updated_offsets.add(off + i)
+
+            offset_to_stmt[off] = stmt
+
+        return [offset_to_stmt[k] for k in sorted(offset_to_stmt)]
+
+    def _optimize_pair(
+        self, last_stmt: Call | Store | Assignment, stmt: Call | Store | Assignment
+    ) -> list[Call] | None:
+        # convert (store, wcsncpy()) to (wcsncpy(), store) if they do not overlap
+        if (
+            isinstance(stmt, Call)
+            and InlinedWcscpy.is_inlined_wcsncpy(stmt)
+            and stmt.args is not None
+            and len(stmt.args) == 3
+            and isinstance(stmt.args[2], Const)
+            and isinstance(stmt.args[2].value, int)
+            and isinstance(last_stmt, (Store, Assignment))
+        ):
+            if isinstance(last_stmt, Store) and isinstance(last_stmt.data, Const):
+                store_addr = last_stmt.addr
+                store_size = last_stmt.size
+            elif isinstance(last_stmt, Assignment):
+                store_addr = last_stmt.dst
+                store_size = last_stmt.dst.size
+            else:
+                return None
+            # check if they overlap
+            wcsncpy_addr = stmt.args[0]
+            wcsncpy_size = stmt.args[2].value * 2
+            delta = self._get_delta(store_addr, wcsncpy_addr)
+            if delta is not None:
+                if (0 <= delta <= store_size) or (delta < 0 and -delta <= wcsncpy_size):
+                    # they overlap, do not switch
+                    pass
+                else:
+                    last_stmt, stmt = stmt, last_stmt
+
+        # swap two statements if they are out of order
+        if InlinedWcscpy.is_inlined_wcsncpy(last_stmt) and InlinedWcscpy.is_inlined_wcsncpy(stmt):
+            assert last_stmt.args is not None and stmt.args is not None
+            delta = self._get_delta(last_stmt.args[0], stmt.args[0])
+            if delta is not None and delta < 0:
+                last_stmt, stmt = stmt, last_stmt
+
         if InlinedWcscpy.is_inlined_wcsncpy(last_stmt):
             assert last_stmt.args is not None
             assert self.kb is not None
@@ -55,6 +218,22 @@ class InlinedWcscpyConsolidation(PeepholeOptimizationMultiStmtBase):
                         )
                     if r and s is not None:
                         new_str = s_last + s
+            elif (
+                isinstance(stmt, Assignment)
+                and isinstance(stmt.dst, VirtualVariable)
+                and isinstance(stmt.src, Const)
+                and isinstance(stmt.src.value, int)
+            ):
+                # consolidating a call and an assignment, in case the assignment statement is storing the suffix of a
+                # string (but the suffix is too short to qualify an inlined strcpy optimization)
+                addr_curr = stmt.dst
+                delta = self._get_delta(addr_last, addr_curr)
+                if delta is not None and delta == len(s_last):
+                    r, s = InlinedWcscpy.is_integer_likely_a_wide_string(
+                        stmt.src.value, stmt.dst.size, self.project.arch.memory_endness, min_length=1  # type:ignore
+                    )
+                    if r and s is not None:
+                        new_str = s_last + s
 
             if new_str is not None:
                 assert self.project is not None
@@ -83,17 +262,21 @@ class InlinedWcscpyConsolidation(PeepholeOptimizationMultiStmtBase):
 
     @staticmethod
     def _parse_addr(addr: Expression) -> tuple[Expression, int]:
+        # we force the base to 64-bit because it does not really matter when we use it
+
+        if isinstance(addr, VirtualVariable) and addr.was_stack:
+            return StackBaseOffset(None, 64, 0), addr.stack_offset
         if isinstance(addr, Register):
             return addr, 0
         if isinstance(addr, StackBaseOffset):
-            return StackBaseOffset(None, addr.bits, 0), addr.offset
+            return StackBaseOffset(None, 64, 0), addr.offset
         if (
             isinstance(addr, UnaryOp)
             and addr.op == "Reference"
             and isinstance(addr.operand, VirtualVariable)
             and addr.operand.was_stack
         ):
-            return StackBaseOffset(None, addr.bits, 0), addr.operand.stack_offset
+            return StackBaseOffset(None, 64, 0), addr.operand.stack_offset
         if isinstance(addr, BinaryOp):
             if addr.op == "Add" and isinstance(addr.operands[1], Const) and isinstance(addr.operands[1].value, int):
                 base_0, offset_0 = InlinedWcscpyConsolidation._parse_addr(addr.operands[0])

angr/analyses/decompiler/utils.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 import pathlib
 import copy
+from types import FunctionType
 from typing import Any
 from collections.abc import Iterable
 import logging
@@ -958,9 +959,15 @@ def peephole_optimize_multistmts(block, stmt_opts):
             for opt in stmt_opts:
                 matched = False
                 stmt_seq_len = None
-                for stmt_class_seq in opt.stmt_classes:
-                    if match_stmt_classes(statements, stmt_idx, stmt_class_seq):
-                        stmt_seq_len = len(stmt_class_seq)
+                for stmt_class_seq_or_method in opt.stmt_classes:
+                    if isinstance(stmt_class_seq_or_method, FunctionType):
+                        r = stmt_class_seq_or_method(statements, stmt_idx)
+                        if r > 0:
+                            stmt_seq_len = r
+                            matched = True
+                            break
+                    elif match_stmt_classes(statements, stmt_idx, stmt_class_seq_or_method):
+                        stmt_seq_len = len(stmt_class_seq_or_method)
                         matched = True
                         break
 

angr/analyses/flirt/flirt.py

@@ -35,7 +35,7 @@ class FlirtAnalysis(Analysis):
       current binary, and then match all possible signatures for the architecture.
     """
 
-    def __init__(self, sig: FlirtSignature | str | None = None, max_mismatched_bytes: int = 0):
+    def __init__(self, sig: FlirtSignature | str | None = None, max_mismatched_bytes: int = 0, dry_run: bool = False):
 
         from angr.flirt import FLIRT_SIGNATURES_BY_ARCH  # pylint:disable=import-outside-toplevel
 
@@ -94,9 +94,10 @@ class FlirtAnalysis(Analysis):
                 sig_ = path_to_sig.get(max_suggestion_sig_path)
                 assert sig_ is not None
                 _l.info("Applying FLIRT signature %s for library %s.", sig_, lib)
-                self._apply_changes(
-                    sig_.sig_name if not self._temporary_sig else None, sig_to_suggestions[max_suggestion_sig_path]
-                )
+                if not dry_run:
+                    self._apply_changes(
+                        sig_.sig_name if not self._temporary_sig else None, sig_to_suggestions[max_suggestion_sig_path]
+                    )
                 self.matched_suggestions[lib] = (sig_, sig_to_suggestions[max_suggestion_sig_path])
 
     def _find_hits_by_strings(self, regions: list[bytes]) -> Generator[FlirtSignature]:

angr/analyses/variable_recovery/engine_ail.py

@@ -171,6 +171,45 @@ class SimEngineVRAIL(
             if isinstance(funcaddr_typevar, typevars.TypeVariable):
                 load_typevar = self._create_access_typevar(funcaddr_typevar, False, self.arch.bytes, 0)
                 self.state.add_type_constraint(typevars.Subtype(funcaddr_typevar, load_typevar))
+        elif isinstance(target, str):
+            # special handling for some intrinsics
+            match target:
+                case (
+                    "InterlockedExchange8"
+                    | "InterlockedExchange16"
+                    | "InterlockedExchange"
+                    | "InterlockedExchange64"
+                    | "InterlockedCompareExchange16"
+                    | "InterlockedCompareExchange"
+                    | "InterlockedCompareExchange64"
+                    | "InterlockedCompareExchange128"
+                    | "InterlockedExchangeAdd"
+                    | "InterlockedExchangeAdd64"
+                ):
+                    arg_tv = (
+                        args[0].typevar
+                        if args[0].typevar is not None
+                        else args[1].typevar if args[1].typevar is not None else None
+                    )
+                    if arg_tv is not None:
+                        ret_ty = self._create_access_typevar(
+                            arg_tv, False, args[0].data.size() // self.arch.byte_width, 0
+                        )
+                        return RichR(self.state.top(ret_expr_bits), typevar=ret_ty)
+                case (
+                    "InterlockedIncrement"
+                    | "InterlockedIncrement16"
+                    | "InterlockedIncrement64"
+                    | "InterlockedDecrement"
+                    | "InterlockedDecrement16"
+                    | "InterlockedDecrement64"
+                ):
+                    arg_tv = args[0].typevar if args[0].typevar is not None else None
+                    if arg_tv is not None:
+                        ret_ty = self._create_access_typevar(
+                            arg_tv, False, args[0].data.size() // self.arch.byte_width, 0
+                        )
+                        return RichR(self.state.top(ret_expr_bits), typevar=ret_ty)
 
         # discover the prototype
         prototype: SimTypeFunction | None = None

angr/emulator.py

@@ -95,7 +95,8 @@ class Emulator:
         num_inst_executed: int = 0
         while self._state.history.jumpkind != "Ijk_Exit":
             # Check if there is a breakpoint at the current address
-            if completed_engine_execs > 0 and self._state.addr in self._engine.get_breakpoints():
+            addr_with_lower_bit_cleared = self._state.addr & ~1
+            if completed_engine_execs > 0 and addr_with_lower_bit_cleared in self._engine.get_breakpoints():
                 return EmulatorStopReason.BREAKPOINT
 
             # Check if we've already executed the requested number of instructions

angr/engines/hook.py

@@ -54,7 +54,7 @@ class HooksMixin(SuccessorsEngine, ProcedureMixin):
         if procedure is None:
             procedure = self._lookup_hook(state, procedure)
         if procedure is None:
-            return super().process_successors(successors, procedure=procedure, **kwargs)
+            return super().process_successors(successors, **kwargs)
 
         if isinstance(procedure.addr, SootAddressDescriptor):
             l.debug("Running %s (originally at %r)", repr(procedure), procedure.addr)

angr/engines/icicle.py

@@ -8,7 +8,7 @@ from dataclasses import dataclass
 from typing_extensions import override
 
 import pypcode
-from archinfo import Arch, Endness, ArchARMCortexM
+from archinfo import Arch, ArchPcode, Endness, ArchARMCortexM
 
 from angr.engines.concrete import ConcreteEngine, HeavyConcreteState
 from angr.engines.failure import SimEngineFailure
@@ -72,6 +72,8 @@ class IcicleEngine(ConcreteEngine):
         accurate, just a set of heuristics to get the right architecture. When
         adding a new architecture, this function may need to be updated.
         """
+        if isinstance(arch, ArchARMCortexM) or (isinstance(arch, ArchPcode) and arch.pcode_arch == "ARM:LE:32:Cortex"):
+            return "armv7m"
         if arch.linux_name == "arm":
             return "armv7a" if arch.memory_endness == Endness.LE else "armeb"
         return arch.linux_name
@@ -83,12 +85,21 @@ class IcicleEngine(ConcreteEngine):
         """
         return icicle_arch.startswith(("arm", "thumb"))
 
+    @staticmethod
+    def __is_cortex_m(angr_arch: Arch, icicle_arch: str) -> bool:
+        """
+        Check if the architecture is cortex-m based on the address.
+        """
+        return isinstance(angr_arch, ArchARMCortexM) or icicle_arch == "armv7m"
+
     @staticmethod
     def __is_thumb(angr_arch: Arch, icicle_arch: str, addr: int) -> bool:
         """
         Check if the architecture is thumb based on the address.
         """
-        return isinstance(angr_arch, ArchARMCortexM) or (IcicleEngine.__is_arm(icicle_arch) and addr & 1 == 1)
+        return IcicleEngine.__is_cortex_m(angr_arch, icicle_arch) or (
+            IcicleEngine.__is_arm(icicle_arch) and addr & 1 == 1
+        )
 
     @staticmethod
     def __get_pages(state: HeavyConcreteState) -> set[int]:
@@ -132,7 +143,10 @@ class IcicleEngine(ConcreteEngine):
         for register in state.arch.register_list:
             register = register.vex_name.lower() if register.vex_name is not None else register.name
             try:
-                emu.reg_write(register, state.solver.eval(state.registers.load(register), cast_to=int))
+                emu.reg_write(
+                    register,
+                    state.solver.eval(state.registers.load(register), cast_to=int),
+                )
                 copied_registers.add(register)
             except KeyError:
                 log.debug("Register %s not found in icicle", register)
@@ -242,11 +256,13 @@ class IcicleEngine(ConcreteEngine):
     @override
     def add_breakpoint(self, addr: int) -> None:
         """Add a breakpoint at the given address."""
+        addr = addr & ~1  # Clear thumb bit if set
         self.breakpoints.add(addr)
 
     @override
     def remove_breakpoint(self, addr: int) -> None:
         """Remove a breakpoint at the given address, if present."""
+        addr = addr & ~1  # Clear thumb bit if set
         self.breakpoints.discard(addr)
 
     @override

angr/knowledge_plugins/functions/function.py

@@ -759,8 +759,7 @@ class Function(Serializable):
         if hooker:
             if hasattr(hooker, "DYNAMIC_RET") and hooker.DYNAMIC_RET:
                 return True
-            if hasattr(hooker, "NO_RET"):
-                return not hooker.NO_RET
+            return hooker.returns
 
         # Cannot determine
         return None
@@ -1579,6 +1578,7 @@ class Function(Serializable):
                     return False
                 self.prototype = proto.with_arch(self.project.arch)
                 self.prototype_libname = library.name
+                self.returning = library.is_returning(name)
 
                 # update self.calling_convention if necessary
                 if self.calling_convention is None:

angr/procedures/definitions/__init__.py

@@ -427,6 +427,15 @@ class SimLibrary:
 
         return func_name in self.prototypes or func_name in self.prototypes_json
 
+    def is_returning(self, name: str) -> bool:
+        """
+        Check if a function is known to return.
+
+        :param name:    The name of the function.
+        :return:        A bool indicating if the function is known to return or not.
+        """
+        return name not in self.non_returning
+
 
 class SimCppLibrary(SimLibrary):
     """

angr/procedures/definitions/parse_win32json.py

@@ -2443,22 +2443,33 @@ def do_it(in_dir):
 
             parsed_cprotos[(prefix, lib, suffix)].append((func, proto, ""))
 
+    non_returning_functions = {
+        "KeBugCheck",
+        "KeBugCheckEx",
+    }
+
     # dump to JSON files
     for (prefix, libname, suffix), parsed_cprotos_per_lib in parsed_cprotos.items():
         filename = libname.replace(".", "_") + ".json"
         os.makedirs(prefix, exist_ok=True)
         logging.debug("Writing to file %s...", filename)
+        non_returning = []
         d = {
             "_t": "lib",
             "type_collection_names": ["win32"],
             "library_names": [libname if not suffix else f"{libname}.{suffix}"],
             "default_cc": {"X86": "SimCCStdcall", "AMD64": "SimCCMicrosoftAMD64"},
+            "non_returning": non_returning,
             "functions": OrderedDict(),
         }
         for func, cproto, doc in sorted(parsed_cprotos_per_lib, key=lambda x: x[0]):
             d["functions"][func] = {"proto": json.dumps(cproto.to_json()).replace('"', "'")}
             if doc:
                 d["functions"][func]["doc"] = doc
+            if func in non_returning_functions:
+                non_returning.append(func)
+        if not non_returning:
+            del d["non_returning"]
         with open(os.path.join(prefix, filename), "w") as f:
             f.write(json.dumps(d, indent="\t"))
 

angr/procedures/definitions/wdk/ntoskrnl.json

@@ -10,6 +10,10 @@
 		"X86": "SimCCStdcall",
 		"AMD64": "SimCCMicrosoftAMD64"
 	},
+	"non_returning": [
+		"KeBugCheck",
+		"KeBugCheckEx"
+	],
 	"functions": {
 		"CcAsyncCopyRead": {
 			"proto": "{'_t': 'func', 'args': [{'_t': 'ptr', 'pts_to': {'_t': '_ref', 'name': 'FILE_OBJECT', 'ot': '_ref'}}, {'_t': 'ptr', 'pts_to': {'_t': 'llong', 'label': 'Int64'}}, {'_t': 'int', 'signed': false, 'label': 'UInt32'}, {'_t': '_ref', 'name': 'BOOLEAN', 'ot': 'char'}, {'_t': 'ptr', 'pts_to': {'_t': 'bot', 'label': 'Void'}}, {'_t': 'ptr', 'pts_to': {'_t': '_ref', 'name': 'IO_STATUS_BLOCK', 'ot': '_ref'}}, {'_t': '_ref', 'name': 'PETHREAD', 'ot': 'ptr'}, {'_t': 'ptr', 'pts_to': {'_t': '_ref', 'name': 'CC_ASYNC_READ_CONTEXT', 'ot': '_ref'}}], 'returnty': {'_t': '_ref', 'name': 'BOOLEAN', 'ot': 'char'}, 'arg_names': ['FileObject', 'FileOffset', 'Length', 'Wait', 'Buffer', 'IoStatus', 'IoIssuerThread', 'AsyncReadContext']}"

{angr-9.2.176.dist-info → angr-9.2.177.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: angr
-Version: 9.2.176
+Version: 9.2.177
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 License: BSD-2-Clause
 Project-URL: Homepage, https://angr.io/
@@ -16,12 +16,12 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: cxxheaderparser
 Requires-Dist: GitPython
-Requires-Dist: archinfo==9.2.176
+Requires-Dist: archinfo==9.2.177
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.176
-Requires-Dist: cle==9.2.176
+Requires-Dist: claripy==9.2.177
+Requires-Dist: cle==9.2.177
 Requires-Dist: msgspec
 Requires-Dist: mulpyplexer
 Requires-Dist: networkx!=2.8.1,>=2.0
@@ -31,7 +31,7 @@ Requires-Dist: pycparser>=2.18
 Requires-Dist: pydemumble
 Requires-Dist: pyformlang
 Requires-Dist: pypcode<4.0,>=3.2.1
-Requires-Dist: pyvex==9.2.176
+Requires-Dist: pyvex==9.2.177
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy

{angr-9.2.176.dist-info → angr-9.2.177.dist-info}/RECORD

@@ -1,23 +1,23 @@
-angr-9.2.176.dist-info/RECORD,,
-angr-9.2.176.dist-info/WHEEL,sha256=wTy_3c4XcOAcqIE15cpeRqeJHiJiSBH-pmU5VVW1EO8,137
-angr-9.2.176.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
-angr-9.2.176.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
-angr-9.2.176.dist-info/METADATA,sha256=lrk4bMUevPqReFweFtx6o_EAXq9sgiK_Sryiv0K4Ozw,4366
-angr-9.2.176.dist-info/licenses/LICENSE,sha256=PmWf0IlSz6Jjp9n7nyyBQA79Q5C2ma68LRykY1V3GF0,1456
+angr-9.2.177.dist-info/RECORD,,
+angr-9.2.177.dist-info/WHEEL,sha256=wTy_3c4XcOAcqIE15cpeRqeJHiJiSBH-pmU5VVW1EO8,137
+angr-9.2.177.dist-info/entry_points.txt,sha256=Vjh1C8PMyr5dZFMnik5WkEP01Uwr2T73I3a6N32sgQU,44
+angr-9.2.177.dist-info/top_level.txt,sha256=dKw0KWTbwLXytFvv15oAAG4sUs3ey47tt6DorJG9-hw,5
+angr-9.2.177.dist-info/METADATA,sha256=nSqVeQ_B1EMMDD_YHtcBhdpPcIoiE-1rh_ekW4aiSFs,4366
+angr-9.2.177.dist-info/licenses/LICENSE,sha256=PmWf0IlSz6Jjp9n7nyyBQA79Q5C2ma68LRykY1V3GF0,1456
 angr/vaults.py,sha256=D_gkDegCyPlZMKGC5E8zINYAaZfSXNWbmhX0rXCYpvM,9718
-angr/unicornlib.dylib,sha256=Xe_s7tqQ6Y8WWACManOsrDwOUU5kXFRnLVnwXO9yevA,264656
+angr/unicornlib.dylib,sha256=vSEEmSHW4Ubx1-p_bbq370cyqti9NRO98WwnojR7Mb8,264656
 angr/state_hierarchy.py,sha256=qDQCUGXmQm3vOxE3CSoiqTH4OAFFOWZZt9BLhNpeOhA,8484
 angr/callable.py,sha256=j9Orwd4H4fPqOYylcEt5GuLGPV7ZOqyA_OYO2bp5PAA,6437
 angr/sim_type.py,sha256=8AJjzu_hp4GvgXogz8KnLiPXSnxBGUy-D3G8w4wEicQ,144714
 angr/knowledge_base.py,sha256=hRoSLuLaOXmddTSF9FN5TVs7liftpBGq_IICz5AaYBk,4533
-angr/emulator.py,sha256=572e9l-N4VUzUzLKylqpv3JmBvVC5VExi1tLy6MZSoU,4633
-angr/rustylib.abi3.so,sha256=rhBQ7CwyB6nILTkaGnc4a7QFjwuGNX9aREDbmfSNwxw,5259540
+angr/emulator.py,sha256=aZXi8-jQ_9uelN2zvlecR2ZYXPey4PHyju6yVJIWDAk,4708
+angr/rustylib.abi3.so,sha256=0LiBw7dKTl6XRTtknkIAbW8bW0UB-PYbqpjoN2BsyoI,5259756
 angr/codenode.py,sha256=hCrQRp4Ebb2X6JicNmY1PXo3_Pm8GDxVivVW0Pwe84k,3918
 angr/graph_utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 angr/sim_manager.py,sha256=w7yTfWR-P9yoN5x85eeiNpj9dTrnjpJ3o5aoFpDAPnc,39396
 angr/serializable.py,sha256=l908phj_KcqopEEL_oCufbP_H6cm3Wc9v-5xdux1-6g,1533
 angr/code_location.py,sha256=kXNJDEMge9VRHadrK4E6HQ8wDdCaHSXNqyAZuHDEGuM,5397
-angr/__init__.py,sha256=4UvTdkXxjnXyp62HCIJ0DcE_mJsddEmoelS1AbMR5ZQ,9246
+angr/__init__.py,sha256=aC71aVWcBP7xns-lX1-sgjw1ZhoYMyYpT71RqZaJHsc,9246
 angr/blade.py,sha256=OGGW-oggqI9_LvgZhiQuh9Ktkvf3vhRBmH0XviNyZ6o,15801
 angr/factory.py,sha256=PPNWvTiWaIgzxzyoTr8ObSF-TXp1hCdbY2e-0xBePNc,17815
 angr/sim_state_options.py,sha256=dsMY3UefvL7yZKXloubMhzUET3N2Crw-Fpw2Vd1ouZQ,12468
@@ -310,8 +310,8 @@ angr/procedures/definitions/cgc.py,sha256=Jrb74dNzy05h_nmsC3GjN5Yr5_jWIjpZ24ZsVk
 angr/procedures/definitions/gnulib.py,sha256=GK4eVXFxwgwhJ9cr47PiTUS4fKYrqPfMtIvwM464Oyo,1107
 angr/procedures/definitions/linux_kernel.py,sha256=xPpfHkfaA_5jS6mPX1YDCPLHEAirAmeGW6mLDBKIlC8,239128
 angr/procedures/definitions/parse_glibc.py,sha256=-vmm4hKO2GnBVXmk6Nq4fxGHuLxesRbF52UIrPk4a6Q,2092
-angr/procedures/definitions/parse_win32json.py,sha256=z4Rjr3L9HTSWsKtKImUynpcvMUJCinG4fIii-o7dPXw,109101
-angr/procedures/definitions/__init__.py,sha256=_0icfYOL57Jz4yUNZ0hVemX-CaUfKe93f_rWG-_8oso,43342
+angr/procedures/definitions/parse_win32json.py,sha256=LzvSZC5u6Jkbe-tx9L7swZmJ0DOm26BjTmJWZGiMhBw,109413
+angr/procedures/definitions/__init__.py,sha256=wYoWkHRSh6wjWE-9wPgNJbTfyeHaqkN2zDWOtHJMdF8,43644
 angr/procedures/definitions/msvcr.py,sha256=CQgWXrKcEjx9xfPf2BZOOPaQJ5AUqwdNtN_5FdYtRzg,651
 angr/procedures/definitions/parse_syscalls_from_local_system.py,sha256=ssyMjeyuPVYHnbmArwDPO0XXMW1n5Odv__n17cdLVcY,1823
 angr/procedures/definitions/linux_loader.py,sha256=uEeMktLesh0NzHmRfgP76IuSzL4YMssR_SSjBRSqA9c,267
@@ -328,7 +328,7 @@ angr/procedures/definitions/wdk/hal.json,sha256=RxvRTa5sumqXXPJai2YrdssJD5fbWeTQ
 angr/procedures/definitions/wdk/api-ms-win-dx-d3dkmt-l1-1-6.json,sha256=W4md-By6xMbKPnSvDQG4Sqh5C6HSrl_61NHY9GWGbQM,460
 angr/procedures/definitions/wdk/gdi32.json,sha256=YByprF-byACUskCT17vLClW6P0b3BfA53HRgCYxPGTk,44925
 angr/procedures/definitions/wdk/fwpuclnt.json,sha256=EYx_oyvbqFnSvI6LeiPy1BbAEnc-WMyn_7aOr3qxP_M,69854
-angr/procedures/definitions/wdk/ntoskrnl.json,sha256=YpUmEfHaIMctYyqWoNauhnnnK-fe-NpA6Hb7FQLm3Ic,680493
+angr/procedures/definitions/wdk/ntoskrnl.json,sha256=Y7NWnwB-Yg4_ecbz9yZwmwH2UofZcNB1D8T-3keJpEg,680550
 angr/procedures/definitions/wdk/fwpkclnt.json,sha256=W_0xXafBO0bheqpLGXOO0tVORvx2KXMwrhPaoBUJTko,1225
 angr/procedures/definitions/wdk/ksecdd.json,sha256=xYYdocSCK8LBeQYFlhZ7ZKiTK-ju26KDWRIQiw7rBKQ,13262
 angr/procedures/definitions/wdk/secur32.json,sha256=M9aMvWxz7zzLtZU4X7Ue5tNJOuNtHvHWHz81e7DvTNs,3432
@@ -914,15 +914,15 @@ angr/knowledge_plugins/functions/soot_function.py,sha256=OzCvQPWxnjbwPWTW0JXrQey
 angr/knowledge_plugins/functions/function_parser.py,sha256=DTdVwYt6nXLMc0EOh-V_GhvZYQ947UNBaA77qn7Y6Vo,12379
 angr/knowledge_plugins/functions/function_manager.py,sha256=StsK3biTFRRA2ugrmeQLuHiN894p789Tlw1CIKlE0PY,23462
 angr/knowledge_plugins/functions/__init__.py,sha256=asiLNiT6sHbjP6eU-kDpawIoVxv4J35cwz5yQHtQ2E0,167
-angr/knowledge_plugins/functions/function.py,sha256=wyOVBKNGbiiBcWLuzgYMwgcJIG9tFkThCNMEJX1O2EE,72292
+angr/knowledge_plugins/functions/function.py,sha256=orSBM5R073Tf-PDWw8NcvKl_iUgCnnk1SyFFMPZP6VE,72303
 angr/knowledge_plugins/xrefs/xref.py,sha256=U2H1rfffp5EXoh0awlGxMBxA4K5MIwl3CXjV3Uih3tA,4856
 angr/knowledge_plugins/xrefs/xref_manager.py,sha256=1n373rtV91xicAfSUresRigsZ6qCBhPOaJKrN_SW3QY,4157
 angr/knowledge_plugins/xrefs/__init__.py,sha256=5PhqVOtTZ27lCjJ9wp7akUeJydqILbyCBZK0gP7BGQs,193
 angr/knowledge_plugins/xrefs/xref_types.py,sha256=LcQ9pD4E4XlC51Us49xiqAoGAFGpnCrpYO4mOzILiKI,308
 angr/engines/unicorn.py,sha256=fq2akQ4dVFAWqek0Yr4JTaTJWwp5vICiSQ7Sg4wuDJE,24533
 angr/engines/concrete.py,sha256=kEt6Dyp8QAIaOP3oW5lRcDs_2UMP2vbiNzylGiqvf7g,2143
-angr/engines/icicle.py,sha256=V08Rco5MBtNvXyVvUUt9ZdWOw16d6pgWEwEr4yC444Q,10421
-angr/engines/hook.py,sha256=lAEYYAXQY_GDOpsz3JZ7IswxrBccZnZ6EaQwyNBb4W8,2590
+angr/engines/icicle.py,sha256=JSbHnTJePV1l6dmF5WPhlzYjm6ZApQfjCUrgJ4jewOg,11033
+angr/engines/hook.py,sha256=YMCUWs-cC3fQCN9xlYAy7vaMPKWDNJkl9KtCMYUyMP0,2569
 angr/engines/__init__.py,sha256=_3oRkiTrPO7QPiCg3qXymt4o9ZAOrAHt5pdfjkp3W9k,1661
 angr/engines/procedure.py,sha256=8kgFH56nkqSWm0p1apuGBaFngl-4BnAzE0bXhq9mc6Y,2561
 angr/engines/engine.py,sha256=2kwOT-sbxKXAVX2PmsPTr8Ax36Vxq6hkRdDKaITBQNc,657
@@ -1101,7 +1101,7 @@ angr/analyses/cfg_slice_to_sink/transitions.py,sha256=9Y1qG789dsAcv73FwgYtppUzPW
 angr/analyses/variable_recovery/irsb_scanner.py,sha256=1dL2IC7fZGuRrhmcpa2Q-G666aMPmbM8zSzmIRpLNSY,5141
 angr/analyses/variable_recovery/variable_recovery_fast.py,sha256=OeSnBVpcNlZU-miBlIrbyaPt2IHtExtnpBoACnWNs_Q,27996
 angr/analyses/variable_recovery/__init__.py,sha256=eA1SHzfSx8aPufUdkvgMmBnbI6VDYKKMJklcOoCO7Ao,208
-angr/analyses/variable_recovery/engine_ail.py,sha256=UWM9TmiGfhA8VrjNRV3jLZbT47yYmlKDnGVkzR1YnjM,33761
+angr/analyses/variable_recovery/engine_ail.py,sha256=N9sEHMUT9qVMJCm1h4da3vLnSLPDp3oY9fE3WN60ioc,35652
 angr/analyses/variable_recovery/variable_recovery.py,sha256=I45eVUpOOcSobA_QyXl3aRNa0kppJH_7YOj95fPPTdE,22272
 angr/analyses/variable_recovery/engine_vex.py,sha256=Sjh3bZZfnEaich7PLTitaZITSMW7agqgyxck4gWKDbQ,21465
 angr/analyses/variable_recovery/variable_recovery_base.py,sha256=Ewd0TzNdZ_gRYXtXjVrJfODNABMMPjnuvMy9-Nnyui0,16813
@@ -1222,11 +1222,11 @@ angr/analyses/decompiler/node_replacer.py,sha256=jJd3XkIwFE07bIbLriJ6_mQEvfhm90C
 angr/analyses/decompiler/decompilation_options.py,sha256=bs6CNpU3UxepgBB_9eUH4jriNpGoryyPP0sR1hDWpTk,8477
 angr/analyses/decompiler/region_walker.py,sha256=u0hR0bEX1hSwkv-vejIM1gS-hcX2F2DLsDqpKhQ5_pQ,752
 angr/analyses/decompiler/graph_region.py,sha256=uSDdCLXfLZJVcb0wMdgBh-KtBJUUhLGHQ-Ap4dNs8wo,18186
-angr/analyses/decompiler/utils.py,sha256=slKEGEpWBN7X1ACbMDbd3e4Zs9txgDYeGBFqnFGCpD4,42705
+angr/analyses/decompiler/utils.py,sha256=B7YwnEBF6AZ5DG3E7zHK0TF7zOLeiMWEcc18YL_eUyA,43074
 angr/analyses/decompiler/decompiler.py,sha256=adX2UJv6s4JAF7Qf6HTgwPo28QQ6yCzrrQrtlqDZyfE,31864
 angr/analyses/decompiler/goto_manager.py,sha256=wVoeXJcadIda84LloGgqW-rL0QHLv3fx4vZHLhmz-_o,4027
 angr/analyses/decompiler/block_similarity.py,sha256=S1lTlXFyOmJlQa7I3y7xgLsENLS4XGET7tdD55k_6Vg,6859
-angr/analyses/decompiler/ail_simplifier.py,sha256=c6xgZIZkvToFpcnOxWx6h0t39hdQ_EkFUafQkJ8Rhq4,93281
+angr/analyses/decompiler/ail_simplifier.py,sha256=NdPdj7IpmltxdPuhxdwHnd6qG2xHrA5ZPlDLvDyaH8U,93303
 angr/analyses/decompiler/jump_target_collector.py,sha256=CucT99luxIVrioM-keMMjyNKWE5QaXEFQOFphtyU8b4,1189
 angr/analyses/decompiler/label_collector.py,sha256=fsCkldy8ZKH4FjkREByg-NDmfCd7Pmuz2K1Dks9oVjM,814
 angr/analyses/decompiler/jumptable_entry_condition_rewriter.py,sha256=f_JyNiSZfoudElfl2kIzONoYCiosR4xYFOe8Q5SkvLg,2176
@@ -1271,7 +1271,7 @@ angr/analyses/decompiler/region_simplifiers/cascading_ifs.py,sha256=kPWajH8__ap-
 angr/analyses/decompiler/region_simplifiers/expr_folding.py,sha256=naCgnDUjdiDsh6dvoNO-VARfbTfaEYpu3EX9HkJ1cqE,31790
 angr/analyses/decompiler/peephole_optimizations/basepointeroffset_and_mask.py,sha256=2Tb4zGnFA5hZH8oI6t1hoRstGDmOBsOoQxf6fU5Ct7A,1105
 angr/analyses/decompiler/peephole_optimizations/tidy_stack_addr.py,sha256=8gPWhFTcezgO7pZ_v0pxR7pweds4_GrrY82ur6Nrlf8,4796
-angr/analyses/decompiler/peephole_optimizations/cas_intrinsics.py,sha256=2A7NZIzZpDCq3i8e72l7c7KHfEwfJvzi5NffoXU_NNE,4559
+angr/analyses/decompiler/peephole_optimizations/cas_intrinsics.py,sha256=lzlyhe1RP020ezYN77QRFu5p7zNaH4XSMkpBhxRP7ms,7959
 angr/analyses/decompiler/peephole_optimizations/remove_redundant_nots.py,sha256=V5Vm1zUGjsauyOYXbUgDfZEgmChLbY8wnvmcRbfdMk0,1278
 angr/analyses/decompiler/peephole_optimizations/bool_expr_xor_1.py,sha256=vLXt0ekjRep4SgaNq1wyxVkBTzOMTa03d3rgkjUOcUg,995
 angr/analyses/decompiler/peephole_optimizations/bswap.py,sha256=fXV_a58W2X30KCanYeSHdZ2yPcfDlyZq_OkYNMkglrg,6420
@@ -1319,7 +1319,7 @@ angr/analyses/decompiler/peephole_optimizations/coalesce_adjacent_shrs.py,sha256
 angr/analyses/decompiler/peephole_optimizations/remove_redundant_bitmasks.py,sha256=FUf1bg9nADlwT1upwTKcVhhPcvZ98C-8PlmkWoHqwZ4,4787
 angr/analyses/decompiler/peephole_optimizations/remove_redundant_shifts_around_comparators.py,sha256=pMdKsNJtAIPqyWsR8cUEyujdF7e7kbqqvVgelVmKtqY,1610
 angr/analyses/decompiler/peephole_optimizations/optimized_div_simplifier.py,sha256=M4GxEWKs6V9aEYejGluZ8w8QpvPKpaESeFFzid88HjE,14208
-angr/analyses/decompiler/peephole_optimizations/inlined_wcscpy_consolidation.py,sha256=R1k3ByTY2tL72O9VLjVkXqIY-1dnTbvstma1pguZxLw,5393
+angr/analyses/decompiler/peephole_optimizations/inlined_wcscpy_consolidation.py,sha256=TfimMI0FwpRBrWVQZy4m9XAf_BBPInu0zfywQ9CoGgs,12712
 angr/analyses/decompiler/peephole_optimizations/a_div_const_add_a_mul_n_div_const.py,sha256=HY6EQkThiyMaahz3bodJUqLBKWY2n4aKGbKyspMXN50,1641
 angr/analyses/decompiler/peephole_optimizations/rewrite_bit_extractions.py,sha256=tezg1gsxxH-iMmo_346NYO0YHwJz_Gpb8Ztm526o0G4,3300
 angr/analyses/decompiler/peephole_optimizations/single_bit_cond_to_boolexpr.py,sha256=3eQSTFUNRDWz0No90GzxM_TaIYa7-xouf8afytds5Dk,2967
@@ -1389,7 +1389,7 @@ angr/analyses/s_reaching_definitions/s_rda_model.py,sha256=FJSge_31FFzyzBJA1xm7d
 angr/analyses/s_reaching_definitions/s_rda_view.py,sha256=7o-llkMUJP_ZhnQ4tkCDrzYok4cAOA7PLt2tX9DY8Mo,13929
 angr/analyses/fcp/__init__.py,sha256=E9dxFckDM9DijfU4RRg9SGL6xDKCz7yBBP-XSkS-S9U,115
 angr/analyses/fcp/fcp.py,sha256=djkJsvSja_De7ptNwllmTHjvVl62BFcH_haBhwhzFtw,16373
-angr/analyses/flirt/flirt.py,sha256=UNXtUBs11WafKeMAW2BwqKJLFhOyObqmRhfCqYdsJpc,10762
+angr/analyses/flirt/flirt.py,sha256=fZ0BvmJnx6ve1j76lMvKFHM2y3g17wg00fU8hWvSl14,10829
 angr/analyses/flirt/flirt_sig.py,sha256=9cWSXqFBEIpui7pluMTaskfD0mVMomNt1mPXN6pIdjg,11574
 angr/analyses/flirt/__init__.py,sha256=1jKkwUDhwwnxG5BRcYtwogLHLBvtZApXgvcAcHrJrdw,1293
 angr/analyses/flirt/consts.py,sha256=9ldvicgtJZa8Hw8cWOKxGkCYtc09I2q5ZWxctXcg20w,4861