//===----------------------------------------------------------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// This file defines HLSL intrinsic functions in tablegen. The HLSLEmitter

// backend processes these definitions and generates two .inc files:

// - hlsl_alias_intrinsics_gen.inc: builtin alias declarations using

// _HLSL_BUILTIN_ALIAS, included by hlsl_alias_intrinsics.h.

// - hlsl_inline_intrinsics_gen.inc: inline function definitions (detail

// helper calls and literal bodies), included by hlsl_intrinsics.h.

//

//===----------------------------------------------------------------------===//

//===----------------------------------------------------------------------===//

// Argument and return type base classes

//===----------------------------------------------------------------------===//

// Base class for argument and return type positions.

class HLSLArgType;

// Base class for return type positions.

class HLSLReturnType;

// Void return type.

def VoidTy : HLSLReturnType;

//===----------------------------------------------------------------------===//

// HLSL element types

//===----------------------------------------------------------------------===//

// Represents a concrete HLSL scalar element type.

// Can be used directly as an argument or return type for a fixed scalar

// (e.g., FloatTy in Args produces a 'float' argument).

class HLSLType<string name> : HLSLArgType, HLSLReturnType {

string Name = name;

string TypeName = name;

// When set, overloads using this type are guarded by

// #ifdef __HLSL_ENABLE_16_BIT and emitted with

// _HLSL_AVAILABILITY(shadermodel, 6.2), or the intrinsic's Availability

// if it is greater.

bit Is16Bit = 0;

// When set, overloads using this type are emitted with

// _HLSL_16BIT_AVAILABILITY(shadermodel, 6.2) instead of _HLSL_AVAILABILITY.

// This macro expands to an availability attribute only when

// __HLSL_ENABLE_16_BIT is defined (i.e. half is a true 16-bit float);

// otherwise it expands to nothing since half is an alias for float.

// If the intrinsic's Availability is >= SM6.2, _HLSL_AVAILABILITY is used

// instead because 16-bit support is already implied.

bit IsConditionally16Bit = 0;

}

def BoolTy : HLSLType<"bool">;

def HalfTy : HLSLType<"half"> { let IsConditionally16Bit = 1; }

def FloatTy : HLSLType<"float">;

def DoubleTy : HLSLType<"double">;

def Int16Ty : HLSLType<"int16_t"> { let Is16Bit = 1; }

def UInt16Ty : HLSLType<"uint16_t"> { let Is16Bit = 1; }

def IntTy : HLSLType<"int">;

def UIntTy : HLSLType<"uint">;

def Int64Ty : HLSLType<"int64_t">;

def UInt64Ty : HLSLType<"uint64_t">;

//===----------------------------------------------------------------------===//

// Element type groups

//===----------------------------------------------------------------------===//

defvar AllFloatTypes = [HalfTy, FloatTy, DoubleTy];

defvar SignedIntTypes = [Int16Ty, IntTy, Int64Ty];

defvar UnsignedIntTypes = [UInt16Ty, UIntTy, UInt64Ty];

defvar AllIntTypes = [Int16Ty, UInt16Ty, IntTy, UIntTy,

Int64Ty, UInt64Ty];

defvar SignedTypes = [Int16Ty, HalfTy, IntTy, FloatTy,

Int64Ty, DoubleTy];

defvar AllNumericTypes = [Int16Ty, UInt16Ty, HalfTy, IntTy, UIntTy,

FloatTy, Int64Ty, UInt64Ty, DoubleTy];

defvar AllTypesWithBool = [BoolTy, Int16Ty, UInt16Ty, HalfTy,

IntTy, UIntTy, FloatTy, Int64Ty,

UInt64Ty, DoubleTy];

defvar NumericTypesNoDbl = [Int16Ty, UInt16Ty, HalfTy, IntTy, UIntTy,

FloatTy, Int64Ty, UInt64Ty];

//===----------------------------------------------------------------------===//

// Argument/return types

//

// These classes are usable in both argument and return type positions.

//===----------------------------------------------------------------------===//

// The varying type — expanded per VaryingTypes.

// As an argument: the arg type varies with each overload.

// As a return type: returns the same type as the varying arg.

def Varying : HLSLArgType, HLSLReturnType;

// The scalar element of the varying type.

// As an argument: always the scalar element type regardless of overload shape.

// As a return type: returns the scalar element type (e.g., float dot(float3, float3)).

def VaryingElemType : HLSLArgType, HLSLReturnType;

// The varying shape with a fixed element type.

// As an argument: same shape as Varying but with the given element type.

// As a return type: same shape as the varying arg but with the given element type.

// For example, VaryingShape<UIntTy> with a float3 overload produces uint3.

class VaryingShape<HLSLType ty> : HLSLArgType, HLSLReturnType {

HLSLType ElementType = ty;

}

// A concrete vector type (e.g., VectorType<UIntTy, 4> -> uint4).

// As an argument: the arg is always this vector type.

// As a return type: always returns this vector type, ignoring argument shape.

class VectorType<HLSLType ty, int size> : HLSLArgType, HLSLReturnType {

HLSLType ElementType = ty;

int Size = size;

}

//===----------------------------------------------------------------------===//

// Shader model versions

//===----------------------------------------------------------------------===//

// Represents a shader model version

class ShaderModel<int major, int minor> {

int Major = major;

int Minor = minor;

}

// Sentinel: no shader model requirement.

def NoSM : ShaderModel<0, 0>;

// Valid Shader Model records

foreach i = 0...9 in {

def SM6_ #i : ShaderModel<6, i>;

}

//===----------------------------------------------------------------------===//

// Matrix dimension records

//===----------------------------------------------------------------------===//

class MatDim<int rows, int cols> {

int Rows = rows;

int Cols = cols;

}

foreach r = 1...4 in

foreach c = 1...4 in

def Mat#r#"x"#c : MatDim<r, c>;

// All non-1x1 matrix dimensions (1x2 through 4x4).

defvar AllMatDims = [Mat1x2, Mat1x3, Mat1x4,

Mat2x1, Mat2x2, Mat2x3, Mat2x4,

Mat3x1, Mat3x2, Mat3x3, Mat3x4,

Mat4x1, Mat4x2, Mat4x3, Mat4x4];

//===----------------------------------------------------------------------===//

// HLSLBuiltin class

//===----------------------------------------------------------------------===//

class HLSLBuiltin<string name, string builtin = ""> {

string Name = name;

// When set, generates a _HLSL_BUILTIN_ALIAS(Builtin) declaration that

// aliases the named Clang builtin. Mutually exclusive with DetailFunc

// and Body.

string Builtin = builtin;

// Doxygen documentation comment emitted before overloads in generated code.

string Doc = "";

// When set, generates an inline function body calling

// __detail::DetailFunc(args...) instead of _HLSL_BUILTIN_ALIAS(Builtin).

// Parameters are named p0, p1, p2, ... by default, or use ParamNames to

// specify custom names. Mutually exclusive with Body and Builtin.

string DetailFunc = "";

// When set, generates an inline function with this literal body text.

// Intended for single-statement functions. Multi-line functions should

// instead be defined as a helper and called with DetailFunc.

// Parameters are named p0, p1, p2, ... by default, or use ParamNames to

// specify custom names. Mutually exclusive with DetailFunc and Builtin.

code Body = "";

// Determines how the return type is derived for each overload.

HLSLReturnType ReturnType = VoidTy;

// Argument list. Each entry is either:

// Varying - type varies with VaryingTypes (expanded per type)

// HLSLType - a fixed scalar type at that position (e.g., UIntTy)

// VectorType - a fixed vector type at that position

// The number of arguments is deduced from the length of this list.

// Examples:

// [Varying] -> func(T)

// [Varying, Varying, Varying] -> func(T, T, T)

// [Varying, UIntTy] -> func(T, uint)

// [UIntTy, UIntTy, IntTy] -> func(uint, uint, int)

// [] -> func()

list<HLSLArgType> Args = [];

// Custom parameter names for generated functions.

// When empty, inline functions (Body or DetailFunc) use p0, p1, p2, ...

// and alias functions omit parameter names.

list<string> ParamNames = [];

// When set, emits 'constexpr' instead of 'inline' for inline functions

// (i.e., functions using Body or DetailFunc).

bit IsConstexpr = 0;

// Whether the function has the convergent attribute

bit IsConvergent = 0;

// Argument element types — drives overload expansion.

// One overload set is generated per type (scalar + vectors + matrices).

// Only used when Args contains Varying entries.

list<HLSLType> VaryingTypes = [];

// Whether to generate scalar overloads for Varying typed arguments.

bit VaryingScalar = 0;

// Vector sizes to generate for Varying typed arguments (e.g., [2,3,4]).

list<int> VaryingVecSizes = [];

// Matrix dimensions to generate for Varying typed arguments.

list<MatDim> VaryingMatDims = [];

// Default shader model availability version for all types.

// Use NoSM for no availability requirement.

ShaderModel Availability = NoSM;

}

//===----------------------------------------------------------------------===//

// HLSLBuiltin helper subclasses

//===----------------------------------------------------------------------===//

// T func(T) with scalar + vec2/3/4 + matrix overloads.

class HLSLOneArgBuiltin<string name, string builtin>

: HLSLBuiltin<name, builtin> {

let Args = [Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// T func(T, T) with scalar + vec2/3/4 + matrix overloads.

class HLSLTwoArgBuiltin<string name, string builtin>

: HLSLBuiltin<name, builtin> {

let Args = [Varying, Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// T func(T, T, T) with scalar + vec2/3/4 + matrix overloads.

class HLSLThreeArgBuiltin<string name, string builtin>

: HLSLBuiltin<name, builtin> {

let Args = [Varying, Varying, Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// Detail function base: generates inline function bodies calling

// __detail::DetailFunc(args...) instead of _HLSL_BUILTIN_ALIAS.

class HLSLDetail<string name, string detail> : HLSLBuiltin<name> {

let DetailFunc = detail;

}

// T func(T) with scalar + vec2/3/4 + matrix overloads.

class HLSLOneArgDetail<string name, string detail>

: HLSLDetail<name, detail> {

let Args = [Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// T func(T, T) with scalar + vec2/3/4 + matrix overloads.

class HLSLTwoArgDetail<string name, string detail>

: HLSLDetail<name, detail> {

let Args = [Varying, Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// T func(T, T, T) with scalar + vec2/3/4 + matrix overloads.

class HLSLThreeArgDetail<string name, string detail>

: HLSLDetail<name, detail> {

let Args = [Varying, Varying, Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

// Inline body variant: T func(T) with a literal inline body (no builtin alias).

// Body must be specified (e.g., let Body = "return p0;").

class HLSLOneArgInlineBuiltin<string name> : HLSLBuiltin<name> {

let Args = [Varying];

let ReturnType = Varying;

let VaryingScalar = 1;

let VaryingVecSizes = [2, 3, 4];

let VaryingMatDims = AllMatDims;

}

//===----------------------------------------------------------------------===//

// Intrinsic definitions (sorted alphabetically by function name)

//===----------------------------------------------------------------------===//

// TODO: Convert hand-written overloads from hlsl_intrinsics.h and

// hlsl_alias_intrinsics.h into TableGen below.

// Include "hlsl_alias_intrinsics_gen.inc" in hlsl_alias_intrinsics.h

// Include "hlsl_inline_intrinsics_gen.inc" in hlsl_intrinsics.h