angr 9.2.140__py3-none-manylinux2014_x86_64.whl → 9.2.141__py3-none-manylinux2014_x86_64.whl

angr/analyses/decompiler/structuring/structurer_base.py

@@ -371,8 +371,8 @@ class StructurerBase(Analysis):
                         jump_stmt = this_node.nodes[-1].statements[-1]
                         this_node = this_node.nodes[-1]
 
-                    assert isinstance(this_node, ailment.Block)
                     if isinstance(jump_stmt, ailment.Stmt.Jump):
+                        assert isinstance(this_node, ailment.Block)
                         next_node = node.nodes[i + 1]
                         if (
                             isinstance(jump_stmt.target, ailment.Expr.Const)
@@ -381,6 +381,7 @@ class StructurerBase(Analysis):
                             # this goto is useless
                             this_node.statements = this_node.statements[:-1]
                     elif isinstance(jump_stmt, ailment.Stmt.ConditionalJump):
+                        assert isinstance(this_node, ailment.Block)
                         next_node = node.nodes[i + 1]
                         if (
                             isinstance(jump_stmt.true_target, ailment.Expr.Const)

angr/analyses/decompiler/utils.py

@@ -625,6 +625,48 @@ def update_labels(graph: networkx.DiGraph):
     return add_labels(remove_labels(graph))
 
 
+def _flatten_structured_node(packed_node: SequenceNode | MultiNode) -> list[ailment.Block]:
+    if not packed_node or not packed_node.nodes:
+        return []
+
+    blocks = []
+    if packed_node.nodes is not None:
+        for _node in packed_node.nodes:
+            if isinstance(_node, (SequenceNode, MultiNode)):
+                blocks += _flatten_structured_node(_node)
+            else:
+                blocks.append(_node)
+
+    return blocks
+
+
+def _find_node_in_graph(node: ailment.Block, graph: networkx.DiGraph) -> ailment.Block | None:
+    for bb in graph:
+        if bb.addr == node.addr and bb.idx == node.idx:
+            return bb
+    return None
+
+
+def structured_node_has_multi_predecessors(node: SequenceNode | MultiNode, graph: networkx.DiGraph) -> bool:
+    if graph is None:
+        return False
+
+    first_block = None
+    if isinstance(node, (SequenceNode, MultiNode)) and node.nodes:
+        flat_blocks = _flatten_structured_node(node)
+        node = flat_blocks[0]
+
+    if isinstance(node, ailment.Block):
+        first_block = node
+
+    if first_block is not None:
+        graph_node = _find_node_in_graph(first_block, graph)
+        if graph_node is not None:
+            return len(list(graph.predecessors(graph_node))) > 1
+
+    return False
+
+
 def structured_node_is_simple_return(
     node: SequenceNode | MultiNode, graph: networkx.DiGraph, use_packed_successors=False
 ) -> bool:
@@ -639,21 +681,6 @@ def structured_node_is_simple_return(
 
     Returns true on any block ending in linear statements and a return.
     """
-
-    def _flatten_structured_node(packed_node: SequenceNode | MultiNode) -> list[ailment.Block]:
-        if not packed_node or not packed_node.nodes:
-            return []
-
-        blocks = []
-        if packed_node.nodes is not None:
-            for _node in packed_node.nodes:
-                if isinstance(_node, (SequenceNode, MultiNode)):
-                    blocks += _flatten_structured_node(_node)
-                else:
-                    blocks.append(_node)
-
-        return blocks
-
     # sanity check: we need a graph to understand returning blocks
     if graph is None:
         return False
@@ -676,11 +703,10 @@ def structured_node_is_simple_return(
     if valid_last_stmt:
         # note that the block may not be the same block in the AIL graph post dephication. we must find the block again
         # in the graph.
-        for bb in graph:
-            if bb.addr == last_block.addr and bb.idx == last_block.idx:
-                # found it
-                succs = list(graph.successors(bb))
-                return not succs or succs == [bb]
+        last_graph_block = _find_node_in_graph(last_block, graph)
+        if last_graph_block is not None:
+            succs = list(graph.successors(last_graph_block))
+            return not succs or succs == [last_graph_block]
     return False
 
 

angr/analyses/s_reaching_definitions/s_rda_view.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
 import logging
+from collections.abc import Callable
 from collections import defaultdict
 
+from ailment import Block
 from ailment.statement import Statement, Assignment, Call, Label
 from ailment.expression import VirtualVariable, VirtualVariableCategory, Expression
 
@@ -22,7 +24,7 @@ class RegVVarPredicate:
     Implements a predicate that is used in get_reg_vvar_by_stmt_idx and get_reg_vvar_by_insn.
     """
 
-    def __init__(self, reg_offset: int, vvars: set[VirtualVariable], arch):
+    def __init__(self, reg_offset: int, vvars: list[VirtualVariable], arch):
         self.reg_offset = reg_offset
         self.vvars = vvars
         self.arch = arch
@@ -47,7 +49,8 @@ class RegVVarPredicate:
             and stmt.dst.was_reg
             and stmt.dst.reg_offset == self.reg_offset
         ):
-            self.vvars.add(stmt.dst)
+            if stmt.dst not in self.vvars:
+                self.vvars.append(stmt.dst)
             return True
         if isinstance(stmt, Call):
             if (
@@ -55,7 +58,8 @@ class RegVVarPredicate:
                 and stmt.ret_expr.was_reg
                 and stmt.ret_expr.reg_offset == self.reg_offset
             ):
-                self.vvars.add(stmt.ret_expr)
+                if stmt.ret_expr not in self.vvars:
+                    self.vvars.append(stmt.ret_expr)
                 return True
             # is it clobbered maybe?
             clobbered_regs = self._get_call_clobbered_regs(stmt)
@@ -69,7 +73,7 @@ class StackVVarPredicate:
     Implements a predicate that is used in get_stack_vvar_by_stmt_idx and get_stack_vvar_by_insn.
     """
 
-    def __init__(self, stack_offset: int, size: int, vvars: set[VirtualVariable]):
+    def __init__(self, stack_offset: int, size: int, vvars: list[VirtualVariable]):
         self.stack_offset = stack_offset
         self.size = size
         self.vvars = vvars
@@ -82,7 +86,8 @@ class StackVVarPredicate:
             and stmt.dst.stack_offset <= self.stack_offset < stmt.dst.stack_offset + stmt.dst.size
             and stmt.dst.stack_offset <= self.stack_offset + self.size <= stmt.dst.stack_offset + stmt.dst.size
         ):
-            self.vvars.add(stmt.dst)
+            if stmt.dst not in self.vvars:
+                self.vvars.append(stmt.dst)
             return True
         return False
 
@@ -96,7 +101,13 @@ class SRDAView:
         self.model = model
 
     def _get_vvar_by_stmt(
-        self, block_addr: int, block_idx: int | None, stmt_idx: int, op_type: ObservationPointType, predicate
+        self,
+        block_addr: int,
+        block_idx: int | None,
+        stmt_idx: int,
+        op_type: ObservationPointType,
+        predicate: Callable,
+        consecutive: bool = False,
     ):
         # find the starting block
         for block in self.model.func_graph:
@@ -107,7 +118,10 @@ class SRDAView:
             return
 
         traversed = set()
-        queue = [(the_block, stmt_idx if op_type == ObservationPointType.OP_BEFORE else stmt_idx + 1)]
+        queue: list[tuple[Block, int | None]] = [
+            (the_block, stmt_idx if op_type == ObservationPointType.OP_BEFORE else stmt_idx + 1)
+        ]
+        predicate_returned_true = False
         while queue:
             block, start_stmt_idx = queue.pop(0)
             traversed.add(block)
@@ -115,7 +129,8 @@ class SRDAView:
             stmts = block.statements[:start_stmt_idx] if start_stmt_idx is not None else block.statements
 
             for stmt in reversed(stmts):
-                should_break = predicate(stmt)
+                r = predicate(stmt)
+                should_break = (predicate_returned_true and r is False) if consecutive else r
                 if should_break:
                     break
             else:
@@ -129,7 +144,7 @@ class SRDAView:
         self, reg_offset: int, block_addr: int, block_idx: int | None, stmt_idx: int, op_type: ObservationPointType
     ) -> VirtualVariable | None:
         reg_offset = get_reg_offset_base(reg_offset, self.model.arch)
-        vvars = set()
+        vvars = []
         predicater = RegVVarPredicate(reg_offset, vvars, self.model.arch)
         self._get_vvar_by_stmt(block_addr, block_idx, stmt_idx, op_type, predicater.predicate)
 
@@ -137,14 +152,14 @@ class SRDAView:
             # not found - check function arguments
             for func_arg in self.model.func_args:
                 if isinstance(func_arg, VirtualVariable):
-                    func_arg_category = func_arg.oident[0]
+                    func_arg_category = func_arg.parameter_category
                     if func_arg_category == VirtualVariableCategory.REGISTER:
-                        func_arg_regoff = func_arg.oident[1]
+                        func_arg_regoff = func_arg.parameter_reg_offset
                         if func_arg_regoff == reg_offset:
-                            vvars.add(func_arg)
+                            vvars.append(func_arg)
 
         assert len(vvars) <= 1
-        return next(iter(vvars), None)
+        return vvars[0] if vvars else None
 
     def get_stack_vvar_by_stmt(  # pylint: disable=too-many-positional-arguments
         self,
@@ -155,21 +170,24 @@ class SRDAView:
         stmt_idx: int,
         op_type: ObservationPointType,
     ) -> VirtualVariable | None:
-        vvars = set()
+        vvars = []
         predicater = StackVVarPredicate(stack_offset, size, vvars)
-        self._get_vvar_by_stmt(block_addr, block_idx, stmt_idx, op_type, predicater.predicate)
+        self._get_vvar_by_stmt(block_addr, block_idx, stmt_idx, op_type, predicater.predicate, consecutive=True)
 
         if not vvars:
             # not found - check function arguments
             for func_arg in self.model.func_args:
                 if isinstance(func_arg, VirtualVariable):
-                    func_arg_category = func_arg.oident[0]
+                    func_arg_category = func_arg.parameter_category
                     if func_arg_category == VirtualVariableCategory.STACK:
-                        func_arg_stackoff = func_arg.oident[1]
+                        func_arg_stackoff = func_arg.oident[1]  # type: ignore
                         if func_arg_stackoff == stack_offset and func_arg.size == size:
-                            vvars.add(func_arg)
-        assert len(vvars) <= 1
-        return next(iter(vvars), None)
+                            vvars.append(func_arg)
+        # there might be multiple vvars; we prioritize the one whose size fits the best
+        for v in vvars:
+            if v.stack_offset == stack_offset and v.size == size:
+                return v
+        return vvars[0] if vvars else None
 
     def _get_vvar_by_insn(self, addr: int, op_type: ObservationPointType, predicate, block_idx: int | None = None):
         # find the starting block
@@ -202,23 +220,23 @@ class SRDAView:
         self, reg_offset: int, addr: int, op_type: ObservationPointType, block_idx: int | None = None
     ) -> VirtualVariable | None:
         reg_offset = get_reg_offset_base(reg_offset, self.model.arch)
-        vvars = set()
+        vvars = []
         predicater = RegVVarPredicate(reg_offset, vvars, self.model.arch)
 
         self._get_vvar_by_insn(addr, op_type, predicater.predicate, block_idx=block_idx)
 
         assert len(vvars) <= 1
-        return next(iter(vvars), None)
+        return vvars[0] if vvars else None
 
     def get_stack_vvar_by_insn(  # pylint: disable=too-many-positional-arguments
         self, stack_offset: int, size: int, addr: int, op_type: ObservationPointType, block_idx: int | None = None
     ) -> VirtualVariable | None:
-        vvars = set()
+        vvars = []
         predicater = StackVVarPredicate(stack_offset, size, vvars)
         self._get_vvar_by_insn(addr, op_type, predicater.predicate, block_idx=block_idx)
 
         assert len(vvars) <= 1
-        return next(iter(vvars), None)
+        return vvars[0] if vvars else None
 
     def get_vvar_value(self, vvar: VirtualVariable) -> Expression | None:
         if vvar not in self.model.all_vvar_definitions:
@@ -227,7 +245,7 @@ class SRDAView:
 
         for block in self.model.func_graph:
             if block.addr == codeloc.block_addr and block.idx == codeloc.block_idx:
-                if codeloc.stmt_idx < len(block.statements):
+                if codeloc.stmt_idx is not None and codeloc.stmt_idx < len(block.statements):
                     stmt = block.statements[codeloc.stmt_idx]
                     if isinstance(stmt, Assignment) and stmt.dst.likes(vvar):
                         return stmt.src

angr/analyses/variable_recovery/engine_ail.py

@@ -333,7 +333,7 @@ class SimEngineVRAIL(
         tvs = set()
         for _, vvar in expr.src_and_vvars:
             if vvar is not None:
-                r = self._read_from_vvar(vvar, expr=expr, vvar_id=self._mapped_vvarid(vvar.varid))
+                r = self._read_from_vvar(vvar, expr=vvar, vvar_id=self._mapped_vvarid(vvar.varid))
                 if r.typevar is not None:
                     tvs.add(r.typevar)
 

angr/analyses/variable_recovery/engine_vex.py

@@ -8,12 +8,13 @@ from archinfo.arch_arm import is_arm_arch
 
 from angr.block import Block
 from angr.errors import SimMemoryMissingError
-from angr.calling_conventions import SimRegArg, SimStackArg, default_cc
+from angr.calling_conventions import SimRegArg, SimStackArg, SimTypeFunction, default_cc
 from angr.engines.vex.claripy.datalayer import value as claripy_value
 from angr.engines.light import SimEngineNostmtVEX
 from angr.knowledge_plugins import Function
 from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
 from angr.analyses.typehoon import typevars, typeconsts
+from angr.sim_type import SimTypeBottom
 from .engine_base import SimEngineVRBase, RichR
 from .irsb_scanner import VEXIRSBScanner
 
@@ -222,24 +223,39 @@ class SimEngineVRVEX(
 
     def _process_block_end(self, stmt_result, whitelist):
         # handles block-end calls
+        has_call = False
         current_addr = self.state.block_addr
         for target_func in self.call_info.get(current_addr, []):
             self._handle_function_concrete(target_func)
+            has_call = True
 
-        if self.block.vex.jumpkind == "Ijk_Call":
+        if has_call or self.block.vex.jumpkind == "Ijk_Call":
             # emulates return values from calls
             cc = None
+            proto: SimTypeFunction | None = None
             for target_func in self.call_info.get(self.state.block_addr, []):
                 if target_func.calling_convention is not None:
                     cc = target_func.calling_convention
+                    proto = target_func.prototype
                     break
             if cc is None:
                 cc = default_cc(self.arch.name, platform=self.project.simos.name)(self.arch)
-            if isinstance(cc.RETURN_VAL, SimRegArg):
-                reg_offset, reg_size = self.arch.registers[cc.RETURN_VAL.reg_name]
+
+            if proto is not None and not isinstance(proto.returnty, SimTypeBottom):
+                ret_reg = cc.return_val(proto.returnty)
+            else:
+                ret_reg = cc.RETURN_VAL
+            if isinstance(ret_reg, SimRegArg):
+                reg_offset, reg_size = self.arch.registers[ret_reg.reg_name]
                 data = self._top(reg_size * self.arch.byte_width)
                 self._assign_to_register(reg_offset, data, reg_size, create_variable=False)
 
+                # handle tail-call optimizations
+                if self.block.vex.jumpkind == "Ijk_Boring":
+                    self.state.ret_val_size = (
+                        reg_size if self.state.ret_val_size is None else max(self.state.ret_val_size, reg_size)
+                    )
+
         elif self.block.vex.jumpkind == "Ijk_Ret":
             # handles return statements
 

angr/calling_conventions.py

@@ -2,7 +2,8 @@
 from __future__ import annotations
 import logging
 from typing import cast
-from collections.abc import Iterable
+
+from collections.abc import Iterable, Sequence
 from collections import defaultdict
 import contextlib
 
@@ -82,7 +83,8 @@ class AllocHelper:
 
     def size(self):
         val = self.translate(self.ptr, claripy.BVV(0, len(self.ptr)))
-        assert val.op == "BVV"
+        assert isinstance(val, claripy.ast.Base) and val.op == "BVV"
+        assert isinstance(val.args[0], int)
         return abs(val.args[0])
 
     @classmethod
@@ -130,6 +132,7 @@ def refine_locs_with_struct_type(
         arg_type = SimTypeInt(label=arg_type.label).with_arch(arch)
 
     if isinstance(arg_type, (SimTypeReg, SimTypeNum, SimTypeFloat)):
+        assert arg_type.size is not None
         seen_bytes = 0
         pieces = []
         while seen_bytes < arg_type.size // arch.byte_width:
@@ -147,20 +150,21 @@ def refine_locs_with_struct_type(
             piece.is_fp = True
         return piece
     if isinstance(arg_type, SimTypeFixedSizeArray):
+        assert arg_type.elem_type.size is not None and arg_type.length is not None
         # TODO explicit stride
-        locs = [
+        locs_list = [
             refine_locs_with_struct_type(
                 arch, locs, arg_type.elem_type, offset=offset + i * arg_type.elem_type.size // arch.byte_width
             )
             for i in range(arg_type.length)
         ]
-        return SimArrayArg(locs)
+        return SimArrayArg(locs_list)
     if isinstance(arg_type, SimStruct):
-        locs = {
+        locs_dict = {
             field: refine_locs_with_struct_type(arch, locs, field_ty, offset=offset + arg_type.offsets[field])
             for field, field_ty in arg_type.fields.items()
         }
-        return SimStructArg(arg_type, locs)
+        return SimStructArg(arg_type, locs_dict)
     if isinstance(arg_type, SimUnion):
         # Treat a SimUnion as functionality equivalent to its longest member
         for member in arg_type.members.values():
@@ -574,8 +578,8 @@ class SimCC:
     # (if applicable) and the arguments. Probably zero.
     STACKARG_SP_DIFF = 0  # The amount of stack space reserved for the return address
     CALLER_SAVED_REGS: list[str] = []  # Caller-saved registers
-    RETURN_ADDR: SimFunctionArgument = None  # The location where the return address is stored, as a SimFunctionArgument
-    RETURN_VAL: SimFunctionArgument = None  # The location where the return value is stored, as a SimFunctionArgument
+    RETURN_ADDR: SimFunctionArgument  # The location where the return address is stored, as a SimFunctionArgument
+    RETURN_VAL: SimFunctionArgument  # The location where the return value is stored, as a SimFunctionArgument
     OVERFLOW_RETURN_VAL: SimFunctionArgument | None = (
         None  # The second half of the location where a double-length return value is stored
     )
@@ -728,6 +732,7 @@ class SimCC:
             l.warning("Function argument type cannot be BOT. Treating it as a 32-bit int.")
             arg_type = SimTypeInt().with_arch(self.arch)
         is_fp = isinstance(arg_type, SimTypeFloat)
+        assert arg_type.size is not None
         size = arg_type.size // self.arch.byte_width
         try:
             arg = next(session.fp_iter) if is_fp else next(session.int_iter)
@@ -760,7 +765,7 @@ class SimCC:
     def is_fp_value(val):
         return (
             isinstance(val, (float, claripy.ast.FP))
-            or (isinstance(val, claripy.ast.Base) and val.op.startswith("fp"))
+            or (isinstance(val, claripy.ast.Base) and val.op.startswith("fp"))  # type: ignore
             or (isinstance(val, claripy.ast.Base) and val.op == "Reverse" and val.args[0].op.startswith("fp"))
         )
 
@@ -1130,7 +1135,7 @@ class SimCC:
 
     @staticmethod
     def find_cc(
-        arch: archinfo.Arch, args: list[SimFunctionArgument], sp_delta: int, platform: str = "Linux"
+        arch: archinfo.Arch, args: Sequence[SimFunctionArgument], sp_delta: int, platform: str = "Linux"
     ) -> SimCC | None:
         """
         Pinpoint the best-fit calling convention and return the corresponding SimCC instance, or None if no fit is

angr/factory.py

@@ -7,6 +7,7 @@ from typing import overload, TYPE_CHECKING
 import archinfo
 from archinfo.arch_soot import ArchSoot, SootAddressDescriptor
 
+from .knowledge_plugins.functions import Function
 from .sim_state import SimState
 from .calling_conventions import default_cc, SimRegArg, SimStackArg, PointerWrapper, SimCCUnknown
 from .callable import Callable
@@ -236,7 +237,7 @@ class AngrObjectFactory:
 
     def callable(
         self,
-        addr,
+        addr: int | Function,
         prototype=None,
         concrete_only=False,
         perform_merge=True,
@@ -251,8 +252,9 @@ class AngrObjectFactory:
         A Callable is a representation of a function in the binary that can be interacted with like a native python
         function.
 
-        :param addr:            The address of the function to use
-        :param prototype:         The prototype of the call to use, as a string or a SimTypeFunction
+        :param addr:            The address of the function to use. If you pass in the function object, we will take
+                                its addr.
+        :param prototype:       The prototype of the call to use, as a string or a SimTypeFunction
         :param concrete_only:   Throw an exception if the execution splits into multiple states
         :param perform_merge:   Merge all result states into one at the end (only relevant if concrete_only=False)
         :param base_state:      The state from which to do these runs
@@ -263,6 +265,9 @@ class AngrObjectFactory:
                                 python function.
         :rtype:                 angr.callable.Callable
         """
+        if isinstance(addr, Function):
+            addr = addr.addr
+
         return Callable(
             self.project,
             addr=addr,

angr/knowledge_plugins/variables/variable_manager.py

@@ -12,6 +12,7 @@ from cle.backends.elf.variable import Variable
 
 from angr.utils.orderedset import OrderedSet
 from angr.utils.ail import is_phi_assignment
+from angr.utils.types import unpack_pointer, replace_pointer_pts_to
 from angr.protos import variables_pb2
 from angr.serializable import Serializable
 from angr.sim_variable import SimVariable, SimStackVariable, SimMemoryVariable, SimRegisterVariable
@@ -19,7 +20,6 @@ from angr.sim_type import (
     TypeRef,
     SimType,
     SimStruct,
-    SimTypePointer,
     SimTypeBottom,
     SimTypeChar,
     SimTypeShort,
@@ -985,10 +985,12 @@ class VariableManagerInternal(Serializable):
             if name not in self.types:
                 self.types[name] = TypeRef(name, ty).with_arch(self.manager._kb._project.arch)
             ty = self.types[name]
-        elif isinstance(ty, SimTypePointer) and isinstance(ty.pts_to, SimStruct):
-            typeref = self._register_struct_type(ty.pts_to)
-            ty = ty.copy().with_arch(self.manager._kb._project.arch)
-            ty.pts_to = typeref
+        elif (inner_ty := unpack_pointer(ty, iterative=True)) and isinstance(inner_ty, SimStruct):
+            typeref = self._register_struct_type(inner_ty)
+            # rebuild the multi-layer pointer type
+            replaced_ty = replace_pointer_pts_to(ty, inner_ty, typeref)
+            assert replaced_ty is not None
+            ty = replaced_ty.with_arch(self.manager._kb._project.arch)
         elif isinstance(ty, SimStruct):
             ty = self._register_struct_type(ty, name=name)
 

angr/simos/simos.py

@@ -23,7 +23,9 @@ class SimOS:
     A class describing OS/arch-level configuration.
     """
 
-    def __init__(self, project: angr.Project, name=None):
+    name: str | None
+
+    def __init__(self, project: angr.Project, name: str | None = None):
         self.arch = project.arch
         self.project = project
         self.name = name

angr/utils/types.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from angr.sim_type import TypeRef, SimType, SimTypePointer, SimTypeArray, SimTypeFixedSizeArray
+
+
+def unpack_typeref(ty):
+    if isinstance(ty, TypeRef):
+        return ty.type
+    return ty
+
+
+def unpack_pointer(ty, iterative: bool = False) -> SimType | None:
+    if isinstance(ty, SimTypePointer):
+        if iterative:
+            inner = unpack_pointer(ty.pts_to, iterative=True)
+            return inner if inner is not None else ty.pts_to
+        return ty.pts_to
+    return None
+
+
+def replace_pointer_pts_to(ty: SimType, old_pts_to: SimType, new_pts_to: SimType) -> SimTypePointer | None:
+    if isinstance(ty, SimTypePointer):
+        if ty.pts_to is old_pts_to:
+            inner = new_pts_to
+        elif isinstance(ty.pts_to, SimTypePointer):
+            # recursively replace pts_to inside
+            inner = replace_pointer_pts_to(ty.pts_to, old_pts_to, new_pts_to)
+        else:
+            return None
+        return SimTypePointer(inner, label=ty.label, offset=ty.offset)
+    return None
+
+
+def unpack_array(ty) -> SimType | None:
+    if isinstance(ty, SimTypeArray):
+        return ty.elem_type
+    if isinstance(ty, SimTypeFixedSizeArray):
+        return ty.elem_type
+    return None
+
+
+def squash_array_reference(ty):
+    pointed_to = unpack_pointer(ty)
+    if pointed_to:
+        array_of = unpack_array(pointed_to)
+        if array_of:
+            return SimTypePointer(array_of)
+    return ty

{angr-9.2.140.dist-info → angr-9.2.141.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: angr
-Version: 9.2.140
+Version: 9.2.141
 Summary: A multi-architecture binary analysis toolkit, with the ability to perform dynamic symbolic execution and various static analyses on binaries
 Home-page: https://github.com/angr/angr
 License: BSD-2-Clause
@@ -16,13 +16,13 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: CppHeaderParser
 Requires-Dist: GitPython
-Requires-Dist: ailment==9.2.140
-Requires-Dist: archinfo==9.2.140
+Requires-Dist: ailment==9.2.141
+Requires-Dist: archinfo==9.2.141
 Requires-Dist: cachetools
 Requires-Dist: capstone==5.0.3
 Requires-Dist: cffi>=1.14.0
-Requires-Dist: claripy==9.2.140
-Requires-Dist: cle==9.2.140
+Requires-Dist: claripy==9.2.141
+Requires-Dist: cle==9.2.141
 Requires-Dist: itanium-demangler
 Requires-Dist: mulpyplexer
 Requires-Dist: nampa
@@ -31,7 +31,7 @@ Requires-Dist: protobuf>=5.28.2
 Requires-Dist: psutil
 Requires-Dist: pycparser>=2.18
 Requires-Dist: pyformlang
-Requires-Dist: pyvex==9.2.140
+Requires-Dist: pyvex==9.2.141
 Requires-Dist: rich>=13.1.0
 Requires-Dist: sortedcontainers
 Requires-Dist: sympy