angr 9.2.116__py3-none-win_amd64.whl → 9.2.118__py3-none-win_amd64.whl

angr/engines/pcode/lifter.py

@@ -4,6 +4,7 @@
 #       to reduce duplication with Vex
 #     - Fix default_exit_target
 #     - Fix/remove NotImplementedError's
+from __future__ import annotations
 
 import logging
 from typing import Optional
@@ -129,7 +130,7 @@ class IRSB:
     _direct_next: bool | None
     _exit_statements: Sequence[tuple[int, int, ExitStatement]]
     _instruction_addresses: Sequence[int] | None
-    _ops: Sequence["pypcode.PcodeOp"]  # FIXME: Merge into _statements
+    _ops: Sequence[pypcode.PcodeOp]  # FIXME: Merge into _statements
     _size: int | None
     _statements: Iterable  # Note: currently unused
     _disassembly: PcodeDisassemblerBlock | None
@@ -237,7 +238,7 @@ class IRSB:
         jumpkind: str | None = None,
         direct_next: bool | None = None,
         size: int | None = None,
-    ) -> "IRSB":
+    ) -> IRSB:
         block = IRSB(None, addr, arch)
         block._set_attributes(statements, nxt, tyenv, jumpkind, direct_next, size=size)
         return block
@@ -250,7 +251,7 @@ class IRSB:
     def exit_statements(self) -> Sequence[tuple[int, int, ExitStatement]]:
         return self._exit_statements
 
-    def copy(self) -> "IRSB":
+    def copy(self) -> IRSB:
         """
         Copy by creating an empty IRSB and then filling in the leftover
         attributes. Copy is made as deep as possible
@@ -269,7 +270,7 @@ class IRSB:
 
         return new
 
-    def extend(self, extendwith: "IRSB") -> "IRSB":
+    def extend(self, extendwith: IRSB) -> IRSB:
         """
         Appends an irsb to the current irsb. The irsb that is appended is invalidated.
         The appended irsb's jumpkind and default exit are used.
@@ -295,12 +296,7 @@ class IRSB:
         print(self._pp_str())
 
     def __repr__(self) -> str:
-        return "IRSB <0x{:x} bytes, {} ins., {}> at 0x{:x}".format(
-            self.size,
-            self.instructions,
-            self.arch,
-            self.addr,
-        )
+        return f"IRSB <0x{self.size:x} bytes, {self.instructions} ins., {self.arch}> at 0x{self.addr:x}"
 
     def __str__(self) -> str:
         return self._pp_str()
@@ -335,7 +331,7 @@ class IRSB:
         """
         Return an iterator of all expressions contained in the IRSB.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     # FIXME: Rename this to num_instructions or something + fix pyvex IRSB.
     @property
@@ -371,7 +367,7 @@ class IRSB:
         """
         A list of all operations done by the IRSB, as libVEX enum names
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def all_constants(self):
@@ -379,14 +375,14 @@ class IRSB:
         Returns all constants in the block (including incrementing of the program counter) as
         :class:`pyvex.const.IRConst`.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def constants(self):
         """
         The constants (excluding updates of the program counter) in the IRSB as :class:`pyvex.const.IRConst`.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
     @property
     def constant_jump_targets(self):
@@ -439,10 +435,7 @@ class IRSB:
             else:
                 sa.append(f"   {i:02d} | {pypcode.PcodePrettyPrinter.fmt_op(op)}")
 
-        if isinstance(self.next, int):
-            next_str = "%x" % self.next
-        else:
-            next_str = str(self.next)
+        next_str = f"{self.next:x}" if isinstance(self.next, int) else str(self.next)
         sa.append(f"   NEXT: {next_str}; {self.jumpkind}")
         sa.append("}")
         return "\n".join(sa)
@@ -456,17 +449,17 @@ class IRSB:
         return self.default_exit_target is not None
 
     def _set_attributes(
-        self: "IRSB",
-        statements: Iterable = None,
+        self: IRSB,
+        statements: Iterable | None = None,
         nxt: int | None = None,
         tyenv=None,  # Unused, kept for compatibility
         jumpkind: str | None = None,
         direct_next: bool | None = None,
         size: int | None = None,
-        ops: Sequence["pypcode.PcodeOp"] | None = None,
+        ops: Sequence[pypcode.PcodeOp] | None = None,
         instruction_addresses: Iterable[int] | None = None,
-        exit_statements: Sequence[tuple[int, int, ExitStatement]] = None,
-        default_exit_target: Optional = None,
+        exit_statements: Sequence[tuple[int, int, ExitStatement]] | None = None,
+        default_exit_target: Optional | None = None,
     ) -> None:
         # pylint: disable=unused-argument
         self._statements = statements if statements is not None else []
@@ -479,7 +472,7 @@ class IRSB:
         self._exit_statements = exit_statements or []
         self.default_exit_target = default_exit_target
 
-    def _from_py(self, irsb: "IRSB") -> None:
+    def _from_py(self, irsb: IRSB) -> None:
         self._set_attributes(
             irsb.statements,
             irsb.next,
@@ -623,7 +616,7 @@ class Lifter:
         Ijk_NoDecode, signalling to pyvex that other lifters should be used on the undecodable data.
 
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 # pylint:disable=unused-argument
@@ -776,10 +769,7 @@ def lift(
         next_addr = addr + final_irsb.size
         if max_bytes is not None:
             max_bytes -= final_irsb.size
-        if isinstance(data, (str, bytes, bytearray)):
-            data_left = data[final_irsb.size :]
-        else:
-            data_left = data + final_irsb.size
+        data_left = data[final_irsb.size :] if isinstance(data, (str, bytes, bytearray)) else data + final_irsb.size
         if max_inst is not None:
             max_inst -= final_irsb.instructions
         if (max_bytes is None or max_bytes > 0) and (max_inst is None or max_inst > 0) and data_left:
@@ -814,7 +804,7 @@ class PcodeBasicBlockLifter:
     Lifts basic blocks to P-code
     """
 
-    context: "pypcode.Context"
+    context: pypcode.Context
     behaviors: BehaviorFactory
 
     def __init__(self, arch: archinfo.Arch):
@@ -827,8 +817,8 @@ class PcodeBasicBlockLifter:
                 "AVR8": "avr8:LE:16:atmega256",
             }
             if arch.name not in archinfo_to_lang_map:
-                l.error("Unknown mapping of %s to pcode languge id", arch.name)
-                raise NotImplementedError()
+                l.error("Unknown mapping of %s to pcode language id", arch.name)
+                raise NotImplementedError
             langid = archinfo_to_lang_map[arch.name]
 
         self.context = pypcode.Context(langid)
@@ -923,9 +913,8 @@ class PcodeBasicBlockLifter:
                 elif op.opcode == pypcode.OpCode.CALLIND:
                     if next_block is None:
                         next_block = (None, "Ijk_Call")
-                elif op.opcode == pypcode.OpCode.RETURN:
-                    if next_block is None:
-                        next_block = (None, "Ijk_Ret")
+                elif op.opcode == pypcode.OpCode.RETURN and next_block is None:
+                    next_block = (None, "Ijk_Ret")
 
             # FIXME: Do this lazily
             disasm = self.context.disassemble(
@@ -980,7 +969,7 @@ class PcodeLifter(Lifter):
 
         if self.irsb.size == 0:
             l.debug("raising lifting exception")
-            raise LiftingException("pypcode: could not decode any instructions @ 0x%x" % self.addr)
+            raise LiftingException(f"pypcode: could not decode any instructions @ 0x{self.addr:x}")
 
 
 class PcodeLifterEngineMixin(SimEngineBase):
@@ -1150,23 +1139,19 @@ class PcodeLifterEngineMixin(SimEngineBase):
         if num_inst is None and self._single_step:
             num_inst = 1
         if opt_level is None:
-            if state and o.OPTIMIZE_IR in state.options:
-                opt_level = 1
-            else:
-                opt_level = self._default_opt_level
+            opt_level = 1 if state and o.OPTIMIZE_IR in state.options else self._default_opt_level
         if strict_block_end is None:
             strict_block_end = self.default_strict_block_end
-        if self.selfmodifying_code:
-            if opt_level > 0:
-                if once("vex-engine-smc-opt-warning"):
-                    l.warning(
-                        "Self-modifying code is not always correctly optimized by"
-                        " PyVEX. To guarantee correctness, VEX optimizations have been"
-                        " disabled."
-                    )
-                opt_level = 0
-                if state and o.OPTIMIZE_IR in state.options:
-                    state.options.remove(o.OPTIMIZE_IR)
+        if self.selfmodifying_code and opt_level > 0:
+            if once("vex-engine-smc-opt-warning"):
+                l.warning(
+                    "Self-modifying code is not always correctly optimized by"
+                    " PyVEX. To guarantee correctness, VEX optimizations have been"
+                    " disabled."
+                )
+            opt_level = 0
+            if state and o.OPTIMIZE_IR in state.options:
+                state.options.remove(o.OPTIMIZE_IR)
         if skip_stmts is not True:
             skip_stmts = False
 
@@ -1202,23 +1187,21 @@ class PcodeLifterEngineMixin(SimEngineBase):
                 stop_point = self._first_stoppoint(irsb, extra_stop_points)
                 if stop_point is None:
                     return irsb
-                else:
-                    size = stop_point - addr
-                    # check the cache again
-                    cache_key = (
-                        addr,
-                        insn_bytes,
-                        size,
-                        num_inst,
-                        thumb,
-                        opt_level,
-                        strict_block_end,
-                    )
-                    if cache_key in self._block_cache:
-                        self._block_cache_hits += 1
-                        return self._block_cache[cache_key]
-                    else:
-                        self._block_cache_misses += 1
+                size = stop_point - addr
+                # check the cache again
+                cache_key = (
+                    addr,
+                    insn_bytes,
+                    size,
+                    num_inst,
+                    thumb,
+                    opt_level,
+                    strict_block_end,
+                )
+                if cache_key in self._block_cache:
+                    self._block_cache_hits += 1
+                    return self._block_cache[cache_key]
+                self._block_cache_misses += 1
             else:
                 # a special case: `size` is used as the maximum allowed size
                 tmp_cache_key = (
@@ -1249,7 +1232,7 @@ class PcodeLifterEngineMixin(SimEngineBase):
             buff, size, _ = self._load_bytes(addr, size, state, clemory)
 
         if not buff or size == 0:
-            raise SimEngineError("No bytes in memory for block starting at %#x." % addr)
+            raise SimEngineError(f"No bytes in memory for block starting at {addr:#x}.")
 
         # phase 5: lift to pcode
         l.debug("Creating pcode.IRSB of arch %s at %#x", arch.name, addr)
@@ -1333,7 +1316,7 @@ class PcodeLifterEngineMixin(SimEngineBase):
                                 "to, open an issue."
                             )
                         else:
-                            raise TypeError("Unsupported backer type %s." % type(backer))
+                            raise TypeError(f"Unsupported backer type {type(backer)}.")
             elif state:
                 if state.memory.SUPPORTS_CONCRETE_LOAD:
                     buff = state.memory.concrete_load(addr, max_size)
@@ -1378,19 +1361,19 @@ class PcodeLifterEngineMixin(SimEngineBase):
 
         first_imark = True
         for addr in irsb.instruction_addresses:
-            if not first_imark:
-                if self.__is_stop_point(addr, extra_stop_points):
-                    # could this part be moved by pyvex?
-                    return addr
+            if not first_imark and self.__is_stop_point(addr, extra_stop_points):
+                # could this part be moved by pyvex?
+                return addr
             first_imark = False
         return None
 
     def __is_stop_point(self, addr: int, extra_stop_points: Sequence[int] | None = None) -> bool:
-        if self.project is not None and addr in self.project._sim_procedures:
-            return True
-        elif extra_stop_points is not None and addr in extra_stop_points:
-            return True
-        return False
+        return bool(
+            self.project is not None
+            and addr in self.project._sim_procedures
+            or extra_stop_points is not None
+            and addr in extra_stop_points
+        )
 
     def __getstate__(self):
         ostate = super().__getstate__()

angr/engines/procedure.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 l = logging.getLogger(name=__name__)

angr/engines/soot/__init__.py

@@ -1 +1,2 @@
+from __future__ import annotations
 from .engine import SootMixin

angr/engines/soot/engine.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
 import logging
 
+import claripy
 from archinfo.arch_soot import (
     ArchSoot,
     SootAddressDescriptor,
@@ -37,30 +39,29 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         try:
             method = the_binary.get_soot_method(method, params=method.params)
         except CLEError as ex:
-            raise SimTranslationError(f"CLE error: {ex}")
+            raise SimTranslationError("CLE error") from ex
 
         if stmt_idx is None:
             return method.blocks[0] if method.blocks else None
-        else:
-            # try:
-            #    _, block = method.block_by_label.floor_item(stmt_idx)
-            # except KeyError:
-            #    return None
-            # return block
-            # TODO: Re-enable the above code once bintrees are used
-
-            # FIXME: stmt_idx does not index from the start of the method but from the start
-            #        of the block therefore it always returns the block with label 0 independently
-            #        of where we are
-            # block = method.block_by_label.get(stmt_idx, None)
-            # if block is not None:
-            #     return block
-            # Slow path
-            for block_idx, block in enumerate(method.blocks):
-                # if block.label <= stmt_idx < block.label + len(block.statements):
-                if block_idx == addr.block_idx:
-                    return block
-            return None
+        # try:
+        #    _, block = method.block_by_label.floor_item(stmt_idx)
+        # except KeyError:
+        #    return None
+        # return block
+        # TODO: Re-enable the above code once bintrees are used
+
+        # FIXME: stmt_idx does not index from the start of the method but from the start
+        #        of the block therefore it always returns the block with label 0 independently
+        #        of where we are
+        # block = method.block_by_label.get(stmt_idx, None)
+        # if block is not None:
+        #     return block
+        # Slow path
+        for block_idx, block in enumerate(method.blocks):
+            # if block.label <= stmt_idx < block.label + len(block.statements):
+            if block_idx == addr.block_idx:
+                return block
+        return None
 
     def process_successors(self, successors, **kwargs):
         state = self.state
@@ -70,13 +71,13 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
 
         if isinstance(addr, SootAddressTerminator):
             successors.processed = True
-            return
+            return None
 
         if self.project.use_sim_procedures:
             procedure = self._get_sim_procedure(addr)
             if procedure is not None:
                 self.process_procedure(state, successors, procedure)
-                return
+                return None
 
         binary = state.regs._ip_binary
         method = binary.get_soot_method(addr.method, none_if_missing=True)
@@ -104,7 +105,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
             # STEP 4: Execute unconstrained procedure
             self.process_procedure(state, successors, procedure)
             # self._add_return_exit(state, successors)
-            return
+            return None
 
         block = method.blocks[addr.block_idx]
         starting_stmt_idx = addr.stmt_idx
@@ -116,6 +117,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         self._handle_soot_block(state, successors, block, starting_stmt_idx, method)
 
         successors.processed = True
+        return None
 
     def _handle_soot_block(self, state, successors, block, starting_stmt_idx, method=None):
         stmt = stmt_idx = None
@@ -134,7 +136,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
                 next_addr = self._get_next_linear_instruction(state, stmt_idx)
                 l.debug("Advancing execution linearly to %s", next_addr)
                 if next_addr is not None:
-                    successors.add_successor(state.copy(), next_addr, state.solver.true, "Ijk_Boring")
+                    successors.add_successor(state.copy(), next_addr, claripy.true, "Ijk_Boring")
 
     def _handle_soot_stmt(self, state, successors, stmt_idx, stmt):
         # execute statement
@@ -172,11 +174,11 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
             # add invoke state as the successor and terminate execution
             # prematurely, since Soot does not guarantee that an invoke stmt
             # terminates a block
-            successors.add_successor(invoke_state, addr, state.solver.true, "Ijk_Call")
+            successors.add_successor(invoke_state, addr, claripy.true, "Ijk_Call")
             return True
 
         # add jmp exit
-        elif s_stmt.has_jump_targets:
+        if s_stmt.has_jump_targets:
             for target, condition in s_stmt.jmp_targets_with_conditions:
                 if not target:
                     target = self._get_next_linear_instruction(state, stmt_idx)
@@ -185,20 +187,19 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
             return True
 
         # add return exit
-        elif isinstance(s_stmt, (SimSootStmt_Return, SimSootStmt_ReturnVoid)):
+        if isinstance(s_stmt, (SimSootStmt_Return, SimSootStmt_ReturnVoid)):
             l.debug("Return exit")
             self._add_return_exit(state, successors, s_stmt.return_value)
             return True
 
         # go on linearly
-        else:
-            return False
+        return False
 
     @classmethod
     def _add_return_exit(cls, state, successors, return_val=None):
         ret_state = state.copy()
         cls.prepare_return_state(ret_state, return_val)
-        successors.add_successor(ret_state, state.callstack.ret_addr, ret_state.solver.true, "Ijk_Ret")
+        successors.add_successor(ret_state, state.callstack.ret_addr, claripy.true, "Ijk_Ret")
         successors.processed = True
 
     def _get_sim_procedure(self, addr):
@@ -231,9 +232,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         procedure_cls = SIM_PROCEDURES["angr.unconstrained"]["unconstrained()"]
 
         # Lazy-initialize it
-        proc = procedure_cls(project=self.project)
-
-        return proc
+        return procedure_cls(project=self.project)
 
     @staticmethod
     def _is_method_beginning(addr):
@@ -248,17 +247,15 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         new_stmt_idx = addr.stmt_idx + 1
         if new_stmt_idx < len(current_bb.statements):
             return SootAddressDescriptor(addr.method, addr.block_idx, new_stmt_idx)
-        else:
-            new_bb_idx = addr.block_idx + 1
-            if new_bb_idx < len(method.blocks):
-                return SootAddressDescriptor(addr.method, new_bb_idx, 0)
-            else:
-                l.warning(
-                    "falling into a non existing bb: %d in %s",
-                    new_bb_idx,
-                    SootMethodDescriptor.from_soot_method(method),
-                )
-                raise IncorrectLocationException()
+        new_bb_idx = addr.block_idx + 1
+        if new_bb_idx < len(method.blocks):
+            return SootAddressDescriptor(addr.method, new_bb_idx, 0)
+        l.warning(
+            "falling into a non existing bb: %d in %s",
+            new_bb_idx,
+            SootMethodDescriptor.from_soot_method(method),
+        )
+        raise IncorrectLocationException
 
     @classmethod
     def setup_callsite(cls, state, args, ret_addr, ret_var=None):
@@ -321,11 +318,11 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         if type(statement) is SimSootStmt_Return:
             exit_code = statement.return_value
             # TODO symbolic exit code?
-            exit_code = state.solver.BVV(exit_code, state.arch.bits)
+            exit_code = claripy.BVV(exit_code, state.arch.bits)
         state.history.add_event("terminate", exit_code=exit_code)
-        successors.add_successor(state, state.regs.ip, state.solver.true, "Ijk_Exit")
+        successors.add_successor(state, state.regs.ip, claripy.true, "Ijk_Exit")
         successors.processed = True
-        raise BlockTerminationNotice()
+        raise BlockTerminationNotice
 
     #
     # JNI Native Interface
@@ -345,7 +342,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
 
         # set successor flags
         ret_state.regs._ip = ret_state.callstack.ret_addr
-        ret_state.scratch.guard = ret_state.solver.true
+        ret_state.scratch.guard = claripy.true
         ret_state.history.jumpkind = "Ijk_Ret"
 
         # if available, lookup the return value in native memory
@@ -353,9 +350,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
         if ret_var is not None:
             # get return symbol from native state
             native_cc = javavm_simos.get_native_cc()
-            ret_symbol = (
-                native_cc.return_val(javavm_simos.get_native_type(ret_var.type)).get_value(native_state).to_claripy()
-            )
+            ret_symbol = native_cc.return_val(javavm_simos.get_native_type(ret_var.type)).get_value(native_state)
             # convert value to java type
             if ret_var.type in ArchSoot.primitive_types:
                 # return value has a primitive type
@@ -401,7 +396,7 @@ class SootMixin(SuccessorsMixin, ProcedureMixin):
             ref = SootArgument(class_, "Class")
 
         # add to args
-        final_args = [jni_env, ref] + args
+        final_args = [jni_env, ref, *args]
 
         # Step 3: generate C prototype from java_method
         voidp = parse_type("void*")

angr/engines/soot/exceptions.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+
 class BlockTerminationNotice(Exception):
     pass
 

angr/engines/soot/expressions/__init__.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 l = logging.getLogger("angr.engines.soot.expressions")

angr/engines/soot/expressions/arrayref.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 from ..values import SimSootValue_ArrayRef

angr/engines/soot/expressions/base.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from . import translate_expr
 from ..values import translate_value
 
@@ -11,12 +12,10 @@ class SimSootExpr:
         self._execute()
 
     def _execute(self):
-        raise NotImplementedError()
+        raise NotImplementedError
 
     def _translate_expr(self, expr):
-        expr_ = translate_expr(expr, self.state)
-        return expr_
+        return translate_expr(expr, self.state)
 
     def _translate_value(self, value):
-        value_ = translate_value(value, self.state)
-        return value_
+        return translate_value(value, self.state)

angr/engines/soot/expressions/binop.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import operator
 
 from .base import SimSootExpr

angr/engines/soot/expressions/cast.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 from archinfo import ArchSoot

angr/engines/soot/expressions/condition.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import operator
 
 from archinfo.arch_soot import SootNullConstant

angr/engines/soot/expressions/constants.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+import claripy
 from archinfo.arch_soot import SootClassDescriptor, SootNullConstant
 from claripy import FSORT_DOUBLE, FSORT_FLOAT
 
@@ -7,28 +9,28 @@ from .base import SimSootExpr
 
 class SimSootExpr_IntConstant(SimSootExpr):
     def _execute(self):
-        self.expr = self.state.solver.BVV(self.expr.value, 32)
+        self.expr = claripy.BVV(self.expr.value, 32)
 
 
 class SimSootExpr_LongConstant(SimSootExpr):
     def _execute(self):
-        self.expr = self.state.solver.BVV(self.expr.value, 64)
+        self.expr = claripy.BVV(self.expr.value, 64)
 
 
 class SimSootExpr_FloatConstant(SimSootExpr):
     def _execute(self):
-        self.expr = self.state.solver.FPV(self.expr.value, FSORT_FLOAT)
+        self.expr = claripy.FPV(self.expr.value, FSORT_FLOAT)
 
 
 class SimSootExpr_DoubleConstant(SimSootExpr):
     def _execute(self):
-        self.expr = self.state.solver.FPV(self.expr.value, FSORT_DOUBLE)
+        self.expr = claripy.FPV(self.expr.value, FSORT_DOUBLE)
 
 
 class SimSootExpr_StringConstant(SimSootExpr):
     def _execute(self):
         # strip away quotes introduced by soot
-        str_val = self.state.solver.StringV(self.expr.value.strip('"'))
+        str_val = claripy.StringV(self.expr.value.strip('"'))
         str_ref = SimSootValue_StringRef(self.state.memory.get_new_uuid())
         self.state.memory.store(str_ref, str_val)
         self.expr = str_ref

angr/engines/soot/expressions/instanceOf.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import logging
 
 from .base import SimSootExpr

angr/engines/soot/expressions/instancefieldref.py

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