clang/lib/CodeGen/CGHLSLRuntime.cpp

   1 //===----- CGHLSLRuntime.cpp - Interface to HLSL Runtimes -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This provides an abstract class for HLSL code generation.  Concrete
  10 // subclasses of this implement code generation for specific HLSL
  11 // runtime libraries.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "CGHLSLRuntime.h"
  16 #include "CGDebugInfo.h"
  17 #include "CodeGenModule.h"
  18 #include "clang/AST/Decl.h"
  19 #include "clang/Basic/TargetOptions.h"
  20 #include "llvm/IR/IntrinsicsDirectX.h"
  21 #include "llvm/IR/Metadata.h"
  22 #include "llvm/IR/Module.h"
  23 #include "llvm/Support/FormatVariadic.h"
  24
  25 using namespace clang;
  26 using namespace CodeGen;
  27 using namespace clang::hlsl;
  28 using namespace llvm;
  29
  30 namespace {
  31
  32 void addDxilValVersion(StringRef ValVersionStr, llvm::Module &M) {
  33   // The validation of ValVersionStr is done at HLSLToolChain::TranslateArgs.
  34   // Assume ValVersionStr is legal here.
  35   VersionTuple Version;
  36   if (Version.tryParse(ValVersionStr) || Version.getBuild() ||
  37       Version.getSubminor() || !Version.getMinor()) {
  38     return;
  39   }
  40
  41   uint64_t Major = Version.getMajor();
  42   uint64_t Minor = *Version.getMinor();
  43
  44   auto &Ctx = M.getContext();
  45   IRBuilder<> B(M.getContext());
  46   MDNode *Val = MDNode::get(Ctx, {ConstantAsMetadata::get(B.getInt32(Major)),
  47                                   ConstantAsMetadata::get(B.getInt32(Minor))});
  48   StringRef DXILValKey = "dx.valver";
  49   auto *DXILValMD = M.getOrInsertNamedMetadata(DXILValKey);
  50   DXILValMD->addOperand(Val);
  51 }
  52 void addDisableOptimizations(llvm::Module &M) {
  53   StringRef Key = "dx.disable_optimizations";
  54   M.addModuleFlag(llvm::Module::ModFlagBehavior::Override, Key, 1);
  55 }
  56 // cbuffer will be translated into global variable in special address space.
  57 // If translate into C,
  58 // cbuffer A {
  59 //   float a;
  60 //   float b;
  61 // }
  62 // float foo() { return a + b; }
  63 //
  64 // will be translated into
  65 //
  66 // struct A {
  67 //   float a;
  68 //   float b;
  69 // } cbuffer_A __attribute__((address_space(4)));
  70 // float foo() { return cbuffer_A.a + cbuffer_A.b; }
  71 //
  72 // layoutBuffer will create the struct A type.
  73 // replaceBuffer will replace use of global variable a and b with cbuffer_A.a
  74 // and cbuffer_A.b.
  75 //
  76 void layoutBuffer(CGHLSLRuntime::Buffer &Buf, const DataLayout &DL) {
  77   if (Buf.Constants.empty())
  78     return;
  79
  80   std::vector<llvm::Type *> EltTys;
  81   for (auto &Const : Buf.Constants) {
  82     GlobalVariable *GV = Const.first;
  83     Const.second = EltTys.size();
  84     llvm::Type *Ty = GV->getValueType();
  85     EltTys.emplace_back(Ty);
  86   }
  87   Buf.LayoutStruct = llvm::StructType::get(EltTys[0]->getContext(), EltTys);
  88 }
  89
  90 GlobalVariable *replaceBuffer(CGHLSLRuntime::Buffer &Buf) {
  91   // Create global variable for CB.
  92   GlobalVariable *CBGV = new GlobalVariable(
  93       Buf.LayoutStruct, /*isConstant*/ true,
  94       GlobalValue::LinkageTypes::ExternalLinkage, nullptr,
  95       llvm::formatv("{0}{1}", Buf.Name, Buf.IsCBuffer ? ".cb." : ".tb."),
  96       GlobalValue::NotThreadLocal);
  97
  98   IRBuilder<> B(CBGV->getContext());
  99   Value *ZeroIdx = B.getInt32(0);
 100   // Replace Const use with CB use.
 101   for (auto &[GV, Offset] : Buf.Constants) {
 102     Value *GEP =
 103         B.CreateGEP(Buf.LayoutStruct, CBGV, {ZeroIdx, B.getInt32(Offset)});
 104
 105     assert(Buf.LayoutStruct->getElementType(Offset) == GV->getValueType() &&
 106            "constant type mismatch");
 107
 108     // Replace.
 109     GV->replaceAllUsesWith(GEP);
 110     // Erase GV.
 111     GV->removeDeadConstantUsers();
 112     GV->eraseFromParent();
 113   }
 114   return CBGV;
 115 }
 116
 117 } // namespace
 118
 119 void CGHLSLRuntime::addConstant(VarDecl *D, Buffer &CB) {
 120   if (D->getStorageClass() == SC_Static) {
 121     // For static inside cbuffer, take as global static.
 122     // Don't add to cbuffer.
 123     CGM.EmitGlobal(D);
 124     return;
 125   }
 126
 127   auto *GV = cast<GlobalVariable>(CGM.GetAddrOfGlobalVar(D));
 128   // Add debug info for constVal.
 129   if (CGDebugInfo *DI = CGM.getModuleDebugInfo())
 130     if (CGM.getCodeGenOpts().getDebugInfo() >=
 131         codegenoptions::DebugInfoKind::LimitedDebugInfo)
 132       DI->EmitGlobalVariable(cast<GlobalVariable>(GV), D);
 133
 134   // FIXME: support packoffset.
 135   // See https://github.com/llvm/llvm-project/issues/57914.
 136   uint32_t Offset = 0;
 137   bool HasUserOffset = false;
 138
 139   unsigned LowerBound = HasUserOffset ? Offset : UINT_MAX;
 140   CB.Constants.emplace_back(std::make_pair(GV, LowerBound));
 141 }
 142
 143 void CGHLSLRuntime::addBufferDecls(const DeclContext *DC, Buffer &CB) {
 144   for (Decl *it : DC->decls()) {
 145     if (auto *ConstDecl = dyn_cast<VarDecl>(it)) {
 146       addConstant(ConstDecl, CB);
 147     } else if (isa<CXXRecordDecl, EmptyDecl>(it)) {
 148       // Nothing to do for this declaration.
 149     } else if (isa<FunctionDecl>(it)) {
 150       // A function within an cbuffer is effectively a top-level function,
 151       // as it only refers to globally scoped declarations.
 152       CGM.EmitTopLevelDecl(it);
 153     }
 154   }
 155 }
 156
 157 void CGHLSLRuntime::addBuffer(const HLSLBufferDecl *D) {
 158   Buffers.emplace_back(Buffer(D));
 159   addBufferDecls(D, Buffers.back());
 160 }
 161
 162 void CGHLSLRuntime::finishCodeGen() {
 163   auto &TargetOpts = CGM.getTarget().getTargetOpts();
 164   llvm::Module &M = CGM.getModule();
 165   Triple T(M.getTargetTriple());
 166   if (T.getArch() == Triple::ArchType::dxil)
 167     addDxilValVersion(TargetOpts.DxilValidatorVersion, M);
 168
 169   generateGlobalCtorDtorCalls();
 170   if (CGM.getCodeGenOpts().OptimizationLevel == 0)
 171     addDisableOptimizations(M);
 172
 173   const DataLayout &DL = M.getDataLayout();
 174
 175   for (auto &Buf : Buffers) {
 176     layoutBuffer(Buf, DL);
 177     GlobalVariable *GV = replaceBuffer(Buf);
 178     M.insertGlobalVariable(GV);
 179     llvm::hlsl::ResourceClass RC = Buf.IsCBuffer
 180                                        ? llvm::hlsl::ResourceClass::CBuffer
 181                                        : llvm::hlsl::ResourceClass::SRV;
 182     llvm::hlsl::ResourceKind RK = Buf.IsCBuffer
 183                                       ? llvm::hlsl::ResourceKind::CBuffer
 184                                       : llvm::hlsl::ResourceKind::TBuffer;
 185     std::string TyName =
 186         Buf.Name.str() + (Buf.IsCBuffer ? ".cb." : ".tb.") + "ty";
 187     addBufferResourceAnnotation(GV, TyName, RC, RK, Buf.Binding);
 188   }
 189 }
 190
 191 CGHLSLRuntime::Buffer::Buffer(const HLSLBufferDecl *D)
 192     : Name(D->getName()), IsCBuffer(D->isCBuffer()),
 193       Binding(D->getAttr<HLSLResourceBindingAttr>()) {}
 194
 195 void CGHLSLRuntime::addBufferResourceAnnotation(llvm::GlobalVariable *GV,
 196                                                 llvm::StringRef TyName,
 197                                                 llvm::hlsl::ResourceClass RC,
 198                                                 llvm::hlsl::ResourceKind RK,
 199                                                 BufferResBinding &Binding) {
 200   llvm::Module &M = CGM.getModule();
 201
 202   NamedMDNode *ResourceMD = nullptr;
 203   switch (RC) {
 204   case llvm::hlsl::ResourceClass::UAV:
 205     ResourceMD = M.getOrInsertNamedMetadata("hlsl.uavs");
 206     break;
 207   case llvm::hlsl::ResourceClass::SRV:
 208     ResourceMD = M.getOrInsertNamedMetadata("hlsl.srvs");
 209     break;
 210   case llvm::hlsl::ResourceClass::CBuffer:
 211     ResourceMD = M.getOrInsertNamedMetadata("hlsl.cbufs");
 212     break;
 213   default:
 214     assert(false && "Unsupported buffer type!");
 215     return;
 216   }
 217
 218   assert(ResourceMD != nullptr &&
 219          "ResourceMD must have been set by the switch above.");
 220
 221   llvm::hlsl::FrontendResource Res(
 222       GV, TyName, RK, Binding.Reg.value_or(UINT_MAX), Binding.Space);
 223   ResourceMD->addOperand(Res.getMetadata());
 224 }
 225
 226 static llvm::hlsl::ResourceKind
 227 castResourceShapeToResourceKind(HLSLResourceAttr::ResourceKind RK) {
 228   switch (RK) {
 229   case HLSLResourceAttr::ResourceKind::Texture1D:
 230     return llvm::hlsl::ResourceKind::Texture1D;
 231   case HLSLResourceAttr::ResourceKind::Texture2D:
 232     return llvm::hlsl::ResourceKind::Texture2D;
 233   case HLSLResourceAttr::ResourceKind::Texture2DMS:
 234     return llvm::hlsl::ResourceKind::Texture2DMS;
 235   case HLSLResourceAttr::ResourceKind::Texture3D:
 236     return llvm::hlsl::ResourceKind::Texture3D;
 237   case HLSLResourceAttr::ResourceKind::TextureCube:
 238     return llvm::hlsl::ResourceKind::TextureCube;
 239   case HLSLResourceAttr::ResourceKind::Texture1DArray:
 240     return llvm::hlsl::ResourceKind::Texture1DArray;
 241   case HLSLResourceAttr::ResourceKind::Texture2DArray:
 242     return llvm::hlsl::ResourceKind::Texture2DArray;
 243   case HLSLResourceAttr::ResourceKind::Texture2DMSArray:
 244     return llvm::hlsl::ResourceKind::Texture2DMSArray;
 245   case HLSLResourceAttr::ResourceKind::TextureCubeArray:
 246     return llvm::hlsl::ResourceKind::TextureCubeArray;
 247   case HLSLResourceAttr::ResourceKind::TypedBuffer:
 248     return llvm::hlsl::ResourceKind::TypedBuffer;
 249   case HLSLResourceAttr::ResourceKind::RawBuffer:
 250     return llvm::hlsl::ResourceKind::RawBuffer;
 251   case HLSLResourceAttr::ResourceKind::StructuredBuffer:
 252     return llvm::hlsl::ResourceKind::StructuredBuffer;
 253   case HLSLResourceAttr::ResourceKind::CBufferKind:
 254     return llvm::hlsl::ResourceKind::CBuffer;
 255   case HLSLResourceAttr::ResourceKind::SamplerKind:
 256     return llvm::hlsl::ResourceKind::Sampler;
 257   case HLSLResourceAttr::ResourceKind::TBuffer:
 258     return llvm::hlsl::ResourceKind::TBuffer;
 259   case HLSLResourceAttr::ResourceKind::RTAccelerationStructure:
 260     return llvm::hlsl::ResourceKind::RTAccelerationStructure;
 261   case HLSLResourceAttr::ResourceKind::FeedbackTexture2D:
 262     return llvm::hlsl::ResourceKind::FeedbackTexture2D;
 263   case HLSLResourceAttr::ResourceKind::FeedbackTexture2DArray:
 264     return llvm::hlsl::ResourceKind::FeedbackTexture2DArray;
 265   }
 266   // Make sure to update HLSLResourceAttr::ResourceKind when add new Kind to
 267   // hlsl::ResourceKind. Assume FeedbackTexture2DArray is the last enum for
 268   // HLSLResourceAttr::ResourceKind.
 269   static_assert(
 270       static_cast<uint32_t>(
 271           HLSLResourceAttr::ResourceKind::FeedbackTexture2DArray) ==
 272       (static_cast<uint32_t>(llvm::hlsl::ResourceKind::NumEntries) - 2));
 273   llvm_unreachable("all switch cases should be covered");
 274 }
 275
 276 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
 277   const Type *Ty = D->getType()->getPointeeOrArrayElementType();
 278   if (!Ty)
 279     return;
 280   const auto *RD = Ty->getAsCXXRecordDecl();
 281   if (!RD)
 282     return;
 283   const auto *Attr = RD->getAttr<HLSLResourceAttr>();
 284   if (!Attr)
 285     return;
 286
 287   HLSLResourceAttr::ResourceClass RC = Attr->getResourceType();
 288   llvm::hlsl::ResourceKind RK =
 289       castResourceShapeToResourceKind(Attr->getResourceShape());
 290
 291   QualType QT(Ty, 0);
 292   BufferResBinding Binding(D->getAttr<HLSLResourceBindingAttr>());
 293   addBufferResourceAnnotation(GV, QT.getAsString(),
 294                               static_cast<llvm::hlsl::ResourceClass>(RC), RK,
 295                               Binding);
 296 }
 297
 298 CGHLSLRuntime::BufferResBinding::BufferResBinding(
 299     HLSLResourceBindingAttr *Binding) {
 300   if (Binding) {
 301     llvm::APInt RegInt(64, 0);
 302     Binding->getSlot().substr(1).getAsInteger(10, RegInt);
 303     Reg = RegInt.getLimitedValue();
 304     llvm::APInt SpaceInt(64, 0);
 305     Binding->getSpace().substr(5).getAsInteger(10, SpaceInt);
 306     Space = SpaceInt.getLimitedValue();
 307   } else {
 308     Space = 0;
 309   }
 310 }
 311
 312 void clang::CodeGen::CGHLSLRuntime::setHLSLEntryAttributes(
 313     const FunctionDecl *FD, llvm::Function *Fn) {
 314   const auto *ShaderAttr = FD->getAttr<HLSLShaderAttr>();
 315   assert(ShaderAttr && "All entry functions must have a HLSLShaderAttr");
 316   const StringRef ShaderAttrKindStr = "hlsl.shader";
 317   Fn->addFnAttr(ShaderAttrKindStr,
 318                 ShaderAttr->ConvertShaderTypeToStr(ShaderAttr->getType()));
 319   if (HLSLNumThreadsAttr *NumThreadsAttr = FD->getAttr<HLSLNumThreadsAttr>()) {
 320     const StringRef NumThreadsKindStr = "hlsl.numthreads";
 321     std::string NumThreadsStr =
 322         formatv("{0},{1},{2}", NumThreadsAttr->getX(), NumThreadsAttr->getY(),
 323                 NumThreadsAttr->getZ());
 324     Fn->addFnAttr(NumThreadsKindStr, NumThreadsStr);
 325   }
 326 }
 327
 328 static Value *buildVectorInput(IRBuilder<> &B, Function *F, llvm::Type *Ty) {
 329   if (const auto *VT = dyn_cast<FixedVectorType>(Ty)) {
 330     Value *Result = PoisonValue::get(Ty);
 331     for (unsigned I = 0; I < VT->getNumElements(); ++I) {
 332       Value *Elt = B.CreateCall(F, {B.getInt32(I)});
 333       Result = B.CreateInsertElement(Result, Elt, I);
 334     }
 335     return Result;
 336   }
 337   return B.CreateCall(F, {B.getInt32(0)});
 338 }
 339
 340 llvm::Value *CGHLSLRuntime::emitInputSemantic(IRBuilder<> &B,
 341                                               const ParmVarDecl &D,
 342                                               llvm::Type *Ty) {
 343   assert(D.hasAttrs() && "Entry parameter missing annotation attribute!");
 344   if (D.hasAttr<HLSLSV_GroupIndexAttr>()) {
 345     llvm::Function *DxGroupIndex =
 346         CGM.getIntrinsic(Intrinsic::dx_flattened_thread_id_in_group);
 347     return B.CreateCall(FunctionCallee(DxGroupIndex));
 348   }
 349   if (D.hasAttr<HLSLSV_DispatchThreadIDAttr>()) {
 350     llvm::Function *DxThreadID = CGM.getIntrinsic(Intrinsic::dx_thread_id);
 351     return buildVectorInput(B, DxThreadID, Ty);
 352   }
 353   assert(false && "Unhandled parameter attribute");
 354   return nullptr;
 355 }
 356
 357 void CGHLSLRuntime::emitEntryFunction(const FunctionDecl *FD,
 358                                       llvm::Function *Fn) {
 359   llvm::Module &M = CGM.getModule();
 360   llvm::LLVMContext &Ctx = M.getContext();
 361   auto *EntryTy = llvm::FunctionType::get(llvm::Type::getVoidTy(Ctx), false);
 362   Function *EntryFn =
 363       Function::Create(EntryTy, Function::ExternalLinkage, FD->getName(), &M);
 364
 365   // Copy function attributes over, we have no argument or return attributes
 366   // that can be valid on the real entry.
 367   AttributeList NewAttrs = AttributeList::get(Ctx, AttributeList::FunctionIndex,
 368                                               Fn->getAttributes().getFnAttrs());
 369   EntryFn->setAttributes(NewAttrs);
 370   setHLSLEntryAttributes(FD, EntryFn);
 371
 372   // Set the called function as internal linkage.
 373   Fn->setLinkage(GlobalValue::InternalLinkage);
 374
 375   BasicBlock *BB = BasicBlock::Create(Ctx, "entry", EntryFn);
 376   IRBuilder<> B(BB);
 377   llvm::SmallVector<Value *> Args;
 378   // FIXME: support struct parameters where semantics are on members.
 379   // See: https://github.com/llvm/llvm-project/issues/57874
 380   unsigned SRetOffset = 0;
 381   for (const auto &Param : Fn->args()) {
 382     if (Param.hasStructRetAttr()) {
 383       // FIXME: support output.
 384       // See: https://github.com/llvm/llvm-project/issues/57874
 385       SRetOffset = 1;
 386       Args.emplace_back(PoisonValue::get(Param.getType()));
 387       continue;
 388     }
 389     const ParmVarDecl *PD = FD->getParamDecl(Param.getArgNo() - SRetOffset);
 390     Args.push_back(emitInputSemantic(B, *PD, Param.getType()));
 391   }
 392
 393   CallInst *CI = B.CreateCall(FunctionCallee(Fn), Args);
 394   (void)CI;
 395   // FIXME: Handle codegen for return type semantics.
 396   // See: https://github.com/llvm/llvm-project/issues/57875
 397   B.CreateRetVoid();
 398 }
 399
 400 static void gatherFunctions(SmallVectorImpl<Function *> &Fns, llvm::Module &M,
 401                             bool CtorOrDtor) {
 402   const auto *GV =
 403       M.getNamedGlobal(CtorOrDtor ? "llvm.global_ctors" : "llvm.global_dtors");
 404   if (!GV)
 405     return;
 406   const auto *CA = dyn_cast<ConstantArray>(GV->getInitializer());
 407   if (!CA)
 408     return;
 409   // The global_ctor array elements are a struct [Priority, Fn *, COMDat].
 410   // HLSL neither supports priorities or COMDat values, so we will check those
 411   // in an assert but not handle them.
 412
 413   llvm::SmallVector<Function *> CtorFns;
 414   for (const auto &Ctor : CA->operands()) {
 415     if (isa<ConstantAggregateZero>(Ctor))
 416       continue;
 417     ConstantStruct *CS = cast<ConstantStruct>(Ctor);
 418
 419     assert(cast<ConstantInt>(CS->getOperand(0))->getValue() == 65535 &&
 420            "HLSL doesn't support setting priority for global ctors.");
 421     assert(isa<ConstantPointerNull>(CS->getOperand(2)) &&
 422            "HLSL doesn't support COMDat for global ctors.");
 423     Fns.push_back(cast<Function>(CS->getOperand(1)));
 424   }
 425 }
 426
 427 void CGHLSLRuntime::generateGlobalCtorDtorCalls() {
 428   llvm::Module &M = CGM.getModule();
 429   SmallVector<Function *> CtorFns;
 430   SmallVector<Function *> DtorFns;
 431   gatherFunctions(CtorFns, M, true);
 432   gatherFunctions(DtorFns, M, false);
 433
 434   // Insert a call to the global constructor at the beginning of the entry block
 435   // to externally exported functions. This is a bit of a hack, but HLSL allows
 436   // global constructors, but doesn't support driver initialization of globals.
 437   for (auto &F : M.functions()) {
 438     if (!F.hasFnAttribute("hlsl.shader"))
 439       continue;
 440     IRBuilder<> B(&F.getEntryBlock(), F.getEntryBlock().begin());
 441     for (auto *Fn : CtorFns)
 442       B.CreateCall(FunctionCallee(Fn));
 443
 444     // Insert global dtors before the terminator of the last instruction
 445     B.SetInsertPoint(F.back().getTerminator());
 446     for (auto *Fn : DtorFns)
 447       B.CreateCall(FunctionCallee(Fn));
 448   }
 449
 450   // No need to keep global ctors/dtors for non-lib profile after call to
 451   // ctors/dtors added for entry.
 452   Triple T(M.getTargetTriple());
 453   if (T.getEnvironment() != Triple::EnvironmentType::Library) {
 454     if (auto *GV = M.getNamedGlobal("llvm.global_ctors"))
 455       GV->eraseFromParent();
 456     if (auto *GV = M.getNamedGlobal("llvm.global_dtors"))
 457       GV->eraseFromParent();
 458   }
 459 }