implement support for dumping descriptor table clauses

Author: inbelic

llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h

@@ -53,6 +53,8 @@ enum class RegisterType { BReg, TReg, UReg, SReg };
 struct Register {
   RegisterType ViewType;
   uint32_t Number;
+
+  void dump(raw_ostream &OS) const;
 };
 
 // Models the end of a descriptor table and stores its visibility

llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp

@@ -11,13 +11,105 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Frontend/HLSL/HLSLRootSignature.h"
+#include "llvm/ADT/bit.h"
 
 namespace llvm {
 namespace hlsl {
 namespace rootsig {
 
+static void dumpRegType(raw_ostream& OS, RegisterType Type) {
+  switch (Type) {
+  case RegisterType::BReg:
+    OS << "b";
+    break;
+  case RegisterType::TReg:
+    OS << "t";
+    break;
+  case RegisterType::UReg:
+    OS << "u";
+    break;
+  case RegisterType::SReg:
+    OS << "s";
+    break;
+  }
+}
+
+void Register::dump(raw_ostream &OS) const {
+  dumpRegType(OS, ViewType);
+  OS << Number;
+}
+
+static void dumpClauseType(raw_ostream& OS, ClauseType Type) {
+  switch (Type) {
+  case ClauseType::CBuffer:
+    OS << "CBV";
+    break;
+  case ClauseType::SRV:
+    OS << "SRV";
+    break;
+  case ClauseType::UAV:
+    OS << "UAV";
+    break;
+  case ClauseType::Sampler:
+    OS << "Sampler";
+    break;
+  }
+}
+
+static void dumpDescriptorRangeFlag(raw_ostream &OS, unsigned Bit) {
+  switch (static_cast<DescriptorRangeFlags>(Bit)) {
+    case DescriptorRangeFlags::DescriptorsVolatile:
+      OS << "DescriptorsVolatile";
+      break;
+    case DescriptorRangeFlags::DataVolatile:
+      OS << "DataVolatile";
+      break;
+    case DescriptorRangeFlags::DataStaticWhileSetAtExecute:
+      OS << "DataStaticWhileSetAtExecute";
+      break;
+    case DescriptorRangeFlags::DataStatic:
+      OS << "DataStatic";
+      break;
+    case DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks:
+      OS << "DescriptorsStaticKeepingBufferBoundsChecks";
+      break;
+    default:
+      OS << "invalid: " << Bit;
+      break;
+  }
+}
+
+static void dumpDescriptorRangeFlags(raw_ostream &OS, DescriptorRangeFlags Flags) {
+  bool FlagSet = false;
+  unsigned Remaining = llvm::to_underlying(Flags);
+  while (Remaining) {
+    unsigned Bit = 1u << llvm::countr_zero(Remaining);
+    if (Remaining & Bit) {
+      if (FlagSet)
+        OS << " | ";
+      dumpDescriptorRangeFlag(OS, Bit);
+      FlagSet = true;
+    }
+    Remaining &= ~Bit;
+  }
+  if (!FlagSet)
+    OS << "None";
+}
+
 void DescriptorTableClause::dump(raw_ostream &OS) const {
-  OS << "Clause!";
+  dumpClauseType(OS, Type);
+  OS << "(";
+  Reg.dump(OS);
+  OS << ", numDescriptors = " << NumDescriptors;
+  OS << ", space = " << Space;
+  OS << ", offset = ";
+  if (Offset == DescriptorTableOffsetAppend)
+    OS << "DESCRIPTOR_TABLE_OFFSET_APPEND";
+  else
+    OS << Offset;
+  OS << ", flags = ";
+  dumpDescriptorRangeFlags(OS, Flags);
+  OS << ")";
 }
 
 } // namespace rootsig

llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp

@@ -13,18 +13,86 @@ using namespace llvm::hlsl::rootsig;
 
 namespace {
 
-TEST(HLSLRootSignatureTest, DescriptorTablesDump) {
-  // Default clause
+TEST(HLSLRootSignatureTest, DescriptorCBVClauseDump) {
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::CBuffer;
   Clause.Reg = { RegisterType::BReg, 0 };
+  Clause.setDefaultFlags();
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
   Clause.dump(OS);
   OS.flush();
 
-  EXPECT_EQ(Out, "Clause!");
+  std::string Expected =
+    "CBV(b0, numDescriptors = 1, space = 0, "
+    "offset = DESCRIPTOR_TABLE_OFFSET_APPEND, "
+    "flags = DataStaticWhileSetAtExecute)";
+  EXPECT_EQ(Out, Expected);
+}
+
+TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
+  DescriptorTableClause Clause;
+  Clause.Type = ClauseType::SRV;
+  Clause.Reg = { RegisterType::TReg, 0 };
+  Clause.NumDescriptors = 2;
+  Clause.Space = 42;
+  Clause.Offset = 3;
+  Clause.Flags = DescriptorRangeFlags::None;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  Clause.dump(OS);
+  OS.flush();
+
+  std::string Expected =
+    "SRV(t0, numDescriptors = 2, space = 42, offset = 3, flags = None)";
+  EXPECT_EQ(Out, Expected);
+}
+
+
+TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
+  DescriptorTableClause Clause;
+  Clause.Type = ClauseType::UAV;
+  Clause.Reg = { RegisterType::UReg, 0 };
+  Clause.NumDescriptors = 2;
+  Clause.Space = 42;
+  Clause.Offset = 3;
+  Clause.Flags = DescriptorRangeFlags::ValidFlags;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  Clause.dump(OS);
+  OS.flush();
+
+  std::string Expected =
+    "UAV(u0, numDescriptors = 2, space = 42, offset = 3, flags = "
+    "DescriptorsVolatile | "
+    "DataVolatile | "
+    "DataStaticWhileSetAtExecute | "
+    "DataStatic | "
+    "DescriptorsStaticKeepingBufferBoundsChecks)";
+  EXPECT_EQ(Out, Expected);
+}
+
+TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
+  DescriptorTableClause Clause;
+  Clause.Type = ClauseType::Sampler;
+  Clause.Reg = { RegisterType::SReg, 0 };
+  Clause.NumDescriptors = 2;
+  Clause.Space = 42;
+  Clause.Offset = 3;
+  Clause.Flags = DescriptorRangeFlags::ValidSamplerFlags;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  Clause.dump(OS);
+  OS.flush();
+
+  std::string Expected =
+    "Sampler(s0, numDescriptors = 2, space = 42, offset = 3, "
+    "flags = DescriptorsVolatile)";
+  EXPECT_EQ(Out, Expected);
 }
 
 } // namespace