angr 9.2.118__py3-none-macosx_11_0_arm64.whl → 9.2.120__py3-none-macosx_11_0_arm64.whl

angr/angrdb/serializers/structured_code.py

@@ -3,10 +3,10 @@ from typing import Any, TYPE_CHECKING
 import json
 import pickle
 
-from ...analyses.decompiler.structured_codegen import DummyStructuredCodeGenerator
-from ...analyses.decompiler.decompilation_cache import DecompilationCache
-from ...knowledge_plugins import StructuredCodeManager
-from ..models import DbStructuredCode
+from angr.analyses.decompiler.structured_codegen import DummyStructuredCodeGenerator
+from angr.analyses.decompiler.decompilation_cache import DecompilationCache
+from angr.knowledge_plugins import StructuredCodeManager
+from angr.angrdb.models import DbStructuredCode
 
 if TYPE_CHECKING:
     from angr.knowledge_base import KnowledgeBase

angr/angrdb/serializers/variables.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING
 
-from ...knowledge_plugins import VariableManager
-from ...knowledge_plugins.variables.variable_manager import VariableManagerInternal
-from ..models import DbVariableCollection
+from angr.knowledge_plugins import VariableManager
+from angr.knowledge_plugins.variables.variable_manager import VariableManagerInternal
+from angr.angrdb.models import DbVariableCollection
 
 if TYPE_CHECKING:
     from angr.knowledge_base import KnowledgeBase

angr/angrdb/serializers/xrefs.py

@@ -1,7 +1,7 @@
 # pylint:disable=unused-import
 from __future__ import annotations
-from ..models import DbXRefs
-from ...knowledge_plugins.xrefs import XRefManager
+from angr.angrdb.models import DbXRefs
+from angr.knowledge_plugins.xrefs import XRefManager
 
 
 class XRefsSerializer:

angr/calling_conventions.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 import logging
 from typing import cast
+from collections.abc import Iterable
 from collections import defaultdict
 
 import claripy
@@ -49,6 +50,7 @@ class AllocHelper:
         self.base = claripy.BVS("alloc_base", ptrsize)
         self.ptr = self.base
         self.stores = {}
+        self.store_asts = {}
 
     def alloc(self, size):
         out = self.ptr
@@ -58,7 +60,7 @@ class AllocHelper:
     def dump(self, val, state, loc=None):
         if loc is None:
             loc = self.stack_loc(val, state.arch)
-        self.stores[self.ptr.cache_key] = (val, loc)
+        self.stores[self.ptr] = (val, loc)
         return self.alloc(self.calc_size(val, state.arch))
 
     def translate(self, val, base):
@@ -66,7 +68,7 @@ class AllocHelper:
             return SimStructValue(
                 val.struct, {field: self.translate(subval, base) for field, subval in val._values.items()}
             )
-        if isinstance(val, claripy.Bits):
+        if isinstance(val, claripy.ast.Bits):
             return val.replace(self.base, base)
         if type(val) is list:
             return [self.translate(subval, base) for subval in val]
@@ -75,7 +77,7 @@ class AllocHelper:
     def apply(self, state, base):
         for ptr, (val, loc) in self.stores.items():
             translated_val = self.translate(val, base)
-            translated_ptr = self.translate(ptr.ast, base)
+            translated_ptr = self.translate(ptr, base)
             loc.set_value(state, translated_val, stack_base=translated_ptr)
 
     def size(self):
@@ -87,7 +89,7 @@ class AllocHelper:
     def calc_size(cls, val, arch):
         if type(val) is SimStructValue:
             return val.struct.size // arch.byte_width
-        if isinstance(val, claripy.Bits):
+        if isinstance(val, claripy.ast.Bits):
             return len(val) // arch.byte_width
         if type(val) is list:
             # TODO real strides
@@ -98,7 +100,7 @@ class AllocHelper:
 
     @classmethod
     def stack_loc(cls, val, arch, offset=0):
-        if isinstance(val, claripy.Bits):
+        if isinstance(val, claripy.ast.Bits):
             return SimStackArg(offset, len(val) // arch.byte_width)
         if type(val) is list:
             # TODO real strides
@@ -264,7 +266,7 @@ class SimFunctionArgument:
     def refine(self, size, arch=None, offset=None, is_fp=None):
         raise NotImplementedError
 
-    def get_footprint(self) -> list[SimRegArg | SimStackArg]:
+    def get_footprint(self) -> Iterable[SimRegArg | SimStackArg]:
         """
         Return a list of SimRegArg and SimStackArgs that are the base components used for this location
         """
@@ -289,13 +291,18 @@ class SimRegArg(SimFunctionArgument):
         self.clear_entire_reg = clear_entire_reg
 
     def get_footprint(self):
-        yield self
+        return {self}
 
     def __repr__(self):
         return f"<{self.reg_name}>"
 
     def __eq__(self, other):
-        return type(other) is SimRegArg and self.reg_name == other.reg_name and self.reg_offset == other.reg_offset
+        return (
+            type(other) is SimRegArg
+            and self.reg_name == other.reg_name
+            and self.reg_offset == other.reg_offset
+            and self.size == other.size
+        )
 
     def __hash__(self):
         return hash((self.size, self.reg_name, self.reg_offset))
@@ -337,12 +344,12 @@ class SimStackArg(SimFunctionArgument):
     :ivar bool is_fp:  Whether loads from this location should return a floating point bitvector
     """
 
-    def __init__(self, stack_offset, size, is_fp=False):
+    def __init__(self, stack_offset: int, size: int, is_fp: bool = False):
         SimFunctionArgument.__init__(self, size, is_fp)
-        self.stack_offset = stack_offset
+        self.stack_offset: int = stack_offset
 
     def get_footprint(self):
-        yield self
+        return {self}
 
     def __repr__(self):
         return f"[{self.stack_offset:#x}]"
@@ -385,8 +392,7 @@ class SimComboArg(SimFunctionArgument):
         self.locations = locations
 
     def get_footprint(self):
-        for x in self.locations:
-            yield from x.get_footprint()
+        return {y for x in self.locations for y in x.get_footprint()}
 
     def __repr__(self):
         return f"SimComboArg({self.locations!r})"
@@ -423,8 +429,21 @@ class SimStructArg(SimFunctionArgument):
         self.locs = locs
 
     def get_footprint(self):
-        for x in self.locs.values():
-            yield from x.get_footprint()
+        regs: defaultdict[str, set[SimRegArg]] = defaultdict(set)
+        others: set[SimRegArg | SimStackArg] = set()
+        for loc in self.locs.values():
+            for footloc in loc.get_footprint():
+                if isinstance(footloc, SimRegArg):
+                    regs[footloc.reg_name].add(footloc)
+                else:
+                    others.add(footloc)
+
+        for reg, locset in regs.items():
+            min_offset = min(loc.reg_offset for loc in locset)
+            max_offset = max(loc.reg_offset + loc.size for loc in locset)
+            others.add(SimRegArg(reg, max_offset - min_offset, min_offset))
+
+        return others
 
     def get_value(self, state, **kwargs):
         return SimStructValue(
@@ -442,8 +461,7 @@ class SimArrayArg(SimFunctionArgument):
         self.locs = locs
 
     def get_footprint(self):
-        for x in self.locs:
-            yield from x.get_footprint()
+        return {y for x in self.locs for y in x.get_footprint()}
 
     def get_value(self, state, **kwargs):
         return [getter.get_value(state, **kwargs) for getter in self.locs]
@@ -470,7 +488,7 @@ class SimReferenceArgument(SimFunctionArgument):
         self.main_loc = main_loc
 
     def get_footprint(self):
-        yield from self.ptr_loc.get_footprint()
+        return self.main_loc.get_footprint()
 
     def get_value(self, state, **kwargs):
         ptr_val = self.ptr_loc.get_value(state, **kwargs)
@@ -946,7 +964,7 @@ class SimCC:
                 raise TypeError(f"Type mismatch: expected {ty}, got pointer-wrapper")
 
             if arg.buffer:
-                if isinstance(arg.value, claripy.Bits):
+                if isinstance(arg.value, claripy.ast.Bits):
                     real_value = arg.value.chop(state.arch.byte_width)
                 elif type(arg.value) in (bytes, str):
                     real_value = claripy.BVV(arg.value).chop(8)
@@ -1069,15 +1087,21 @@ class SimCC:
         if sp_delta != cls.STACKARG_SP_DIFF:
             return False
 
+        def _arg_ident(a: SimRegArg | SimStackArg) -> int | str:
+            if isinstance(a, SimRegArg):
+                return a.reg_name
+            return a.stack_offset
+
         sample_inst = cls(arch)
-        all_fp_args = list(sample_inst.fp_args)
-        all_int_args = list(sample_inst.int_args)
+        all_fp_args: set[int | str] = {_arg_ident(a) for a in sample_inst.fp_args}
+        all_int_args: set[int | str] = {_arg_ident(a) for a in sample_inst.int_args}
         both_iter = sample_inst.memory_args
-        some_both_args = [next(both_iter) for _ in range(len(args))]
+        some_both_args: set[int | str] = {_arg_ident(next(both_iter)) for _ in range(len(args))}
 
         new_args = []
         for arg in args:
-            if arg not in all_fp_args and arg not in all_int_args and arg not in some_both_args:
+            arg_ident = _arg_ident(arg)
+            if arg_ident not in all_fp_args and arg_ident not in all_int_args and arg_ident not in some_both_args:
                 if isinstance(arg, SimRegArg) and arg.reg_name in sample_inst.CALLER_SAVED_REGS:
                     continue
                 return False
@@ -1258,6 +1282,8 @@ class SimCCMicrosoftAMD64(SimCC):
 
     ArgSession = MicrosoftAMD64ArgSession
 
+    STRUCT_RETURN_THRESHOLD = 64
+
     def next_arg(self, session, arg_type):
         if isinstance(arg_type, (SimTypeArray, SimTypeFixedSizeArray)):  # hack
             arg_type = SimTypePointer(arg_type.elem_type).with_arch(self.arch)
@@ -1282,7 +1308,26 @@ class SimCCMicrosoftAMD64(SimCC):
     def return_in_implicit_outparam(self, ty):
         if isinstance(ty, SimTypeBottom):
             return False
-        return not isinstance(ty, SimTypeFloat) and ty.size > 64
+        return not isinstance(ty, SimTypeFloat) and ty.size > self.STRUCT_RETURN_THRESHOLD
+
+    def return_val(self, ty, perspective_returned=False):
+        if ty._arch is None:
+            ty = ty.with_arch(self.arch)
+        if not isinstance(ty, SimStruct):
+            return super().return_val(ty, perspective_returned)
+
+        if ty.size > self.STRUCT_RETURN_THRESHOLD:
+            # TODO this code is duplicated a ton of places. how should it be a function?
+            byte_size = ty.size // self.arch.byte_width
+            referenced_locs = [SimStackArg(offset, self.arch.bytes) for offset in range(0, byte_size, self.arch.bytes)]
+            referenced_loc = refine_locs_with_struct_type(self.arch, referenced_locs, ty)
+            if perspective_returned:
+                ptr_loc = self.RETURN_VAL
+            else:
+                ptr_loc = self.next_arg(self.ArgSession(self), SimTypePointer(SimTypeBottom()).with_arch(self.arch))
+            return SimReferenceArgument(ptr_loc, referenced_loc)
+
+        return refine_locs_with_struct_type(self.arch, [self.RETURN_VAL], ty)
 
 
 class SimCCSyscall(SimCC):

angr/concretization_strategies/__init__.py

@@ -95,3 +95,20 @@ from .range import SimConcretizationStrategyRange
 from .single import SimConcretizationStrategySingle
 from .solutions import SimConcretizationStrategySolutions
 from .unlimited_range import SimConcretizationStrategyUnlimitedRange
+
+
+__all__ = (
+    "SimConcretizationStrategy",
+    "SimConcretizationStrategyAny",
+    "SimConcretizationStrategyControlledData",
+    "SimConcretizationStrategyEval",
+    "SimConcretizationStrategyMax",
+    "SimConcretizationStrategyNonzero",
+    "SimConcretizationStrategyNonzeroRange",
+    "SimConcretizationStrategyNorepeats",
+    "SimConcretizationStrategyNorepeatsRange",
+    "SimConcretizationStrategyRange",
+    "SimConcretizationStrategySingle",
+    "SimConcretizationStrategySolutions",
+    "SimConcretizationStrategyUnlimitedRange",
+)

angr/concretization_strategies/max.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from ..errors import SimSolverError
+from angr.errors import SimSolverError
 from . import SimConcretizationStrategy
 
 

angr/concretization_strategies/norepeats.py

@@ -29,8 +29,8 @@ class SimConcretizationStrategyNorepeats(SimConcretizationStrategy):
         )
 
     def merge(self, others):
-        seen = {s.cache_key for s in self._repeat_constraints}
+        seen = {s.hash() for s in self._repeat_constraints}
         for c in itertools.chain.from_iterable(o._repeat_constraints for o in others):
-            if c.cache_key not in seen:
-                seen.add(c.cache_key)
+            if c.hash() not in seen:
+                seen.add(c.hash())
                 self._repeat_constraints.append(c)

angr/concretization_strategies/norepeats_range.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from . import SimConcretizationStrategy
-from ..errors import SimMergeError
+from angr.errors import SimMergeError
 
 
 class SimConcretizationStrategyNorepeatsRange(SimConcretizationStrategy):

angr/distributed/__init__.py

@@ -1,4 +1,9 @@
-# angr.distributed provides a simple implementation for conducting long-running symbolic-execution-based tasks.
+""" angr.distributed provides a simple implementation for conducting
+long-running symbolic-execution-based tasks.
+"""
+
 from __future__ import annotations
 
 from .server import Server
+
+__all__ = ("Server",)

angr/distributed/server.py

@@ -9,7 +9,6 @@ from .worker import Worker
 
 
 _l = logging.getLogger(__name__)
-_l.setLevel(logging.INFO)
 
 
 class Server:

angr/distributed/worker.py

@@ -5,12 +5,11 @@ import logging
 import sys
 
 from angr.utils.mp import Initializer
-from ..exploration_techniques import ExplorationTechnique, Bucketizer
-from ..vaults import VaultDirShelf
+from angr.exploration_techniques import ExplorationTechnique, Bucketizer
+from angr.vaults import VaultDirShelf
 
 
 _l = logging.getLogger(__name__)
-_l.setLevel(logging.INFO)
 
 
 class BadStatesDropper(ExplorationTechnique):
@@ -86,7 +85,10 @@ class Worker:
     def run(self, initializer: Initializer):
         initializer.initialize()
 
-        from ..exploration_techniques.spiller import Spiller, PickledStatesDb  # pylint:disable=import-outside-toplevel
+        from angr.exploration_techniques.spiller import (
+            Spiller,
+            PickledStatesDb,
+        )  # pylint:disable=import-outside-toplevel
 
         _l.debug("Worker %d starts running...", self.worker_id)
         if self._recursion_limit is not None and self._recursion_limit != sys.getrecursionlimit():

angr/engines/__init__.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from .successors import SimSuccessors
 from .engine import SimEngine, SuccessorsMixin, TLSMixin
 
@@ -30,6 +31,28 @@ class UberEngine(
     pass
 
 
+__all__ = [
+    "SimSuccessors",
+    "SimEngine",
+    "SuccessorsMixin",
+    "TLSMixin",
+    "HeavyVEXMixin",
+    "TrackActionsMixin",
+    "SimInspectMixin",
+    "HeavyResilienceMixin",
+    "SuperFastpathMixin",
+    "ProcedureMixin",
+    "ProcedureEngine",
+    "SimEngineUnicorn",
+    "SimEngineFailure",
+    "SimEngineSyscall",
+    "SimEngineConcrete",
+    "HooksMixin",
+    "SootMixin",
+    "UberEngine",
+]
+
+
 try:
     from .pcode import HeavyPcodeMixin
 
@@ -38,5 +61,7 @@ try:
     ):  # pylint:disable=abstract-method
         pass
 
+    __all__.append("UberEnginePcode")
+
 except ImportError:
     pass

angr/engines/concrete.py

@@ -6,10 +6,9 @@ import claripy
 
 from angr.errors import AngrError
 from .engine import SuccessorsMixin
-from ..errors import SimConcreteRegisterError
+from angr.errors import SimConcreteRegisterError
 
 l = logging.getLogger("angr.engines.concrete")
-# l.setLevel(logging.DEBUG)
 
 try:
     from angr_targets.concrete import ConcreteTarget
@@ -61,7 +60,7 @@ class SimEngineConcrete(SuccessorsMixin):
 
         successors.engine = "SimEngineConcrete"
         successors.sort = "SimEngineConcrete"
-        successors.add_successor(new_state, new_state.ip, claripy.true, new_state.unicorn.jumpkind)
+        successors.add_successor(new_state, new_state.ip, claripy.true(), new_state.unicorn.jumpkind)
         successors.description = "Concrete Successors"
         successors.processed = True
 

angr/engines/engine.py

@@ -204,7 +204,7 @@ class SuccessorsMixin(SimEngine):
 
 
 # pylint:disable=wrong-import-position
-from .. import sim_options as o
-from ..state_plugins.inspect import BP_BEFORE, BP_AFTER
+from angr import sim_options as o
+from angr.state_plugins.inspect import BP_BEFORE, BP_AFTER
 from .successors import SimSuccessors
-from ..errors import SimException
+from angr.errors import SimException

angr/engines/failure.py

@@ -16,7 +16,7 @@ class SimEngineFailure(SuccessorsMixin, ProcedureMixin):
             raise AngrExitError(f"Cannot execute following jumpkind {jumpkind}")
 
         if jumpkind == "Ijk_Exit":
-            from ..procedures import SIM_PROCEDURES
+            from angr.procedures import SIM_PROCEDURES
 
             l.debug("Execution terminated at %#x", state.addr)
             terminator = SIM_PROCEDURES["stubs"]["PathTerminator"](project=self.project)
@@ -25,4 +25,4 @@ class SimEngineFailure(SuccessorsMixin, ProcedureMixin):
         return super().process_successors(successors, **kwargs)
 
 
-from ..errors import AngrExitError
+from angr.errors import AngrExitError

angr/engines/light/__init__.py

@@ -1,3 +1,15 @@
 from __future__ import annotations
+
 from .data import ArithmeticExpression, SpOffset, RegisterOffset
 from .engine import SimEngineLight, SimEngineLightVEXMixin, SimEngineLightAILMixin, SimEngineLightVEX, SimEngineLightAIL
+
+__all__ = (
+    "ArithmeticExpression",
+    "SpOffset",
+    "RegisterOffset",
+    "SimEngineLight",
+    "SimEngineLightVEXMixin",
+    "SimEngineLightAILMixin",
+    "SimEngineLightVEX",
+    "SimEngineLightAIL",
+)

angr/engines/light/data.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import ailment
 
-from ...utils.constants import is_alignment_mask
+from angr.utils.constants import is_alignment_mask
 
 
 class ArithmeticExpression:

angr/engines/light/engine.py

@@ -10,12 +10,12 @@ import pyvex
 import claripy
 import archinfo
 
-from ...misc.ux import once
-from ...engines.vex.claripy.datalayer import value as claripy_value
-from ...engines.vex.claripy.irop import UnsupportedIROpError, SimOperationError, vexop_to_simop
-from ...code_location import CodeLocation
-from ...utils.constants import DEFAULT_STATEMENT
-from ..engine import SimEngine
+from angr.misc.ux import once
+from angr.engines.vex.claripy.datalayer import value as claripy_value
+from angr.engines.vex.claripy.irop import UnsupportedIROpError, SimOperationError, vexop_to_simop
+from angr.code_location import CodeLocation
+from angr.utils.constants import DEFAULT_STATEMENT
+from angr.engines.engine import SimEngine
 import contextlib
 
 
@@ -419,7 +419,7 @@ class SimEngineLightVEXMixin(SimEngineLightMixin):
         vector_size, vector_count = None, None
         if handler is not None:
             # vector information
-            m = re.match(r"Iop_[^\d]+(\d+)U{0,1}x(\d+)", expr.op)
+            m = re.match(r"Iop_[^\d]+(\d+)[SU]{0,1}x(\d+)", expr.op)
             if m is not None:
                 vector_size = int(m.group(1))
                 vector_count = int(m.group(2))
@@ -1340,12 +1340,8 @@ class SimEngineLightAILMixin(SimEngineLightMixin):
         if expr_1 is None:
             expr_1 = arg1
 
-        try:
-            if isinstance(expr_1, claripy.ast.BV) and expr_1.concrete:
-                return expr_0 << expr_1.concrete_value
-        except TypeError:
-            pass
-
+        if isinstance(expr_0, claripy.ast.BV) and isinstance(expr_1, claripy.ast.BV) and expr_1.concrete:
+            return expr_0 << expr_1.concrete_value
         return ailment.Expr.BinaryOp(expr.idx, "Shl", [expr_0, expr_1], expr.signed, **expr.tags)
 
     def _ail_handle_Sal(self, expr):
@@ -1385,10 +1381,9 @@ class SimEngineLightAILMixin(SimEngineLightMixin):
         if expr_1 is None:
             expr_1 = arg1
 
-        try:
-            return expr_0 >> expr_1
-        except TypeError:
-            return ailment.Expr.BinaryOp(expr.idx, "Sar", [expr_0, expr_1], expr.signed, **expr.tags)
+        if isinstance(expr_0, claripy.ast.Bits) and isinstance(expr_1, claripy.ast.Bits) and expr_1.concrete:
+            return expr_0 >> expr_1.concrete_value
+        return ailment.Expr.BinaryOp(expr.idx, "Sar", [expr_0, expr_1], expr.signed, **expr.tags)
 
     def _ail_handle_Concat(self, expr):
         arg0, arg1 = expr.operands

angr/engines/pcode/__init__.py

@@ -1,3 +1,9 @@
 from __future__ import annotations
-from .engine import HeavyPcodeMixin
+
 from .cc import register_pcode_arch_default_cc
+from .engine import HeavyPcodeMixin
+
+__all__ = (
+    "register_pcode_arch_default_cc",
+    "HeavyPcodeMixin",
+)

angr/engines/pcode/behavior.py

@@ -5,7 +5,7 @@ from collections.abc import Callable, Iterable
 import claripy
 from claripy.ast.bv import BV
 
-from ...errors import AngrError
+from angr.errors import AngrError
 
 try:
     from pypcode import OpCode

angr/engines/pcode/cc.py

@@ -3,7 +3,7 @@ import logging
 
 from archinfo import ArchPcode
 
-from ...calling_conventions import (
+from angr.calling_conventions import (
     SimCC,
     SimRegArg,
     SimStackArg,

angr/engines/pcode/emulate.py

@@ -4,12 +4,12 @@ import logging
 import claripy
 from claripy.ast.bv import BV
 
-from ..engine import SimEngineBase
-from ...utils.constants import DEFAULT_STATEMENT
+from angr.engines.engine import SimEngineBase
+from angr.utils.constants import DEFAULT_STATEMENT
 from .lifter import IRSB
 from .behavior import OpBehavior
-from ...errors import AngrError
-from ...state_plugins.inspect import BP_BEFORE, BP_AFTER
+from angr.errors import AngrError
+from angr.state_plugins.inspect import BP_BEFORE, BP_AFTER
 import contextlib
 
 with contextlib.suppress(ImportError):

angr/engines/pcode/engine.py

@@ -7,9 +7,9 @@ import logging
 from angr.calling_conventions import DEFAULT_CC, default_cc, SimRegArg
 from angr.engines.engine import SuccessorsMixin, SimSuccessors
 from angr.misc.ux import once
-from ...utils.constants import DEFAULT_STATEMENT
-from ... import sim_options as o
-from ... import errors
+from angr.utils.constants import DEFAULT_STATEMENT
+from angr import sim_options as o
+from angr import errors
 from .lifter import PcodeLifterEngineMixin, IRSB
 from .emulate import PcodeEmulatorMixin
 
@@ -85,7 +85,7 @@ class HeavyPcodeMixin(
         successors.sort = "IRSB"
         successors.description = "IRSB"
         self.state.history.recent_block_count = 1
-        self.state.scratch.guard = claripy.true
+        self.state.scratch.guard = claripy.true()
         self.state.scratch.sim_procedure = None
         addr = successors.addr
         self.state.scratch.bbl_addr = addr
@@ -240,7 +240,7 @@ class HeavyPcodeMixin(
                 l.debug("%s adding postcall exit.", self)
 
                 ret_state = exit_state.copy()
-                guard = claripy.true if o.TRUE_RET_EMULATION_GUARD in self.state.options else claripy.false
+                guard = claripy.true() if o.TRUE_RET_EMULATION_GUARD in self.state.options else claripy.false()
                 ret_target = claripy.BVV(successors.addr + self.state.scratch.irsb.size, ret_state.arch.bits)
                 if ret_state.arch.call_pushes_ret and not exit_jumpkind.startswith("Ijk_Sys"):
                     ret_state.regs.sp = ret_state.regs.sp + ret_state.arch.bytes

angr/engines/pcode/lifter.py

@@ -20,13 +20,13 @@ from cachetools import LRUCache
 from pyvex.errors import PyVEXError, SkipStatementsError, LiftingException
 
 from .behavior import BehaviorFactory
-from ..engine import SimEngineBase
-from ...state_plugins.inspect import BP_AFTER, BP_BEFORE
-from ...sim_state import SimState
-from ...misc.ux import once
-from ...errors import SimEngineError, SimTranslationError, SimError
-from ... import sim_options as o
-from ...block import DisassemblerBlock, DisassemblerInsn
+from angr.engines.engine import SimEngineBase
+from angr.state_plugins.inspect import BP_AFTER, BP_BEFORE
+from angr.sim_state import SimState
+from angr.misc.ux import once
+from angr.errors import SimEngineError, SimTranslationError, SimError
+from angr import sim_options as o
+from angr.block import DisassemblerBlock, DisassemblerInsn
 
 
 try:

angr/engines/procedure.py

@@ -67,6 +67,6 @@ class ProcedureEngine(ProcedureMixin, SuccessorsMixin):
         self.process_procedure(self.state, successors, procedure, **kwargs)
 
 
-from .. import sim_options as o
-from .. import errors
-from ..state_plugins.inspect import BP_BEFORE, BP_AFTER
+from angr import sim_options as o
+from angr import errors
+from angr.state_plugins.inspect import BP_BEFORE, BP_AFTER

angr/engines/soot/__init__.py

@@ -1,2 +1,5 @@
 from __future__ import annotations
+
 from .engine import SootMixin
+
+__all__ = ("SootMixin",)