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

angr/analyses/identifier/functions/strlen.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import random
 
-from ..func import Func, TestData
+from angr.analyses.identifier.func import Func, TestData
 
 
 class strlen(Func):

angr/analyses/identifier/functions/strncmp.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import random
 
-from ..func import Func, TestData
+from angr.analyses.identifier.func import Func, TestData
 
 
 def rand_str(length, byte_list=None):

angr/analyses/identifier/functions/strncpy.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import random
 
-from ..func import Func, TestData
+from angr.analyses.identifier.func import Func, TestData
 
 
 def rand_str(length, byte_list=None):

angr/analyses/identifier/functions/strtol.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 import random
 import string
 
-from ..func import Func, TestData
+from angr.analyses.identifier.func import Func, TestData
 
 
 digs = string.digits + string.ascii_letters

angr/analyses/identifier/identify.py

@@ -10,9 +10,9 @@ from networkx import NetworkXError
 from .errors import IdentifierException
 from .functions import Functions
 from .runner import Runner
-from .. import Analysis
-from ... import options
-from ...errors import AngrError, SimSegfaultError, SimEngineError, SimMemoryError, SimError
+from angr.analyses import Analysis
+from angr import options
+from angr.errors import AngrError, SimSegfaultError, SimEngineError, SimMemoryError, SimError
 
 l = logging.getLogger(name=__name__)
 

angr/analyses/identifier/runner.py

@@ -5,12 +5,12 @@ import os
 
 import claripy
 
-from ... import sim_options as so
-from ... import SIM_LIBRARIES
-from ... import BP_BEFORE, BP_AFTER
-from ...storage.file import SimFile, SimFileDescriptor
-from ...state_plugins import SimSystemPosix
-from ...errors import AngrCallableMultistateError, AngrCallableError, AngrError, SimError
+from angr import sim_options as so
+from angr import SIM_LIBRARIES
+from angr import BP_BEFORE, BP_AFTER
+from angr.storage.file import SimFile, SimFileDescriptor
+from angr.state_plugins import SimSystemPosix
+from angr.errors import AngrCallableMultistateError, AngrCallableError, AngrError, SimError
 from .custom_callable import IdentifierCallable
 
 

angr/analyses/init_finder.py

@@ -7,7 +7,7 @@ import pyvex
 import claripy
 
 from angr.analyses import visitors, ForwardAnalysis
-from ..engines.light import SimEngineLight, SimEngineLightVEXMixin
+from angr.engines.light import SimEngineLight, SimEngineLightVEXMixin
 from . import register_analysis, PropagatorAnalysis
 from .analysis import Analysis
 from .propagator.vex_vars import VEXTmp

angr/analyses/loop_analysis.py

@@ -3,8 +3,8 @@ from __future__ import annotations
 import logging
 
 from angr.analyses import ForwardAnalysis, visitors
-from ..block import SootBlockNode
-from ..errors import AngrLoopAnalysisError
+from angr.block import SootBlockNode
+from angr.errors import AngrLoopAnalysisError
 from . import register_analysis
 from .analysis import Analysis
 

angr/analyses/propagator/__init__.py

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

angr/analyses/propagator/engine_ail.py

@@ -11,10 +11,10 @@ from angr.knowledge_plugins.propagations.prop_value import PropValue, Detail
 from angr.knowledge_plugins.key_definitions.atoms import Register
 
 from angr.code_location import ExternalCodeLocation
-from ...utils.constants import is_alignment_mask
-from ...engines.light import SimEngineLightAILMixin
-from ...sim_variable import SimStackVariable, SimMemoryVariable
-from ..reaching_definitions.reaching_definitions import OP_BEFORE, OP_AFTER
+from angr.utils.constants import is_alignment_mask
+from angr.engines.light import SimEngineLightAILMixin
+from angr.sim_variable import SimStackVariable, SimMemoryVariable
+from angr.analyses.reaching_definitions.reaching_definitions import OP_BEFORE, OP_AFTER
 from .engine_base import SimEnginePropagatorBase
 
 if TYPE_CHECKING:

angr/analyses/propagator/engine_base.py

@@ -2,8 +2,8 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 import logging
 
-from ...engines.light import SimEngineLight
-from ...errors import SimEngineError
+from angr.engines.light import SimEngineLight
+from angr.errors import SimEngineError
 
 if TYPE_CHECKING:
     from angr.analyses.reaching_definitions.reaching_definitions import ReachingDefinitionsModel

angr/analyses/propagator/engine_vex.py

@@ -7,8 +7,8 @@ import pyvex
 import archinfo
 
 from angr.knowledge_plugins.propagations.states import RegisterAnnotation, RegisterComparisonAnnotation
-from ...engines.light import SimEngineLightVEXMixin
-from ...calling_conventions import DEFAULT_CC, SYSCALL_CC, default_cc, SimRegArg
+from angr.engines.light import SimEngineLightVEXMixin
+from angr.calling_conventions import DEFAULT_CC, SYSCALL_CC, default_cc, SimRegArg
 from .values import Top, Bottom
 from .engine_base import SimEnginePropagatorBase
 from .top_checker_mixin import TopCheckerMixin

angr/analyses/propagator/outdated_definition_walker.py

@@ -5,9 +5,9 @@ from collections.abc import Callable
 
 from ailment import Block, Stmt, Expr, AILBlockWalker
 
-from ...code_location import CodeLocation
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
-from ...knowledge_plugins.key_definitions import atoms
+from angr.code_location import CodeLocation
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
+from angr.knowledge_plugins.key_definitions import atoms
 
 if TYPE_CHECKING:
     from archinfo import Arch

angr/analyses/propagator/propagator.py

@@ -13,9 +13,9 @@ from angr.analyses import ForwardAnalysis, visitors
 from angr.knowledge_plugins.propagations.propagation_model import PropagationModel
 from angr.knowledge_plugins.propagations.prop_value import PropValue, Detail
 from angr.knowledge_plugins.propagations.states import PropagatorAILState, PropagatorVEXState, PropagatorState
-from ... import sim_options
-from .. import register_analysis
-from ..analysis import Analysis
+from angr import sim_options
+from angr.analyses import register_analysis
+from angr.analyses.analysis import Analysis
 from .engine_vex import SimEnginePropagatorVEX
 from .engine_ail import SimEnginePropagatorAIL
 import contextlib

angr/analyses/propagator/top_checker_mixin.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 import claripy
 
-from ...engines.light.engine import SimEngineLightMixin
+from angr.engines.light.engine import SimEngineLightMixin
 
 
 class TopCheckerMixin(SimEngineLightMixin):

angr/analyses/proximity_graph.py

@@ -7,9 +7,9 @@ import networkx
 import ailment
 from ailment import AILBlockWalker
 
-from ..codenode import BlockNode
-from ..sim_variable import SimMemoryVariable
-from ..knowledge_plugins.functions import Function
+from angr.codenode import BlockNode
+from angr.sim_variable import SimMemoryVariable
+from angr.knowledge_plugins.functions import Function
 from .analysis import Analysis, AnalysesHub
 
 if TYPE_CHECKING:

angr/analyses/reaching_definitions/__init__.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
-from typing import Set, Optional, Union, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
-from ...knowledge_plugins.key_definitions import LiveDefinitions
-from ...knowledge_plugins.key_definitions.constants import ObservationPointType
-from ...knowledge_plugins.key_definitions.atoms import (
+from angr.knowledge_plugins.key_definitions import LiveDefinitions
+from angr.knowledge_plugins.key_definitions.constants import ObservationPointType
+from angr.knowledge_plugins.key_definitions.atoms import (
     AtomKind,
     Atom,
     Register,
@@ -12,8 +12,8 @@ from ...knowledge_plugins.key_definitions.atoms import (
     GuardUse,
     ConstantSrc,
 )
-from ...knowledge_plugins.key_definitions.definition import Definition
-from .. import register_analysis
+from angr.knowledge_plugins.key_definitions.definition import Definition
+from angr.analyses import register_analysis
 from .reaching_definitions import ReachingDefinitionsAnalysis, ReachingDefinitionsModel
 from .function_handler import FunctionHandler, FunctionCallData
 from .rd_state import ReachingDefinitionsState

angr/analyses/reaching_definitions/dep_graph.py

@@ -13,8 +13,8 @@ import networkx
 import claripy
 from cle.loader import Loader
 
-from ...code_location import CodeLocation, ExternalCodeLocation
-from ...knowledge_plugins.key_definitions.atoms import (
+from angr.code_location import CodeLocation, ExternalCodeLocation
+from angr.knowledge_plugins.key_definitions.atoms import (
     Atom,
     MemoryLocation,
     AtomKind,
@@ -23,9 +23,9 @@ from ...knowledge_plugins.key_definitions.atoms import (
     ConstantSrc,
     GuardUse,
 )
-from ...knowledge_plugins.key_definitions.definition import A, Definition, DefinitionMatchPredicate
-from ...knowledge_plugins.key_definitions.undefined import UNDEFINED
-from ...knowledge_plugins.cfg import CFGModel
+from angr.knowledge_plugins.key_definitions.definition import A, Definition, DefinitionMatchPredicate
+from angr.knowledge_plugins.key_definitions.undefined import UNDEFINED
+from angr.knowledge_plugins.cfg import CFGModel
 
 if TYPE_CHECKING:
     pass

angr/analyses/reaching_definitions/engine_ail.py

@@ -10,14 +10,14 @@ import ailment
 import pyvex
 from claripy import FSORT_DOUBLE, FSORT_FLOAT
 
-from ...engines.light import SimEngineLight, SimEngineLightAILMixin, SpOffset
-from ...errors import SimEngineError, SimMemoryMissingError
-from ...calling_conventions import default_cc, SimRegArg, SimTypeBottom
-from ...storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from ...knowledge_plugins.key_definitions.atoms import Atom, Register, Tmp, MemoryLocation
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
-from ...knowledge_plugins.key_definitions.live_definitions import Definition, LiveDefinitions
-from ...code_location import CodeLocation, ExternalCodeLocation
+from angr.engines.light import SimEngineLight, SimEngineLightAILMixin, SpOffset
+from angr.errors import SimEngineError, SimMemoryMissingError
+from angr.calling_conventions import default_cc, SimRegArg, SimTypeBottom
+from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
+from angr.knowledge_plugins.key_definitions.atoms import Atom, Register, Tmp, MemoryLocation
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
+from angr.knowledge_plugins.key_definitions.live_definitions import Definition, LiveDefinitions
+from angr.code_location import CodeLocation, ExternalCodeLocation
 from .subject import SubjectType
 from .rd_state import ReachingDefinitionsState
 from .function_handler import FunctionHandler, FunctionCallData

angr/analyses/reaching_definitions/engine_vex.py

@@ -7,23 +7,23 @@ import logging
 import pyvex
 import claripy
 
-from ...storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from ...engines.light import SimEngineLight, SimEngineLightVEXMixin, SpOffset
-from ...engines.vex.claripy.datalayer import value as claripy_value
-from ...engines.vex.claripy.irop import operations as vex_operations
-from ...errors import SimEngineError, SimMemoryMissingError
-from ...utils.constants import DEFAULT_STATEMENT
-from ...knowledge_plugins.key_definitions.live_definitions import Definition, LiveDefinitions
-from ...knowledge_plugins.key_definitions.tag import LocalVariableTag, ParameterTag, Tag
-from ...knowledge_plugins.key_definitions.atoms import Atom, Register, MemoryLocation, Tmp
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
-from ...knowledge_plugins.key_definitions.heap_address import HeapAddress
-from ...code_location import CodeLocation, ExternalCodeLocation
+from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
+from angr.engines.light import SimEngineLight, SimEngineLightVEXMixin, SpOffset
+from angr.engines.vex.claripy.datalayer import value as claripy_value
+from angr.engines.vex.claripy.irop import operations as vex_operations
+from angr.errors import SimEngineError, SimMemoryMissingError
+from angr.utils.constants import DEFAULT_STATEMENT
+from angr.knowledge_plugins.key_definitions.live_definitions import Definition, LiveDefinitions
+from angr.knowledge_plugins.key_definitions.tag import LocalVariableTag, ParameterTag, Tag
+from angr.knowledge_plugins.key_definitions.atoms import Atom, Register, MemoryLocation, Tmp
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER
+from angr.knowledge_plugins.key_definitions.heap_address import HeapAddress
+from angr.code_location import CodeLocation, ExternalCodeLocation
 from .rd_state import ReachingDefinitionsState
 from .function_handler import FunctionCallData
 
 if TYPE_CHECKING:
-    from ...knowledge_plugins import FunctionManager
+    from angr.knowledge_plugins import FunctionManager
     from .function_handler import FunctionHandler
 
 
@@ -737,6 +737,11 @@ class SimEngineRDVEX(
 
         return MultiValues(self.state.top(bits))
 
+    def _handle_Mod(self, expr):
+        _, _ = self._expr(expr.args[0]), self._expr(expr.args[1])
+        bits = expr.result_size(self.tyenv)
+        return MultiValues(self.state.top(bits))
+
     def _handle_And(self, expr):
         expr0, expr1 = self._expr(expr.args[0]), self._expr(expr.args[1])
         bits = expr.result_size(self.tyenv)

angr/analyses/reaching_definitions/heap_allocator.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 import logging
 
 
-from ...knowledge_plugins.key_definitions.heap_address import HeapAddress
-from ...knowledge_plugins.key_definitions.unknown_size import UnknownSize
-from ...knowledge_plugins.key_definitions.undefined import Undefined
+from angr.knowledge_plugins.key_definitions.heap_address import HeapAddress
+from angr.knowledge_plugins.key_definitions.unknown_size import UnknownSize
+from angr.knowledge_plugins.key_definitions.undefined import Undefined
 
 _l = logging.getLogger(name=__name__)
 

angr/analyses/reaching_definitions/rd_state.py

@@ -13,16 +13,10 @@ from angr.knowledge_plugins.key_definitions.heap_address import HeapAddress
 from angr.knowledge_plugins.key_definitions.definition import A
 from angr.engines.light import SpOffset
 from angr.code_location import CodeLocation
-from ...storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
-from ...storage.memory_mixins import MultiValuedMemory
-from ...knowledge_plugins.key_definitions import LiveDefinitions, DerefSize, Definition
-from ...knowledge_plugins.key_definitions.atoms import (
-    Atom,
-    GuardUse,
-    Register,
-    MemoryLocation,
-    ConstantSrc,
-)
+from angr.storage.memory_mixins.paged_memory.pages.multi_values import MultiValues
+from angr.storage.memory_mixins import MultiValuedMemory
+from angr.knowledge_plugins.key_definitions import LiveDefinitions, DerefSize, Definition
+from angr.knowledge_plugins.key_definitions.atoms import Atom, GuardUse, Register, MemoryLocation, ConstantSrc
 from .heap_allocator import HeapAllocator
 from .subject import Subject, SubjectType
 from .rd_initializer import RDAStateInitializer

angr/analyses/reaching_definitions/reaching_definitions.py

@@ -8,17 +8,17 @@ import ailment
 import pyvex
 
 from angr.analyses import ForwardAnalysis
-from ...block import Block
-from ...knowledge_plugins.cfg.cfg_node import CFGNode
-from ...codenode import CodeNode
-from ...engines.light import SimEngineLight
-from ...knowledge_plugins.functions import Function
-from ...knowledge_plugins.key_definitions import ReachingDefinitionsModel, LiveDefinitions
-from ...knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER, ObservationPointType, ObservationPoint
-from ...code_location import CodeLocation, ExternalCodeLocation
-from ...misc.ux import deprecated
-from ..forward_analysis.visitors.graph import NodeType
-from ..analysis import Analysis
+from angr.block import Block
+from angr.knowledge_plugins.cfg.cfg_node import CFGNode
+from angr.codenode import CodeNode
+from angr.engines.light import SimEngineLight
+from angr.knowledge_plugins.functions import Function
+from angr.knowledge_plugins.key_definitions import ReachingDefinitionsModel, LiveDefinitions
+from angr.knowledge_plugins.key_definitions.constants import OP_BEFORE, OP_AFTER, ObservationPointType, ObservationPoint
+from angr.code_location import CodeLocation, ExternalCodeLocation
+from angr.misc.ux import deprecated
+from angr.analyses.forward_analysis.visitors.graph import NodeType
+from angr.analyses.analysis import Analysis
 from .engine_ail import SimEngineRDAIL
 from .engine_vex import SimEngineRDVEX
 from .rd_state import ReachingDefinitionsState

angr/analyses/reaching_definitions/subject.py

@@ -3,9 +3,9 @@ from enum import Enum
 
 import ailment
 
-from ...block import Block
-from ...knowledge_plugins.functions.function_manager import Function
-from ..forward_analysis import FunctionGraphVisitor, SingleNodeGraphVisitor
+from angr.block import Block
+from angr.knowledge_plugins.functions.function_manager import Function
+from angr.analyses.forward_analysis import FunctionGraphVisitor, SingleNodeGraphVisitor
 
 
 class SubjectType(Enum):

angr/analyses/reassembler.py

@@ -16,11 +16,11 @@ from . import Analysis
 from .cfg.cfg_emulated import CFGEmulated
 from .ddg import DDG
 from .cfg.cfg_fast import CFGFast
-from ..codenode import CodeNode
-from ..knowledge_plugins.cfg.memory_data import MemoryDataSort
-from ..knowledge_plugins.functions import Function
-from ..knowledge_base import KnowledgeBase
-from ..sim_variable import SimMemoryVariable, SimTemporaryVariable
+from angr.codenode import CodeNode
+from angr.knowledge_plugins.cfg.memory_data import MemoryDataSort
+from angr.knowledge_plugins.functions import Function
+from angr.knowledge_base import KnowledgeBase
+from angr.sim_variable import SimMemoryVariable, SimTemporaryVariable
 
 if TYPE_CHECKING:
     from .cfg import CFGNode

angr/analyses/{s_propagator/s_propagator.py → s_propagator.py}

@@ -38,7 +38,7 @@ class SPropagatorAnalysis(Analysis):
     Constant and expression propagation that only supports SSA AIL graphs.
     """
 
-    def __init__(
+    def __init__(  # pylint: disable=too-many-positional-arguments
         self,
         subject,
         func_graph=None,

angr/analyses/s_reaching_definitions/__init__.py

@@ -1,2 +1,12 @@
 from __future__ import annotations
-from .s_rda import SReachingDefinitionsAnalysis, SRDAModel, SRDAView
+
+from .s_rda_model import SRDAModel
+from .s_rda_view import SRDAView
+from .s_reaching_definitions import SReachingDefinitionsAnalysis
+
+
+__all__ = (
+    "SRDAModel",
+    "SRDAView",
+    "SReachingDefinitionsAnalysis",
+)

angr/analyses/s_reaching_definitions/s_rda_model.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Generator
+from typing import Any
+
+from ailment.expression import VirtualVariable, Tmp
+
+from angr.knowledge_plugins.key_definitions import atoms, Definition
+from angr.code_location import CodeLocation
+
+
+class SRDAModel:
+    """
+    The model for SRDA.
+    """
+
+    def __init__(self, func_graph, arch):
+        self.func_graph = func_graph
+        self.arch = arch
+        self.varid_to_vvar: dict[int, VirtualVariable] = {}
+        self.all_vvar_definitions: dict[VirtualVariable, CodeLocation] = {}
+        self.all_vvar_uses: dict[VirtualVariable, set[tuple[VirtualVariable | None, CodeLocation]]] = defaultdict(set)
+        self.all_tmp_definitions: dict[CodeLocation, dict[atoms.Tmp, int]] = defaultdict(dict)
+        self.all_tmp_uses: dict[CodeLocation, dict[atoms.Tmp, set[tuple[Tmp, int]]]] = defaultdict(dict)
+        self.phi_vvar_ids: set[int] = set()
+        self.phivarid_to_varids: dict[int, set[int]] = {}
+
+    @property
+    def all_definitions(self) -> Generator[Definition]:
+        for vvar, defloc in self.all_vvar_definitions.items():
+            yield Definition(atoms.VirtualVariable(vvar.varid, vvar.size, vvar.category, vvar.oident), defloc)
+
+    def is_phi_vvar_id(self, idx: int) -> bool:
+        return idx in self.phi_vvar_ids
+
+    def get_all_definitions(self, block_loc: CodeLocation) -> set[Definition]:
+        s = set()
+        for vvar, codeloc in self.all_vvar_definitions.items():
+            if codeloc.block_addr == block_loc.block_addr and codeloc.block_idx == block_loc.block_idx:
+                s.add(Definition(atoms.VirtualVariable(vvar.varid, vvar.size, vvar.category, vvar.oident), codeloc))
+        return s | self.get_all_tmp_definitions(block_loc)
+
+    def get_all_tmp_definitions(self, block_loc: CodeLocation) -> set[Definition]:
+        s = set()
+        for tmp_atom, stmt_idx in self.all_tmp_definitions[block_loc].items():
+            s.add(Definition(tmp_atom, CodeLocation(block_loc.block_addr, stmt_idx, block_idx=block_loc.block_idx)))
+        return s
+
+    def get_uses_by_location(
+        self, loc: CodeLocation, exprs: bool = False
+    ) -> set[Definition] | set[tuple[Definition, Any | None]]:
+        """
+        Retrieve all definitions that are used at a given location.
+
+        :param loc:     The code location.
+        :return:        A set of definitions that are used at the given location.
+        """
+        if exprs:
+            defs: set[tuple[Definition, Any]] = set()
+            for vvar, uses in self.all_vvar_uses.items():
+                for expr, loc_ in uses:
+                    if loc_ == loc:
+                        defs.add(
+                            (
+                                Definition(
+                                    atoms.VirtualVariable(vvar.varid, vvar.size, vvar.category, vvar.oident),
+                                    self.all_vvar_definitions[vvar],
+                                ),
+                                expr,
+                            )
+                        )
+            return defs
+
+        defs: set[Definition] = set()
+        for vvar, uses in self.all_vvar_uses.items():
+            for _, loc_ in uses:
+                if loc_ == loc:
+                    defs.add(
+                        Definition(
+                            atoms.VirtualVariable(vvar.varid, vvar.size, vvar.category, vvar.oident),
+                            self.all_vvar_definitions[vvar],
+                        )
+                    )
+        return defs
+
+    def get_vvar_uses(self, obj: atoms.VirtualVariable) -> set[CodeLocation]:
+        the_vvar = self.varid_to_vvar.get(obj.varid, None)
+        if the_vvar is not None:
+            return {loc for _, loc in self.all_vvar_uses[the_vvar]}
+        return set()
+
+    def get_vvar_uses_with_expr(self, obj: atoms.VirtualVariable) -> set[tuple[CodeLocation, VirtualVariable]]:
+        the_vvar = self.varid_to_vvar.get(obj.varid, None)
+        if the_vvar is not None:
+            return {(loc, expr) for expr, loc in self.all_vvar_uses[the_vvar]}
+        return set()
+
+    def get_tmp_uses(self, obj: atoms.Tmp, block_loc: CodeLocation) -> set[CodeLocation]:
+        if block_loc not in self.all_tmp_uses:
+            return set()
+        if obj not in self.all_tmp_uses[block_loc]:
+            return set()
+        s = set()
+        for _, stmt_idx in self.all_tmp_uses[block_loc][obj]:
+            s.add(CodeLocation(block_loc.block_addr, stmt_idx, block_idx=block_loc.block_idx))
+        return s
+
+    def get_uses_by_def(self, def_: Definition) -> set[CodeLocation]:
+        if isinstance(def_.atom, atoms.Tmp):
+            return self.get_tmp_uses(
+                def_.atom,
+                CodeLocation(def_.codeloc.block_addr, def_.codeloc.stmt_idx, block_idx=def_.codeloc.block_idx),
+            )
+        if isinstance(def_.atom, atoms.VirtualVariable):
+            return self.get_vvar_uses(def_.atom)
+        return set()