[llvm] 66889bf - [HLSL][RootSignature] Implement serialization of `RootConstants` and `RootFlags` (#141130)

[via llvm-commits]

Author: Finn Plummer
Date: 2025-05-29T10:31:08-07:00
New Revision: 66889bf300f6a34808b9ebbee7130c5e1ef21538

URL: https://github.com/llvm/llvm-project/commit/66889bf300f6a34808b9ebbee7130c5e1ef21538
DIFF: https://github.com/llvm/llvm-project/commit/66889bf300f6a34808b9ebbee7130c5e1ef21538.diff

LOG: [HLSL][RootSignature] Implement serialization of `RootConstants` and `RootFlags` (#141130)

- Implements serialization of the currently completely defined
`RootElement`s, namely `RootConstants` and `RootFlags`

- Adds unit testing for the serialization methods

Resolves: https://github.com/llvm/llvm-project/issues/138190 and
https://github.com/llvm/llvm-project/issues/138192

Added: 
    

Modified: 
    llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
    llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
    llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp

Removed: 
    


################################################################################
diff  --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
index fea9a9962991c..14f5ddea3f978 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
@@ -46,6 +46,8 @@ enum class RootFlags : uint32_t {
   ValidFlags = 0x00000fff
 };
 
+raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags);
+
 enum class RootDescriptorFlags : unsigned {
   None = 0,
   DataVolatile = 0x2,
@@ -93,6 +95,8 @@ struct RootConstants {
   ShaderVisibility Visibility = ShaderVisibility::All;
 };
 
+raw_ostream &operator<<(raw_ostream &OS, const RootConstants &Constants);
+
 enum class DescriptorType : uint8_t { SRV = 0, UAV, CBuffer };
 // Models RootDescriptor : CBV | SRV | UAV, by collecting like parameters
 struct RootDescriptor {

diff  --git a/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp b/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
index ec0d130a6767c..6e0e0cdcd5946 100644
--- a/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
+++ b/llvm/lib/Frontend/HLSL/HLSLRootSignature.cpp
@@ -132,6 +132,79 @@ static raw_ostream &operator<<(raw_ostream &OS,
   return OS;
 }
 
+raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags) {
+  OS << "RootFlags(";
+  bool FlagSet = false;
+  unsigned Remaining = llvm::to_underlying(Flags);
+  while (Remaining) {
+    unsigned Bit = 1u << llvm::countr_zero(Remaining);
+    if (Remaining & Bit) {
+      if (FlagSet)
+        OS << " | ";
+
+      switch (static_cast<RootFlags>(Bit)) {
+      case RootFlags::AllowInputAssemblerInputLayout:
+        OS << "AllowInputAssemblerInputLayout";
+        break;
+      case RootFlags::DenyVertexShaderRootAccess:
+        OS << "DenyVertexShaderRootAccess";
+        break;
+      case RootFlags::DenyHullShaderRootAccess:
+        OS << "DenyHullShaderRootAccess";
+        break;
+      case RootFlags::DenyDomainShaderRootAccess:
+        OS << "DenyDomainShaderRootAccess";
+        break;
+      case RootFlags::DenyGeometryShaderRootAccess:
+        OS << "DenyGeometryShaderRootAccess";
+        break;
+      case RootFlags::DenyPixelShaderRootAccess:
+        OS << "DenyPixelShaderRootAccess";
+        break;
+      case RootFlags::AllowStreamOutput:
+        OS << "AllowStreamOutput";
+        break;
+      case RootFlags::LocalRootSignature:
+        OS << "LocalRootSignature";
+        break;
+      case RootFlags::DenyAmplificationShaderRootAccess:
+        OS << "DenyAmplificationShaderRootAccess";
+        break;
+      case RootFlags::DenyMeshShaderRootAccess:
+        OS << "DenyMeshShaderRootAccess";
+        break;
+      case RootFlags::CBVSRVUAVHeapDirectlyIndexed:
+        OS << "CBVSRVUAVHeapDirectlyIndexed";
+        break;
+      case RootFlags::SamplerHeapDirectlyIndexed:
+        OS << "SamplerHeapDirectlyIndexed";
+        break;
+      default:
+        OS << "invalid: " << Bit;
+        break;
+      }
+
+      FlagSet = true;
+    }
+    Remaining &= ~Bit;
+  }
+
+  if (!FlagSet)
+    OS << "None";
+
+  OS << ")";
+
+  return OS;
+}
+
+raw_ostream &operator<<(raw_ostream &OS, const RootConstants &Constants) {
+  OS << "RootConstants(num32BitConstants = " << Constants.Num32BitConstants
+     << ", " << Constants.Reg << ", space = " << Constants.Space
+     << ", visibility = " << Constants.Visibility << ")";
+
+  return OS;
+}
+
 raw_ostream &operator<<(raw_ostream &OS, const DescriptorTable &Table) {
   OS << "DescriptorTable(numClauses = " << Table.NumClauses
      << ", visibility = " << Table.Visibility << ")";

diff  --git a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
index 3f92fa0f05794..8597ed78b4fbb 100644
--- a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
+++ b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
@@ -108,4 +108,73 @@ TEST(HLSLRootSignatureTest, DescriptorTableDump) {
   EXPECT_EQ(Out, Expected);
 }
 
+TEST(HLSLRootSignatureTest, DefaultRootConstantsDump) {
+  RootConstants Constants;
+  Constants.Num32BitConstants = 1;
+  Constants.Reg = {RegisterType::BReg, 3};
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  OS << Constants;
+  OS.flush();
+
+  std::string Expected = "RootConstants(num32BitConstants = 1, b3, space = 0, "
+                         "visibility = All)";
+  EXPECT_EQ(Out, Expected);
+}
+
+TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
+  RootConstants Constants;
+  Constants.Num32BitConstants = 983;
+  Constants.Reg = {RegisterType::BReg, 34593};
+  Constants.Space = 7;
+  Constants.Visibility = ShaderVisibility::Pixel;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  OS << Constants;
+  OS.flush();
+
+  std::string Expected = "RootConstants(num32BitConstants = 983, b34593, "
+                         "space = 7, visibility = Pixel)";
+  EXPECT_EQ(Out, Expected);
+}
+
+TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
+  RootFlags Flags = RootFlags::None;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  OS << Flags;
+  OS.flush();
+
+  std::string Expected = "RootFlags(None)";
+  EXPECT_EQ(Out, Expected);
+}
+
+TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
+  RootFlags Flags = RootFlags::ValidFlags;
+
+  std::string Out;
+  llvm::raw_string_ostream OS(Out);
+  OS << Flags;
+  OS.flush();
+
+  std::string Expected = "RootFlags("
+                         "AllowInputAssemblerInputLayout | "
+                         "DenyVertexShaderRootAccess | "
+                         "DenyHullShaderRootAccess | "
+                         "DenyDomainShaderRootAccess | "
+                         "DenyGeometryShaderRootAccess | "
+                         "DenyPixelShaderRootAccess | "
+                         "AllowStreamOutput | "
+                         "LocalRootSignature | "
+                         "DenyAmplificationShaderRootAccess | "
+                         "DenyMeshShaderRootAccess | "
+                         "CBVSRVUAVHeapDirectlyIndexed | "
+                         "SamplerHeapDirectlyIndexed)";
+
+  EXPECT_EQ(Out, Expected);
+}
+
 } // namespace