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

angr/utils/cowdict.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from collections import ChainMap
 
 
@@ -26,8 +27,7 @@ class ChainMapCOW(ChainMap):
             ch = self.new_child()
             ch.collapse_threshold = self.collapse_threshold
             return ch
-        else:
-            return self
+        return self
 
 
 class DefaultChainMapCOW(ChainMapCOW):
@@ -60,5 +60,4 @@ class DefaultChainMapCOW(ChainMapCOW):
             r.default_factory = self.default_factory
             r.collapse_threshold = self.collapse_threshold
             return r
-        else:
-            return self
+        return self

angr/utils/dynamic_dictlist.py

@@ -1,13 +1,10 @@
+from __future__ import annotations
 import platform
-from typing import Union, Generic, TypeVar
+from typing import Generic, TypeVar
 
 
 # Ref: https://github.com/angr/angr/pull/3471#issuecomment-1236515950
-if platform.python_implementation() == "PyPy":
-    LIST2DICT_THRESHOLD = 96
-else:
-    # cpython
-    LIST2DICT_THRESHOLD = 2048
+LIST2DICT_THRESHOLD = 96 if platform.python_implementation() == "PyPy" else 2048
 
 
 VT = TypeVar("VT")
@@ -27,7 +24,7 @@ class DynamicDictList(Generic[VT]):
     def __init__(
         self,
         max_size: int | None = None,
-        content: Union["DynamicDictList", dict[int, VT], list[VT]] | None = None,
+        content: DynamicDictList | dict[int, VT] | list[VT] | None = None,
     ):
         self.list_content: list[VT] | None = None
         self.dict_content: dict[int, VT] | None = None

angr/utils/endness.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from ailment.expression import Const
 
 

angr/utils/enums_conv.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-member
+from __future__ import annotations
 import logging
 
 l = logging.getLogger(name=__name__)

angr/utils/env.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 
 

angr/utils/formatting.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import sys
 from collections.abc import Sequence, Callable
 

angr/utils/funcid.py

@@ -1,4 +1,5 @@
 # pylint:disable=too-many-boolean-expressions
+from __future__ import annotations
 
 import capstone
 
@@ -31,7 +32,7 @@ def is_function_security_check_cookie(func, project, security_cookie_addr: int)
     return False
 
 
-def is_function_security_init_cookie(func: "Function", project, security_cookie_addr: int | None) -> bool:
+def is_function_security_init_cookie(func: Function, project, security_cookie_addr: int | None) -> bool:
     if func.is_plt or func.is_syscall or func.is_simprocedure:
         return False
     # the function should have only one return point
@@ -74,7 +75,7 @@ def is_function_security_init_cookie(func: "Function", project, security_cookie_
     return False
 
 
-def is_function_security_init_cookie_win8(func: "Function", project, security_cookie_addr: int) -> bool:
+def is_function_security_init_cookie_win8(func: Function, project, security_cookie_addr: int) -> bool:
     # disassemble the first instruction
     if func.is_plt or func.is_syscall or func.is_simprocedure:
         return False
@@ -113,21 +114,21 @@ def is_function_security_init_cookie_win8(func: "Function", project, security_co
     return False
 
 
-def is_function_likely_security_init_cookie(func: "Function") -> bool:
+def is_function_likely_security_init_cookie(func: Function) -> bool:
     """
     Conducts a fuzzy match for security_init_cookie function.
     """
 
     callees = [node for node in func.transition_graph if isinstance(node, Function)]
     callee_names = {callee.name for callee in callees}
-    if callee_names.issuperset(
-        {
-            "GetSystemTimeAsFileTime",
-            "GetCurrentProcessId",
-            "GetCurrentThreadId",
-            "GetTickCount",
-            "QueryPerformanceCounter",
-        }
-    ):
-        return True
-    return False
+    return bool(
+        callee_names.issuperset(
+            {
+                "GetSystemTimeAsFileTime",
+                "GetCurrentProcessId",
+                "GetCurrentThreadId",
+                "GetTickCount",
+                "QueryPerformanceCounter",
+            }
+        )
+    )

angr/utils/graph.py

@@ -1,4 +1,6 @@
-from collections import defaultdict
+from __future__ import annotations
+from typing import Any
+from collections import defaultdict, OrderedDict
 import logging
 
 import networkx
@@ -183,10 +185,7 @@ def dominates(idom, dominator_node, node):
     while n:
         if n == dominator_node:
             return True
-        if n in idom and n != idom[n]:
-            n = idom[n]
-        else:
-            n = None
+        n = idom[n] if n in idom and n != idom[n] else None
     return False
 
 
@@ -256,12 +255,10 @@ class TemporaryNode:
         self._label = label
 
     def __repr__(self):
-        return "TN[%s]" % self._label
+        return f"TN[{self._label}]"
 
     def __eq__(self, other):
-        if isinstance(other, TemporaryNode) and other._label == self._label:
-            return True
-        return False
+        return bool(isinstance(other, TemporaryNode) and other._label == self._label)
 
     def __hash__(self):
         return hash(("TemporaryNode", self._label))
@@ -294,7 +291,7 @@ class ContainerNode:
         return hash(("CN", self._obj))
 
     def __repr__(self):
-        return "CN[%s]" % repr(self._obj)
+        return f"CN[{self._obj!r}]"
 
 
 class Dominators:
@@ -324,7 +321,7 @@ class Dominators:
     def _graph_successors(self, graph, node):
         """
         Return the successors of a node in the graph.
-        This method can be overriden in case there are special requirements with the graph and the successors. For
+        This method can be overridden in case there are special requirements with the graph and the successors. For
         example, when we are dealing with a control flow graph, we may not want to get the FakeRet successors.
 
         :param graph: The graph.
@@ -519,9 +516,8 @@ class Dominators:
     def _pd_eval(self, v):
         if self._ancestor[v.index] is None:
             return v
-        else:
-            self._pd_compress(v)
-            return self._label[v.index]
+        self._pd_compress(v)
+        return self._label[v.index]
 
     def _pd_compress(self, v):
         if self._ancestor[self._ancestor[v.index].index] is not None:
@@ -595,8 +591,7 @@ class GraphUtils:
 
         ordered_merge_points = GraphUtils.quasi_topological_sort_nodes(graph, merge_points)
 
-        addrs = [n.addr for n in ordered_merge_points]
-        return addrs
+        return [n.addr for n in ordered_merge_points]
 
     @staticmethod
     def find_widening_points(function_addr, function_endpoints, graph):  # pylint: disable=unused-argument
@@ -701,7 +696,7 @@ class GraphUtils:
             return src_addr + dst_addr
 
         # collapse all strongly connected components
-        edges = sorted(list(graph.edges()), key=_sort_edge)
+        edges = sorted(graph.edges(), key=_sort_edge)
         for src, dst in edges:
             scc_index = GraphUtils._components_index_node(sccs, src)
             if scc_index is not None:
@@ -741,8 +736,7 @@ class GraphUtils:
             return ordered_nodes
 
         nodes = set(nodes)
-        ordered_nodes = [n for n in ordered_nodes if n in nodes]
-        return ordered_nodes
+        return [n for n in ordered_nodes if n in nodes]
 
     @staticmethod
     def _components_index_node(components, node):
@@ -820,3 +814,42 @@ class GraphUtils:
                                 break
 
         ordered_nodes.extend(GraphUtils.quasi_topological_sort_nodes(subgraph))
+
+    @staticmethod
+    def loop_nesting_forest(graph: networkx.DiGraph, start_node) -> OrderedDict[Any, networkx.DiGraph]:
+        """
+        Generates the loop-nesting forest for the provided directional graph. This is *not* the algorithm proposed by
+        Ramalingam.
+
+        :param graph:       the graph to generate the loop-nesting forest for.
+        :param start_node:  the node to start traversing the graph from.
+        :return:            An ordered dict of loop heads to their corresponding loop nodes.
+        """
+
+        # TODO: Should we replace this function using dfs_back_edges()?
+
+        loop_head_to_loop_nodes = OrderedDict()
+
+        graph_copy = networkx.DiGraph(graph)
+
+        while True:
+            cycles_iter = networkx.simple_cycles(graph_copy)
+            try:
+                cycle = next(cycles_iter)
+            except StopIteration:
+                break
+
+            loop_backedge = (None, None)
+
+            for n in networkx.dfs_preorder_nodes(graph_copy, source=start_node):
+                if n in cycle:
+                    idx = cycle.index(n)
+                    loop_backedge = (cycle[-1], cycle[idx]) if idx == 0 else (cycle[idx - 1], cycle[idx])
+                    break
+
+            loop_head = loop_backedge[1]
+            loop_head_to_loop_nodes[loop_head] = networkx.DiGraph(graph_copy.subgraph(cycle))
+
+            graph_copy.remove_edge(*loop_backedge)
+
+        return loop_head_to_loop_nodes

angr/utils/lazy_import.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import importlib.util
 import sys
 

angr/utils/library.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from ..sim_type import (
@@ -46,8 +47,7 @@ def get_function_name(s):
     else:
         raise ValueError("Cannot find any space in the function declaration string.")
 
-    func_name = func_name[pos + 1 :]
-    return func_name
+    return func_name[pos + 1 :]
 
 
 def register_kernel_types():
@@ -72,7 +72,7 @@ def register_kernel_types():
     )
 
 
-def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
+def convert_cproto_to_py(c_decl) -> tuple[str, SimTypeFunction, str]:
     """
     Convert a C-style function declaration string to its corresponding SimTypes-based Python representation.
 
@@ -84,7 +84,7 @@ def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
     s = []
 
     try:
-        s.append("# %s" % c_decl)  # comment string
+        s.append(f"# {c_decl}")  # comment string
 
         parsed = parse_file(c_decl)
         parsed_decl = parsed[0]
@@ -100,7 +100,7 @@ def convert_cproto_to_py(c_decl) -> tuple[str, "SimTypeFunction", str]:
         try:
             func_name = get_function_name(c_decl)
             func_proto = None
-            s.append('"%s": None,' % func_name)
+            s.append(f'"{func_name}": None,')
         except ValueError:
             # Failed to extract the function name. Is it a function declaration?
             func_name, func_proto = None, None
@@ -121,7 +121,7 @@ def convert_cppproto_to_py(
 
     s = []
     try:
-        s.append("# %s" % cpp_decl)
+        s.append(f"# {cpp_decl}")
 
         parsed = parse_cpp_file(cpp_decl, with_param_names=with_param_names)
         parsed_decl = parsed[0]
@@ -136,7 +136,7 @@ def convert_cppproto_to_py(
         try:
             func_name = get_function_name(cpp_decl)
             func_proto = None
-            s.append('"%s": None,' % func_name)
+            s.append(f'"{func_name}": None,')
         except ValueError:
             # Failed to extract the function name. Is it a function declaration?
             func_name, func_proto = None, None
@@ -145,7 +145,7 @@ def convert_cppproto_to_py(
 
 
 def parsedcprotos2py(
-    parsed_cprotos: list[tuple[str, "SimTypeFunction", str]], fd_spots=frozenset(), remove_sys_prefix=False
+    parsed_cprotos: list[tuple[str, SimTypeFunction, str]], fd_spots=frozenset(), remove_sys_prefix=False
 ) -> str:
     """
     Parse a list of C function declarations and output to Python code that can be embedded into
@@ -196,11 +196,8 @@ def cprotos2py(cprotos: list[str], fd_spots=frozenset(), remove_sys_prefix=False
 
 
 def get_cpp_function_name(demangled_name, specialized=True, qualified=True):
-    if not specialized:
-        # remove "<???>"s
-        name = normalize_cpp_function_name(demangled_name)
-    else:
-        name = demangled_name
+    # remove "<???>"s
+    name = normalize_cpp_function_name(demangled_name) if not specialized else demangled_name
 
     if not qualified:
         # remove leading namespaces

angr/utils/loader.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import archinfo
@@ -6,7 +7,7 @@ if TYPE_CHECKING:
     from angr import Project
 
 
-def is_pc(project: "Project", ins_addr: int, addr: int) -> bool:
+def is_pc(project: Project, ins_addr: int, addr: int) -> bool:
     """
     Check if the given address is program counter (PC) or not. This function is for handling the case on some bizarre
     architectures where PC is always the currently executed instruction address plus a constant value.
@@ -21,13 +22,12 @@ def is_pc(project: "Project", ins_addr: int, addr: int) -> bool:
             # thumb mode
             ins_addr = ins_addr - 1
             return addr == ins_addr + 4
-        else:
-            # arm mode
-            return addr == ins_addr + 8
+        # arm mode
+        return addr == ins_addr + 8
     return ins_addr == addr
 
 
-def is_in_readonly_section(project: "Project", addr: int) -> bool:
+def is_in_readonly_section(project: Project, addr: int) -> bool:
     """
     Check if the specified address is inside a read-only section.
 
@@ -41,7 +41,7 @@ def is_in_readonly_section(project: "Project", addr: int) -> bool:
     return False
 
 
-def is_in_readonly_segment(project: "Project", addr: int) -> bool:
+def is_in_readonly_segment(project: Project, addr: int) -> bool:
     """
     Check if the specified address is inside a read-only segment.
 

angr/utils/mp.py

@@ -1,4 +1,5 @@
-from typing import NamedTuple, Optional, Any
+from __future__ import annotations
+from typing import NamedTuple, Any
 from collections.abc import Callable
 import multiprocessing
 import platform
@@ -20,10 +21,10 @@ class Initializer:
     A singleton class with global state used to initialize a multiprocessing.Process
     """
 
-    _single: Optional["Initializer"] = None
+    _single: Initializer | None = None
 
     @classmethod
-    def get(cls) -> "Initializer":
+    def get(cls) -> Initializer:
         """
         A wrapper around init since this class is a singleton
         """

angr/utils/orderedset.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import collections.abc
 
 

angr/utils/segment_list.py

@@ -1,4 +1,5 @@
 # pylint:disable=no-else-break
+from __future__ import annotations
 import logging
 
 from angr.errors import AngrCFGError, AngrRuntimeError
@@ -27,8 +28,7 @@ class Segment:
         self.sort = sort
 
     def __repr__(self):
-        s = f"[{self.start:#x}-{self.end:#x}, {self.sort}]"
-        return s
+        return f"[{self.start:#x}-{self.end:#x}, {self.sort}]"
 
     @property
     def size(self):
@@ -274,7 +274,7 @@ class SegmentList:
                     # |-- address + size --|
                     # no overlap
                     break
-                elif segment.start < address + size <= segment.start + segment.size:
+                if segment.start < address + size <= segment.start + segment.size:
                     #            |---- segment ----|
                     # |-- address + size --|
                     #
@@ -284,7 +284,7 @@ class SegmentList:
                         # remove the segment
                         self._list.remove(segment)
                     break
-                elif address + size > segment.start + segment.size:
+                if address + size > segment.start + segment.size:
                     #            |---- segment ----|
                     # |--------- address + size ----------|
                     self._list.remove(segment)
@@ -432,10 +432,8 @@ class SegmentList:
             return False
         if self._list[idx].start <= address < self._list[idx].end:
             return True
-        if idx > 0 and address < self._list[idx - 1].end:
-            # TODO: It seems that this branch is never reached. Should it be removed?
-            return True
-        return False
+        # TODO: It seems that this is never True. Should it be removed?
+        return idx > 0 and address < self._list[idx - 1].end
 
     def occupied_by_sort(self, address: int) -> str | None:
         """
@@ -521,7 +519,7 @@ class SegmentList:
 
         # self._debug_check()
 
-    def copy(self) -> "SegmentList":
+    def copy(self) -> SegmentList:
         """
         Make a copy of the SegmentList.
 

angr/utils/ssa/__init__.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+from collections import defaultdict
+from typing import Any
+
+import archinfo
+from ailment import Expression, Block
+from ailment.expression import VirtualVariable, Const, Phi, Tmp, Load, Register, StackBaseOffset, DirtyExpression
+from ailment.statement import Statement, Assignment, Call
+from ailment.block_walker import AILBlockWalkerBase
+
+from angr.knowledge_plugins.key_definitions import atoms
+from angr.code_location import CodeLocation
+from .vvar_uses_collector import VVarUsesCollector
+from .tmp_uses_collector import TmpUsesCollector
+
+
+def get_reg_offset_base_and_size(
+    reg_offset: int, arch: archinfo.Arch, size: int | None = None, resilient: bool = True
+) -> tuple[int, int] | None:
+    """
+    Translate a given register offset into the offset of its full register and obtain the size of the full register.
+
+    :param reg_offset:  The offset of the register to translate.
+    :param arch:        The corresponding Arch object.
+    :param size:        Size of the register to translate. Optional.
+    :param resilient:   When set to True, this function will return the provided offset and size for registers that the
+                        arch does not know about.
+    :return:            A tuple of translated offset and the size of the full register.
+    """
+
+    base_reg_and_size = arch.get_base_register(reg_offset, size=size)
+    if resilient and base_reg_and_size is None:
+        return reg_offset, size
+    return base_reg_and_size
+
+
+def get_reg_offset_base(
+    reg_offset: int, arch: archinfo.Arch, size: int | None = None, resilient: bool = True
+) -> int | None:
+    """
+    Translate a given register offset into the offset of its full register.
+
+    :param reg_offset:  The offset of the register to translate.
+    :param arch:        The corresponding Arch object.
+    :param size:        Size of the register to translate. Optional.
+    :param resilient:   When set to True, this function will return the provided offset and size for registers that the
+                        arch does not know about.
+    :return:            The translated offset of the full register.
+    """
+
+    base_reg_and_size = arch.get_base_register(reg_offset, size=size)
+    if base_reg_and_size is None:
+        return reg_offset if resilient else None
+    return base_reg_and_size[0]
+
+
+def get_vvar_deflocs(
+    blocks, phi_vvars: dict[VirtualVariable, set[VirtualVariable]] | None = None
+) -> dict[VirtualVariable, CodeLocation]:
+    vvar_to_loc: dict[VirtualVariable, CodeLocation] = {}
+
+    for block in blocks:
+        for stmt_idx, stmt in enumerate(block.statements):
+            if isinstance(stmt, Assignment) and isinstance(stmt.dst, VirtualVariable):
+                vvar_to_loc[stmt.dst] = CodeLocation(block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx)
+                if phi_vvars is not None and isinstance(stmt.src, Phi):
+                    phi_vvars[stmt.dst] = {vvar_ for src, vvar_ in stmt.src.src_and_vvars}
+            elif isinstance(stmt, Call):
+                if isinstance(stmt.ret_expr, VirtualVariable):
+                    vvar_to_loc[stmt.ret_expr] = CodeLocation(
+                        block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx
+                    )
+                if isinstance(stmt.fp_ret_expr, VirtualVariable):
+                    vvar_to_loc[stmt.fp_ret_expr] = CodeLocation(
+                        block.addr, stmt_idx, ins_addr=stmt.ins_addr, block_idx=block.idx
+                    )
+
+    return vvar_to_loc
+
+
+def get_vvar_uselocs(blocks) -> dict[int, set[tuple[VirtualVariable, CodeLocation]]]:
+    vvar_to_loc: dict[int, set[tuple[VirtualVariable, CodeLocation]]] = defaultdict(set)
+
+    for block in blocks:
+        collector = VVarUsesCollector()
+        collector.walk(block)
+        for vvar_idx, vvar_and_uselocs in collector.vvar_and_uselocs.items():
+            if vvar_idx not in vvar_to_loc:
+                vvar_to_loc[vvar_idx] = vvar_and_uselocs
+            else:
+                vvar_to_loc[vvar_idx] |= vvar_and_uselocs
+
+    return vvar_to_loc
+
+
+def get_tmp_deflocs(blocks) -> dict[CodeLocation, dict[atoms.Tmp, int]]:
+    tmp_to_loc: dict[CodeLocation, dict[atoms.Tmp, int]] = defaultdict(dict)
+
+    for block in blocks:
+        codeloc = CodeLocation(block.addr, None, block_idx=block.idx)
+        for stmt_idx, stmt in enumerate(block.statements):
+            if isinstance(stmt, Assignment) and isinstance(stmt.dst, Tmp):
+                tmp_to_loc[codeloc][atoms.Tmp(stmt.dst.tmp_idx, stmt.dst.bits)] = stmt_idx
+
+    return tmp_to_loc
+
+
+def get_tmp_uselocs(blocks) -> dict[CodeLocation, dict[atoms.Tmp, set[tuple[Tmp, int]]]]:
+    tmp_to_loc: dict[CodeLocation, dict[atoms.Tmp, set[tuple[Tmp, int]]]] = defaultdict(dict)
+
+    for block in blocks:
+        collector = TmpUsesCollector()
+        collector.walk(block)
+        block_loc = CodeLocation(block.addr, None, block_idx=block.idx)
+        for (tmp_idx, tmp_bits), tmp_and_stmtids in collector.tmp_and_uselocs.items():
+            if tmp_idx not in tmp_to_loc[block_loc]:
+                tmp_to_loc[block_loc][atoms.Tmp(tmp_idx, tmp_bits)] = tmp_and_stmtids
+            else:
+                tmp_to_loc[block_loc][atoms.Tmp(tmp_idx, tmp_bits)] |= tmp_and_stmtids
+
+    return tmp_to_loc
+
+
+def is_const_assignment(stmt: Statement) -> tuple[bool, Const | None]:
+    if isinstance(stmt, Assignment) and isinstance(stmt.src, (Const, StackBaseOffset)):
+        return True, stmt.src
+    return False, None
+
+
+class AILBlacklistExprTypeWalker(AILBlockWalkerBase):
+    """
+    Walks an AIL expression or statement and determines if it does not contain certain types of expressions.
+    """
+
+    def __init__(self, blacklist_expr_types: tuple[type, ...]):
+        super().__init__()
+        self.blacklist_expr_types = blacklist_expr_types
+        self.has_blacklisted_exprs = False
+
+    def _handle_expr(
+        self, expr_idx: int, expr: Expression, stmt_idx: int, stmt: Statement | None, block: Block | None
+    ) -> Any:
+        if isinstance(expr, self.blacklist_expr_types):
+            self.has_blacklisted_exprs = True
+            return None
+        return super()._handle_expr(expr_idx, expr, stmt_idx, stmt, block)
+
+
+def is_const_and_vvar_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Load, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_tmp_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Load, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_load_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Register, Phi, Call, DirtyExpression))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_const_vvar_load_dirty_assignment(stmt: Statement) -> bool:
+    if isinstance(stmt, Assignment):
+        walker = AILBlacklistExprTypeWalker((Tmp, Register, Phi, Call))
+        walker.walk_expression(stmt.src)
+        return not walker.has_blacklisted_exprs
+    return False
+
+
+def is_phi_assignment(stmt: Statement) -> tuple[bool, Phi | None]:
+    if isinstance(stmt, Assignment) and isinstance(stmt.src, Phi):
+        return True, stmt.src
+    return False, None
+
+
+__all__ = (
+    "VVarUsesCollector",
+    "get_vvar_deflocs",
+    "get_vvar_uselocs",
+    "is_const_assignment",
+    "is_phi_assignment",
+    "is_const_and_vvar_assignment",
+    "is_const_vvar_load_assignment",
+    "is_const_vvar_load_dirty_assignment",
+    "get_tmp_uselocs",
+    "get_tmp_deflocs",
+)