nfc: move RootDescriptorFlags

Author: inbelic

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -94,7 +94,7 @@ class RootSignatureParser {
     std::optional<llvm::hlsl::rootsig::Register> Reg;
     std::optional<uint32_t> Space;
     std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
-    std::optional<llvm::hlsl::rootsig::RootDescriptorFlags> Flags;
+    std::optional<llvm::dxbc::RootDescriptorFlags> Flags;
   };
   std::optional<ParsedRootDescriptorParams>
   parseRootDescriptorParams(RootSignatureToken::Kind RegType);
@@ -139,8 +139,7 @@ class RootSignatureParser {
   std::optional<llvm::hlsl::rootsig::ComparisonFunc> parseComparisonFunc();
   std::optional<llvm::hlsl::rootsig::StaticBorderColor>
   parseStaticBorderColor();
-  std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
-  parseRootDescriptorFlags();
+  std::optional<llvm::dxbc::RootDescriptorFlags> parseRootDescriptorFlags();
   std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
   parseDescriptorRangeFlags();
 

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -1114,7 +1114,7 @@ RootSignatureParser::parseStaticBorderColor() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
+std::optional<llvm::dxbc::RootDescriptorFlags>
 RootSignatureParser::parseRootDescriptorFlags() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1125,23 +1125,23 @@ RootSignatureParser::parseRootDescriptorFlags() {
       getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_non_zero_flag);
       return std::nullopt;
     }
-    return RootDescriptorFlags::None;
+    return llvm::dxbc::RootDescriptorFlags::None;
   }
 
   TokenKind Expected[] = {
 #define ROOT_DESCRIPTOR_FLAG_ENUM(NAME, LIT) TokenKind::en_##NAME,
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   };
 
-  std::optional<RootDescriptorFlags> Flags;
+  std::optional<llvm::dxbc::RootDescriptorFlags> Flags;
 
   do {
     if (tryConsumeExpectedToken(Expected)) {
       switch (CurToken.TokKind) {
 #define ROOT_DESCRIPTOR_FLAG_ENUM(NAME, LIT)                                   \
   case TokenKind::en_##NAME:                                                   \
-    Flags =                                                                    \
-        maybeOrFlag<RootDescriptorFlags>(Flags, RootDescriptorFlags::NAME);    \
+    Flags = maybeOrFlag<llvm::dxbc::RootDescriptorFlags>(                      \
+        Flags, llvm::dxbc::RootDescriptorFlags::NAME);                         \
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
       default:

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -535,7 +535,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::All);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
-            RootDescriptorFlags::DataStaticWhileSetAtExecute);
+            llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute);
 
   Elem = Elements[1];
   ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
@@ -545,8 +545,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 4u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
             ShaderVisibility::Geometry);
-  ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
-            RootDescriptorFlags::ValidFlags);
+  auto ValidRootDescriptorFlags = llvm::dxbc::RootDescriptorFlags(0xe);
+  ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, ValidRootDescriptorFlags);
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
@@ -556,17 +556,18 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::Hull);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
-            RootDescriptorFlags::DataVolatile);
+            llvm::dxbc::RootDescriptorFlags::DataVolatile);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
-            RootDescriptorFlags::DataVolatile);
+            llvm::dxbc::RootDescriptorFlags::DataVolatile);
 
   Elem = Elements[3];
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 0u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::All);
-  ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::None);
+  ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
+            llvm::dxbc::RootDescriptorFlags::None);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }

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

@@ -29,14 +29,6 @@ namespace rootsig {
 // carried over from their values in DXC. For reference:
 // https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
 
-enum class RootDescriptorFlags : unsigned {
-  None = 0,
-  DataVolatile = 0x2,
-  DataStaticWhileSetAtExecute = 0x4,
-  DataStatic = 0x8,
-  ValidFlags = 0xe,
-};
-
 enum class DescriptorRangeFlags : unsigned {
   None = 0,
   DescriptorsVolatile = 0x1,
@@ -151,16 +143,16 @@ struct RootDescriptor {
   Register Reg;
   uint32_t Space = 0;
   ShaderVisibility Visibility = ShaderVisibility::All;
-  RootDescriptorFlags Flags;
+  dxbc::RootDescriptorFlags Flags;
 
   void setDefaultFlags() {
     switch (Type) {
     case DescriptorType::CBuffer:
     case DescriptorType::SRV:
-      Flags = RootDescriptorFlags::DataStaticWhileSetAtExecute;
+      Flags = dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute;
       break;
     case DescriptorType::UAV:
-      Flags = RootDescriptorFlags::DataVolatile;
+      Flags = dxbc::RootDescriptorFlags::DataVolatile;
       break;
     }
   }

llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp

@@ -215,16 +215,9 @@ static raw_ostream &operator<<(raw_ostream &OS, const ClauseType &Type) {
   return OS;
 }
 
-static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = {
-    {"DataVolatile", RootDescriptorFlags::DataVolatile},
-    {"DataStaticWhileSetAtExecute",
-     RootDescriptorFlags::DataStaticWhileSetAtExecute},
-    {"DataStatic", RootDescriptorFlags::DataStatic},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const RootDescriptorFlags &Flags) {
-  printFlags(OS, Flags, ArrayRef(RootDescriptorFlagNames));
+                               const dxbc::RootDescriptorFlags &Flags) {
+  printFlags(OS, Flags, dxbc::getRootDescriptorFlags());
 
   return OS;
 }

llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp

@@ -131,7 +131,7 @@ TEST(HLSLRootSignatureTest, RootSRVDump) {
   Descriptor.Reg = {RegisterType::TReg, 0};
   Descriptor.Space = 42;
   Descriptor.Visibility = ShaderVisibility::Geometry;
-  Descriptor.Flags = RootDescriptorFlags::None;
+  Descriptor.Flags = llvm::dxbc::RootDescriptorFlags::None;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -149,7 +149,7 @@ TEST(HLSLRootSignatureTest, RootUAVDump) {
   Descriptor.Reg = {RegisterType::UReg, 92374};
   Descriptor.Space = 932847;
   Descriptor.Visibility = ShaderVisibility::Hull;
-  Descriptor.Flags = RootDescriptorFlags::ValidFlags;
+  Descriptor.Flags = llvm::dxbc::RootDescriptorFlags(0xe);
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);