tvm
Loading...
Searching...
No Matches
Namespaces | Macros | Functions
op.h File Reference

Shared primitive construction and constant helpers. More...

#include <tvm/ir/op.h>
#include <tvm/ir/prim/expr.h>
#include <algorithm>
#include <limits>
#include <type_traits>
#include <utility>
Include dependency graph for op.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

namespace  tvm
 An object that builds and maintains block scope and StmtSref mapping for Dependence analysis.
 
namespace  tvm::prim
 

Macros

#define TVM_DEFINE_ASSIGN_OP_OVERLOAD(Name, OpFunc)
 
#define TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD(Name)
 
#define TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD_SPANNED(Name)
 
#define TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD(Name)
 
#define TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD_SPANNED(Name)
 
#define TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD(Name)
 
#define TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD_SPANNED(Name)
 
#define TVM_DECLARE_INTRIN_UNARY_WITH_CHECK(OpName, CheckInputDType)
 
#define TVM_DECLARE_INTRIN_UNARY(OpName)    TVM_DECLARE_INTRIN_UNARY_WITH_CHECK(OpName, [](const char*, const PrimType&) {})
 
#define TVM_DECLARE_FLOAT_INTRIN_UNARY(OpName)    TVM_DECLARE_INTRIN_UNARY_WITH_CHECK(OpName, CheckMathUnaryOpInputDType)
 
#define TVM_DECLARE_INTRIN_BINARY(OpName)
 

Functions

TVM_TIRX_DLL const Op & tvm::prim::vscale_op ()
 Get the target's vscale value. It will be lowered to llvm.vscale intrinsic (https://llvm.org/docs/LangRef.html#llvm-vscale-intrinsic)
 
TVM_TIRX_DLL const Op & tvm::prim::ceil_op ()
 Round up to the nearest integral value.
 
TVM_TIRX_DLL const Op & tvm::prim::log2_op ()
 Base-two logarithm.
 
TVM_TIRX_DLL const Op & tvm::prim::clz_op ()
 Count leading zero bits.
 
TVM_TIRX_DLL const Op & tvm::prim::if_then_else_op ()
 Same as select, used for unsafe memory access.
 
TVM_TIRX_DLL const Op & tvm::prim::likely_op ()
 Marks a condition is likely going to happen.
 
TVM_TIRX_DLL PrimExpr tvm::add (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 add operator
 
TVM_TIRX_DLL PrimExpr tvm::sub (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 subtraction operator
 
TVM_TIRX_DLL PrimExpr tvm::neg (PrimExpr a, Location loc=UnknownLoc())
 negation.
 
TVM_TIRX_DLL PrimExpr tvm::mul (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 multiplication operator
 
TVM_TIRX_DLL PrimExpr tvm::left_shift (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 left shift operator
 
TVM_TIRX_DLL PrimExpr tvm::right_shift (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 right shift operator
 
TVM_TIRX_DLL PrimExpr tvm::greater (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 greater
 
TVM_TIRX_DLL PrimExpr tvm::greater_equal (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 greater_equal
 
TVM_TIRX_DLL PrimExpr tvm::less (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 less
 
TVM_TIRX_DLL PrimExpr tvm::less_equal (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 less_equal
 
TVM_TIRX_DLL PrimExpr tvm::equal (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 equal
 
TVM_TIRX_DLL PrimExpr tvm::not_equal (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 not_equal
 
TVM_TIRX_DLL PrimExpr tvm::logical_and (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 and
 
TVM_TIRX_DLL PrimExpr tvm::logical_or (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 or
 
TVM_TIRX_DLL PrimExpr tvm::logical_not (PrimExpr a, Location loc=UnknownLoc())
 not
 
TVM_TIRX_DLL PrimExpr tvm::div (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute division in C semantics.
 
TVM_TIRX_DLL PrimExpr tvm::truncdiv (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute trunc(a / b)
 
TVM_TIRX_DLL PrimExpr tvm::truncmod (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute the remainder of truncdiv
 
TVM_TIRX_DLL PrimExpr tvm::indexdiv (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute floor(a / b) where a and b are non-negative.
 
TVM_TIRX_DLL PrimExpr tvm::shapediv (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute ceil(a / b) where a and b are non-negative.
 
TVM_TIRX_DLL PrimExpr tvm::indexmod (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute the remainder floor(a / b) where a and b are non-negative.
 
TVM_TIRX_DLL PrimExpr tvm::floordiv (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute floor(a / b)
 
TVM_TIRX_DLL PrimExpr tvm::ceildiv (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute ceil(a / b)
 
TVM_TIRX_DLL PrimExpr tvm::floormod (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 compute the remainder of floordiv
 
TVM_TIRX_DLL PrimExpr tvm::max (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 take maximum of two values
 
TVM_TIRX_DLL PrimExpr tvm::min (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 take minimum of two values
 
TVM_TIRX_DLL PrimExpr tvm::bitwise_and (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 take bitwise and of two values
 
TVM_TIRX_DLL PrimExpr tvm::bitwise_or (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 take bitwise or of two values
 
TVM_TIRX_DLL PrimExpr tvm::bitwise_xor (PrimExpr a, PrimExpr b, Location loc=UnknownLoc())
 take bitwise xor of two values
 
TVM_TIRX_DLL PrimExpr tvm::bitwise_neg (PrimExpr a, Location loc=UnknownLoc())
 take bitwise negation of two values
 
TVM_TIRX_DLL PrimExpr tvm::if_then_else (PrimExpr cond, PrimExpr true_value, PrimExpr false_value, Location loc=UnknownLoc())
 Conditional expression.
 
TVM_TIRX_DLL PrimExpr tvm::likely (PrimExpr cond, Location loc=UnknownLoc())
 Mark condition as likely.
 
TVM_TIRX_DLL PrimExpr tvm::ceil (PrimExpr x, Location loc=UnknownLoc())
 Round up to the nearest integral value, preserving the input type.
 
TVM_TIRX_DLL PrimExpr tvm::log2 (PrimExpr x, Location loc=UnknownLoc())
 Construct a base-two logarithm with the input's primitive type.
 
TVM_TIRX_DLL PrimExpr tvm::prim::clz (PrimExpr x, Location loc=UnknownLoc())
 Count leading zero bits, preserving the input primitive type.
 
TVM_TIRX_DLL PrimExpr tvm::prim::min_value (PrimType dtype, Location loc=UnknownLoc())
 
TVM_TIRX_DLL PrimExpr tvm::prim::max_value (PrimType dtype, Location loc=UnknownLoc())
 
TVM_TIRX_DLL PrimExpr tvm::prim::cast (PrimType t, PrimExpr value, Location loc=UnknownLoc())
 cast value to type.
 
TVM_TIRX_DLL PrimExpr tvm::prim::cast (DLDataType t, PrimExpr value, Location loc=UnknownLoc())
 
TVM_TIRX_DLL PrimExpr tvm::prim::IntegerAbs (PrimExpr x, Location loc=UnknownLoc())
 Construct integer absolute value; floating absolute value belongs to TIRX.
 
template<typename ValueType , typename = typename std::enable_if<(std::is_standard_layout<ValueType>::value && std::is_trivial<ValueType>::value) || std::is_same<ValueType, ffi::BigInt>::value>::type>
PrimExpr tvm::prim::MakeConst (PrimType dtype, ValueType value, Location loc=UnknownLoc())
 Make a const value with certain data type.
 
template<typename ValueType >
PrimExpr tvm::prim::MakeConstScalar (PrimType dtype, ValueType value, Location loc=UnknownLoc())
 
template<>
PrimExpr tvm::prim::MakeConstScalar (PrimType dtype, bool value, Location loc)
 
PrimExpr tvm::operator+= (PrimExpr &a, PrimExpr b)
 
PrimExpr tvm::operator-= (PrimExpr &a, PrimExpr b)
 
PrimExpr tvm::operator*= (PrimExpr &a, PrimExpr b)
 
PrimExpr tvm::operator+ (const PrimExpr &a, float b)
 
PrimExpr tvm::operator+ (float a, const PrimExpr &b)
 
PrimExpr tvm::operator+ (int a, const PrimExpr &b)
 
PrimExpr tvm::operator+ (const PrimExpr &a, int b)
 
PrimExpr tvm::operator+ (const PrimExpr &a, double b)
 
PrimExpr tvm::operator- (const PrimExpr &a, float b)
 
PrimExpr tvm::operator- (float a, const PrimExpr &b)
 
PrimExpr tvm::operator- (int a, const PrimExpr &b)
 
PrimExpr tvm::operator- (const PrimExpr &a, int b)
 
PrimExpr tvm::operator- (const PrimExpr &a, double b)
 
PrimExpr tvm::operator* (const PrimExpr &a, float b)
 
PrimExpr tvm::operator* (float a, const PrimExpr &b)
 
PrimExpr tvm::operator* (int a, const PrimExpr &b)
 
PrimExpr tvm::operator* (const PrimExpr &a, int b)
 
PrimExpr tvm::operator* (const PrimExpr &a, double b)
 
PrimExpr tvm::operator> (const PrimExpr &a, float b)
 
PrimExpr tvm::operator> (float a, const PrimExpr &b)
 
PrimExpr tvm::operator> (int a, const PrimExpr &b)
 
PrimExpr tvm::operator> (const PrimExpr &a, int b)
 
PrimExpr tvm::operator> (const PrimExpr &a, double b)
 
PrimExpr tvm::operator>= (const PrimExpr &a, float b)
 
PrimExpr tvm::operator>= (float a, const PrimExpr &b)
 
PrimExpr tvm::operator>= (int a, const PrimExpr &b)
 
PrimExpr tvm::operator>= (const PrimExpr &a, int b)
 
PrimExpr tvm::operator>= (const PrimExpr &a, double b)
 
PrimExpr tvm::operator< (const PrimExpr &a, float b)
 
PrimExpr tvm::operator< (float a, const PrimExpr &b)
 
PrimExpr tvm::operator< (int a, const PrimExpr &b)
 
PrimExpr tvm::operator< (const PrimExpr &a, int b)
 
PrimExpr tvm::operator< (const PrimExpr &a, double b)
 
PrimExpr tvm::operator<= (const PrimExpr &a, float b)
 
PrimExpr tvm::operator<= (float a, const PrimExpr &b)
 
PrimExpr tvm::operator<= (int a, const PrimExpr &b)
 
PrimExpr tvm::operator<= (const PrimExpr &a, int b)
 
PrimExpr tvm::operator<= (const PrimExpr &a, double b)
 
PrimExpr tvm::max (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::max (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::max (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::max (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::max (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::min (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::min (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::min (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::min (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::min (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::div (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::div (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::div (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::div (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::div (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::add (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::add (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::add (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::add (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::add (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::sub (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::sub (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::sub (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::sub (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::sub (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::mul (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::mul (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::mul (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::mul (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::mul (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater_equal (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater_equal (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater_equal (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater_equal (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::greater_equal (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::less (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::less (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::less (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::less (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::less (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::less_equal (const PrimExpr &a, float b, Location loc=UnknownLoc())
 
PrimExpr tvm::less_equal (float a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::less_equal (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::less_equal (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::less_equal (const PrimExpr &a, double b, Location loc=UnknownLoc())
 
PrimExpr tvm::indexdiv (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::indexdiv (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::indexmod (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::indexmod (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::truncdiv (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::truncdiv (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::truncmod (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::truncmod (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::floordiv (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::floordiv (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::floormod (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::floormod (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::right_shift (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::right_shift (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::left_shift (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::left_shift (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_and (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_and (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_or (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_or (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_xor (const PrimExpr &a, int b, Location loc=UnknownLoc())
 
PrimExpr tvm::bitwise_xor (int a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::operator>> (const PrimExpr &a, int b)
 
PrimExpr tvm::operator>> (int a, const PrimExpr &b)
 
PrimExpr tvm::operator<< (const PrimExpr &a, int b)
 
PrimExpr tvm::operator<< (int a, const PrimExpr &b)
 
PrimExpr tvm::operator& (const PrimExpr &a, int b)
 
PrimExpr tvm::operator& (int a, const PrimExpr &b)
 
PrimExpr tvm::operator| (const PrimExpr &a, int b)
 
PrimExpr tvm::operator| (int a, const PrimExpr &b)
 
PrimExpr tvm::operator^ (const PrimExpr &a, int b)
 
PrimExpr tvm::operator^ (int a, const PrimExpr &b)
 
PrimExpr tvm::operator&& (const PrimExpr &a, bool b)
 
PrimExpr tvm::operator&& (bool a, const PrimExpr &b)
 
PrimExpr tvm::operator|| (const PrimExpr &a, bool b)
 
PrimExpr tvm::operator|| (bool a, const PrimExpr &b)
 
PrimExpr tvm::logical_and (const PrimExpr &a, bool b, Location loc=UnknownLoc())
 
PrimExpr tvm::logical_and (bool a, const PrimExpr &b, Location loc=UnknownLoc())
 
PrimExpr tvm::logical_or (const PrimExpr &a, bool b, Location loc=UnknownLoc())
 
PrimExpr tvm::logical_or (bool a, const PrimExpr &b, Location loc=UnknownLoc())
 
template<typename TA >
void tvm::DivAmbiguityError (const TA &a)
 Helper function to raise a compiler error about division ambiguity.
 
template<typename TB >
PrimExpr tvm::operator/ (const PrimExpr &a, const TB &b)
 
template<typename TB >
PrimExpr tvm::operator/= (const PrimExpr &a, const TB &b)
 
template<typename TB >
PrimExpr tvm::operator% (const PrimExpr &a, const TB &b)
 
bool tvm::prim::IsConstInt (const PrimExpr &x, int64_t value)
 Check whether x is a constant integer expression.
 
bool tvm::prim::IsOne (const PrimExpr &x)
 Check whether x is a constant integer 1.
 
bool tvm::prim::IsZero (const PrimExpr &x)
 Check whether x is a constant integer 0.
 
bool tvm::prim::IsConstInt (const PrimExpr &x)
 Check whether x is an integer constant, including wide IntImm values.
 
bool tvm::prim::IsConstNumber (const PrimExpr &x)
 Check whether x is an integer or floating-point constant.
 
TVM_TIRX_DLL bool tvm::prim::IsPowerOfTwoInt (const PrimExpr &x, int *shift)
 Check whether x is a constant power of two If x is power of two, write the power to the shift.
 
bool tvm::prim::IsPositiveConst (const PrimExpr &a)
 Check whether a is a positive integer constant.
 
bool tvm::prim::IsNegativeConst (const PrimExpr &a)
 Check whether a is a negative integer constant.
 
TVM_TIRX_DLL PrimExpr tvm::prim::infinity (PrimType dtype, Location loc=UnknownLoc())
 
TVM_TIRX_DLL PrimExpr tvm::prim::pow (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 Calculate power(x, y)
 
TVM_TIRX_DLL PrimExpr tvm::prim::abs (PrimExpr x, Location loc=UnknownLoc())
 Calculate absolute value of x.
 
TVM_TIRX_DLL PrimExpr tvm::prim::isnan (PrimExpr x, Location loc=UnknownLoc())
 Check if x is NaN.
 
TVM_TIRX_DLL PrimExpr tvm::prim::isfinite (PrimExpr x, Location loc=UnknownLoc())
 Check if x is finite.
 
TVM_TIRX_DLL PrimExpr tvm::prim::isinf (PrimExpr x, Location loc=UnknownLoc())
 Check if x is infinite.
 
TVM_TIRX_DLL PrimExpr tvm::prim::floor (PrimExpr x, Location loc=UnknownLoc())
 Calculate floor(x)
 
TVM_TIRX_DLL PrimExpr tvm::prim::round (PrimExpr x, Location loc=UnknownLoc())
 Round x to the nearest integer, ties to even.
 
TVM_TIRX_DLL PrimExpr tvm::prim::nearbyint (PrimExpr x, Location loc=UnknownLoc())
 Round x to the nearest integer, ties to even.
 
TVM_TIRX_DLL PrimExpr tvm::prim::trunc (PrimExpr x, Location loc=UnknownLoc())
 Calculate trunc(x)
 
TVM_TIRX_DLL PrimExpr tvm::prim::fmod (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 Floating-point remainder of x divided by y.
 
TVM_TIRX_DLL const Op & tvm::prim::pow_op ()
 Raise x to the power y. Arguments: x, y.
 
TVM_TIRX_DLL const Op & tvm::prim::fabs_op ()
 Absolute value. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::fmod_op ()
 Floating-point remainder. Arguments: x, y.
 
TVM_TIRX_DLL const Op & tvm::prim::floor_op ()
 Round toward negative infinity. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::round_op ()
 Round to nearest integer, ties to even. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::nearbyint_op ()
 Round to nearest integer, ties to even. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::trunc_op ()
 Round toward zero. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::exp_op ()
 Natural exponential. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::exp2_op ()
 Base-two exponential. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::exp10_op ()
 Base-ten exponential. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::erf_op ()
 Error function. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::tanh_op ()
 Hyperbolic tangent. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::sigmoid_op ()
 Logistic sigmoid. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::sqrt_op ()
 Square root. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::rsqrt_op ()
 Reciprocal square root. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::log_op ()
 Natural logarithm. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::log1p_op ()
 Natural logarithm of one plus x. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::log10_op ()
 Base-ten logarithm. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::tan_op ()
 Tangent. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::cos_op ()
 Cosine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::cosh_op ()
 Hyperbolic cosine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::sin_op ()
 Sine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::sinh_op ()
 Hyperbolic sine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::asin_op ()
 Inverse sine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::acos_op ()
 Inverse cosine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::atan_op ()
 Inverse tangent. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::acosh_op ()
 Inverse hyperbolic cosine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::asinh_op ()
 Inverse hyperbolic sine. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::atanh_op ()
 Inverse hyperbolic tangent. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::atan2_op ()
 Inverse tangent of y/x with quadrant selection. Arguments: y, x.
 
TVM_TIRX_DLL const Op & tvm::prim::nextafter_op ()
 Next representable value from x toward y. Arguments: x, y.
 
TVM_TIRX_DLL const Op & tvm::prim::hypot_op ()
 Euclidean length of x and y. Arguments: x, y.
 
TVM_TIRX_DLL const Op & tvm::prim::copysign_op ()
 Magnitude of x with the sign of y. Arguments: x, y.
 
TVM_TIRX_DLL const Op & tvm::prim::ldexp_op ()
 Multiply x by two raised to exponent. Arguments: x, exponent.
 
TVM_TIRX_DLL const Op & tvm::prim::isnan_op ()
 Check for NaN, preserving the lane count. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::popcount_op ()
 Count set bits. Argument: x.
 
TVM_TIRX_DLL const Op & tvm::prim::fma_op ()
 Fused multiply-add, x * y + z. Arguments: x, y, z.
 
TVM_TIRX_DLL const Op & tvm::prim::assume_op ()
 Record a known condition for simplification. Argument: condition.
 
TVM_TIRX_DLL PrimExpr tvm::prim::assume (PrimExpr condition, Location loc=UnknownLoc())
 Record a known condition for compile-time simplification.
 
PrimExpr tvm::prim::fma (PrimExpr x, PrimExpr y, PrimExpr z, Location loc=UnknownLoc())
 Fused multiply-add of x, y and z, in that order.
 
void tvm::prim::CheckMathUnaryOpInputDType (const char *op_name, const PrimType &dtype)
 
PrimExpr tvm::prim::exp (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::exp2 (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::exp10 (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::erf (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::tanh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::sigmoid (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::sqrt (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::rsqrt (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::log (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::log10 (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::log1p (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::popcount (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::tan (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::cos (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::cosh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::sin (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::sinh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::asin (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::acos (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::atan (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::acosh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::asinh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::atanh (PrimExpr x, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::atan2 (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::nextafter (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::copysign (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::hypot (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 
PrimExpr tvm::prim::ldexp (PrimExpr x, PrimExpr y, Location loc=UnknownLoc())
 
template<typename FReduce >
PrimExpr tvm::prim::foldl (FReduce freduce, PrimExpr init_value, const ffi::Array< PrimExpr > &values, Location loc=UnknownLoc())
 

Detailed Description

Shared primitive construction and constant helpers.

Macro Definition Documentation

◆ TVM_DECLARE_FLOAT_INTRIN_UNARY

#define TVM_DECLARE_FLOAT_INTRIN_UNARY (   OpName)     TVM_DECLARE_INTRIN_UNARY_WITH_CHECK(OpName, CheckMathUnaryOpInputDType)

◆ TVM_DECLARE_INTRIN_BINARY

#define TVM_DECLARE_INTRIN_BINARY (   OpName)
Value:
inline PrimExpr OpName(PrimExpr x, PrimExpr y, Location loc = UnknownLoc()) { \
static const Op op = Op::Get("prim." #OpName); \
return Call(x.ty(), op, {x, y}, {}, {}, loc).as_or_throw<PrimExpr>(); \
}

◆ TVM_DECLARE_INTRIN_UNARY

#define TVM_DECLARE_INTRIN_UNARY (   OpName)     TVM_DECLARE_INTRIN_UNARY_WITH_CHECK(OpName, [](const char*, const PrimType&) {})

◆ TVM_DECLARE_INTRIN_UNARY_WITH_CHECK

#define TVM_DECLARE_INTRIN_UNARY_WITH_CHECK (   OpName,
  CheckInputDType 
)
Value:
inline PrimExpr OpName(PrimExpr x, Location loc = UnknownLoc()) { \
static const Op op = Op::Get("prim." #OpName); \
PrimType x_ty = x.ty(); \
CheckInputDType(#OpName, x_ty); \
if (x_ty.MatchesElementType(DLDataTypeCode::kDLBfloat, 16)) { \
PrimType bf16_ty = x_ty; \
PrimType f32_ty = \
x_ty.IsScalableVector() \
? PrimType::ScalableVector(DLDataTypeCode::kDLFloat, 32, x_ty.VScaleFactor()) \
: PrimType::Float(32, x_ty.lanes()); \
PrimExpr x_fp32 = prim::Cast(f32_ty, x, loc); \
PrimExpr result_fp32 = Call(f32_ty, op, {x_fp32}, {}, {}, loc).as_or_throw<PrimExpr>(); \
return prim::Cast(bf16_ty, result_fp32, loc); \
} else { \
return Call(x_ty, op, {x}, {}, {}, loc).as_or_throw<PrimExpr>(); \
} \
}

◆ TVM_DEFINE_ASSIGN_OP_OVERLOAD

#define TVM_DEFINE_ASSIGN_OP_OVERLOAD (   Name,
  OpFunc 
)
Value:
inline PrimExpr Name(PrimExpr& a, PrimExpr b) { \
a = OpFunc(a, b); \
return a; \
}

◆ TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD

#define TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, float b) { return Name(a, PrimExpr(b)); } \
inline PrimExpr Name(float a, const PrimExpr& b) { return Name(PrimExpr(a), b); } \
inline PrimExpr Name(int a, const PrimExpr& b) { return Name(prim::MakeConst(b.ty(), a), b); } \
inline PrimExpr Name(const PrimExpr& a, int b) { return Name(a, prim::MakeConst(a.ty(), b)); } \
inline PrimExpr Name(const PrimExpr& a, double b) { \
return Name(a, FloatImm(PrimType::Float(64), b)); \
}

◆ TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD_SPANNED

#define TVM_DEFINE_BINOP_CONST_VAL_OVERLOAD_SPANNED (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, float b, Location loc = UnknownLoc()) { \
return Name(a, PrimExpr(b), loc); \
} \
inline PrimExpr Name(float a, const PrimExpr& b, Location loc = UnknownLoc()) { \
return Name(PrimExpr(a), b, loc); \
} \
inline PrimExpr Name(int a, const PrimExpr& b, Location loc = UnknownLoc()) { \
return Name(prim::MakeConst(b.ty(), a), b, loc); \
} \
inline PrimExpr Name(const PrimExpr& a, int b, Location loc = UnknownLoc()) { \
return Name(a, prim::MakeConst(a.ty(), b), loc); \
} \
inline PrimExpr Name(const PrimExpr& a, double b, Location loc = UnknownLoc()) { \
return Name(a, FloatImm(PrimType::Float(64), b), loc); \
}

◆ TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD

#define TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, int b) { return Name(a, prim::MakeConst(a.ty(), b)); } \
inline PrimExpr Name(int a, const PrimExpr& b) { return Name(prim::MakeConst(b.ty(), a), b); }

◆ TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD_SPANNED

#define TVM_DEFINE_INT_OP_CONST_VAL_OVERLOAD_SPANNED (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, int b, Location loc = UnknownLoc()) { \
return Name(a, prim::MakeConst(a.ty(), b), loc); \
} \
inline PrimExpr Name(int a, const PrimExpr& b, Location loc = UnknownLoc()) { \
return Name(prim::MakeConst(b.ty(), a), b, loc); \
}

◆ TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD

#define TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, bool b) { return Name(a, PrimExpr(b)); } \
inline PrimExpr Name(bool a, const PrimExpr& b) { return Name(PrimExpr(a), b); }

◆ TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD_SPANNED

#define TVM_DEFINE_LOGICAL_OP_CONST_VAL_OVERLOAD_SPANNED (   Name)
Value:
inline PrimExpr Name(const PrimExpr& a, bool b, Location loc = UnknownLoc()) { \
return Name(a, PrimExpr(b), loc); \
} \
inline PrimExpr Name(bool a, const PrimExpr& b, Location loc = UnknownLoc()) { \
return Name(PrimExpr(a), b, loc); \
}
Generated by doxygen 1.9.8