[DirectX backend] Add analysis to collect DXILResources

[python3kgae]

Summary

Now only DXILTranslateMetadata uses DXILResources, so DXILResourceWrapper is only used by DXILTranslateMetadata.
Once we add lower for createHandle, DXILResourceWrapper will be used in more passes.
Also we can add resource index allocation in DXILResourceWrapper.

[python3kgae]

Add printer pass for test

[beanz]

llvm/lib/Target/DirectX/DXILResource.cpp

232

How difficult would it be go make the printed output here look more like DXC's disassembly output? It would be very convenient if we could use the printer pass to generate the disassembly printing too.

llvm/lib/Target/DirectX/DXILResource.h

57

Maybe rather than print we make these dump functions that default to dbgs(), then we can print them in the debugger.

llvm/lib/Target/DirectX/DXILResourceAnalysis.h

42

This being a pointer is unfortunate. If you change dxil::Resources to not store a reference to the module (which it probably doesn't need), you could add a public collect method and change it to have a constructor that takes the module and a default constructor that doesn't collect the resources.

[python3kgae]

Change print format.
Add Resources::collect and dump.

[python3kgae]

Fix clang-format

[beanz]

llvm/lib/Target/DirectX/DXILResource.cpp

70

Instead of a static array if you use a switch statement we don't need the asserts above.

101

Using a switch here makes sense too.

233

"comment" is a lot longer to write than just adding a ; to the front of the lines, and just including it in the string avoids double-calling operator<<

348

here too

llvm/lib/Target/DirectX/DXILResource.h

84

85

115

[beanz]

llvm/lib/Target/DirectX/DXILResource.h

165

Include llvm/Support/Compiler.h so that LLVM_DUMP_METHOD is properly defined to make the dump method not stripped in debug builds.

[python3kgae]

Use switch instead of static array.

[beanz]

A few last really nitpicky whitespace issues. Otherwise looks good.

llvm/lib/Target/DirectX/DXILResource.cpp

347

nit: please add a blank line between functions.

llvm/lib/Target/DirectX/DXILResourceAnalysis.cpp

27

nit: blank line here too

46

nit: blank line here too

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

31

nit: blank lines before and after this function too.

[python3kgae]

Add space between functions.

[python3kgae]

clang-format

llvm/lib/Target/DirectX/CMakeLists.txt

add_llvm_target(DirectXCodeGen
   DirectXRegisterInfo.cpp
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
   DXILMetadata.cpp
   DXILOpBuilder.cpp
   DXILOpLowering.cpp
   DXILPrepare.cpp
   DXILResource.cpp
+  DXILResourceAnalysis.cpp
   DXILTranslateMetadata.cpp
   PointerTypeAnalysis.cpp
 
   LINK_COMPONENTS
   AsmPrinter
   Core
   SelectionDAG
   Support

llvm/lib/Target/DirectX/DXILResource.h

 
 #ifndef LLVM_TARGET_DIRECTX_DXILRESOURCE_H
 #define LLVM_TARGET_DIRECTX_DXILRESOURCE_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/Support/Compiler.h"
 #include <cstdint>
 
 namespace llvm {
 class Module;
 class GlobalVariable;
 
 namespace dxil {
 
protected:
   StringRef Name;
   uint32_t Space;
   uint32_t LowerBound;
   uint32_t RangeSize;
   ResourceBase(uint32_t I, FrontendResource R);
 
   void write(LLVMContext &Ctx, MutableArrayRef<Metadata *> Entries);
 
+  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,
enum class Kinds : uint32_t {
     Sampler,
     TBuffer,
     RTAccelerationStructure,
     FeedbackTexture2D,
     FeedbackTexture2DArray,
     NumEntries,
   };
 
+  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 {
     Invalid = 0,
     I1,
     I16,
     U16,
     I32,
enum class ComponentType : uint32_t {
     UNormF32,
     SNormF64,
     UNormF64,
     PackedS8x32,
     PackedU8x32,
     LastEntry
   };
 
+  static StringRef getComponentTypeName(ComponentType CompType);
+  static void printComponentType(Kinds Kind, ComponentType CompType,
+                                 unsigned alignment, raw_ostream &OS);
+
 public:
   struct ExtendedProperties {
     llvm::Optional<ComponentType> ElementType;
 
     // The value ordering of this enumeration is part of the DXIL ABI. Elements
     // can only be added to the end, and not removed.
     enum Tags : uint32_t {
       TypedBufferElementType = 0,
class UAVResource : public ResourceBase {
   ResourceBase::ExtendedProperties ExtProps;
 
   void parseSourceType(StringRef S);
 
 public:
   UAVResource(uint32_t I, FrontendResource R);
 
   MDNode *write();
+  void print(raw_ostream &O) const;
 };
 
 // FIXME: Fully computing the resource structures requires analyzing the IR
 // because some flags are set based on what operations are performed on the
 // resource. This partial patch handles some of the leg work, but not all of it.
 // See issue https://github.com/llvm/llvm-project/issues/57936.
 class Resources {
-  Module &Mod;
   llvm::SmallVector<UAVResource> UAVs;
 
-  void collectUAVs();
+  void collectUAVs(Module &M);
 
 public:
-  Resources(Module &M) : Mod(M) { collectUAVs(); }
+  void collect(Module &M);
 
-  void write();
+  void write(Module &M);
+  void print(raw_ostream &O) const;
+  LLVM_DUMP_METHOD void dump() const;
 };
 
 } // namespace dxil
 } // namespace llvm
 
 #endif // LLVM_TARGET_DIRECTX_DXILRESOURCE_H

llvm/lib/Target/DirectX/DXILResource.cpp

 ///
 //===----------------------------------------------------------------------===//
 
 #include "DXILResource.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Format.h"
 
 using namespace llvm;
 using namespace llvm::dxil;
 
 GlobalVariable *FrontendResource::getGlobalVariable() {
   return cast<GlobalVariable>(
       cast<ConstantAsMetadata>(Entry->getOperand(0))->getValue());
 }
 
 StringRef FrontendResource::getSourceType() {
   return cast<MDString>(Entry->getOperand(1))->getString();
 }
 
 Constant *FrontendResource::getID() {
   return cast<ConstantAsMetadata>(Entry->getOperand(2))->getValue();
 }
 
-void Resources::collectUAVs() {
-  NamedMDNode *Entry = Mod.getNamedMetadata("hlsl.uavs");
+void Resources::collectUAVs(Module &M) {
+  NamedMDNode *Entry = M.getNamedMetadata("hlsl.uavs");
   if (!Entry || Entry->getNumOperands() == 0)
     return;
 
   uint32_t Counter = 0;
   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) {
   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:
+    return "invalid";
+  case ComponentType::I1:
+    return "i1";
+  case ComponentType::I16:
+    return "i16";
+  case ComponentType::U16:
+    return "u16";
+  case ComponentType::I32:
+    return "i32";
+  case ComponentType::U32:
+    return "u32";
+  case ComponentType::I64:
+    return "i64";
+  case ComponentType::U64:
+    return "u64";
+  case ComponentType::F16:
+    return "f16";
+  case ComponentType::F32:
+    return "f32";
+  case ComponentType::F64:
+    return "f64";
+  case ComponentType::SNormF16:
+    return "snorm_f16";
+  case ComponentType::UNormF16:
+    return "unorm_f16";
+  case ComponentType::SNormF32:
+    return "snorm_f32";
+  case ComponentType::UNormF32:
+    return "unorm_f32";
+  case ComponentType::SNormF64:
+    return "snorm_f64";
+  case ComponentType::UNormF64:
+    return "unorm_f64";
+  case ComponentType::PackedS8x32:
+    return "p32i8";
+  case ComponentType::PackedU8x32:
+    return "p32u8";
+  }
+}
+
+void ResourceBase::printComponentType(Kinds Kind, ComponentType CompType,
+                                       unsigned alignment, raw_ostream &OS) {
+  switch (Kind) {
+  default:
+    // TODO: add vector size.
+    OS << right_justify(getComponentTypeName(CompType), alignment);
+    break;
+  case Kinds::RawBuffer:
+    OS << right_justify("byte", alignment);
+    break;
+  case Kinds::StructuredBuffer:
+    OS << right_justify("struct", alignment);
+    break;
+  case Kinds::CBuffer:
+  case Kinds::Sampler:
+    OS << right_justify("NA", alignment);
+    break;
+  case Kinds::Invalid:
+  case Kinds::NumEntries:
+    break;
+  }
+}
+
+StringRef ResourceBase::getKindName(Kinds Kind) {
+  switch (Kind) {
+  case Kinds::NumEntries:
+  case Kinds::Invalid:
+    return "invalid";
+  case Kinds::Texture1D:
+    return "1d";
+  case Kinds::Texture2D:
+    return "2d";
+  case Kinds::Texture2DMS:
+    return "2dMS";
+  case Kinds::Texture3D:
+    return "3d";
+  case Kinds::TextureCube:
+    return "cube";
+  case Kinds::Texture1DArray:
+    return "1darray";
+  case Kinds::Texture2DArray:
+    return "2darray";
+  case Kinds::Texture2DMSArray:
+    return "2darrayMS";
+  case Kinds::TextureCubeArray:
+    return "cubearray";
+  case Kinds::TypedBuffer:
+    return "buf";
+  case Kinds::RawBuffer:
+    return "rawbuf";
+  case Kinds::StructuredBuffer:
+    return "structbuf";
+  case Kinds::CBuffer:
+    return "cbuffer";
+  case Kinds::Sampler:
+    return "sampler";
+  case Kinds::TBuffer:
+    return "tbuffer";
+  case Kinds::RTAccelerationStructure:
+    return "ras";
+  case Kinds::FeedbackTexture2D:
+    return "fbtex2d";
+  case Kinds::FeedbackTexture2DArray:
+    return "fbtex2darray";
+  }
+}
+
+void ResourceBase::printKind(Kinds Kind, unsigned alignment,
+                                          raw_ostream &OS, bool SRV,
+                                          bool HasCounter,
+                                          uint32_t SampleCount) {
+  switch (Kind) {
+  default:
+    OS << right_justify(getKindName(Kind), alignment);
+    break;
+
+  case Kinds::RawBuffer:
+  case Kinds::StructuredBuffer:
+    if (SRV)
+      OS << right_justify("r/o", alignment);
+    else {
+      if (!HasCounter)
+        OS << right_justify("r/w", alignment);
+      else
+        OS << right_justify("r/w+cnt", alignment);
+    }
+    break;
+  case Kinds::TypedBuffer:
+    OS << right_justify("buf", alignment);
+    break;
+  case Kinds::Texture2DMS:
+  case Kinds::Texture2DMSArray: {
+    std::string dimName = getKindName(Kind).str();
+    if (SampleCount)
+      dimName += std::to_string(SampleCount);
+    OS << right_justify(dimName, alignment);
+  } break;
+  case Kinds::CBuffer:
+  case Kinds::Sampler:
+    OS << right_justify("NA", alignment);
+    break;
+  case Kinds::Invalid:
+  case Kinds::NumEntries:
+    break;
+  }
+}
+
+void ResourceBase::print(raw_ostream &OS, StringRef IDPrefix,
+                         StringRef BindingPrefix) const {
+  std::string ResID = IDPrefix.str();
+  ResID += std::to_string(ID);
+  OS << right_justify(ResID, 8);
+
+  std::string Bind = BindingPrefix.str();
+  Bind += std::to_string(LowerBound);
+  if (Space)
+    Bind += ",space" + std::to_string(Space);
+
+  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() {
   parseSourceType(R.getSourceType());
 }
 
+void UAVResource::print(raw_ostream &OS) const {
+  OS << "; " << left_justify(Name, 31);
+
+  OS << right_justify("UAV", 10);
+
+  printComponentType(
+      Shape, ExtProps.ElementType.value_or(ComponentType::Invalid), 8, OS);
+
+  // FIXME: support SampleCount.
+  // See https://github.com/llvm/llvm-project/issues/58175
+  printKind(Shape, 12, OS, /*SRV*/ false, HasCounter);
+  // Print the binding part.
+  ResourceBase::print(OS, "U", "u");
+}
+
 // FIXME: Capture this in HLSL source. I would go do this right now, but I want
 // to get this in first so that I can make sure to capture all the extra
 // information we need to remove the source type string from here (See issue:
 // https://github.com/llvm/llvm-project/issues/57991).
 void UAVResource::parseSourceType(StringRef S) {
   IsROV = S.startswith("RasterizerOrdered");
   if (IsROV)
     S = S.substr(strlen("RasterizerOrdered"));
Entries[6] =
       ConstantAsMetadata::get(B.getInt32(static_cast<uint32_t>(Shape)));
   Entries[7] = ConstantAsMetadata::get(B.getInt1(GloballyCoherent));
   Entries[8] = ConstantAsMetadata::get(B.getInt1(HasCounter));
   Entries[9] = ConstantAsMetadata::get(B.getInt1(IsROV));
   Entries[10] = ExtProps.write(Ctx);
   return MDNode::get(Ctx, Entries);
 }
 
-void Resources::write() {
+void Resources::write(Module &M) {
   Metadata *ResourceMDs[4] = {nullptr, nullptr, nullptr, nullptr};
   SmallVector<Metadata *> UAVMDs;
   for (auto &UAV : UAVs)
     UAVMDs.emplace_back(UAV.write());
 
   if (!UAVMDs.empty())
-    ResourceMDs[1] = MDNode::get(Mod.getContext(), UAVMDs);
+    ResourceMDs[1] = MDNode::get(M.getContext(), UAVMDs);
 
-  NamedMDNode *DXResMD = Mod.getOrInsertNamedMetadata("dx.resources");
-  DXResMD->addOperand(MDNode::get(Mod.getContext(), ResourceMDs));
+  NamedMDNode *DXResMD = M.getOrInsertNamedMetadata("dx.resources");
+  DXResMD->addOperand(MDNode::get(M.getContext(), ResourceMDs));
 
-  NamedMDNode *Entry = Mod.getNamedMetadata("hlsl.uavs");
+  NamedMDNode *Entry = M.getNamedMetadata("hlsl.uavs");
   if (Entry)
     Entry->eraseFromParent();
 }
+void Resources::print(raw_ostream &O) const {
+  O << ";\n"
+    << "; Resource Bindings:\n"
+    << ";\n"
+    << "; Name                                 Type  Format         Dim      "
+       "ID      HLSL Bind  Count\n"
+    << "; ------------------------------ ---------- ------- ----------- "
+       "------- -------------- ------\n";
+
+  for (auto &UAV : UAVs)
+    UAV.print(O);
+}
+
+void Resources::dump() const { print(dbgs()); }

llvm/lib/Target/DirectX/DXILResourceAnalysis.h

+//===- DXILResourceAnalysis.h   - DXIL Resource analysis-------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains Analysis for information about DXIL resources.
+///
+//===----------------------------------------------------------------------===//
+
+#include "DXILResource.h"
+#include "llvm/IR/PassManager.h"
+#include "llvm/Pass.h"
+#include <memory>
+
+namespace llvm {
+/// Analysis pass that exposes the \c DXILResource for a module.
+class DXILResourceAnalysis : public AnalysisInfoMixin<DXILResourceAnalysis> {
+  friend AnalysisInfoMixin<DXILResourceAnalysis>;
+  static AnalysisKey Key;
+
+public:
+  typedef dxil::Resources Result;
+  dxil::Resources run(Module &M, ModuleAnalysisManager &AM);
+};
+
+/// Printer pass for the \c DXILResourceAnalysis results.
+class DXILResourcePrinterPass : public PassInfoMixin<DXILResourcePrinterPass> {
+  raw_ostream &OS;
+
+public:
+  explicit DXILResourcePrinterPass(raw_ostream &OS) : OS(OS) {}
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+/// The legacy pass manager's analysis pass to compute DXIL resource
+/// information.
+class DXILResourceWrapper : public ModulePass {
+  dxil::Resources Resources;
+
+public:
+  static char ID; // Pass identification, replacement for typeid
+
+  DXILResourceWrapper();
+
+  dxil::Resources &getDXILResource() { return Resources; }
+  const dxil::Resources &getDXILResource() const { return Resources; }
+
+  /// Calculate the DXILResource for the module.
+  bool runOnModule(Module &M) override;
+
+  void print(raw_ostream &O, const Module *M = nullptr) const override;
+};
+} // namespace llvm

llvm/lib/Target/DirectX/DXILResourceAnalysis.cpp

+//===- DXILResourceAnalysis.cpp - DXIL Resource analysis-------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains Analysis for information about DXIL resources.
+///
+//===----------------------------------------------------------------------===//
+
+#include "DXILResourceAnalysis.h"
+#include "DirectX.h"
+#include "llvm/IR/PassManager.h"
+
+using namespace llvm;
+
+#define DEBUG_TYPE "dxil-resource-analysis"
+
+dxil::Resources DXILResourceAnalysis::run(Module &M,
+                                          ModuleAnalysisManager &AM) {
+  dxil::Resources R;
+  R.collect(M);
+  return R;
+}
+AnalysisKey DXILResourceAnalysis::Key;
+
+PreservedAnalyses DXILResourcePrinterPass::run(Module &M,
+                                               ModuleAnalysisManager &AM) {
+  dxil::Resources Res = AM.getResult<DXILResourceAnalysis>(M);
+  Res.print(OS);
+  return PreservedAnalyses::all();
+}
+
+char DXILResourceWrapper::ID = 0;
+INITIALIZE_PASS_BEGIN(DXILResourceWrapper, DEBUG_TYPE,
+                      "DXIL resource Information", true, true)
+INITIALIZE_PASS_END(DXILResourceWrapper, DEBUG_TYPE,
+                    "DXIL resource Information", true, true)
+
+bool DXILResourceWrapper::runOnModule(Module &M) {
+  Resources.collect(M);
+  return false;
+}
+DXILResourceWrapper::DXILResourceWrapper() : ModulePass(ID) {}
+
+void DXILResourceWrapper::print(raw_ostream &OS, const Module *) const {
+  Resources.print(OS);
+}

llvm/lib/Target/DirectX/DXILTranslateMetadata.cpp

 //===- DXILTranslateMetadata.cpp - Pass to emit DXIL metadata ---*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 //===----------------------------------------------------------------------===//
 
 #include "DXILMetadata.h"
 #include "DXILResource.h"
+#include "DXILResourceAnalysis.h"
 #include "DirectX.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Pass.h"
 
 using namespace llvm;
 
 namespace {
 class DXILTranslateMetadata : public ModulePass {
 public:
   static char ID; // Pass identification, replacement for typeid
   explicit DXILTranslateMetadata() : ModulePass(ID) {}
 
   StringRef getPassName() const override { return "DXIL Metadata Emit"; }
-
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.setPreservesAll();
+    AU.addRequired<DXILResourceWrapper>();
+  }
   bool runOnModule(Module &M) override;
 };
 
 } // namespace
 
 bool DXILTranslateMetadata::runOnModule(Module &M) {
 
   dxil::ValidatorVersionMD ValVerMD(M);
   if (ValVerMD.isEmpty())
     ValVerMD.update(VersionTuple(1, 0));
   dxil::createShaderModelMD(M);
 
-  dxil::Resources Res(M);
-  Res.write();
+  dxil::Resources &Res = getAnalysis<DXILResourceWrapper>().getDXILResource();
+  Res.write(M);
   return false;
 }
 
 char DXILTranslateMetadata::ID = 0;
 
 ModulePass *llvm::createDXILTranslateMetadataPass() {
   return new DXILTranslateMetadata();
 }
 
-INITIALIZE_PASS(DXILTranslateMetadata, "dxil-metadata-emit",
+INITIALIZE_PASS_BEGIN(DXILTranslateMetadata, "dxil-metadata-emit",
+                      "DXIL Metadata Emit", false, false)
+INITIALIZE_PASS_DEPENDENCY(DXILResourceWrapper)
+INITIALIZE_PASS_END(DXILTranslateMetadata, "dxil-metadata-emit",
                     "DXIL Metadata Emit", false, false)

llvm/lib/Target/DirectX/DirectX.h

 /// Pass to lowering LLVM intrinsic call to DXIL op function call.
 ModulePass *createDXILOpLoweringLegacyPass();
 
 /// Initializer for DXILTranslateMetadata.
 void initializeDXILTranslateMetadataPass(PassRegistry &);
 
 /// Pass to emit metadata for DXIL.
 ModulePass *createDXILTranslateMetadataPass();
+
+/// Initializer for DXILTranslateMetadata.
+void initializeDXILResourceWrapperPass(PassRegistry &);
+
 } // namespace llvm
 
 #endif // LLVM_LIB_TARGET_DIRECTX_DIRECTX_H

llvm/lib/Target/DirectX/DirectXTargetMachine.h

public:
 
   TargetPassConfig *createPassConfig(PassManagerBase &PM) override;
 
   TargetLoweringObjectFile *getObjFileLowering() const override {
     return TLOF.get();
   }
 
   TargetTransformInfo getTargetTransformInfo(const Function &F) const override;
+  void registerPassBuilderCallbacks(PassBuilder &PB) override;
 };
 } // namespace llvm
 
 #endif // LLVM_DIRECTX_DIRECTXTARGETMACHINE_H

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 //===- DirectXTargetMachine.cpp - DirectX Target Implementation -*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains DirectX target initializer.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "DirectXTargetMachine.h"
+#include "DXILResourceAnalysis.h"
 #include "DXILWriter/DXILWriterPass.h"
 #include "DirectX.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
 #include "TargetInfo/DirectXTargetInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/MCSectionDXContainer.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/MC/TargetRegistry.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 using namespace llvm;
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
   RegisterTargetMachine<DirectXTargetMachine> X(getTheDirectXTarget());
   auto *PR = PassRegistry::getPassRegistry();
   initializeDXILPrepareModulePass(*PR);
   initializeEmbedDXILPassPass(*PR);
   initializeDXILOpLoweringLegacyPass(*PR);
   initializeDXILTranslateMetadataPass(*PR);
+  initializeDXILResourceWrapperPass(*PR);
 }
 
 class DXILTargetObjectFile : public TargetLoweringObjectFile {
 public:
   DXILTargetObjectFile() = default;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override {
: LLVMTargetMachine(T,
                         OL),
       TLOF(std::make_unique<DXILTargetObjectFile>()),
       Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {
   initAsmInfo();
 }
 
 DirectXTargetMachine::~DirectXTargetMachine() {}
 
+void DirectXTargetMachine::registerPassBuilderCallbacks(PassBuilder &PB) {
+  PB.registerPipelineParsingCallback(
+      [](StringRef PassName, ModulePassManager &PM,
+         ArrayRef<PassBuilder::PipelineElement>) {
+        if (PassName == "print-dxil-resource") {
+          PM.addPass(DXILResourcePrinterPass(dbgs()));
+          return true;
+        }
+        return false;
+      });
+
+  PB.registerAnalysisRegistrationCallback([](ModuleAnalysisManager &MAM) {
+    MAM.registerPass([&] { return DXILResourceAnalysis(); });
+  });
+}
+
 bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
     MachineModuleInfoWrapperPass *MMIWP) {
   TargetPassConfig *PassConfig = createPassConfig(PM);
   PassConfig->addCodeGenPrepare();
 
   if (TargetPassConfig::willCompleteCodeGenPipeline()) {

llvm/test/CodeGen/DirectX/UAVMetadata.ll

 ; RUN: opt -S -dxil-metadata-emit < %s | FileCheck %s
-; ModuleID = '/home/cbieneman/dev/shuffle.hlsl'
+; RUN: opt -S --passes="print-dxil-resource" < %s 2>&1 | FileCheck %s --check-prefix=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
+
 @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

 !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}
 
-
 ; 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]+]]}