def HLSLVkConstantId : InheritableAttr {

let Spellings = [CXX11<"vk", "constant_id">];

let Args = [IntArgument<"Id">];

let Subjects = SubjectList<[ExternalGlobalVar]>;

let LangOpts = [HLSL];

let Documentation = [VkConstantIdDocs];

}

def VkConstantIdDocs : Documentation {

let Category = DocCatFunction;

let Content = [{

The ``vk::constant_id`` attribute specifies the id for a SPIR-V specialization

constant. The attribute applies to const global scalar variables. The variable must be initialized with a C++11 constexpr.

In SPIR-V, the

variable will be replaced with an `OpSpecConstant` with the given id.

The syntax is:

.. code-block:: text

``[[vk::constant_id(<Id>)]] const T Name = <Init>``

}];

}

class HLSLScalarTemplate

: Template<["bool", "char", "short", "int", "long long int",

"unsigned short", "unsigned int", "unsigned long long int",

"__fp16", "float", "double"],

["_bool", "_char", "_short", "_int", "_longlong", "_ushort",

"_uint", "_ulonglong", "_half", "_float", "_double"]>;

def HLSLGetSpirvSpecConstant : LangBuiltin<"HLSL_LANG">, HLSLScalarTemplate {

let Spellings = ["__builtin_get_spirv_spec_constant"];

let Attributes = [NoThrow, Const, Pure];

let Prototype = "T(unsigned int, T)";

}

def err_specialization_const

: Error<"variable with 'vk::constant_id' attribute must be a const "

"int/float/enum/bool and be initialized with a literal">;

HLSLVkConstantIdAttr *

mergeVkConstantIdAttr(Decl *D, const AttributeCommonInfo &AL, int Id);

void handleVkConstantIdAttr(Decl *D, const ParsedAttr &AL);

#include "CodeGenFunction.h"

static std::string getSpecConstantFunctionName(clang::QualType SpecConstantType,

ASTContext &Context) {

// The parameter types for our conceptual intrinsic function.

QualType ClangParamTypes[] = {Context.IntTy, SpecConstantType};

// Create a temporary FunctionDecl for the builtin fuction. It won't be

// added to the AST.

FunctionProtoType::ExtProtoInfo EPI;

QualType FnType =

Context.getFunctionType(SpecConstantType, ClangParamTypes, EPI);

DeclarationName FuncName = &Context.Idents.get("__spirv_SpecConstant");

FunctionDecl *FnDeclForMangling = FunctionDecl::Create(

Context, Context.getTranslationUnitDecl(), SourceLocation(),

SourceLocation(), FuncName, FnType, /*TSI=*/nullptr, SC_Extern);

// Attach the created parameter declarations to the function declaration.

SmallVector<ParmVarDecl *, 2> ParamDecls;

for (QualType ParamType : ClangParamTypes) {

ParmVarDecl *PD = ParmVarDecl::Create(

Context, FnDeclForMangling, SourceLocation(), SourceLocation(),

/*IdentifierInfo*/ nullptr, ParamType, /*TSI*/ nullptr, SC_None,

/*DefaultArg*/ nullptr);

ParamDecls.push_back(PD);

}

FnDeclForMangling->setParams(ParamDecls);

// Get the mangled name.

std::string Name;

llvm::raw_string_ostream MangledNameStream(Name);

MangleContext *Mangler = Context.createMangleContext();

Mangler->mangleName(FnDeclForMangling, MangledNameStream);

MangledNameStream.flush();

return Name;

}

case Builtin::BI__builtin_get_spirv_spec_constant_bool:

case Builtin::BI__builtin_get_spirv_spec_constant_short:

case Builtin::BI__builtin_get_spirv_spec_constant_ushort:

case Builtin::BI__builtin_get_spirv_spec_constant_int:

case Builtin::BI__builtin_get_spirv_spec_constant_uint:

case Builtin::BI__builtin_get_spirv_spec_constant_longlong:

case Builtin::BI__builtin_get_spirv_spec_constant_ulonglong:

case Builtin::BI__builtin_get_spirv_spec_constant_half:

case Builtin::BI__builtin_get_spirv_spec_constant_float:

case Builtin::BI__builtin_get_spirv_spec_constant_double: {

llvm::Function *SpecConstantFn = getSpecConstantFunction(E->getType());

llvm::Value *SpecId = EmitScalarExpr(E->getArg(0));

llvm::Value *DefaultVal = EmitScalarExpr(E->getArg(1));

llvm::Value *Args[] = {SpecId, DefaultVal};

return Builder.CreateCall(SpecConstantFn, Args);

}

llvm::Function *clang::CodeGen::CodeGenFunction::getSpecConstantFunction(

const clang::QualType &SpecConstantType) {

// Find or create the declaration for the function.

llvm::Module *M = &CGM.getModule();

std::string MangledName =

getSpecConstantFunctionName(SpecConstantType, getContext());

llvm::Function *SpecConstantFn = M->getFunction(MangledName);

if (!SpecConstantFn) {

llvm::Type *IntType = ConvertType(getContext().IntTy);

llvm::Type *RetTy = ConvertType(SpecConstantType);

llvm::Type *ArgTypes[] = {IntType, RetTy};

llvm::FunctionType *FnTy = llvm::FunctionType::get(RetTy, ArgTypes, false);

SpecConstantFn = llvm::Function::Create(

FnTy, llvm::GlobalValue::ExternalLinkage, MangledName, M);

}

return SpecConstantFn;

}

// Returns a builtin function that the SPIR-V backend will expand into a spec

// constant.

llvm::Function *

getSpecConstantFunction(const clang::QualType &SpecConstantType);

else if (const auto *CI = dyn_cast<HLSLVkConstantIdAttr>(Attr))

NewAttr = S.HLSL().mergeVkConstantIdAttr(D, *CI, CI->getId());

if (getLangOpts().HLSL)

if (!HLSL().handleInitialization(VDecl, Init))

return;

// HLSL variable with the `vk::constant_id` attribute must be initialized.

if (!Var->isInvalidDecl() && Var->hasAttr<HLSLVkConstantIdAttr>()) {

Diag(Var->getLocation(), diag::err_specialization_const);

Var->setInvalidDecl();

return;

}

case ParsedAttr::AT_HLSLVkConstantId:

S.HLSL().handleVkConstantIdAttr(D, AL);

break;