! * \brief Implementation helper for TVM_FFI_VISIT_END(node). * Calling convention may change; do not call directly from user code. */

Populate ``TypeField.dataclass_field`` for every own reflected field. ``@c_class`` fields originate from C++ reflection, so there is no user-

Compile a .c file with a large `.rodata` blob to force the oversize path. Returns the path to the generated .o file. Skips the test if the build

Decorate the given source code with TVM FFI export macros.

Find a shared library by target_name name across known directories. Parameters ---------- package The package name where the libr

Return the ``TypeMethod`` entry for ``name`` or :data:`None`.

Find the ROCm install path.

Install structural dunder methods on *cls*. Each dunder delegates to the corresponding C++ recursive structural operation (``RecursiveEq``, `

Return True when *obj* is a ``@c_class`` / ``@py_class`` **instance** (not a type).

Create a quiet NaN with a deterministic payload.

! \return begin iterator */

Measures overhead of running torch.cuda.current_stream.

Measures overhead of running dlpack via auto convert by directly take torch.Tensor as inputs.

! \return The capacity of the list */

! * \brief Get the extra context of the error object. * \return The extra context of the error object. */

! \return find the key and returns the associated iterator */

Find dlpack header files for C compilation.

Generate a function signature string for this function.

Generate function signatures for global functions. It processes: global/${prefix}@${import_from="tvm_ffi")

Check if the Tensor is contiguous # Returns `bool` - True if the Tensor is contiguous, false otherwise

Return a dynamic view of the dict's keys.

Normalize and bounds-check a Python index.

! \return size of the arguments */

! * \brief Swap this array with another Object * \param other The other Object */

Return path prefix for test_types object.

Helper to call metadata FFI functions and return the String result

! * \brief Get the product of a shape. * \param shape The input shape. * \param out_strides The output strides. * \return The product of the shape

! \brief Extract raw pointer and length from a Bytes or SmallBytes value. */

! * \brief Get the underlying DLTensor pointer. * \return The underlying DLTensor pointer. */

! \brief Extract raw pointer and length from a String or SmallStr value. */

* \brief Check if the data in the DLTensor is aligned to the given alignment. * \param arr The input DLTensor. * \param alignment The alignment to c

! \brief Return true for Bytes or SmallBytes type indices. */

! * \brief Check if the device uses direct address, where address of data indicate alignment. * \param device The input device. * \return True if t

! \brief If the entry is head of linked list */

! \brief Return true for Str or SmallStr type indices. */

! \brief Pop the top TempAccessStep; truncate materialized_paths_ to match. */

! \brief Append a TempAccessStep to the descent stack; cache unchanged. */

! * \brief Ensure the list has at least n slots. * \param n The lower bound of required capacity. * * \note Leak-safety: Any's move constr

! \brief Clear the container to empty, release all entries and memory acquired */

! \brief Set the entry to be empty */

! * \brief List frame patterns that should be excluded as they contain less information */

! * \brief Same as StableHashBytes, but for small string data. * \param data The data pointer * \return the hash value. */

Build the localns dict for resolving ``cls``'s annotations. By default, includes only classes from ``cls.__module__``, preserving standard Py

Compile all sources in *src_dir* to object files in *out_dir*.

Extract FFI-registered entries from a ``@py_class`` body. Two sources are collected: 1. **TypeAttrColumn dunders** — names in :data:`_FFI_RE

Return the ``List[Any]`` column for this attribute; create if missing. Returns ``None`` when ``create`` is false and the column doesn't exist

Compile simple CUDA kernels to CUBIN. Returns the raw CUBIN bytes.

Create a dummy CUBIN file for testing.

Create a simple test object file with TVM_FFI_EMBED_CUBIN macro usage. We avoid including the full header to prevent CUDA dependency in tests.

Record ``(instance.value → instance)`` in the value-entries column. No-op for non-payload enums. For payload enums, the first writer of a gi

Write content to path if it does not already exist with the same content.

Return all variants ordered by ordinal.

Return *cls*'s own annotations dict (not inherited).

Return annotations declared directly on *cls*.

Parse a type schema from either a JSON string or an already-parsed dict.

Phase 2: resolve annotations, register fields, install dunders. Returns True on success, False if forward references are unresolved.

Test helper: resolve a ``"$method:NAME"`` string ref and call it. Parses the ``$method:`` prefix, looks up ``NAME`` in the instance's ``TypeI

! \return begin iterator */

Run dlpack conversion + tvm_ffi.nop. Measures overhead of running dlpack for each args then invoke

Measures overhead of running dlpack with latest 1.1.

! \return end iterator */

! \return end iterator */

! \return end iterator */

Generate an `__all__` variable for the given names.

Get the runtime module property mask. The mapping is stated in ModulePropertyMask. Returns ------- Bitmask of runtime module

Get the items from the dict.

Return path prefix for test_link_order_caller object.

Remove and return value for key, or default if not present.

Reverse the list in-place.

Set the link order for symbol resolution. When resolving symbols, this library will search in the specified libraries in the order pr

! \return The size of the array */

! \brief Get the size of the shape. */