[HLSL] CodeGen hlsl resource binding.

[python3kgae]

Summary

''register(ID, space)'' like register(t3, space1) will be translated into
i32 3, i32 1 as the last 2 operands for resource annotation metadata.

NamedMetadata for CBuffers and SRVs are added as "hlsl.srvs" and "hlsl.cbufs".

[Anastasia]

clang/lib/CodeGen/CGHLSLRuntime.h

52

Does this apply to buffers only? In which case it might be better to either nest this into Buffer definition or rename into something like BufferResBinding. Also adding some documenting comments would help here, even if they could just refer to the language documentation.

73

This is not part of this change but any reason why it is a protected member and not private?

94

Similarly - is this buffer specific? Then you could either rename to addBufferResourceAnnotation or make this a member of a Buffer instead...

[python3kgae]

Rename ResBinding and addResourceAnnotation to BufferResBinding and addBufferResourceAnnotation.

[beanz]

clang/lib/CodeGen/CGHLSLRuntime.h

73

I wrote that code, and had a vague idea of a use case in my head where we might provide subclasses of the HLSLRuntime, but in retrospect that is unlikely anytime soon, so we could safely make that private.

[python3kgae]

Rebase.

[python3kgae]

Add resource shape to metadata.
Conflict with https://reviews.llvm.org/D135110, will rebase once https://reviews.llvm.org/D135110 is in.

[python3kgae]

Fix clang-format missed by arc lint

[beanz]

clang/include/clang/Basic/HLSLRuntime.h

31 ↗

(On Diff #467812)

If this is only used in the clangCodeGen library, we can move it into libLLVMFrontendHLSL to share instead of keeping them in sync.

clang/lib/CodeGen/CGHLSLRuntime.cpp

223

Shouldn't this be using FrontendResource?

289

since we're relying on these two enums basically being identical, can you add static_asserts up near the top of this file to ensure that they are the same? It would be unfortunate if in the future one got updated and the other didn't.

[python3kgae]

Rebase to use FrontendResource.

[python3kgae]

Rebase for D136031

[beanz]

clang/lib/CodeGen/CGHLSLRuntime.h

73

The ResourceCounters here was a stand-in for allocating resource indices.

If you have a different path for allocating these, we shouldn't need the counter anymore. I'm a little concerned that it looks like you're not allocating these in code generation. Can you explain how you intend to allocate indices? Is there a reason not to do this in code gen?

[beanz]

clang/lib/CodeGen/CGHLSLRuntime.h

73

Wait... I guess I actually fed the ResourceCounter to the ID, which is fine.

I don't like that we're not allocating the indices in codegen, but we can address that in a subsequent patch.

[python3kgae]

clang/lib/CodeGen/CGHLSLRuntime.h

73

The reason not to do it in codeGen is that we have to remove unused global resources even in Od and update the ID in the backend.

The plan is to allocate the ID after unused global resources are deleted.

clang/lib/CodeGen/CGHLSLRuntime.h

 
 #include "llvm/IR/IRBuilder.h"
 
 #include "clang/Basic/HLSLRuntime.h"
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Frontend/HLSL/HLSLResource.h"
 
 #include <vector>
 
 namespace llvm {
 class GlobalVariable;
 class Function;
 class StructType;
 } // namespace llvm
 
 namespace clang {
 class VarDecl;
 class ParmVarDecl;
 class HLSLBufferDecl;
+class HLSLResourceBindingAttr;
 class CallExpr;
 class Type;
 class DeclContext;
 
 class FunctionDecl;
 
 namespace CodeGen {
 
 class CodeGenModule;
 
 class CGHLSLRuntime {
 public:
+  struct BufferResBinding {
+    // The ID like 2 in register(b2, space1).
+    llvm::Optional<unsigned> Reg;
+    // The Space like 1 is register(b2, space1).
+    // Default value is 0.
+    unsigned Space;
+    BufferResBinding(HLSLResourceBindingAttr *Attr);
+  };
   struct Buffer {
     Buffer(const HLSLBufferDecl *D);
     llvm::StringRef Name;
     // IsCBuffer - Whether the buffer is a cbuffer (and not a tbuffer).
     bool IsCBuffer;
-    llvm::Optional<unsigned> Reg;
-    unsigned Space;
+    BufferResBinding Binding;
     // Global variable and offset for each constant.
     std::vector<std::pair<llvm::GlobalVariable *, unsigned>> Constants;
     llvm::StructType *LayoutStruct = nullptr;
   };
 
 protected:
   CodeGenModule &CGM;
   uint32_t ResourceCounters[static_cast<uint32_t>(
       hlsl::ResourceClass::NumClasses)] = {0};
 
   llvm::Value *emitInputSemantic(llvm::IRBuilder<> &B, const ParmVarDecl &D);
 
 public:
   CGHLSLRuntime(CodeGenModule &CGM) : CGM(CGM) {}
   virtual ~CGHLSLRuntime() {}
 
   void annotateHLSLResource(const VarDecl *D, llvm::GlobalVariable *GV);
   void generateGlobalCtorDtorCalls();
 
   void addBuffer(const HLSLBufferDecl *D);
   void finishCodeGen();
 
   void setHLSLEntryAttributes(const FunctionDecl *FD, llvm::Function *Fn);
 
   void emitEntryFunction(const FunctionDecl *FD, llvm::Function *Fn);
   void setHLSLFunctionAttributes(llvm::Function *, const FunctionDecl *);
 
 private:
+  void addBufferResourceAnnotation(llvm::GlobalVariable *GV,
+                                   llvm::StringRef TyName,
+                                   hlsl::ResourceClass RC,
+                                   llvm::hlsl::ResourceKind RK,
+                                   BufferResBinding &Binding);
   void addConstant(VarDecl *D, Buffer &CB);
   void addBufferDecls(const DeclContext *DC, Buffer &CB);
   llvm::SmallVector<Buffer> Buffers;
 };
 
 } // namespace CodeGen
 } // namespace clang
 
 #endif

clang/lib/CodeGen/CGHLSLRuntime.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "CGHLSLRuntime.h"
 #include "CGDebugInfo.h"
 #include "CodeGenModule.h"
 #include "clang/AST/Decl.h"
 #include "clang/Basic/TargetOptions.h"
-#include "llvm/Frontend/HLSL/HLSLResource.h"
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace clang;
 using namespace CodeGen;
 using namespace hlsl;
for (auto &Const : Buf.Constants) {
     llvm::Type *Ty = GV->getValueType();
     EltTys.emplace_back(Ty);
   }
   Buf.LayoutStruct = llvm::StructType::get(EltTys[0]->getContext(), EltTys);
 }
 
 GlobalVariable *replaceBuffer(CGHLSLRuntime::Buffer &Buf) {
   // Create global variable for CB.
-  GlobalVariable *CBGV =
-      new GlobalVariable(Buf.LayoutStruct, /*isConstant*/ true,
-                         GlobalValue::LinkageTypes::ExternalLinkage, nullptr,
-                         Buf.Name + (Buf.IsCBuffer ? ".cb." : ".tb."),
-                         GlobalValue::NotThreadLocal);
+  GlobalVariable *CBGV = new GlobalVariable(
+      Buf.LayoutStruct, /*isConstant*/ true,
+      llvm::formatv("{0}{1}", Buf.Name, Buf.IsCBuffer ? ".cb." : ".tb."),
 
   IRBuilder<> B(CBGV->getContext());
   Value *ZeroIdx = B.getInt32(0);
   // Replace Const use with CB use.
-  for (auto &[GV, Offset]: Buf.Constants) {
+  for (auto &[GV, Offset] : Buf.Constants) {
     Value *GEP =
         B.CreateGEP(Buf.LayoutStruct, CBGV, {ZeroIdx, B.getInt32(Offset)});
 
     assert(Buf.LayoutStruct->getElementType(Offset) == GV->getValueType() &&
            "constant type mismatch");
 
     // Replace.
     GV->replaceAllUsesWith(GEP);
if (CGM.getCodeGenOpts().OptimizationLevel == 0)
     addDisableOptimizations(M);
 
   const DataLayout &DL = M.getDataLayout();
 
   for (auto &Buf : Buffers) {
     layoutBuffer(Buf, DL);
     GlobalVariable *GV = replaceBuffer(Buf);
     M.getGlobalList().push_back(GV);
-    // FIXME: generate resource binding.
-    // See https://github.com/llvm/llvm-project/issues/57915.
+    hlsl::ResourceClass RC =
+        Buf.IsCBuffer ? hlsl::ResourceClass::CBuffer : hlsl::ResourceClass::SRV;
+    llvm::hlsl::ResourceKind RK = Buf.IsCBuffer
+                                      ? llvm::hlsl::ResourceKind::CBuffer
+                                      : llvm::hlsl::ResourceKind::TBuffer;
+    std::string TyName =
+        Buf.Name.str() + (Buf.IsCBuffer ? ".cb." : ".tb.") + "ty";
+    addBufferResourceAnnotation(GV, TyName, RC, RK, Buf.Binding);
   }
 }
 
-CGHLSLRuntime::Buffer::Buffer(const HLSLBufferDecl *D) {
-  Name = D->getName();
-  IsCBuffer = D->isCBuffer();
-  if (auto *Binding = D->getAttr<HLSLResourceBindingAttr>()) {
-    llvm::APInt RegInt(64, 0);
-    Binding->getSlot().substr(1).getAsInteger(10, RegInt);
-    Reg = RegInt.getLimitedValue();
+CGHLSLRuntime::Buffer::Buffer(const HLSLBufferDecl *D)
+    : Name(D->getName()), IsCBuffer(D->isCBuffer()),
+      Binding(D->getAttr<HLSLResourceBindingAttr>()) {}
+
+void CGHLSLRuntime::addBufferResourceAnnotation(llvm::GlobalVariable *GV,
+                                                llvm::StringRef TyName,
+                                                hlsl::ResourceClass RC,
+                                                llvm::hlsl::ResourceKind RK,
+                                                BufferResBinding &Binding) {
+  uint32_t Counter = ResourceCounters[static_cast<uint32_t>(RC)]++;
+  llvm::Module &M = CGM.getModule();
 
-    llvm::APInt SpaceInt(64, 0);
-    Binding->getSpace().substr(5).getAsInteger(10, RegInt);
-    Space = SpaceInt.getLimitedValue();
-  } else {
-    Space = 0;
+  NamedMDNode *ResourceMD = nullptr;
+  switch (RC) {
+  case hlsl::ResourceClass::UAV:
+    ResourceMD = M.getOrInsertNamedMetadata("hlsl.uavs");
+    break;
+  case hlsl::ResourceClass::SRV:
+    ResourceMD = M.getOrInsertNamedMetadata("hlsl.srvs");
+    break;
+  case hlsl::ResourceClass::CBuffer:
+    ResourceMD = M.getOrInsertNamedMetadata("hlsl.cbufs");
+    break;
+  default:
+    assert(false && "Unsupported buffer type!");
+    return;
   }
+
+  assert(ResourceMD != nullptr &&
+         "ResourceMD must have been set by the switch above.");
+
+  llvm::hlsl::FrontendResource Res(
+      GV, TyName, Counter, RK, Binding.Reg.value_or(UINT_MAX), Binding.Space);
+  ResourceMD->addOperand(Res.getMetadata());
+}
+
+static llvm::hlsl::ResourceKind
+castResourceShapeToResourceKind(HLSLResourceAttr::ResourceKind RK) {
+  switch (RK) {
+  case HLSLResourceAttr::ResourceKind::Texture1D:
+    return llvm::hlsl::ResourceKind::Texture1D;
+  case HLSLResourceAttr::ResourceKind::Texture2D:
+    return llvm::hlsl::ResourceKind::Texture2D;
+  case HLSLResourceAttr::ResourceKind::Texture2DMS:
+    return llvm::hlsl::ResourceKind::Texture2DMS;
+  case HLSLResourceAttr::ResourceKind::Texture3D:
+    return llvm::hlsl::ResourceKind::Texture3D;
+  case HLSLResourceAttr::ResourceKind::TextureCube:
+    return llvm::hlsl::ResourceKind::TextureCube;
+  case HLSLResourceAttr::ResourceKind::Texture1DArray:
+    return llvm::hlsl::ResourceKind::Texture1DArray;
+  case HLSLResourceAttr::ResourceKind::Texture2DArray:
+    return llvm::hlsl::ResourceKind::Texture2DArray;
+  case HLSLResourceAttr::ResourceKind::Texture2DMSArray:
+    return llvm::hlsl::ResourceKind::Texture2DMSArray;
+  case HLSLResourceAttr::ResourceKind::TextureCubeArray:
+    return llvm::hlsl::ResourceKind::TextureCubeArray;
+  case HLSLResourceAttr::ResourceKind::TypedBuffer:
+    return llvm::hlsl::ResourceKind::TypedBuffer;
+  case HLSLResourceAttr::ResourceKind::RawBuffer:
+    return llvm::hlsl::ResourceKind::RawBuffer;
+  case HLSLResourceAttr::ResourceKind::StructuredBuffer:
+    return llvm::hlsl::ResourceKind::StructuredBuffer;
+  case HLSLResourceAttr::ResourceKind::CBufferKind:
+    return llvm::hlsl::ResourceKind::CBuffer;
+  case HLSLResourceAttr::ResourceKind::SamplerKind:
+    return llvm::hlsl::ResourceKind::Sampler;
+  case HLSLResourceAttr::ResourceKind::TBuffer:
+    return llvm::hlsl::ResourceKind::TBuffer;
+  case HLSLResourceAttr::ResourceKind::RTAccelerationStructure:
+    return llvm::hlsl::ResourceKind::RTAccelerationStructure;
+  case HLSLResourceAttr::ResourceKind::FeedbackTexture2D:
+    return llvm::hlsl::ResourceKind::FeedbackTexture2D;
+  case HLSLResourceAttr::ResourceKind::FeedbackTexture2DArray:
+    return llvm::hlsl::ResourceKind::FeedbackTexture2DArray;
+  }
+  // Make sure to update HLSLResourceAttr::ResourceKind when add new Kind to
+  // hlsl::ResourceKind. Assume FeedbackTexture2DArray is the last enum for
+  // HLSLResourceAttr::ResourceKind.
+  static_assert(
+      static_cast<uint32_t>(
+          HLSLResourceAttr::ResourceKind::FeedbackTexture2DArray) ==
+      (static_cast<uint32_t>(llvm::hlsl::ResourceKind::NumEntries) - 2));
 }
 
 void CGHLSLRuntime::annotateHLSLResource(const VarDecl *D, GlobalVariable *GV) {
   const Type *Ty = D->getType()->getPointeeOrArrayElementType();
   if (!Ty)
     return;
   const auto *RD = Ty->getAsCXXRecordDecl();
   if (!RD)
     return;
   const auto *Attr = RD->getAttr<HLSLResourceAttr>();
   if (!Attr)
     return;
 
   HLSLResourceAttr::ResourceClass RC = Attr->getResourceType();
-  uint32_t Counter = ResourceCounters[static_cast<uint32_t>(RC)]++;
+  llvm::hlsl::ResourceKind RK =
+      castResourceShapeToResourceKind(Attr->getResourceShape());
 
-  NamedMDNode *ResourceMD = nullptr;
-  switch (RC) {
-  case HLSLResourceAttr::ResourceClass::UAV:
-    ResourceMD = CGM.getModule().getOrInsertNamedMetadata("hlsl.uavs");
-    break;
-  default:
-    assert(false && "Unsupported buffer type!");
-    return;
-  }
+  QualType QT(Ty, 0);
+  BufferResBinding Binding(D->getAttr<HLSLResourceBindingAttr>());
+  addBufferResourceAnnotation(
+      GV, QT.getAsString(), static_cast<hlsl::ResourceClass>(RC), RK, Binding);
 
-  assert(ResourceMD != nullptr &&
-         "ResourceMD must have been set by the switch above.");
-
-  auto &Ctx = CGM.getModule().getContext();
-  IRBuilder<> B(Ctx);
-  QualType QT(Ty, 0);
-  llvm::hlsl::FrontendResource Res(GV, QT.getAsString(), Counter);
-  ResourceMD->addOperand(Res.getMetadata());
+CGHLSLRuntime::BufferResBinding::BufferResBinding(
+    HLSLResourceBindingAttr *Binding) {
+  if (Binding) {
+    llvm::APInt RegInt(64, 0);
+    Binding->getSlot().substr(1).getAsInteger(10, RegInt);
+    Reg = RegInt.getLimitedValue();
+    llvm::APInt SpaceInt(64, 0);
+    Binding->getSpace().substr(5).getAsInteger(10, SpaceInt);
+    Space = SpaceInt.getLimitedValue();
+  } else {
+    Space = 0;
+  }
 }
 
 void clang::CodeGen::CGHLSLRuntime::setHLSLEntryAttributes(
     const FunctionDecl *FD, llvm::Function *Fn) {
   const auto *ShaderAttr = FD->getAttr<HLSLShaderAttr>();
   assert(ShaderAttr && "All entry functions must have a HLSLShaderAttr");
   const StringRef ShaderAttrKindStr = "hlsl.shader";
   Fn->addFnAttr(ShaderAttrKindStr,

clang/test/CodeGenHLSL/builtins/RWBuffer-annotations.hlsl

 // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -x hlsl -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s 
 
 RWBuffer<float> Buffer1;
 RWBuffer<vector<float, 4> > BufferArray[4];
 
+RWBuffer<float> Buffer2 : register(u3);
+RWBuffer<vector<float, 4> > BufferArray2[4] : register(u4);
+
+RWBuffer<float> Buffer3 : register(u3, space1);
+RWBuffer<vector<float, 4> > BufferArray3[4] : register(u4, space1);
+
+
+
 [numthreads(1,1,1)]
 void main() {
 }
 
-// CHECK: !hlsl.uavs = !{![[Single:[0-9]+]], ![[Array:[0-9]+]]}
-// CHECK-DAG: ![[Single]] = !{ptr @"?Buffer1@@3V?$RWBuffer@M@hlsl@@A", !"RWBuffer<float>", i32 0}
-// CHECK-DAG: ![[Array]] = !{ptr @"?BufferArray@@3PAV?$RWBuffer@T?$__vector@M$03@__clang@@@hlsl@@A", !"RWBuffer<vector<float, 4> >", i32 1}
+// CHECK: !hlsl.uavs = !{![[Single:[0-9]+]], ![[Array:[0-9]+]], ![[SingleAllocated:[0-9]+]], ![[ArrayAllocated:[0-9]+]], ![[SingleSpace:[0-9]+]], ![[ArraySpace:[0-9]+]]}
+// CHECK-DAG: ![[Single]] = !{ptr @"?Buffer1@@3V?$RWBuffer@M@hlsl@@A", !"RWBuffer<float>", i32 0, i32 10, i32 -1, i32 0}
+// CHECK-DAG: ![[Array]] = !{ptr @"?BufferArray@@3PAV?$RWBuffer@T?$__vector@M$03@__clang@@@hlsl@@A", !"RWBuffer<vector<float, 4> >", i32 1, i32 10, i32 -1, i32 0}
+// CHECK-DAG: ![[SingleAllocated]] = !{ptr @"?Buffer2@@3V?$RWBuffer@M@hlsl@@A", !"RWBuffer<float>", i32 2, i32 10, i32 3, i32 0}
+// CHECK-DAG: ![[ArrayAllocated]] = !{ptr @"?BufferArray2@@3PAV?$RWBuffer@T?$__vector@M$03@__clang@@@hlsl@@A", !"RWBuffer<vector<float, 4> >", i32 3, i32 10, i32 4, i32 0}
+// CHECK-DAG: ![[SingleSpace]] = !{ptr @"?Buffer3@@3V?$RWBuffer@M@hlsl@@A", !"RWBuffer<float>", i32 4, i32 10, i32 3, i32 1}
+// CHECK-DAG: ![[ArraySpace]] = !{ptr @"?BufferArray3@@3PAV?$RWBuffer@T?$__vector@M$03@__clang@@@hlsl@@A", !"RWBuffer<vector<float, 4> >", i32 5, i32 10, i32 4, i32 1}

clang/test/CodeGenHLSL/cbuf.hlsl

 // RUN: %clang_cc1 -finclude-default-header -x hlsl -triple \
 // RUN:   dxil-pc-shadermodel6.3-library %s \
 // RUN:   -emit-llvm -disable-llvm-passes -o - | FileCheck %s
 
 // CHECK: @[[CB:.+]] = external constant { float, double }
-cbuffer A : register(b0, space1) {
+cbuffer A : register(b0, space2) {
   float a;
   double b;
 }
 
 // CHECK: @[[TB:.+]] = external constant { float, double }
 tbuffer A : register(t2, space1) {
   float c;
   double d;
 }
 
 float foo() {
 // CHECK: load float, ptr @[[CB]], align 4
 // CHECK: load double, ptr getelementptr inbounds ({ float, double }, ptr @[[CB]], i32 0, i32 1), align 8
 // CHECK: load float, ptr @[[TB]], align 4
 // CHECK: load double, ptr getelementptr inbounds ({ float, double }, ptr @[[TB]], i32 0, i32 1), align 8
   return a + b + c*d;
 }
+
+// CHECK: !hlsl.cbufs = !{![[CBMD:[0-9]+]]}
+// CHECK: !hlsl.srvs = !{![[TBMD:[0-9]+]]}
+// CHECK: ![[CBMD]] = !{ptr @[[CB]], !"A.cb.ty", i32 0, i32 13, i32 0, i32 2}
+// CHECK: ![[TBMD]] = !{ptr @[[TB]], !"A.tb.ty", i32 0, i32 15, i32 2, i32 1}

llvm/include/llvm/Frontend/HLSL/HLSLResource.h

 #include "llvm/IR/Metadata.h"
 
 namespace llvm {
 class Module;
 class GlobalVariable;
 
 namespace hlsl {
 
+// The value ordering of this enumeration is part of the DXIL ABI. Elements
+// can only be added to the end, and not removed.
+enum class ResourceKind : uint32_t {
+  Invalid = 0,
+  Texture1D,
+  Texture2D,
+  Texture2DMS,
+  Texture3D,
+  TextureCube,
+  Texture1DArray,
+  Texture2DArray,
+  Texture2DMSArray,
+  TextureCubeArray,
+  TypedBuffer,
+  RawBuffer,
+  StructuredBuffer,
+  CBuffer,
+  Sampler,
+  TBuffer,
+  RTAccelerationStructure,
+  FeedbackTexture2D,
+  FeedbackTexture2DArray,
+  NumEntries,
+};
+
 class FrontendResource {
   MDNode *Entry;
 
 public:
   FrontendResource(MDNode *E) : Entry(E) {
-    assert(Entry->getNumOperands() == 3 && "Unexpected metadata shape");
+    assert(Entry->getNumOperands() == 6 && "Unexpected metadata shape");
   }
 
-  FrontendResource(GlobalVariable *GV, StringRef TypeStr, uint32_t Counter);
+  FrontendResource(GlobalVariable *GV, StringRef TypeStr, uint32_t Counter,
+                   ResourceKind RK, uint32_t ResIndex, uint32_t Space);
 
   GlobalVariable *getGlobalVariable();
   StringRef getSourceType();
   Constant *getID();
-
+  uint32_t getResourceKind();
+  uint32_t getResourceIndex();
+  uint32_t getSpace();
   MDNode *getMetadata() { return Entry; }
 };
 } // namespace hlsl
 } // namespace llvm
 
 #endif // LLVM_FRONTEND_HLSL_HLSLRESOURCE_H

llvm/lib/Frontend/HLSL/HLSLResource.cpp

 StringRef FrontendResource::getSourceType() {
   return cast<MDString>(Entry->getOperand(1))->getString();
 }
 
 Constant *FrontendResource::getID() {
   return cast<ConstantAsMetadata>(Entry->getOperand(2))->getValue();
 }
 
+uint32_t FrontendResource::FrontendResource::getResourceKind() {
+  return cast<ConstantInt>(
+             cast<ConstantAsMetadata>(Entry->getOperand(3))->getValue())
+      ->getLimitedValue();
+}
+uint32_t FrontendResource::getResourceIndex() {
+  return cast<ConstantInt>(
+             cast<ConstantAsMetadata>(Entry->getOperand(4))->getValue())
+      ->getLimitedValue();
+}
+uint32_t FrontendResource::getSpace() {
+  return cast<ConstantInt>(
+             cast<ConstantAsMetadata>(Entry->getOperand(5))->getValue())
+      ->getLimitedValue();
+}
+
 FrontendResource::FrontendResource(GlobalVariable *GV, StringRef TypeStr,
-                                   uint32_t Counter) {
+                                   uint32_t Counter, ResourceKind RK,
+                                   uint32_t ResIndex, uint32_t Space) {
   auto &Ctx = GV->getContext();
   IRBuilder<> B(Ctx);
-  Entry =
-      MDNode::get(Ctx, {ValueAsMetadata::get(GV), MDString::get(Ctx, TypeStr),
-                        ConstantAsMetadata::get(B.getInt32(Counter))});
+  Entry = MDNode::get(
+      Ctx, {ValueAsMetadata::get(GV), MDString::get(Ctx, TypeStr),
+            ConstantAsMetadata::get(B.getInt32(Counter)),
+            ConstantAsMetadata::get(B.getInt32(static_cast<int>(RK))),
+            ConstantAsMetadata::get(B.getInt32(ResIndex)),
+            ConstantAsMetadata::get(B.getInt32(Space))});
 }

llvm/lib/Target/DirectX/DXILResource.h

protected:
   uint32_t Space;
   uint32_t LowerBound;
   uint32_t RangeSize;
   ResourceBase(uint32_t I, hlsl::FrontendResource R);
 
   void write(LLVMContext &Ctx, MutableArrayRef<Metadata *> Entries) const;
 
   void print(raw_ostream &O, StringRef IDPrefix, StringRef BindingPrefix) const;
-
-  // The value ordering of this enumeration is part of the DXIL ABI. Elements
-  // can only be added to the end, and not removed.
-  enum class Kinds : uint32_t {
-    Invalid = 0,
-    Texture1D,
-    Texture2D,
-    Texture2DMS,
-    Texture3D,
-    TextureCube,
-    Texture1DArray,
-    Texture2DArray,
-    Texture2DMSArray,
-    TextureCubeArray,
-    TypedBuffer,
-    RawBuffer,
-    StructuredBuffer,
-    CBuffer,
-    Sampler,
-    TBuffer,
-    RTAccelerationStructure,
-    FeedbackTexture2D,
-    FeedbackTexture2DArray,
-    NumEntries,
-  };
-
+  using Kinds = hlsl::ResourceKind;
   static StringRef getKindName(Kinds Kind);
   static void printKind(Kinds Kind, unsigned Alignment, raw_ostream &OS,
                         bool SRV = false, bool HasCounter = false,
                         uint32_t SampleCount = 0);
 
   // The value ordering of this enumeration is part of the DXIL ABI. Elements
   // can only be added to the end, and not removed.
   enum class ComponentType : uint32_t {

llvm/lib/Target/DirectX/DXILResource.cpp

void Resources::collectUAVs(Module &M) {
   for (auto *UAV : Entry->operands()) {
     UAVs.push_back(UAVResource(Counter++, FrontendResource(cast<MDNode>(UAV))));
   }
 }
 
 void Resources::collect(Module &M) { collectUAVs(M); }
 
 ResourceBase::ResourceBase(uint32_t I, FrontendResource R)
-    : ID(I), GV(R.getGlobalVariable()), Name(""), Space(0), LowerBound(0),
-      RangeSize(1) {
+    : ID(I), GV(R.getGlobalVariable()), Name(""), Space(R.getSpace()),
+      LowerBound(R.getResourceIndex()), RangeSize(1) {
   if (auto *ArrTy = dyn_cast<ArrayType>(GV->getInitializer()->getType()))
     RangeSize = ArrTy->getNumElements();
 }
 
 StringRef ResourceBase::getComponentTypeName(ComponentType CompType) {
   switch (CompType) {
   case ComponentType::LastEntry:
   case ComponentType::Invalid:
void ResourceBase::print(raw_ostream &OS, StringRef IDPrefix,
   OS << right_justify(Bind, 15);
   if (RangeSize != UINT_MAX)
     OS << right_justify(std::to_string(RangeSize), 6) << "\n";
   else
     OS << right_justify("unbounded", 6) << "\n";
 }
 
 UAVResource::UAVResource(uint32_t I, FrontendResource R)
-    : ResourceBase(I, R), Shape(Kinds::Invalid), GloballyCoherent(false),
-      HasCounter(false), IsROV(false), ExtProps() {
+    : ResourceBase(I, R),
+      Shape(static_cast<ResourceBase::Kinds>(R.getResourceKind())),
+      GloballyCoherent(false), HasCounter(false), IsROV(false), ExtProps() {
   parseSourceType(R.getSourceType());
 }
 
 void UAVResource::print(raw_ostream &OS) const {
   OS << "; " << left_justify(Name, 31);
 
   OS << right_justify("UAV", 10);
 

llvm/test/CodeGen/DirectX/UAVMetadata.ll

 ; RUN: opt -S -dxil-metadata-emit < %s | FileCheck %s
 ; RUN: opt -S --passes="print-dxil-resource" < %s 2>&1 | FileCheck %s --check-prefix=PRINT
 ; RUN: llc %s --filetype=asm -o - < %s 2>&1 | FileCheck %s --check-prefixes=CHECK,PRINT
 
 target datalayout = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64"
 target triple = "dxil-pc-shadermodel6.0-compute"
 
 %"class.hlsl::RWBuffer" = type { ptr }
 
 
 ; PRINT:; Resource Bindings:
 ; PRINT-NEXT:;
 ; PRINT-NEXT:; Name                                 Type  Format         Dim      ID      HLSL Bind  Count
 ; PRINT-NEXT:; ------------------------------ ---------- ------- ----------- ------- -------------- ------
 ; PRINT-NEXT:;                                       UAV     f16         buf      U0             u0     1
-; PRINT-NEXT:;                                       UAV     f32         buf      U1             u0     1
-; PRINT-NEXT:;                                       UAV     f64         buf      U2             u0     1
-; PRINT-NEXT:;                                       UAV      i1         buf      U3             u0     2
-; PRINT-NEXT:;                                       UAV    byte         r/w      U4             u0     1
-; PRINT-NEXT:;                                       UAV  struct         r/w      U5             u0     1
-; PRINT-NEXT:;                                       UAV     i32         buf      U6             u0     1
-; PRINT-NEXT:;                                       UAV  struct         r/w      U7             u0     1
-; PRINT-NEXT:;                                       UAV    byte         r/w      U8             u0     1
-; PRINT-NEXT:;                                       UAV     u64         buf      U9             u0     1
+; PRINT-NEXT:;                                       UAV     f32         buf      U1             u1     1
+; PRINT-NEXT:;                                       UAV     f64         buf      U2             u2     1
+; PRINT-NEXT:;                                       UAV      i1         buf      U3             u3     2
+; PRINT-NEXT:;                                       UAV    byte         r/w      U4             u5     1
+; PRINT-NEXT:;                                       UAV  struct         r/w      U5             u6     1
+; PRINT-NEXT:;                                       UAV     i32         buf      U6             u7     1
+; PRINT-NEXT:;                                       UAV  struct         r/w      U7             u8     1
+; PRINT-NEXT:;                                       UAV    byte         r/w      U8             u9     1
+; PRINT-NEXT:;                                       UAV     u64         buf      U9     u10,space2     1
 
 @Zero = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @One = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Two = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Three = local_unnamed_addr global [2 x %"class.hlsl::RWBuffer"] zeroinitializer, align 4
 @Four = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Five = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Six = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Seven = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Eight = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 @Nine = local_unnamed_addr global %"class.hlsl::RWBuffer" zeroinitializer, align 4
 
 
 !hlsl.uavs = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9}
 
-!0 = !{ptr @Zero, !"RWBuffer<half>", i32 0}
-!1 = !{ptr @One, !"Buffer<vector<float,4>>", i32 1}
-!2 = !{ptr @Two, !"Buffer<double>", i32 2}
-!3 = !{ptr @Three, !"Buffer<bool>", i32 3}
-!4 = !{ptr @Four, !"ByteAddressBuffer<int16_t>", i32 4}
-!5 = !{ptr @Five, !"StructuredBuffer<uint16_t>", i32 5}
-!6 = !{ptr @Six, !"RasterizerOrderedBuffer<int32_t>", i32 6}
-!7 = !{ptr @Seven, !"RasterizerOrderedStructuredBuffer<uint32_t>", i32 7}
-!8 = !{ptr @Eight, !"RasterizerOrderedByteAddressBuffer<int64_t>", i32 8}
-!9 = !{ptr @Nine, !"RWBuffer<uint64_t>", i32 9}
+!0 = !{ptr @Zero, !"RWBuffer<half>", i32 0, i32 10, i32 0, i32 0}
+!1 = !{ptr @One, !"Buffer<vector<float,4>>", i32 1, i32 10, i32 1, i32 0}
+!2 = !{ptr @Two, !"Buffer<double>", i32 2, i32 10, i32 2, i32 0}
+!3 = !{ptr @Three, !"Buffer<bool>", i32 3, i32 10, i32 3, i32 0}
+!4 = !{ptr @Four, !"ByteAddressBuffer<int16_t>", i32 4, i32 11, i32 5, i32 0}
+!5 = !{ptr @Five, !"StructuredBuffer<uint16_t>", i32 5, i32 12, i32 6, i32 0}
+!6 = !{ptr @Six, !"RasterizerOrderedBuffer<int32_t>", i32 6, i32 10, i32 7, i32 0}
+!7 = !{ptr @Seven, !"RasterizerOrderedStructuredBuffer<uint32_t>", i32 7, i32 12, i32 8, i32 0}
+!8 = !{ptr @Eight, !"RasterizerOrderedByteAddressBuffer<int64_t>", i32 8, i32 11, i32 9, i32 0}
+!9 = !{ptr @Nine, !"RWBuffer<uint64_t>", i32 9, i32 10, i32 10, i32 2}
 
 ; CHECK: !dx.resources = !{[[ResList:[!][0-9]+]]}
 
 ; CHECK: [[ResList]] = !{null, [[UAVList:[!][0-9]+]], null, null}
 ; CHECK: [[UAVList]] = !{[[Zero:[!][0-9]+]], [[One:[!][0-9]+]],
 ; CHECK-SAME: [[Two:[!][0-9]+]], [[Three:[!][0-9]+]], [[Four:[!][0-9]+]], 
 ; CHECK-SAME: [[Five:[!][0-9]+]], [[Six:[!][0-9]+]], [[Seven:[!][0-9]+]],
 ; CHECK-SAME: [[Eight:[!][0-9]+]], [[Nine:[!][0-9]+]]}
 ; CHECK: [[Zero]] = !{i32 0, ptr @Zero, !"", i32 0, i32 0, i32 1, i32 10, i1 false, i1 false, i1 false, [[Half:[!][0-9]+]]}
 ; CHECK: [[Half]] = !{i32 0, i32 8}
-; CHECK: [[One]] = !{i32 1, ptr @One, !"", i32 0, i32 0, i32 1, i32 10, i1 false, i1 false, i1 false, [[Float:[!][0-9]+]]}
+; CHECK: [[One]] = !{i32 1, ptr @One, !"", i32 0, i32 1, i32 1, i32 10, i1 false, i1 false, i1 false, [[Float:[!][0-9]+]]}
 ; CHECK: [[Float]] = !{i32 0, i32 9}
-; CHECK: [[Two]] = !{i32 2, ptr @Two, !"", i32 0, i32 0, i32 1, i32 10, i1 false, i1 false, i1 false, [[Double:[!][0-9]+]]}
+; CHECK: [[Two]] = !{i32 2, ptr @Two, !"", i32 0, i32 2, i32 1, i32 10, i1 false, i1 false, i1 false, [[Double:[!][0-9]+]]}
 ; CHECK: [[Double]] = !{i32 0, i32 10}
-; CHECK: [[Three]] = !{i32 3, ptr @Three, !"", i32 0, i32 0, i32 2, i32 10, i1 false, i1 false, i1 false, [[Bool:[!][0-9]+]]}
+; CHECK: [[Three]] = !{i32 3, ptr @Three, !"", i32 0, i32 3, i32 2, i32 10, i1 false, i1 false, i1 false, [[Bool:[!][0-9]+]]}
 ; CHECK: [[Bool]] = !{i32 0, i32 1}
-; CHECK: [[Four]] = !{i32 4, ptr @Four, !"", i32 0, i32 0, i32 1, i32 11, i1 false, i1 false, i1 false, [[I16:[!][0-9]+]]}
+; CHECK: [[Four]] = !{i32 4, ptr @Four, !"", i32 0, i32 5, i32 1, i32 11, i1 false, i1 false, i1 false, [[I16:[!][0-9]+]]}
 ; CHECK: [[I16]] = !{i32 0, i32 2}
-; CHECK: [[Five]] = !{i32 5, ptr @Five, !"", i32 0, i32 0, i32 1, i32 12, i1 false, i1 false, i1 false, [[U16:[!][0-9]+]]}
+; CHECK: [[Five]] = !{i32 5, ptr @Five, !"", i32 0, i32 6, i32 1, i32 12, i1 false, i1 false, i1 false, [[U16:[!][0-9]+]]}
 ; CHECK: [[U16]] = !{i32 0, i32 3}
-; CHECK: [[Six]] = !{i32 6, ptr @Six, !"", i32 0, i32 0, i32 1, i32 10, i1 false, i1 false, i1 true, [[I32:[!][0-9]+]]}
+; CHECK: [[Six]] = !{i32 6, ptr @Six, !"", i32 0, i32 7, i32 1, i32 10, i1 false, i1 false, i1 true, [[I32:[!][0-9]+]]}
 ; CHECK: [[I32]] = !{i32 0, i32 4}
-; CHECK: [[Seven]] = !{i32 7, ptr @Seven, !"", i32 0, i32 0, i32 1, i32 12, i1 false, i1 false, i1 true, [[U32:[!][0-9]+]]}
+; CHECK: [[Seven]] = !{i32 7, ptr @Seven, !"", i32 0, i32 8, i32 1, i32 12, i1 false, i1 false, i1 true, [[U32:[!][0-9]+]]}
 ; CHECK: [[U32]] = !{i32 0, i32 5}
-; CHECK: [[Eight]] = !{i32 8, ptr @Eight, !"", i32 0, i32 0, i32 1, i32 11, i1 false, i1 false, i1 true, [[I64:[!][0-9]+]]}
+; CHECK: [[Eight]] = !{i32 8, ptr @Eight, !"", i32 0, i32 9, i32 1, i32 11, i1 false, i1 false, i1 true, [[I64:[!][0-9]+]]}
 ; CHECK: [[I64]] = !{i32 0, i32 6}
-; CHECK: [[Nine]] = !{i32 9, ptr @Nine, !"", i32 0, i32 0, i32 1, i32 10, i1 false, i1 false, i1 false, [[U64:[!][0-9]+]]}
+; CHECK: [[Nine]] = !{i32 9, ptr @Nine, !"", i32 2, i32 10, i32 1, i32 10, i1 false, i1 false, i1 false, [[U64:[!][0-9]+]]}
 ; CHECK: [[U64]] = !{i32 0, i32 7}