refactoring to use dxil::ResourceClass for range type

joaosaffran · joaosaffran · commit 17dbe9fe954c · 2025-09-08T12:18:24.000-07:00
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
@@ -1241,20 +1241,6 @@ bool SemaHLSL::handleRootSignatureElements(
         << /*version minor*/ VersionEnum;
   };
 
-  auto toDescriptorRangeType = [](llvm::dxil::ResourceClass Type) {
-    switch (Type) {
-    case llvm::dxil::ResourceClass::SRV:
-      return llvm::dxbc::DescriptorRangeType::SRV;
-    case llvm::dxil::ResourceClass::UAV:
-      return llvm::dxbc::DescriptorRangeType::UAV;
-    case llvm::dxil::ResourceClass::CBuffer:
-      return llvm::dxbc::DescriptorRangeType::CBV;
-    case llvm::dxil::ResourceClass::Sampler:
-      return llvm::dxbc::DescriptorRangeType::Sampler;
-    }
-    llvm_unreachable("Unhandled Resource Class");
-  };
-
   // Iterate through the elements and do basic validations
   for (const hlsl::RootSignatureElement &RootSigElem : Elements) {
     SourceLocation Loc = RootSigElem.getLocation();
@@ -1297,8 +1283,8 @@ bool SemaHLSL::handleRootSignatureElements(
         ReportError(Loc, 1, 0xfffffffe);
       }
 
-      if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag(
-              Version, toDescriptorRangeType(Clause->Type), Clause->Flags))
+      if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag(Version, Clause->Type,
+                                                          Clause->Flags))
         ReportFlagError(Loc);
     }
   }
diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h
@@ -209,14 +209,8 @@ inline bool isValidParameterType(uint32_t V) {
   return false;
 }
 
-#define DESCRIPTOR_RANGE(Val, Enum)                                            \
-  case Val:                                                                    \
-    return true;
 inline bool isValidRangeType(uint32_t V) {
-  switch (V) {
-#include "DXContainerConstants.def"
-  }
-  return false;
+  return V <= llvm::to_underlying(dxil::ResourceClass::Sampler);
 }
 
 #define SHADER_VISIBILITY(Val, Enum) Enum = Val,
diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
@@ -104,16 +104,6 @@ DESCRIPTOR_RANGE_FLAG(0x10000, DescriptorsStaticKeepingBufferBoundsChecks, DESCR
 #undef DESCRIPTOR_RANGE_FLAG
 #endif // DESCRIPTOR_RANGE_FLAG
 
-// DESCRIPTOR_RANGE(value, name).
-#ifdef DESCRIPTOR_RANGE
-
-DESCRIPTOR_RANGE(0, SRV)
-DESCRIPTOR_RANGE(1, UAV)
-DESCRIPTOR_RANGE(2, CBV)
-DESCRIPTOR_RANGE(3, Sampler)
-#undef DESCRIPTOR_RANGE
-#endif // DESCRIPTOR_RANGE
-
 #ifdef ROOT_PARAMETER
 
 ROOT_PARAMETER(0, DescriptorTable)
diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h
@@ -31,7 +31,7 @@ LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace);
 LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal);
 LLVM_ABI bool verifyRangeType(uint32_t Type);
 LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version,
-                                        dxbc::DescriptorRangeType Type,
+                                        dxil::ResourceClass Type,
                                         dxbc::DescriptorRangeFlags FlagsVal);
 LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors);
 LLVM_ABI bool verifySamplerFilter(uint32_t Value);
diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h
@@ -32,7 +32,7 @@ struct RootDescriptor {
 };
 
 struct DescriptorRange {
-  dxbc::DescriptorRangeType RangeType;
+  dxil::ResourceClass RangeType;
   uint32_t NumDescriptors;
   uint32_t BaseShaderRegister;
   uint32_t RegisterSpace;
diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp
@@ -149,16 +149,6 @@ ArrayRef<EnumEntry<RootParameterType>> dxbc::getRootParameterTypes() {
   return ArrayRef(RootParameterTypes);
 }
 
-#define DESCRIPTOR_RANGE(Val, Enum) {#Enum, DescriptorRangeType::Enum},
-
-static const EnumEntry<DescriptorRangeType> DescriptorRangeTypes[] = {
-#include "llvm/BinaryFormat/DXContainerConstants.def"
-};
-
-ArrayRef<EnumEntry<DescriptorRangeType>> dxbc::getDescriptorRangeTypes() {
-  return ArrayRef(DescriptorRangeTypes);
-}
-
 #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum},
 
 static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = {
diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp
@@ -331,13 +331,13 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table,
     return make_error<InvalidRSMetadataFormat>("Descriptor Range");
 
   if (*ElementText == "CBV")
-    Range.RangeType = dxbc::DescriptorRangeType::CBV;
+    Range.RangeType = dxil::ResourceClass::CBuffer;
   else if (*ElementText == "SRV")
-    Range.RangeType = dxbc::DescriptorRangeType::SRV;
+    Range.RangeType = dxil::ResourceClass::SRV;
   else if (*ElementText == "UAV")
-    Range.RangeType = dxbc::DescriptorRangeType::UAV;
+    Range.RangeType = dxil::ResourceClass::UAV;
   else if (*ElementText == "Sampler")
-    Range.RangeType = dxbc::DescriptorRangeType::Sampler;
+    Range.RangeType = dxil::ResourceClass::Sampler;
   else
     return make_error<GenericRSMetadataError>("Invalid Descriptor Range type.",
                                               RangeDescriptorNode);
diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp
@@ -51,23 +51,11 @@ bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal) {
   return (Flags | DataFlags) == DataFlags;
 }
 
-bool verifyRangeType(uint32_t Type) {
-  switch (Type) {
-  case llvm::to_underlying(dxbc::DescriptorRangeType::CBV):
-  case llvm::to_underlying(dxbc::DescriptorRangeType::SRV):
-  case llvm::to_underlying(dxbc::DescriptorRangeType::UAV):
-  case llvm::to_underlying(dxbc::DescriptorRangeType::Sampler):
-    return true;
-  };
-
-  return false;
-}
-
-bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type,
+bool verifyDescriptorRangeFlag(uint32_t Version, dxil::ResourceClass Type,
                                dxbc::DescriptorRangeFlags Flags) {
   using FlagT = dxbc::DescriptorRangeFlags;
 
-  const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler);
+  const bool IsSampler = (Type == dxil::ResourceClass::Sampler);
 
   if (Version == 1) {
     // Since the metadata is unversioned, we expect to explicitly see the values
diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp
@@ -137,7 +137,8 @@ void RootSignatureDesc::write(raw_ostream &OS) const {
                              llvm::endianness::little);
       rewriteOffsetToCurrentByte(BOS, writePlaceholder(BOS));
       for (const auto &Range : Table) {
-        support::endian::write(BOS, Range.RangeType, llvm::endianness::little);
+        support::endian::write(BOS, (uint32_t)Range.RangeType,
+                               llvm::endianness::little);
         support::endian::write(BOS, Range.NumDescriptors,
                                llvm::endianness::little);
         support::endian::write(BOS, Range.BaseShaderRegister,
diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp
@@ -316,7 +316,7 @@ Error DXContainerWriter::writeParts(raw_ostream &OS) {
             assert(dxbc::isValidRangeType(R.RangeType) &&
                    "Invalid Descriptor Range Type");
             mcdxbc::DescriptorRange Range;
-            Range.RangeType = dxbc::DescriptorRangeType(R.RangeType);
+            Range.RangeType = dxil::ResourceClass(R.RangeType);
             Range.NumDescriptors = R.NumDescriptors;
             Range.BaseShaderRegister = R.BaseShaderRegister;
             Range.RegisterSpace = R.RegisterSpace;
diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp
@@ -25,21 +25,6 @@
 using namespace llvm;
 using namespace llvm::dxil;
 
-static ResourceClass toResourceClass(dxbc::DescriptorRangeType RangeType) {
-  using namespace dxbc;
-  switch (RangeType) {
-  case DescriptorRangeType::SRV:
-    return ResourceClass::SRV;
-  case DescriptorRangeType::UAV:
-    return ResourceClass::UAV;
-  case DescriptorRangeType::CBV:
-    return ResourceClass::CBuffer;
-  case DescriptorRangeType::Sampler:
-    return ResourceClass::Sampler;
-  }
-  llvm_unreachable("Unknown DescriptorRangeType");
-}
-
 static ResourceClass toResourceClass(dxbc::RootParameterType Type) {
   using namespace dxbc;
   switch (Type) {
@@ -210,11 +195,8 @@ static void validateRootSignature(Module &M,
             Range.NumDescriptors == ~0U
                 ? Range.BaseShaderRegister
                 : Range.BaseShaderRegister + Range.NumDescriptors - 1;
-        Builder.trackBinding(
-            toResourceClass(
-                static_cast<dxbc::DescriptorRangeType>(Range.RangeType)),
-            Range.RegisterSpace, Range.BaseShaderRegister, UpperBound,
-            &ParamInfo);
+        Builder.trackBinding(Range.RangeType, Range.RegisterSpace,
+                             Range.BaseShaderRegister, UpperBound, &ParamInfo);
       }
       break;
     }
diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp
@@ -207,9 +207,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M,
 
         for (const mcdxbc::DescriptorRange &Range : Table) {
           OS << "  - Range Type: "
-             << enumToStringRef(Range.RangeType,
-                                dxbc::getDescriptorRangeTypes())
-             << "\n"
+             << dxil::getResourceClassName(Range.RangeType) << "\n"
              << "    Register Space: " << Range.RegisterSpace << "\n"
              << "    Base Shader Register: " << Range.BaseShaderRegister << "\n"
              << "    Num Descriptors: " << Range.NumDescriptors << "\n"

Original file line number	Diff line number	Diff line change
`@@ -209,14 +209,8 @@ inline bool isValidParameterType(uint32_t V) {`
`209`	`209`	`return false;`
`210`	`210`	`}`
`211`	`211`
`212`		`-#define DESCRIPTOR_RANGE(Val, Enum) \`
`213`		`- case Val: \`
`214`		`- return true;`
`215`	`212`	`inline bool isValidRangeType(uint32_t V) {`
`216`		`- switch (V) {`
`217`		`-#include "DXContainerConstants.def"`
`218`		`- }`
`219`		`- return false;`
	`213`	`+ return V <= llvm::to_underlying(dxil::ResourceClass::Sampler);`
`220`	`214`	`}`
`221`	`215`
`222`	`216`	`#define SHADER_VISIBILITY(Val, Enum) Enum = Val,`