An object that builds and maintains block scope and StmtSref mapping for Dependence analysis. More...

Namespaces
namespace	arith
	namespace of arithmetic analysis.

namespace	attr
	Generic attribute names that can be attached to any function.

namespace	codegen
	namespace for target translation and codegen.

namespace	ffi

namespace	instrument

namespace	ir

namespace	prim

namespace	relax

namespace	runtime

namespace	s_tir

namespace	script

namespace	support

namespace	te
	Tensor expression language DSL.

namespace	tirx

namespace	topi

namespace	transform

Classes
class	ArgumentInfo
	Managed reference to ArgumentInfoNode. More...

class	ArgumentInfoNode
	Information about an input field of an Op (name, type, description). More...

class	AttrRegistry

class	AttrRegistryMap
	ffi::Map<Key, ValueType> used to store meta-data. More...

class	AttrRegistryMapContainerMap
	Generic attribute map. More...

class	Attrs
	Managed reference to AttrsNode. More...

class	AttrsNode
	Base class of all attribute class. More...

class	BaseFunc
	Managed reference to BaseFuncNode. More...

class	BaseFuncNode
	Base node of all functions. More...

class	Call
	Managed reference to CallNode. More...

class	CallNode
	Call corresponds to callable invocation. More...

class	DictAttrs
	Managed reference to DictAttrsNode. More...

class	DictAttrsNode
	Specialized attribute type that is backed by a map. The DictAttrsNode implements the Attrs behavior, its fields are directly accessible via object.field_name like other normal nodes. More...

class	DummyGlobalInfo
	Managed reference to DummyGlobalInfoNode. More...

class	DummyGlobalInfoNode
	A dummy global info sub-class for testing purpose. More...

class	EnvFunc
	Managed reference to EnvFuncNode. More...

class	EnvFuncNode
	A serializable function backed by TVM's global environment. More...

class	Expr
	Managed reference to ExprNode. More...

class	ExprNode
	Base type of all the expressions. More...

class	FloatImm
	Managed reference class to FloatImmNode. More...

class	FloatImmNode
	Constant floating point literals in the program. More...

class	FuncType
	Managed reference to FuncTypeNode. More...

class	FuncTypeNode
	Function type. More...

class	GlobalInfo
	Managed reference to GlobalInfoNode. More...

class	GlobalInfoNode
	GlobalInfo are globally static object that are referred by the IR itself. Base node for all global info that can appear in the IR. More...

class	GlobalVar
	Managed reference to GlobalVarNode. More...

class	GlobalVarNode
	Global variable that lives in the top-level module. More...

class	IntImm
	Managed reference class to IntImmNode. More...

class	IntImmNode
	Constant integer literals in the program. More...

class	IRModule
	Managed reference class to IRModuleNode. More...

class	IRModuleNode
	IRModule that holds functions and type definitions. More...

class	NodeFunctor
	A dynamically dispatched functor on the type of the first argument. More...

class	NodeFunctor< R(const ffi::ObjectRef &n, Args...)>

class	Op
	Managed reference class to OpNode. More...

class	OpaqueExpr
	Managed reference to OpaqueExprNode. More...

class	OpaqueExprNode
	Base node for opaque construction-time expressions. More...

class	OpaqueType
	Managed reference to OpaqueTypeNode. More...

class	OpaqueTypeNode
	Type marker for opaque construction-time expressions. More...

class	OpAttrMap
	ffi::Map<Op,ValueType> used to store meta-information about Op. More...

class	OpNode
	Primitive Op(builtin intrinsics) More...

class	OpRegEntry
	Helper structure to register operators. More...

class	PointerType

class	PointerTypeNode
	Low-level raw pointer type. More...

class	PrimExpr
	Typed reference/view over any Expr whose `ExprNode::ty` is PrimType. More...

class	PrimExprConvertible
	Managed reference to PrimExprConvertibleNode. More...

class	PrimExprConvertibleNode
	Base class for other IR constructs that can be converted to PrimExpr. This is useful for the FFI to convert the expressions to PrimExpr. More...

class	PrimType

class	PrimTypeNode
	Primitive data types used in the low-level IR. More...

class	PrinterConfig

class	PrinterConfigNode

class	Range
	Range container More...

class	RangeNode
	range over one dimension More...

class	ScopeStack
	A scope stack for maintaining hierarchical state during IR visiting. More...

class	SequentialSpan
	Reference class of SequentialSpanNode. More...

class	SequentialSpanNode
	Store a list of spans for an expr generated from mulitple source exprs. More...

class	Source

class	SourceMap

class	SourceMapObj
	Stores locations in frontend source that generated a node. More...

class	SourceName
	The source name of a file span. More...

class	SourceNameNode
	The name of a source fragment. More...

class	SourceNode

class	Span

class	SpanNode
	Stores locations in frontend source that generated a node. More...

class	Target
	Managed reference class to TargetNode. More...

class	TargetKind
	Managed reference class to TargetKindNode. More...

class	TargetKindAttrMap
	ffi::Map<TargetKind, ValueType> used to store meta-information about TargetKind More...

class	TargetKindNode
	Target kind, specifies the kind of the target. More...

class	TargetKindRegEntry
	Helper structure to register TargetKind. More...

class	TargetNode
	Compilation target. More...

class	TargetTag
	Managed reference class to TargetTagNode. More...

class	TargetTagNode
	A target tag. More...

class	TargetTagRegEntry

class	TensorLoad
	Managed reference to TensorLoadNode. More...

class	TensorLoadNode
	Load a value from an indexed expression source. More...

class	TensorMapType
	Managed reference to TensorMapTypeNode. More...

class	TensorMapTypeNode
	The type of tensor map. More...

class	Tuple
	Managed reference to TupleNode. More...

class	TupleGetItem
	Managed reference to TupleGetItemNode. More...

class	TupleGetItemNode
	Get the index-th field out of a tuple. More...

class	TupleNode
	Tuple container. More...

class	TupleType
	Managed reference to TupleTypeNode. More...

class	TupleTypeNode
	The type of tuple values. More...

class	TVMScriptPrinter
	Dispatch vtable used by per-dialect printers to register their object-type printing functions. Internal, but exposed here because TVM_REGISTER_SCRIPT_AS_REPR refers to it. More...

class	Type
	Managed reference to TypeNode. More...

class	TypedEnvFunc
	Please refer to TypedEnvFunc<R(Args..)>. More...

class	TypedEnvFunc< R(Args...)>
	A typed version of EnvFunc. It is backed by a GlobalFuncNode internally. More...

class	TypedExpr
	Typed reference/view over an expression whose result type is a specific Type subtype. More...

class	TypeNode
	Type is the base type of all types. More...

class	UniqueNameSupply
	Managed reference class to UniqueNameSupplyNode. More...

class	UniqueNameSupplyNode
	UniqueNameSupply can be used to generate unique names. More...

class	Var
	Managed reference to VarNode. More...

class	VarNode
	A local variable in the IR. More...

class	VDevice
	Managed reference to VDeviceNode. More...

class	VDeviceNode
	A global info subclass for virtual devices. More...

class	VirtualDevice
	Managed reference class to `VirtualDeviceNode`. More...

class	VirtualDeviceCache
	A cache of `VirtualDevices`. This can be used: More...

class	VirtualDeviceNode
	Describes at compile time the constraints on where data is to be stored at runtime down to the (virtual) device and memory scope level, and how to compile code to compute that data. Used by the `PlanDevices` pass to collect and solve (virtual) device constraints for the whole Relax program. More...

class	With
	RAII wrapper function to enter and exit a context object similar to python's with syntax. More...

class	WithGroup
	A group of RAII contexts managed together. More...

Typedefs
using	MemoryScope = ffi::String
	Abstract label for an area of memory.

using	Device = DLDevice

using	FTargetCanonicalizer = ffi::TypedFunction< ffi::Map< ffi::String, ffi::Any >(ffi::Map< ffi::String, ffi::Any >)>
	Target canonicalizer applied on instantiation of a given TargetKind.

Enumerations
enum class	CallingConv : int { kDefault = 0 , kCPackedFunc = 1 , kDeviceKernelLaunch = 2 }
	Possible Calling conventions. More...

enum class	LinkageType : int { kInternal = 0 , kExternal = 1 }
	Supported linkage types. More...

Functions
template<typename TFunc >
TFunc	WithAttr (TFunc input, const std::string &attr_key, Any attr_value)
	Copy the function or module, but overrides the attribute value key with the value.

template<typename TFunc >
TFunc	WithAttrs (TFunc input, ffi::Map< ffi::String, Any > attrs)
	Copy the function or module, but overrides the attributes with the entries from `attrs`.

template<typename TFunc >
TFunc	WithoutAttr (TFunc input, const std::string &attr_key)
	Copy the function or module, but removes the specified attribute.

bool	operator== (const PrimType &lhs, const PrimType &rhs)

bool	operator!= (const PrimType &lhs, const PrimType &rhs)

PrimExpr	operator+ (PrimExpr a, PrimExpr b)
	add operator

PrimExpr	operator- (PrimExpr a, PrimExpr b)
	subtraction operator

PrimExpr	operator- (PrimExpr a)
	negation.

PrimExpr	operator* (PrimExpr a, PrimExpr b)
	multiplication operator

PrimExpr	operator/ (PrimExpr a, PrimExpr b)
	division operator

PrimExpr	operator<< (PrimExpr a, PrimExpr b)
	left shift operator

PrimExpr	operator>> (PrimExpr a, PrimExpr b)
	right shift operator

PrimExpr	operator> (PrimExpr a, PrimExpr b)
	greater

PrimExpr	operator>= (PrimExpr a, PrimExpr b)
	greater_equal

PrimExpr	operator< (PrimExpr a, PrimExpr b)
	less

PrimExpr	operator<= (PrimExpr a, PrimExpr b)
	less_equal

PrimExpr	operator== (PrimExpr a, PrimExpr b)
	equal

PrimExpr	operator!= (PrimExpr a, PrimExpr b)
	not_equal

PrimExpr	operator&& (PrimExpr a, PrimExpr b)
	and

PrimExpr	operator\|\| (PrimExpr a, PrimExpr b)
	or

PrimExpr	operator! (PrimExpr a)
	not

PrimExpr	operator& (PrimExpr a, PrimExpr b)
	take bitwise and of two values

PrimExpr	operator\| (PrimExpr a, PrimExpr b)
	take bitwise or of two values

PrimExpr	operator^ (PrimExpr a, PrimExpr b)
	take bitwise xor of two values

PrimExpr	operator~ (PrimExpr a)
	take bitwise negation of two values

Type	VoidType ()

bool	IsVoidType (const Type &type)
	Check whether the tyep represents void.

std::string	RedirectedReprPrinterMethod (const ffi::ObjectRef &obj)
	The fallback body used by TVM_REGISTER_SCRIPT_AS_REPR (defined in printer.h).

std::string	Script (const ffi::ObjectRef &node, const ffi::Optional< PrinterConfig > &config=std::nullopt)
	Print `node` as TVMScript with the given `config`.

void	CheckAndUpdateHostConsistency (Target target, Target host)
	Check and update host field of the given legacy target and target host pair. Note that this function is for legacy target api compatibility issue only, not recommended for other use.

Type	GetType (const PrimExpr &expr)
	Get the type of the expression under the unified type system.

Type	GetTypeFromRuntimeDataType (DLDataType dtype)
	Get the type corresponding to a runtime DLPack dtype.

PrimExpr	thread_return (Span span=Span())
	Return from a thread.

PrimExpr	continue_loop (Span span=Span())
	Continue current loop.

PrimExpr	break_loop (Span span=Span())
	Break current loop.

PrimExpr	max_value (PrimType dtype, Span span=Span())

PrimExpr	min_value (PrimType dtype, Span span=Span())

PrimExpr	infinity (PrimType dtype, Span span=Span())

PrimExpr	cast (PrimType t, PrimExpr value, Span span=Span())
	cast value to type.

PrimExpr	reinterpret (PrimType t, PrimExpr value, Span span=Span())
	perform reinterpret cast value to type.

Expr	reinterpret (Type target_ty, Expr value, Span span=Span())
	Perform a reinterpret cast involving an exact primitive or pointer type.

PrimExpr	add (PrimExpr a, PrimExpr b, Span span=Span())
	add operator

PrimExpr	sub (PrimExpr a, PrimExpr b, Span span=Span())
	subtraction operator

PrimExpr	neg (PrimExpr a, Span span=Span())
	negation.

PrimExpr	mul (PrimExpr a, PrimExpr b, Span span=Span())
	multiplication operator

PrimExpr	left_shift (PrimExpr a, PrimExpr b, Span span=Span())
	left shift operator

PrimExpr	right_shift (PrimExpr a, PrimExpr b, Span span=Span())
	right shift operator

PrimExpr	greater (PrimExpr a, PrimExpr b, Span span=Span())
	greater

PrimExpr	greater_equal (PrimExpr a, PrimExpr b, Span span=Span())
	greater_equal

PrimExpr	less (PrimExpr a, PrimExpr b, Span span=Span())
	less

PrimExpr	less_equal (PrimExpr a, PrimExpr b, Span span=Span())
	less_equal

PrimExpr	equal (PrimExpr a, PrimExpr b, Span span=Span())
	equal

PrimExpr	not_equal (PrimExpr a, PrimExpr b, Span span=Span())
	not_equal

PrimExpr	logical_and (PrimExpr a, PrimExpr b, Span span=Span())
	and

PrimExpr	logical_or (PrimExpr a, PrimExpr b, Span span=Span())
	or

PrimExpr	logical_not (PrimExpr a, Span span=Span())
	not

PrimExpr	div (PrimExpr a, PrimExpr b, Span span=Span())
	compute division in C semantics.

PrimExpr	truncdiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute trunc(a / b)

PrimExpr	truncmod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder of truncdiv

PrimExpr	indexdiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute floor(a / b) where a and b are non-negative.

PrimExpr	shapediv (PrimExpr a, PrimExpr b, Span span=Span())
	compute ceil(a / b) where a and b are non-negative.

PrimExpr	indexmod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder floor(a / b) where a and b are non-negative.

PrimExpr	floordiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute floor(a / b)

PrimExpr	logaddexp (PrimExpr a, PrimExpr b, Span span=Span())
	Compute log(exp(a) + exp(b)).

PrimExpr	ceildiv (PrimExpr a, PrimExpr b, Span span=Span())
	compute ceil(a / b)

PrimExpr	floormod (PrimExpr a, PrimExpr b, Span span=Span())
	compute the remainder of floordiv

PrimExpr	max (PrimExpr a, PrimExpr b, Span span=Span())
	take maximum of two values

PrimExpr	min (PrimExpr a, PrimExpr b, Span span=Span())
	take minimum of two values

PrimExpr	bitwise_and (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise and of two values

PrimExpr	bitwise_or (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise or of two values

PrimExpr	bitwise_xor (PrimExpr a, PrimExpr b, Span span=Span())
	take bitwise xor of two values

PrimExpr	bitwise_neg (PrimExpr a, Span span=Span())
	take bitwise negation of two values

PrimExpr	if_then_else (PrimExpr cond, PrimExpr true_value, PrimExpr false_value, Span span=Span())
	Conditional expression.

PrimExpr	likely (PrimExpr cond, Span span=Span())
	Mark condition as likely.

PrimExpr	pow (PrimExpr x, PrimExpr y, Span span=Span())
	Calculate power(x, y)

PrimExpr	abs (PrimExpr x, Span span=Span())
	Calculate absolute value of x.

PrimExpr	isnan (PrimExpr x, Span span=Span())
	Check if x is NaN.

PrimExpr	isfinite (PrimExpr x, Span span=Span())
	Check if x is finite.

PrimExpr	isinf (PrimExpr x, Span span=Span())
	Check if x is infinite.

PrimExpr	sum (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	sum of source expression over axis

PrimExpr	all (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	logical And of source expression over axis

PrimExpr	any (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	logical Or of source expression over axis

PrimExpr	max (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	max of source expression over axis

PrimExpr	min (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	max of source expression over axis

PrimExpr	prod (PrimExpr source, ffi::Array< tirx::IterVar > axis, ffi::Array< PrimExpr > init={}, Span span=Span())
	product of source expression over axis

PrimExpr	floor (PrimExpr x, Span span=Span())
	Calculate floor(x)

PrimExpr	ceil (PrimExpr x, Span span=Span())
	Calculate ceil(x)

PrimExpr	round (PrimExpr x, Span span=Span())
	Round x to the nearest integer, ties to even.

PrimExpr	nearbyint (PrimExpr x, Span span=Span())
	Round x to the nearest integer, ties to even.

PrimExpr	trunc (PrimExpr x, Span span=Span())
	Calculate trunc(x)

PrimExpr	LargeUIntImm (PrimType value_ty, int64_t low, int64_t high, Span span=Span())
	Construct a large uint constant by its low 32 bits and high 32bits.

PrimExpr	q_multiply_shift (PrimExpr x, PrimExpr y, PrimExpr q, PrimExpr s, Span span=Span())
	Execute a multiplication between two Q-numbers x and y followed by a right shift s. The mathematical expression is:

PrimExpr	fast_erf_float_expr (PrimExpr arg, int bits)
	Fast_erf_float expression from Eigen.

void	CheckMathUnaryOpInputDType (const char *op_name, const PrimType &dtype)

PrimExpr	exp (PrimExpr x, Span span=Span())

PrimExpr	exp2 (PrimExpr x, Span span=Span())

PrimExpr	exp10 (PrimExpr x, Span span=Span())

PrimExpr	erf (PrimExpr x, Span span=Span())

PrimExpr	tanh (PrimExpr x, Span span=Span())

PrimExpr	sigmoid (PrimExpr x, Span span=Span())

PrimExpr	sqrt (PrimExpr x, Span span=Span())

PrimExpr	rsqrt (PrimExpr x, Span span=Span())

PrimExpr	log (PrimExpr x, Span span=Span())

PrimExpr	log2 (PrimExpr x, Span span=Span())

PrimExpr	log10 (PrimExpr x, Span span=Span())

PrimExpr	log1p (PrimExpr x, Span span=Span())

PrimExpr	popcount (PrimExpr x, Span span=Span())

PrimExpr	tan (PrimExpr x, Span span=Span())

PrimExpr	cos (PrimExpr x, Span span=Span())

PrimExpr	cosh (PrimExpr x, Span span=Span())

PrimExpr	sin (PrimExpr x, Span span=Span())

PrimExpr	sinh (PrimExpr x, Span span=Span())

PrimExpr	asin (PrimExpr x, Span span=Span())

PrimExpr	acos (PrimExpr x, Span span=Span())

PrimExpr	atan (PrimExpr x, Span span=Span())

PrimExpr	acosh (PrimExpr x, Span span=Span())

PrimExpr	asinh (PrimExpr x, Span span=Span())

PrimExpr	atanh (PrimExpr x, Span span=Span())

PrimExpr	clz (PrimExpr x, Span span=Span())

PrimExpr	atan2 (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	nextafter (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	copysign (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	hypot (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	ldexp (PrimExpr x, PrimExpr y, Span span=Span())

PrimExpr	operator+= (PrimExpr &a, PrimExpr b)

PrimExpr	operator-= (PrimExpr &a, PrimExpr b)

PrimExpr	operator*= (PrimExpr &a, PrimExpr b)

PrimExpr	operator+ (const PrimExpr &a, float b)

PrimExpr	operator+ (float a, const PrimExpr &b)

PrimExpr	operator+ (int a, const PrimExpr &b)

PrimExpr	operator+ (const PrimExpr &a, int b)

PrimExpr	operator+ (const PrimExpr &a, double b)

PrimExpr	operator- (const PrimExpr &a, float b)

PrimExpr	operator- (float a, const PrimExpr &b)

PrimExpr	operator- (int a, const PrimExpr &b)

PrimExpr	operator- (const PrimExpr &a, int b)

PrimExpr	operator- (const PrimExpr &a, double b)

PrimExpr	operator* (const PrimExpr &a, float b)

PrimExpr	operator* (float a, const PrimExpr &b)

PrimExpr	operator* (int a, const PrimExpr &b)

PrimExpr	operator* (const PrimExpr &a, int b)

PrimExpr	operator* (const PrimExpr &a, double b)

PrimExpr	operator> (const PrimExpr &a, float b)

PrimExpr	operator> (float a, const PrimExpr &b)

PrimExpr	operator> (int a, const PrimExpr &b)

PrimExpr	operator> (const PrimExpr &a, int b)

PrimExpr	operator> (const PrimExpr &a, double b)

PrimExpr	operator>= (const PrimExpr &a, float b)

PrimExpr	operator>= (float a, const PrimExpr &b)

PrimExpr	operator>= (int a, const PrimExpr &b)

PrimExpr	operator>= (const PrimExpr &a, int b)

PrimExpr	operator>= (const PrimExpr &a, double b)

PrimExpr	operator< (const PrimExpr &a, float b)

PrimExpr	operator< (float a, const PrimExpr &b)

PrimExpr	operator< (int a, const PrimExpr &b)

PrimExpr	operator< (const PrimExpr &a, int b)

PrimExpr	operator< (const PrimExpr &a, double b)

PrimExpr	operator<= (const PrimExpr &a, float b)

PrimExpr	operator<= (float a, const PrimExpr &b)

PrimExpr	operator<= (int a, const PrimExpr &b)

PrimExpr	operator<= (const PrimExpr &a, int b)

PrimExpr	operator<= (const PrimExpr &a, double b)

PrimExpr	max (const PrimExpr &a, float b, Span span=Span())

PrimExpr	max (float a, const PrimExpr &b, Span span=Span())

PrimExpr	max (int a, const PrimExpr &b, Span span=Span())

PrimExpr	max (const PrimExpr &a, int b, Span span=Span())

PrimExpr	max (const PrimExpr &a, double b, Span span=Span())

PrimExpr	min (const PrimExpr &a, float b, Span span=Span())

PrimExpr	min (float a, const PrimExpr &b, Span span=Span())

PrimExpr	min (int a, const PrimExpr &b, Span span=Span())

PrimExpr	min (const PrimExpr &a, int b, Span span=Span())

PrimExpr	min (const PrimExpr &a, double b, Span span=Span())

PrimExpr	div (const PrimExpr &a, float b, Span span=Span())

PrimExpr	div (float a, const PrimExpr &b, Span span=Span())

PrimExpr	div (int a, const PrimExpr &b, Span span=Span())

PrimExpr	div (const PrimExpr &a, int b, Span span=Span())

PrimExpr	div (const PrimExpr &a, double b, Span span=Span())

PrimExpr	add (const PrimExpr &a, float b, Span span=Span())

PrimExpr	add (float a, const PrimExpr &b, Span span=Span())

PrimExpr	add (int a, const PrimExpr &b, Span span=Span())

PrimExpr	add (const PrimExpr &a, int b, Span span=Span())

PrimExpr	add (const PrimExpr &a, double b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, float b, Span span=Span())

PrimExpr	sub (float a, const PrimExpr &b, Span span=Span())

PrimExpr	sub (int a, const PrimExpr &b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, int b, Span span=Span())

PrimExpr	sub (const PrimExpr &a, double b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, float b, Span span=Span())

PrimExpr	mul (float a, const PrimExpr &b, Span span=Span())

PrimExpr	mul (int a, const PrimExpr &b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, int b, Span span=Span())

PrimExpr	mul (const PrimExpr &a, double b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, float b, Span span=Span())

PrimExpr	greater (float a, const PrimExpr &b, Span span=Span())

PrimExpr	greater (int a, const PrimExpr &b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, int b, Span span=Span())

PrimExpr	greater (const PrimExpr &a, double b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, float b, Span span=Span())

PrimExpr	greater_equal (float a, const PrimExpr &b, Span span=Span())

PrimExpr	greater_equal (int a, const PrimExpr &b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, int b, Span span=Span())

PrimExpr	greater_equal (const PrimExpr &a, double b, Span span=Span())

PrimExpr	less (const PrimExpr &a, float b, Span span=Span())

PrimExpr	less (float a, const PrimExpr &b, Span span=Span())

PrimExpr	less (int a, const PrimExpr &b, Span span=Span())

PrimExpr	less (const PrimExpr &a, int b, Span span=Span())

PrimExpr	less (const PrimExpr &a, double b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, float b, Span span=Span())

PrimExpr	less_equal (float a, const PrimExpr &b, Span span=Span())

PrimExpr	less_equal (int a, const PrimExpr &b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, int b, Span span=Span())

PrimExpr	less_equal (const PrimExpr &a, double b, Span span=Span())

PrimExpr	indexdiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	indexdiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	indexmod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	indexmod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	truncdiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	truncdiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	truncmod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	truncmod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	floordiv (const PrimExpr &a, int b, Span span=Span())

PrimExpr	floordiv (int a, const PrimExpr &b, Span span=Span())

PrimExpr	logaddexp (const PrimExpr &a, int b, Span span=Span())

PrimExpr	logaddexp (int a, const PrimExpr &b, Span span=Span())

PrimExpr	floormod (const PrimExpr &a, int b, Span span=Span())

PrimExpr	floormod (int a, const PrimExpr &b, Span span=Span())

PrimExpr	right_shift (const PrimExpr &a, int b, Span span=Span())

PrimExpr	right_shift (int a, const PrimExpr &b, Span span=Span())

PrimExpr	left_shift (const PrimExpr &a, int b, Span span=Span())

PrimExpr	left_shift (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_and (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_and (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_or (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_or (int a, const PrimExpr &b, Span span=Span())

PrimExpr	bitwise_xor (const PrimExpr &a, int b, Span span=Span())

PrimExpr	bitwise_xor (int a, const PrimExpr &b, Span span=Span())

PrimExpr	operator>> (const PrimExpr &a, int b)

PrimExpr	operator>> (int a, const PrimExpr &b)

PrimExpr	operator<< (const PrimExpr &a, int b)

PrimExpr	operator<< (int a, const PrimExpr &b)

PrimExpr	operator& (const PrimExpr &a, int b)

PrimExpr	operator& (int a, const PrimExpr &b)

PrimExpr	operator\| (const PrimExpr &a, int b)

PrimExpr	operator\| (int a, const PrimExpr &b)

PrimExpr	operator^ (const PrimExpr &a, int b)

PrimExpr	operator^ (int a, const PrimExpr &b)

PrimExpr	operator&& (const PrimExpr &a, bool b)

PrimExpr	operator&& (bool a, const PrimExpr &b)

PrimExpr	operator\|\| (const PrimExpr &a, bool b)

PrimExpr	operator\|\| (bool a, const PrimExpr &b)

PrimExpr	logical_and (const PrimExpr &a, bool b, Span span=Span())

PrimExpr	logical_and (bool a, const PrimExpr &b, Span span=Span())

PrimExpr	logical_or (const PrimExpr &a, bool b, Span span=Span())

PrimExpr	logical_or (bool a, const PrimExpr &b, Span span=Span())

template<typename TA >
void	DivAmbiguityError (const TA &a)
	Helper function to raise a compiler error about division ambiguity.

template<typename TB >
PrimExpr	operator/ (const PrimExpr &a, const TB &b)

template<typename TB >
PrimExpr	operator/= (const PrimExpr &a, const TB &b)

template<typename TB >
PrimExpr	operator% (const PrimExpr &a, const TB &b)

Variables
constexpr int	kNullDeviceType = 0

constexpr int	kInvalidDeviceType = -1

constexpr const char *	kVirtualDevice = "virtual_device"

Detailed Description

An object that builds and maintains block scope and StmtSref mapping for Dependence analysis.

Typedef Documentation

◆ Device

using tvm::Device = typedef DLDevice

◆ FTargetCanonicalizer

using tvm::FTargetCanonicalizer = typedef ffi::TypedFunction<ffi::Map<ffi::String, ffi::Any>(ffi::Map<ffi::String, ffi::Any>)>

Target canonicalizer applied on instantiation of a given TargetKind.

Parameters

target_json Target in JSON format to be transformed during canonicalization.

Returns: The transformed Target JSON object.

◆ MemoryScope

typedef ffi::String tvm::MemoryScope

Abstract label for an area of memory.

Currently uninterpreted and arbitrary. Likely to be replaced by a structured representation of a memory pool in the future. Please try to use this alias instead of ffi::String to aid future code migration.

Enumeration Type Documentation

◆ CallingConv

enum class tvm::CallingConv : int

strong

Possible Calling conventions.

NOTE: The calling convention also implies the way we implement the function during lowering.

Enumerator

kDefault

Default calling convention.

Uses the native calling convention of the target.
Implementation: specified by the native target.

kCPackedFunc

ffi::Function that exposes a Cffi::Function signature.

Calling by ffi::Function calling convention.
Implementation: Expose a function with the Cffi::Function signature.

kDeviceKernelLaunch

Device kernel launch.

Call by ffi::Function calling convention.
Implementation: defined by device runtime(e.g. runtime/cuda)

◆ LinkageType

enum class tvm::LinkageType : int

strong

Supported linkage types.

Enumerator

kInternal

Internal linkage.

kExternal

External linkage.

Function with external linkage should have a global symbol attached to it.

Function Documentation

◆ abs()

PrimExpr tvm::abs	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate absolute value of x.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The absolute value of input data x

◆ acos()

PrimExpr tvm::acos	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ acosh()

PrimExpr tvm::acosh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ add() [1/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ add() [2/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ add() [3/6]

PrimExpr tvm::add	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ add() [4/6]

PrimExpr tvm::add	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ add() [5/6]

PrimExpr tvm::add	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ add() [6/6]

PrimExpr tvm::add	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

add operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ all()

PrimExpr tvm::all	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

logical And of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

◆ any()

PrimExpr tvm::any	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

logical Or of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ asin()

PrimExpr tvm::asin	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ asinh()

PrimExpr tvm::asinh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ atan()

PrimExpr tvm::atan	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ atan2()

PrimExpr tvm::atan2	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ atanh()

PrimExpr tvm::atanh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ bitwise_and() [1/3]

PrimExpr tvm::bitwise_and	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_and() [2/3]

PrimExpr tvm::bitwise_and	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_and() [3/3]

PrimExpr tvm::bitwise_and	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise and of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_neg()

PrimExpr tvm::bitwise_neg	(	PrimExpr	a,
		Span	span = `Span()`
	)

take bitwise negation of two values

Parameters

a	the input expression.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_or() [1/3]

PrimExpr tvm::bitwise_or	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_or() [2/3]

PrimExpr tvm::bitwise_or	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_or() [3/3]

PrimExpr tvm::bitwise_or	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise or of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ bitwise_xor() [1/3]

PrimExpr tvm::bitwise_xor	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_xor() [2/3]

PrimExpr tvm::bitwise_xor	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ bitwise_xor() [3/3]

PrimExpr tvm::bitwise_xor	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take bitwise xor of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ break_loop()

PrimExpr tvm::break_loop ( Span span = Span() )

Break current loop.

Parameters

span	The location of this operation in the source.

Returns: The break loop expression.

◆ cast()

PrimExpr tvm::cast	(	PrimType	t,
		PrimExpr	value,
		Span	span = `Span()`
	)

cast value to type.

Parameters

t	the target type.
value	The value
span	The location of this operation in the source.

Returns: The result expression.

Note: This function may return value if the type is the same.

◆ ceil()

PrimExpr tvm::ceil	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate ceil(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ ceildiv()

PrimExpr tvm::ceildiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute ceil(a / b)

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ CheckAndUpdateHostConsistency()

void tvm::CheckAndUpdateHostConsistency	(	Target *	target,
		Target *	host
	)

Check and update host field of the given legacy target and target host pair. Note that this function is for legacy target api compatibility issue only, not recommended for other use.

Parameters

target	The pointer to a Target typed object with host field to be updated
host	The pointer to a Target typed object for target host to be updated

◆ CheckMathUnaryOpInputDType()

void tvm::CheckMathUnaryOpInputDType	(	const char *	op_name,
		const PrimType &	dtype
	)

inline

◆ clz()

PrimExpr tvm::clz	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ continue_loop()

PrimExpr tvm::continue_loop ( Span span = Span() )

Continue current loop.

Parameters

span	The location of this operation in the source.

Returns: The continue loop expression.

◆ copysign()

PrimExpr tvm::copysign	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ cos()

PrimExpr tvm::cos	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ cosh()

PrimExpr tvm::cosh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ div() [1/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ div() [2/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ div() [3/6]

PrimExpr tvm::div	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ div() [4/6]

PrimExpr tvm::div	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ div() [5/6]

PrimExpr tvm::div	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ div() [6/6]

PrimExpr tvm::div	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute division in C semantics.

a / b as in C/C++.

When operands are integers, it directly corresponds to truncdiv.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ DivAmbiguityError()

template<typename TA >

void tvm::DivAmbiguityError ( const TA & a )

inline

Helper function to raise a compiler error about division ambiguity.

Note: The call to this function will always results in a compiler error.

Template Parameters

TA	Any class type.

◆ equal()

PrimExpr tvm::equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ erf()

PrimExpr tvm::erf	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp()

PrimExpr tvm::exp	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp10()

PrimExpr tvm::exp10	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ exp2()

PrimExpr tvm::exp2	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ fast_erf_float_expr()

PrimExpr tvm::fast_erf_float_expr	(	PrimExpr	arg,
		int	bits
	)

Fast_erf_float expression from Eigen.

Parameters

arg	The input expression.
bits	The number of bits in the type.

Returns: The constructed expression.

◆ floor()

PrimExpr tvm::floor	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate floor(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ floordiv() [1/3]

PrimExpr tvm::floordiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ floordiv() [2/3]

PrimExpr tvm::floordiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ floordiv() [3/3]

PrimExpr tvm::floordiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute floor(a / b)

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ floormod() [1/3]

PrimExpr tvm::floormod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ floormod() [2/3]

PrimExpr tvm::floormod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ floormod() [3/3]

PrimExpr tvm::floormod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder of floordiv

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ GetType()

Type tvm::GetType ( const PrimExpr & expr )

Get the type of the expression under the unified type system.

This function could return a more refined type than the runtime dtype implied by PrimExpr::ty().

Parameters

expr	The input parameter.

Returns: The result type.

See also: tvm/ir/type.h for discussion about the relation between Type and DLPack dtype.

◆ GetTypeFromRuntimeDataType()

Type tvm::GetTypeFromRuntimeDataType ( DLDataType dtype )

Get the type corresponding to a runtime DLPack dtype.

Parameters

dtype The runtime dtype.

Returns: The result type

See also: tvm/ir/type.h for discussion about the relation between Type and DLPack dtype.

◆ greater() [1/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ greater() [2/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ greater() [3/6]

PrimExpr tvm::greater	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ greater() [4/6]

PrimExpr tvm::greater	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater() [5/6]

PrimExpr tvm::greater	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater() [6/6]

PrimExpr tvm::greater	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

greater

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ greater_equal() [1/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [2/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [3/6]

PrimExpr tvm::greater_equal	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [4/6]

PrimExpr tvm::greater_equal	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [5/6]

PrimExpr tvm::greater_equal	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ greater_equal() [6/6]

PrimExpr tvm::greater_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

greater_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ hypot()

PrimExpr tvm::hypot	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ if_then_else()

PrimExpr tvm::if_then_else	(	PrimExpr	cond,
		PrimExpr	true_value,
		PrimExpr	false_value,
		Span	span = `Span()`
	)

Conditional expression.

Parameters

cond	The condition
true_value	The value when results are true.
false_value	The value when results are false.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ indexdiv() [1/3]

PrimExpr tvm::indexdiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ indexdiv() [2/3]

PrimExpr tvm::indexdiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ indexdiv() [3/3]

PrimExpr tvm::indexdiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute floor(a / b) where a and b are non-negative.

Use this function for index split calculation.

This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ indexmod() [1/3]

PrimExpr tvm::indexmod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ indexmod() [2/3]

PrimExpr tvm::indexmod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ indexmod() [3/3]

PrimExpr tvm::indexmod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder floor(a / b) where a and b are non-negative.

Use this function for index split calculation. This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ infinity()

PrimExpr tvm::infinity	(	PrimType	dtype,
		Span	span = `Span()`
	)

Get the value of infinity.

Parameters

dtype	The primitive type.
span	The location of this operation in the source.

Returns: the infinity value in this format.

◆ isfinite()

PrimExpr tvm::isfinite	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is finite.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ isinf()

PrimExpr tvm::isinf	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is infinite.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ isnan()

PrimExpr tvm::isnan	(	PrimExpr	x,
		Span	span = `Span()`
	)

Check if x is NaN.

Parameters

x	The input data
span	The location of this operation in the source.

Returns: The result expression.

◆ IsVoidType()

bool tvm::IsVoidType ( const Type & type )

inline

Check whether the tyep represents void.

Returns: The check result.

◆ LargeUIntImm()

PrimExpr tvm::LargeUIntImm	(	PrimType	value_ty,
		int64_t	low,
		int64_t	high,
		Span	span = `Span()`
	)

Construct a large uint constant by its low 32 bits and high 32bits.

Parameters

value_ty	The final primitive type.
low	The lower 32 bits.
high	The higher 32 bits.
span	The location of this operation in the source.

Returns: The constructed expression.

◆ ldexp()

PrimExpr tvm::ldexp	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ left_shift() [1/3]

PrimExpr tvm::left_shift	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ left_shift() [2/3]

PrimExpr tvm::left_shift	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ left_shift() [3/3]

PrimExpr tvm::left_shift	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

left shift operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ less() [1/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ less() [2/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ less() [3/6]

PrimExpr tvm::less	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ less() [4/6]

PrimExpr tvm::less	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less() [5/6]

PrimExpr tvm::less	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less() [6/6]

PrimExpr tvm::less	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

less

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ less_equal() [1/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [2/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [3/6]

PrimExpr tvm::less_equal	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [4/6]

PrimExpr tvm::less_equal	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [5/6]

PrimExpr tvm::less_equal	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ less_equal() [6/6]

PrimExpr tvm::less_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

less_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ likely()

PrimExpr tvm::likely	(	PrimExpr	cond,
		Span	span = `Span()`
	)

Mark condition as likely.

Parameters

cond	The condition
span	The location of this operation in the source.

Returns: The marked expression.

◆ log()

PrimExpr tvm::log	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log10()

PrimExpr tvm::log10	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log1p()

PrimExpr tvm::log1p	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ log2()

PrimExpr tvm::log2	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ logaddexp() [1/3]

PrimExpr tvm::logaddexp	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ logaddexp() [2/3]

PrimExpr tvm::logaddexp	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ logaddexp() [3/3]

PrimExpr tvm::logaddexp	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

Compute log(exp(a) + exp(b)).

Parameters

a	Left operand.
b	Right operand.
span	The location of this operation in the source.

Returns: The result expression.

◆ logical_and() [1/3]

PrimExpr tvm::logical_and	(	bool	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ logical_and() [2/3]

PrimExpr tvm::logical_and	(	const PrimExpr &	a,
		bool	b,
		Span	span = `Span()`
	)

inline

◆ logical_and() [3/3]

PrimExpr tvm::logical_and	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

and

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ logical_not()

PrimExpr tvm::logical_not	(	PrimExpr	a,
		Span	span = `Span()`
	)

not

Parameters

a	left operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ logical_or() [1/3]

PrimExpr tvm::logical_or	(	bool	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ logical_or() [2/3]

PrimExpr tvm::logical_or	(	const PrimExpr &	a,
		bool	b,
		Span	span = `Span()`
	)

inline

◆ logical_or() [3/3]

PrimExpr tvm::logical_or	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

or

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: This operator does eager constant folding.

◆ max() [1/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ max() [2/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ max() [3/7]

PrimExpr tvm::max	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ max() [4/7]

PrimExpr tvm::max	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ max() [5/7]

PrimExpr tvm::max	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ max() [6/7]

PrimExpr tvm::max	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take maximum of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ max() [7/7]

PrimExpr tvm::max	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

max of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ max_value()

PrimExpr tvm::max_value	(	PrimType	dtype,
		Span	span = `Span()`
	)

Query the maximum possible value of dtype.

Parameters

dtype	The primitive type.
span	The location of this operation in the source.

Returns: the maximum possible value in this format.

◆ min() [1/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ min() [2/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ min() [3/7]

PrimExpr tvm::min	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ min() [4/7]

PrimExpr tvm::min	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ min() [5/7]

PrimExpr tvm::min	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ min() [6/7]

PrimExpr tvm::min	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

take minimum of two values

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ min() [7/7]

PrimExpr tvm::min	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

max of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ min_value()

PrimExpr tvm::min_value	(	PrimType	dtype,
		Span	span = `Span()`
	)

Query the minimum possible value of dtype.

Parameters

dtype	The primitive type.
span	The location of this operation in the source.

Returns: the minimum possible value in this format.

◆ mul() [1/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ mul() [2/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ mul() [3/6]

PrimExpr tvm::mul	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ mul() [4/6]

PrimExpr tvm::mul	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ mul() [5/6]

PrimExpr tvm::mul	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ mul() [6/6]

PrimExpr tvm::mul	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

multiplication operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ nearbyint()

PrimExpr tvm::nearbyint	(	PrimExpr	x,
		Span	span = `Span()`
	)

Round x to the nearest integer, ties to even.

Equivalent to round(). Both use IEEE 754 default rounding mode (ties-to-even).

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ neg()

PrimExpr tvm::neg	(	PrimExpr	a,
		Span	span = `Span()`
	)

negation.

Parameters

a	input.
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ nextafter()

PrimExpr tvm::nextafter	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

inline

◆ not_equal()

PrimExpr tvm::not_equal	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

not_equal

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator!()

PrimExpr tvm::operator! ( PrimExpr a )

not

Parameters

a	left operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator!=() [1/2]

bool tvm::operator!=	(	const PrimType &	lhs,
		const PrimType &	rhs
	)

inline

◆ operator!=() [2/2]

PrimExpr tvm::operator!=	(	PrimExpr	a,
		PrimExpr	b
	)

not_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator%()

template<typename TB >

PrimExpr tvm::operator%	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator&() [1/3]

PrimExpr tvm::operator&	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator&() [2/3]

PrimExpr tvm::operator&	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator&() [3/3]

PrimExpr tvm::operator&	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise and of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator&&() [1/3]

PrimExpr tvm::operator&&	(	bool	a,
		const PrimExpr &	b
	)

inline

◆ operator&&() [2/3]

PrimExpr tvm::operator&&	(	const PrimExpr &	a,
		bool	b
	)

inline

◆ operator&&() [3/3]

PrimExpr tvm::operator&&	(	PrimExpr	a,
		PrimExpr	b
	)

and

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator*() [1/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator*() [2/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator*() [3/6]

PrimExpr tvm::operator*	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator*() [4/6]

PrimExpr tvm::operator*	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator*() [5/6]

PrimExpr tvm::operator*	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator*() [6/6]

PrimExpr tvm::operator*	(	PrimExpr	a,
		PrimExpr	b
	)

multiplication operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator*=()

PrimExpr tvm::operator*=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator+() [1/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator+() [2/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator+() [3/6]

PrimExpr tvm::operator+	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator+() [4/6]

PrimExpr tvm::operator+	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator+() [5/6]

PrimExpr tvm::operator+	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator+() [6/6]

PrimExpr tvm::operator+	(	PrimExpr	a,
		PrimExpr	b
	)

add operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator+=()

PrimExpr tvm::operator+=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator-() [1/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator-() [2/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator-() [3/7]

PrimExpr tvm::operator-	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator-() [4/7]

PrimExpr tvm::operator-	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator-() [5/7]

PrimExpr tvm::operator-	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator-() [6/7]

PrimExpr tvm::operator- ( PrimExpr a )

negation.

Parameters

a input.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator-() [7/7]

PrimExpr tvm::operator-	(	PrimExpr	a,
		PrimExpr	b
	)

subtraction operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator-=()

PrimExpr tvm::operator-=	(	PrimExpr &	a,
		PrimExpr	b
	)

inline

◆ operator/() [1/2]

template<typename TB >

PrimExpr tvm::operator/	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator/() [2/2]

PrimExpr tvm::operator/	(	PrimExpr	a,
		PrimExpr	b
	)

division operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator/=()

template<typename TB >

PrimExpr tvm::operator/=	(	const PrimExpr &	a,
		const TB &	b
	)

inline

◆ operator<() [1/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator<() [2/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator<() [3/6]

PrimExpr tvm::operator<	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<() [4/6]

PrimExpr tvm::operator<	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator<() [5/6]

PrimExpr tvm::operator<	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<() [6/6]

PrimExpr tvm::operator<	(	PrimExpr	a,
		PrimExpr	b
	)

less

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator<<() [1/3]

PrimExpr tvm::operator<<	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<<() [2/3]

PrimExpr tvm::operator<<	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<<() [3/3]

PrimExpr tvm::operator<<	(	PrimExpr	a,
		PrimExpr	b
	)

left shift operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator<=() [1/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator<=() [2/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator<=() [3/6]

PrimExpr tvm::operator<=	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator<=() [4/6]

PrimExpr tvm::operator<=	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator<=() [5/6]

PrimExpr tvm::operator<=	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator<=() [6/6]

PrimExpr tvm::operator<=	(	PrimExpr	a,
		PrimExpr	b
	)

less_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator==() [1/2]

bool tvm::operator==	(	const PrimType &	lhs,
		const PrimType &	rhs
	)

inline

◆ operator==() [2/2]

PrimExpr tvm::operator==	(	PrimExpr	a,
		PrimExpr	b
	)

equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>() [1/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator>() [2/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator>() [3/6]

PrimExpr tvm::operator>	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>() [4/6]

PrimExpr tvm::operator>	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator>() [5/6]

PrimExpr tvm::operator>	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>() [6/6]

PrimExpr tvm::operator>	(	PrimExpr	a,
		PrimExpr	b
	)

greater

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>=() [1/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		double	b
	)

inline

◆ operator>=() [2/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		float	b
	)

inline

◆ operator>=() [3/6]

PrimExpr tvm::operator>=	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>=() [4/6]

PrimExpr tvm::operator>=	(	float	a,
		const PrimExpr &	b
	)

inline

◆ operator>=() [5/6]

PrimExpr tvm::operator>=	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>=() [6/6]

PrimExpr tvm::operator>=	(	PrimExpr	a,
		PrimExpr	b
	)

greater_equal

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator>>() [1/3]

PrimExpr tvm::operator>>	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator>>() [2/3]

PrimExpr tvm::operator>>	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator>>() [3/3]

PrimExpr tvm::operator>>	(	PrimExpr	a,
		PrimExpr	b
	)

right shift operator

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator^() [1/3]

PrimExpr tvm::operator^	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator^() [2/3]

PrimExpr tvm::operator^	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator^() [3/3]

PrimExpr tvm::operator^	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise xor of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator|() [1/3]

PrimExpr tvm::operator\|	(	const PrimExpr &	a,
		int	b
	)

inline

◆ operator|() [2/3]

PrimExpr tvm::operator\|	(	int	a,
		const PrimExpr &	b
	)

inline

◆ operator|() [3/3]

PrimExpr tvm::operator\|	(	PrimExpr	a,
		PrimExpr	b
	)

take bitwise or of two values

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ operator||() [1/3]

PrimExpr tvm::operator\|\|	(	bool	a,
		const PrimExpr &	b
	)

inline

◆ operator||() [2/3]

PrimExpr tvm::operator\|\|	(	const PrimExpr &	a,
		bool	b
	)

inline

◆ operator||() [3/3]

PrimExpr tvm::operator\|\|	(	PrimExpr	a,
		PrimExpr	b
	)

or

Parameters

a	left operand
b	right operand

Returns: The result expression.

Note: This operator does eager constant folding.

◆ operator~()

PrimExpr tvm::operator~ ( PrimExpr a )

take bitwise negation of two values

Parameters

a	the input expression.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ popcount()

PrimExpr tvm::popcount	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ pow()

PrimExpr tvm::pow	(	PrimExpr	x,
		PrimExpr	y,
		Span	span = `Span()`
	)

Calculate power(x, y)

Parameters

x	The left operand.
y	The right operand.
span	The location of this operation in the source.

◆ prod()

PrimExpr tvm::prod	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

product of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ q_multiply_shift()

PrimExpr tvm::q_multiply_shift	(	PrimExpr	x,
		PrimExpr	y,
		PrimExpr	q,
		PrimExpr	s,
		Span	span = `Span()`
	)

Execute a multiplication between two Q-numbers x and y followed by a right shift s. The mathematical expression is:

out = round(x*y*2^-s)

Please note that the two Q-numbers x and y are supposed to have the same number of fractional bits q.

More about Q-numbers here: https://en.wikipedia.org/wiki/Q_(number_format)

The rounding rule is to the nearest value, rounding half up (i.e., round(x.1) = x and round (x.5) = x+1)

Parameters

x	first Q-number
y	second Q-number
q	number of fractional bits in x and y. Needs to be > 0
s	integer right shift
span	The location of this operation in the source.

Returns: The constructed expression.

◆ RedirectedReprPrinterMethod()

std::string tvm::RedirectedReprPrinterMethod ( const ffi::ObjectRef & obj )

The fallback body used by TVM_REGISTER_SCRIPT_AS_REPR (defined in printer.h).

Tries to format obj via tvm::Script; on error falls back to a plain address string. Defined in src/script/printer/config.cc so that <tvm/runtime/logging.h> is not pulled into this public header.

◆ reinterpret() [1/2]

PrimExpr tvm::reinterpret	(	PrimType	t,
		PrimExpr	value,
		Span	span = `Span()`
	)

perform reinterpret cast value to type.

Parameters

t	the target type.
value	The value
span	The location of this operation in the source.

Returns: The result expression.

Note: This function may return value if the type is the same.

◆ reinterpret() [2/2]

Expr tvm::reinterpret	(	Type	target_ty,
		Expr	value,
		Span	span = `Span()`
	)

Perform a reinterpret cast involving an exact primitive or pointer type.

◆ right_shift() [1/3]

PrimExpr tvm::right_shift	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ right_shift() [2/3]

PrimExpr tvm::right_shift	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ right_shift() [3/3]

PrimExpr tvm::right_shift	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

right shift operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ round()

PrimExpr tvm::round	(	PrimExpr	x,
		Span	span = `Span()`
	)

Round x to the nearest integer, ties to even.

Uses IEEE 754 default rounding mode (ties-to-even / banker's rounding). Constant-folding and all backends consistently use std::nearbyint semantics.

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ rsqrt()

PrimExpr tvm::rsqrt	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ Script()

std::string tvm::Script	(	const ffi::ObjectRef &	node,
		const ffi::Optional< PrinterConfig > &	config = `std::nullopt`
	)

Print node as TVMScript with the given config.

Falls back to ffi::ReprPrint for types not registered with TVMScriptPrinter.

◆ shapediv()

PrimExpr tvm::shapediv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute ceil(a / b) where a and b are non-negative.

Use this function for shape split calculation.

This function might take advantage of the fact that a and b are non-negative.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for shape types(int32, int64) when possible.

◆ sigmoid()

PrimExpr tvm::sigmoid	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sin()

PrimExpr tvm::sin	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sinh()

PrimExpr tvm::sinh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sqrt()

PrimExpr tvm::sqrt	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ sub() [1/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		double	b,
		Span	span = `Span()`
	)

inline

◆ sub() [2/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		float	b,
		Span	span = `Span()`
	)

inline

◆ sub() [3/6]

PrimExpr tvm::sub	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ sub() [4/6]

PrimExpr tvm::sub	(	float	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ sub() [5/6]

PrimExpr tvm::sub	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ sub() [6/6]

PrimExpr tvm::sub	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

subtraction operator

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ sum()

PrimExpr tvm::sum	(	PrimExpr	source,
		ffi::Array< tirx::IterVar >	axis,
		ffi::Array< PrimExpr >	init = `{}`,
		Span	span = `Span()`
	)

sum of source expression over axis

Parameters

source	The source expression.
axis	List of iteration variables that will be used for reduction.
init	The value with which to initialize the output.
span	The location of this operation in the source.

Returns: The result.

◆ tan()

PrimExpr tvm::tan	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ tanh()

PrimExpr tvm::tanh	(	PrimExpr	x,
		Span	span = `Span()`
	)

inline

◆ thread_return()

PrimExpr tvm::thread_return ( Span span = Span() )

Return from a thread.

Parameters

span	The location of this operation in the source.

Returns: The return expression.

◆ trunc()

PrimExpr tvm::trunc	(	PrimExpr	x,
		Span	span = `Span()`
	)

Calculate trunc(x)

Parameters

x	The input expression.
span	The location of this operation in the source.

Returns: The result expression.

◆ truncdiv() [1/3]

PrimExpr tvm::truncdiv	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ truncdiv() [2/3]

PrimExpr tvm::truncdiv	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ truncdiv() [3/3]

PrimExpr tvm::truncdiv	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute trunc(a / b)

This is the default integer division behavior in C.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ truncmod() [1/3]

PrimExpr tvm::truncmod	(	const PrimExpr &	a,
		int	b,
		Span	span = `Span()`
	)

inline

◆ truncmod() [2/3]

PrimExpr tvm::truncmod	(	int	a,
		const PrimExpr &	b,
		Span	span = `Span()`
	)

inline

◆ truncmod() [3/3]

PrimExpr tvm::truncmod	(	PrimExpr	a,
		PrimExpr	b,
		Span	span = `Span()`
	)

compute the remainder of truncdiv

This is the default integer division behavior in C.

Parameters

a	left operand
b	right operand
span	The location of this operation in the source.

Returns: The result expression.

Note: this function does eager constant folding for index types(int32, int64) when possible.

◆ VoidType()

Type tvm::VoidType ( )

inline

Returns: a type that represents void.

◆ WithAttr()

template<typename TFunc >

TFunc tvm::WithAttr	(	TFunc	input,
		const std::string &	attr_key,
		Any	attr_value
	)

inline

Copy the function or module, but overrides the attribute value key with the value.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attr_key	The attribute key.
attr_value	The value attribute value.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with updated attributes.

Note: This function performs copy on write optimization for func and module. If we move a uniquely referenced func or module into WithAttr, then no additional copy will be performed.

This is also why we make it as a function instead of a member function and why we pass by value in the first argument.

// Recommended way to trigger copy on write
func = WithAttr(std::move(func), "key1", value1);
func = WithAttr(std::move(func), "key2", value2);

◆ WithAttrs()

template<typename TFunc >

TFunc tvm::WithAttrs	(	TFunc	input,
		ffi::Map< ffi::String, Any >	attrs
	)

inline

Copy the function or module, but overrides the attributes with the entries from attrs.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attrs	Key/values attributes to add to `input`.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with updated attributes.

◆ WithoutAttr()

template<typename TFunc >

TFunc tvm::WithoutAttr	(	TFunc	input,
		const std::string &	attr_key
	)

inline

Copy the function or module, but removes the specified attribute.

Parameters

input	The thing to annotate (BaseFunc or IRModule)
attr_key	The attribute key.

Template Parameters

TFunc The corresponding function or module type.

Returns: The new function or module with removed attribute.

Note: This function performs copy on write optimization for func and module. If we move a uniquely referenced func or module into WithoutAttr, then no additional copy will be performed.

This is also why we make it as a function instead of a member function and why we pass by value in the first argument.

// Recommended way to trigger copy on write
func = WithoutAttr(std::move(func), "key1");
func = WithoutAttr(std::move(func), "key2");

Variable Documentation

◆ kInvalidDeviceType

constexpr int tvm::kInvalidDeviceType = -1

constexpr

◆ kNullDeviceType

constexpr int tvm::kNullDeviceType = 0

constexpr

◆ kVirtualDevice

constexpr const char* tvm::kVirtualDevice = "virtual_device"

constexpr

brief The attribute key for the virtual device. This key will be promoted to first class on functions. For use in the parser and printer only.

Type: VirtualDevice

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ Device

◆ FTargetCanonicalizer

◆ MemoryScope

Enumeration Type Documentation

◆ CallingConv

◆ LinkageType

Function Documentation

◆ abs()

◆ acos()

◆ acosh()

◆ add() [1/6]

◆ add() [2/6]

◆ add() [3/6]

◆ add() [4/6]

◆ add() [5/6]

◆ add() [6/6]

◆ all()

◆ any()

◆ asin()

◆ asinh()

◆ atan()

◆ atan2()

◆ atanh()

◆ bitwise_and() [1/3]

◆ bitwise_and() [2/3]

◆ bitwise_and() [3/3]

◆ bitwise_neg()

◆ bitwise_or() [1/3]

◆ bitwise_or() [2/3]

◆ bitwise_or() [3/3]

◆ bitwise_xor() [1/3]

◆ bitwise_xor() [2/3]

◆ bitwise_xor() [3/3]

◆ break_loop()

◆ cast()

◆ ceil()

◆ ceildiv()

◆ CheckAndUpdateHostConsistency()

◆ CheckMathUnaryOpInputDType()

◆ clz()

◆ continue_loop()

◆ copysign()

◆ cos()

◆ cosh()

◆ div() [1/6]

◆ div() [2/6]

◆ div() [3/6]

◆ div() [4/6]

◆ div() [5/6]

◆ div() [6/6]

◆ DivAmbiguityError()

◆ equal()

◆ erf()

◆ exp()

◆ exp10()

◆ exp2()

◆ fast_erf_float_expr()

◆ floor()

◆ floordiv() [1/3]

◆ floordiv() [2/3]

◆ floordiv() [3/3]

◆ floormod() [1/3]

◆ floormod() [2/3]

◆ floormod() [3/3]

◆ GetType()

◆ GetTypeFromRuntimeDataType()

◆ greater() [1/6]

◆ greater() [2/6]

◆ greater() [3/6]

◆ greater() [4/6]

◆ greater() [5/6]

◆ greater() [6/6]