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

angr/analyses/cfg/indirect_jump_resolvers/mips_elf_got.py

@@ -0,0 +1,148 @@
+# pylint:disable=too-many-positional-arguments
+from __future__ import annotations
+import logging
+
+from capstone.mips_const import (
+    MIPS_REG_T7,
+    MIPS_REG_T8,
+    MIPS_REG_T9,
+    MIPS_REG_RA,
+    MIPS_REG_ZERO,
+    MIPS_OP_REG,
+    MIPS_OP_IMM,
+)
+
+import cle
+
+from .resolver import IndirectJumpResolver
+
+l = logging.getLogger(name=__name__)
+
+
+class MipsElfGotResolver(IndirectJumpResolver):
+    """
+    A timeless indirect jump resolver that resolves GOT stub entries in MIPS ELF binaries.
+
+    Reference: MIPS Assembly Language Programmer's Guide, Calling Position Independent Functions
+    """
+
+    def __init__(self, project):
+        super().__init__(project, timeless=True)
+
+        self._section_cache: dict[tuple[int, str], int] = {}
+        self._simproc_cache: dict[str, int] | None = None
+
+    def filter(self, cfg, addr, func_addr, block, jumpkind):
+        return jumpkind == "Ijk_Call" and addr == func_addr
+
+    def resolve(  # pylint:disable=unused-argument
+        self, cfg, addr, func_addr, block, jumpkind, func_graph_complete: bool = True, **kwargs
+    ):
+        # The stub must look like the following:
+        #   585b80  lw      $t9, -0x7ff0($gp)
+        #   585b84  move    $t7, $ra
+        #   585b88  jalr    $t9
+        #   585b8c  addiu   $t8, $zero, 0x84b
+
+        obj = self.project.loader.find_object_containing(addr)
+        if obj is None:
+            return False, []
+        if not isinstance(obj, cle.ELF):
+            return False, []
+        dynsym_addr = self._find_and_cache_section_addr(obj, ".dynsym")
+        if dynsym_addr is None:
+            return None
+
+        dynstr_addr = self._find_and_cache_section_addr(obj, ".dynstr")
+        if dynstr_addr is None:
+            return None
+
+        if block.size != 16:
+            return False, []
+        the_block = self.project.factory.block(block.addr, size=block.size)
+        if len(the_block.capstone.insns) != 4:
+            return False, []
+
+        insn0 = the_block.capstone.insns[0]
+        if not (
+            insn0.insn.mnemonic == "lw"
+            and insn0.insn.operands[0].type == MIPS_OP_REG
+            and insn0.insn.operands[0].reg == MIPS_REG_T9
+        ):
+            return False, []
+
+        insn1 = the_block.capstone.insns[1]
+        if not (
+            insn1.insn.mnemonic == "move"
+            and insn1.insn.operands[0].type == MIPS_OP_REG
+            and insn1.insn.operands[0].reg == MIPS_REG_T7
+            and insn1.insn.operands[1].type == MIPS_OP_REG
+            and insn1.insn.operands[1].reg == MIPS_REG_RA
+        ):
+            return False, []
+
+        insn2 = the_block.capstone.insns[2]
+        if not (
+            insn2.insn.mnemonic == "jalr"
+            and insn2.insn.operands[0].type == MIPS_OP_REG
+            and insn2.insn.operands[0].reg == MIPS_REG_T9
+        ):
+            return False, []
+
+        insn3 = the_block.capstone.insns[3]
+        if not (
+            insn3.insn.mnemonic == "addiu"
+            and insn3.insn.operands[0].type == MIPS_OP_REG
+            and insn3.insn.operands[0].reg == MIPS_REG_T8
+            and insn3.insn.operands[1].type == MIPS_OP_REG
+            and insn3.insn.operands[1].reg == MIPS_REG_ZERO
+            and insn3.insn.operands[2].type == MIPS_OP_IMM
+        ):
+            return False, []
+
+        dynsym_index = insn3.insn.operands[2].imm
+        symbol_addr = dynsym_addr + dynsym_index * 16
+
+        symbol_name_index = self.project.loader.memory.unpack_word(symbol_addr, size=4)
+        symbol_name_addr = dynstr_addr + symbol_name_index
+        symbol_name_bytes = self.project.loader.memory.load_null_terminated_bytes(symbol_name_addr, 512)
+
+        try:
+            symbol_name = symbol_name_bytes.strip(b"\x00").decode("ascii")
+        except UnicodeDecodeError:
+            return False, []
+
+        symbol = obj.symbols_by_name.get(symbol_name, None)
+        if symbol is None:
+            return False, []
+
+        if symbol.rebased_addr != func_addr:
+            l.debug("Resolved target to %s @ %#x", symbol_name, symbol.rebased_addr)
+            return True, [symbol.rebased_addr]
+
+        # find out if there is a SimProcedure for this import symbol
+        simproc_addr = self._cache_and_find_simproc_by_name(symbol_name)
+        if simproc_addr is not None:
+            l.debug("Resolved target to %s @ %#x", symbol_name, simproc_addr)
+            return True, [simproc_addr]
+        return False, []
+
+    def _find_and_cache_section_addr(self, obj, section_name: str) -> int | None:
+        cache_key = (obj.min_addr, section_name)
+        if cache_key in self._section_cache:
+            return self._section_cache[cache_key]
+
+        for sec in obj.sections:
+            if sec.name == section_name:
+                # cache it
+                self._section_cache[cache_key] = sec.vaddr
+                return sec.vaddr
+        return None
+
+    def _cache_and_find_simproc_by_name(self, symbol_name: str) -> int | None:
+        if self._simproc_cache is None:
+            self._simproc_cache = {}
+            for addr, simproc in self.project._sim_procedures.items():
+                self._simproc_cache[simproc.display_name] = addr
+
+        return self._simproc_cache.get(symbol_name)

angr/analyses/cfg/indirect_jump_resolvers/resolver.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 import typing
 
-from ....errors import SimMemoryError
+from angr.errors import SimMemoryError
 
 if typing.TYPE_CHECKING:
-    from .... import Project
+    from angr import Project
 
 
 class IndirectJumpResolver:

angr/analyses/cfg/indirect_jump_resolvers/x86_pe_iat.py

@@ -3,7 +3,7 @@ import logging
 
 from capstone.x86_const import X86_OP_MEM
 
-from ....simos import SimWindows
+from angr.simos import SimWindows
 from .resolver import IndirectJumpResolver
 
 l = logging.getLogger(name=__name__)

angr/analyses/cfg_slice_to_sink/__init__.py

@@ -1,3 +1,11 @@
 from __future__ import annotations
+
 from .graph import slice_callgraph, slice_cfg_graph, slice_function_graph
 from .cfg_slice_to_sink import CFGSliceToSink
+
+__all__ = (
+    "CFGSliceToSink",
+    "slice_callgraph",
+    "slice_cfg_graph",
+    "slice_function_graph",
+)

angr/analyses/class_identifier.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
-from ..sim_type import SimCppClass, SimTypeCppFunction
-from ..analyses import AnalysesHub
+from angr.sim_type import SimCppClass, SimTypeCppFunction
+from angr.analyses import AnalysesHub
 from . import Analysis, CFGFast, VtableFinder
 
 

angr/analyses/code_tagging.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 import pyvex
 
-from ..utils import looks_like_sql
-from ..knowledge_plugins.xrefs import XRef
+from angr.utils import looks_like_sql
+from angr.knowledge_plugins.xrefs import XRef
 from . import Analysis, AnalysesHub
 
 

angr/analyses/complete_calling_conventions.py

@@ -14,8 +14,8 @@ import claripy
 
 from angr.utils.graph import GraphUtils
 from angr.simos import SimWindows
-from ..utils.mp import mp_context, Initializer
-from ..knowledge_plugins.cfg import CFGModel
+from angr.utils.mp import mp_context, Initializer
+from angr.knowledge_plugins.cfg import CFGModel
 from . import Analysis, register_analysis, VariableRecoveryFast, CallingConventionAnalysis
 
 if TYPE_CHECKING:
@@ -185,7 +185,7 @@ class CompleteCallingConventionsAnalysis(Analysis):
                 if self._cc_callback is not None:
                     self._cc_callback(func_addr)
 
-                percentage = idx + 1 / total_funcs * 100.0
+                percentage = (idx + 1) / total_funcs * 100.0
                 self._update_progress(percentage, text=f"{idx + 1}/{total_funcs} - {func.demangled_name}")
                 if self._low_priority:
                     self._release_gil(idx + 1, 10, 0.000001)

angr/analyses/congruency_check.py

@@ -6,7 +6,6 @@ import claripy
 from . import Analysis
 
 l = logging.getLogger(name=__name__)
-# l.setLevel(logging.DEBUG)
 
 
 class CongruencyCheck(Analysis):
@@ -373,7 +372,7 @@ class CongruencyCheck(Analysis):
         return True
 
 
-from ..errors import AngrIncongruencyError
+from angr.errors import AngrIncongruencyError
 from angr.analyses import AnalysesHub
 
 AnalysesHub.register_default("CongruencyCheck", CongruencyCheck)

angr/analyses/data_dep/__init__.py

@@ -1,3 +1,16 @@
 from __future__ import annotations
+
 from .data_dependency_analysis import DataDependencyGraphAnalysis
 from .dep_nodes import DepNodeTypes, BaseDepNode, VarDepNode, MemDepNode, ConstantDepNode, TmpDepNode, RegDepNode
+
+
+__all__ = (
+    "DataDependencyGraphAnalysis",
+    "DepNodeTypes",
+    "BaseDepNode",
+    "VarDepNode",
+    "MemDepNode",
+    "ConstantDepNode",
+    "TmpDepNode",
+    "RegDepNode",
+)

angr/analyses/data_dep/data_dependency_analysis.py

@@ -12,11 +12,11 @@ import claripy
 from claripy.ast.bv import BV
 from .dep_nodes import DepNodeTypes, ConstantDepNode, MemDepNode, VarDepNode, RegDepNode, TmpDepNode
 from .sim_act_location import SimActLocation, DEFAULT_LOCATION, ParsedInstruction
-from .. import Analysis
-from ...analyses import AnalysesHub
-from ...errors import AngrDDGError, AngrAnalysisError, SimValueError
-from ...state_plugins import SimActionData
-from ...storage import DefaultMemory
+from angr.analyses import Analysis
+from angr.analyses import AnalysesHub
+from angr.errors import AngrDDGError, AngrAnalysisError, SimValueError
+from angr.state_plugins import SimActionData
+from angr.storage import DefaultMemory
 
 if TYPE_CHECKING:
     from .dep_nodes import BaseDepNode

angr/analyses/datagraph_meta.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import logging
 
-from ..sim_procedure import SimProcedure
+from angr.sim_procedure import SimProcedure
 
 l = logging.getLogger(name=__name__)
 

angr/analyses/ddg.py

@@ -6,9 +6,9 @@ import networkx
 import pyvex
 from . import Analysis
 
-from ..code_location import CodeLocation
-from ..errors import SimSolverModeError, SimUnsatError, AngrDDGError
-from ..sim_variable import (
+from angr.code_location import CodeLocation
+from angr.errors import SimSolverModeError, SimUnsatError, AngrDDGError
+from angr.sim_variable import (
     SimRegisterVariable,
     SimMemoryVariable,
     SimTemporaryVariable,

angr/analyses/decompiler/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from .region_identifier import RegionIdentifier
 from .structured_codegen import CStructuredCodeGenerator, ImportSourceCode
 from .clinic import Clinic
@@ -10,7 +11,31 @@ from .callsite_maker import CallSiteMaker
 from .ail_simplifier import AILSimplifier
 from .ssailification import Ssailification
 from .dephication import GraphDephication, SeqNodeDephication
+from .presets import DECOMPILATION_PRESETS
 from . import structuring
 from . import optimization_passes
 
+
 StructuredCodeGenerator = CStructuredCodeGenerator
+
+
+__all__ = (
+    "RegionIdentifier",
+    "CStructuredCodeGenerator",
+    "ImportSourceCode",
+    "Clinic",
+    "RegionSimplifier",
+    "Decompiler",
+    "options",
+    "options_by_category",
+    "BlockSimplifier",
+    "CallSiteMaker",
+    "AILSimplifier",
+    "Ssailification",
+    "GraphDephication",
+    "SeqNodeDephication",
+    "DECOMPILATION_PRESETS",
+    "structuring",
+    "optimization_passes",
+    "StructuredCodeGenerator",
+)

angr/analyses/decompiler/ail_simplifier.py

@@ -27,14 +27,14 @@ from ailment.expression import (
 
 from angr.analyses.s_reaching_definitions import SRDAModel
 from angr.utils.ail import is_phi_assignment, HasExprWalker
-from ...code_location import CodeLocation, ExternalCodeLocation
-from ...sim_variable import SimStackVariable, SimMemoryVariable, SimVariable
-from ...knowledge_plugins.propagations.states import Equivalence
-from ...knowledge_plugins.key_definitions import atoms
-from ...knowledge_plugins.key_definitions.definition import Definition
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE
-from ...errors import AngrRuntimeError
-from .. import Analysis, AnalysesHub
+from angr.code_location import CodeLocation, ExternalCodeLocation
+from angr.sim_variable import SimStackVariable, SimMemoryVariable, SimVariable
+from angr.knowledge_plugins.propagations.states import Equivalence
+from angr.knowledge_plugins.key_definitions import atoms
+from angr.knowledge_plugins.key_definitions.definition import Definition
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE
+from angr.errors import AngrRuntimeError
+from angr.analyses import Analysis, AnalysesHub
 from .ailgraph_walker import AILGraphWalker
 from .expression_narrower import ExpressionNarrowingWalker
 from .block_simplifier import BlockSimplifier

angr/analyses/decompiler/block_simplifier.py

@@ -10,9 +10,9 @@ from ailment import AILBlockWalkerBase
 
 from angr.code_location import ExternalCodeLocation, CodeLocation
 
-from ...analyses.s_propagator import SPropagatorAnalysis
-from ...analyses.s_reaching_definitions import SReachingDefinitionsAnalysis, SRDAModel
-from .. import Analysis, register_analysis
+from angr.analyses.s_propagator import SPropagatorAnalysis
+from angr.analyses.s_reaching_definitions import SReachingDefinitionsAnalysis, SRDAModel
+from angr.analyses import Analysis, register_analysis
 from .peephole_optimizations import (
     MULTI_STMT_OPTS,
     STMT_OPTS,

angr/analyses/decompiler/callsite_maker.py

@@ -11,7 +11,7 @@ from angr.sim_type import SimTypeBottom, SimTypePointer, SimTypeChar, SimTypeInt
 from angr.calling_conventions import SimRegArg, SimStackArg, SimCC, SimStructArg
 from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE
 from angr.analyses import Analysis, register_analysis
-from angr.analyses.s_reaching_definitions.s_rda import SRDAView
+from angr.analyses.s_reaching_definitions import SRDAView
 from angr import SIM_LIBRARIES, SIM_TYPE_COLLECTIONS
 
 if TYPE_CHECKING:
@@ -284,7 +284,9 @@ class CallSiteMaker(Analysis):
 
             if vvar is not None:
                 vvar_value = view.get_vvar_value(vvar)
-                return vvar_value, vvar
+                if not isinstance(vvar_value, Expr.Phi):
+                    return vvar_value, vvar
+                return None, vvar
 
         return None
 
@@ -311,7 +313,7 @@ class CallSiteMaker(Analysis):
                 )
                 if vvar is not None:
                     value = view.get_vvar_value(vvar)
-                    if value is not None:
+                    if value is not None and not isinstance(value, Expr.Phi):
                         return None, value
                     return None, Expr.VirtualVariable(
                         self._atom_idx(),

angr/analyses/decompiler/ccall_rewriters/amd64_ccalls.py

@@ -240,6 +240,26 @@ class AMD64CCallRewriter(CCallRewriterBase):
 
                         r = Expr.BinaryOp(ccall.idx, expr_op, (masked_dep, zero), False, **ccall.tags)
                         return Expr.Convert(None, r.bits, ccall.bits, False, r, **ccall.tags)
+                    if op_v in {
+                        AMD64_OpTypes["G_CC_OP_DECB"],
+                        AMD64_OpTypes["G_CC_OP_DECW"],
+                        AMD64_OpTypes["G_CC_OP_DECL"],
+                        AMD64_OpTypes["G_CC_OP_DECQ"],
+                    }:
+                        # dep_1 == 0 or dep_1 != 0
+                        dep_1 = self._fix_size(
+                            dep_1,
+                            op_v,
+                            AMD64_OpTypes["G_CC_OP_SHRB"],
+                            AMD64_OpTypes["G_CC_OP_SHRW"],
+                            AMD64_OpTypes["G_CC_OP_SHRL"],
+                            ccall.tags,
+                        )
+                        expr_op = "CmpEQ" if cond_v == AMD64_CondTypes["CondZ"] else "CmpNE"
+
+                        zero = Expr.Const(None, None, 0, dep_1.bits)
+                        r = Expr.BinaryOp(ccall.idx, expr_op, (dep_1, zero), False, **ccall.tags)
+                        return Expr.Convert(None, r.bits, ccall.bits, False, r, **ccall.tags)
                 elif cond_v == AMD64_CondTypes["CondL"]:
                     if op_v in {
                         AMD64_OpTypes["G_CC_OP_SUBB"],

angr/analyses/decompiler/clinic.py

@@ -13,13 +13,13 @@ import capstone
 import ailment
 
 from angr.errors import AngrDecompilationError
-from ...knowledge_base import KnowledgeBase
-from ...knowledge_plugins.functions import Function
-from ...knowledge_plugins.cfg.memory_data import MemoryDataSort
-from ...codenode import BlockNode
-from ...utils import timethis
-from ...calling_conventions import SimRegArg, SimStackArg, SimFunctionArgument
-from ...sim_type import (
+from angr.knowledge_base import KnowledgeBase
+from angr.knowledge_plugins.functions import Function
+from angr.knowledge_plugins.cfg.memory_data import MemoryDataSort
+from angr.codenode import BlockNode
+from angr.utils import timethis
+from angr.calling_conventions import SimRegArg, SimStackArg, SimFunctionArgument
+from angr.sim_type import (
     SimTypeChar,
     SimTypeInt,
     SimTypeLongLong,
@@ -29,17 +29,16 @@ from ...sim_type import (
     SimTypeFloat,
     SimTypePointer,
 )
-from ..stack_pointer_tracker import Register, OffsetVal
-from ...sim_variable import SimVariable, SimStackVariable, SimRegisterVariable, SimMemoryVariable
-from ...procedures.stubs.UnresolvableCallTarget import UnresolvableCallTarget
-from ...procedures.stubs.UnresolvableJumpTarget import UnresolvableJumpTarget
-from .. import Analysis, register_analysis
-from ..cfg.cfg_base import CFGBase
-from ..reaching_definitions import ReachingDefinitionsAnalysis
+from angr.analyses.stack_pointer_tracker import Register, OffsetVal
+from angr.sim_variable import SimVariable, SimStackVariable, SimRegisterVariable, SimMemoryVariable
+from angr.procedures.stubs.UnresolvableCallTarget import UnresolvableCallTarget
+from angr.procedures.stubs.UnresolvableJumpTarget import UnresolvableJumpTarget
+from angr.analyses import Analysis, register_analysis
+from angr.analyses.cfg.cfg_base import CFGBase
+from angr.analyses.reaching_definitions import ReachingDefinitionsAnalysis
 from .return_maker import ReturnMaker
 from .ailgraph_walker import AILGraphWalker, RemoveNodeNotice
 from .optimization_passes import (
-    get_default_optimization_passes,
     OptimizationPassStage,
     RegisterSaveAreaSimplifier,
     StackCanarySimplifier,
@@ -129,7 +128,7 @@ class Clinic(Analysis):
         self._func_graph: networkx.DiGraph | None = None
         self._ail_manager = None
         self._blocks_by_addr_and_size = {}
-        self._entry_node_addr: tuple[int, int | None] = self.function.addr, None
+        self.entry_node_addr: tuple[int, int | None] = self.function.addr, None
 
         self._fold_callexprs_into_conditions = fold_callexprs_into_conditions
         self._insert_labels = insert_labels
@@ -165,8 +164,7 @@ class Clinic(Analysis):
         if optimization_passes is not None:
             self._optimization_passes = optimization_passes
         else:
-            self._optimization_passes = get_default_optimization_passes(self.project.arch, self.project.simos.name)
-            l.debug("Get %d optimization passes for the current binary.", len(self._optimization_passes))
+            self._optimization_passes = []
 
         if self._mode == ClinicMode.DECOMPILE:
             self._analyze_for_decompiling()
@@ -713,11 +711,11 @@ class Clinic(Analysis):
             if self._func_graph.in_degree(node) == 0 and CFGBase._is_noop_block(
                 self.project.arch, self.project.factory.block(node.addr, node.size)
             ):
-                if (node.addr, None) == self._entry_node_addr:
+                if (node.addr, None) == self.entry_node_addr:
                     # this is the entry node. after removing this node, the new entry node will be its successor
                     if self._func_graph.out_degree[node] == 1:
                         succ = next(iter(self._func_graph.successors(node)))
-                        self._entry_node_addr = succ.addr, None
+                        self.entry_node_addr = succ.addr, None
                     else:
                         # we just don't remove this node...
                         continue
@@ -1219,6 +1217,7 @@ class Clinic(Analysis):
                 graph=ail_graph,
                 variable_kb=variable_kb,
                 vvar_id_start=self.vvar_id_start,
+                entry_node_addr=self.entry_node_addr,
                 **kwargs,
             )
             if a.out_graph:
@@ -1240,7 +1239,7 @@ class Clinic(Analysis):
         ail_graph: networkx.DiGraph,
         arg_vvars: dict[int, tuple[ailment.Expr.VirtualVariable, SimVariable]],
     ) -> networkx.DiGraph:
-        entrypoint = next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr))
+        entrypoint = next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr))
         new_stmts = []
         for arg in arg_list:
             if not isinstance(arg, SimRegisterVariable):
@@ -1298,7 +1297,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_stackvars=False,
             vvar_id_start=self.vvar_id_start,
@@ -1311,7 +1310,7 @@ class Clinic(Analysis):
         ssailification = self.project.analyses.Ssailification(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             ail_manager=self._ail_manager,
             ssa_stackvars=True,
             vvar_id_start=self.vvar_id_start,
@@ -1324,7 +1323,7 @@ class Clinic(Analysis):
         dephication = self.project.analyses.GraphDephicationVVarMapping(
             self.function,
             ail_graph,
-            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self._entry_node_addr)),
+            entry=next(iter(bb for bb in ail_graph if (bb.addr, bb.idx) == self.entry_node_addr)),
             vvar_id_start=self.vvar_id_start,
         )
         self.vvar_id_start = dephication.vvar_id_start + 1
@@ -1798,10 +1797,10 @@ class Clinic(Analysis):
 
         graph = networkx.DiGraph()
 
-        entry_node = next(iter(node for node in func_graph if node.addr == self._entry_node_addr[0]), None)
+        entry_node = next(iter(node for node in func_graph if node.addr == self.entry_node_addr[0]), None)
         if entry_node is None:
             raise AngrDecompilationError(
-                f"Entry node with address {self._entry_node_addr[0]:#x} not found in the function graph"
+                f"Entry node with address {self.entry_node_addr[0]:#x} not found in the function graph"
             )
 
         # add the entry node into the graph

angr/analyses/decompiler/condition_processor.py

@@ -12,11 +12,11 @@ from unique_log_filter import UniqueLogFilter
 
 
 from angr.utils.graph import GraphUtils
-from ...utils.lazy_import import lazy_import
-from ...utils import is_pyinstaller
-from ...utils.graph import dominates, inverted_idoms
-from ...block import Block, BlockNode
-from ...errors import AngrRuntimeError
+from angr.utils.lazy_import import lazy_import
+from angr.utils import is_pyinstaller
+from angr.utils.graph import dominates, inverted_idoms
+from angr.block import Block, BlockNode
+from angr.errors import AngrRuntimeError
 from .peephole_optimizations import InvertNegatedLogicalConjunctionsAndDisjunctions
 from .structuring.structurer_nodes import (
     MultiNode,
@@ -158,6 +158,8 @@ _ail2claripy_op_mapping = {
     "ExpCmpNE": lambda expr, _, m: _dummy_bools(expr, m),
     "CmpORD": lambda expr, _, m: _dummy_bvs(expr, m),  # in case CmpORDRewriter fails
     "GetMSBs": lambda expr, _, m: _dummy_bvs(expr, m),
+    "InterleaveLOV": lambda expr, _, m: _dummy_bvs(expr, m),
+    "InterleaveHIV": lambda expr, _, m: _dummy_bvs(expr, m),
 }
 
 #

angr/analyses/decompiler/counters/__init__.py

@@ -1,5 +1,16 @@
 from __future__ import annotations
+
 from .boolean_counter import BooleanCounter
 from .call_counter import AILBlockCallCounter
 from .seq_cf_structure_counter import ControlFlowStructureCounter
 from .expression_counters import SingleExpressionCounter, RegisterExpressionCounter, OperatorCounter
+
+
+__all__ = (
+    "BooleanCounter",
+    "AILBlockCallCounter",
+    "ControlFlowStructureCounter",
+    "SingleExpressionCounter",
+    "RegisterExpressionCounter",
+    "OperatorCounter",
+)