Author: Finn Plummer
Date: 2025-07-03T14:44:11-07:00
New Revision: 0ceb0c377a3e67b70965c32e7f21fe8b33f555d2

URL: 
https://github.com/llvm/llvm-project/commit/0ceb0c377a3e67b70965c32e7f21fe8b33f555d2
DIFF: 
https://github.com/llvm/llvm-project/commit/0ceb0c377a3e67b70965c32e7f21fe8b33f555d2.diff

LOG: [NFC][HLSL][DirectX] Let `HLSLRootSignature` reuse the `dxbc` defined 
enums (#145986)

This pr removes the redundancy of having the same enums defined in both
the front-end and back-end of handling root signatures. Since there are
many more uses of the enum in the front-end of the code, we will adhere
to the naming conventions used in the front-end, to minimize the diff.

The macros in `DXContainerConstants.def` are also touched-up to be
consistent and to have each macro name follow its respective definition
in d3d12.h and searchable by name
[here](https://learn.microsoft.com/en-us/windows/win32/api/d3d12/).

Additionally, the many `getEnumNames` are moved to `DXContainer` from
`HLSLRootSignatureUtils` as they we will want them to be exposed
publicly anyways.

Changes for each enum follow the pattern of a commit that will make the
enum definition in `DXContainer` adhere to above listed naming
conventions, followed by a commit to actually use that enum in the
front-end.

Resolves https://github.com/llvm/llvm-project/issues/145815

Added: 
    

Modified: 
    clang/include/clang/Parse/ParseHLSLRootSignature.h
    clang/lib/Parse/ParseHLSLRootSignature.cpp
    clang/lib/Sema/SemaHLSL.cpp
    clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
    llvm/include/llvm/BinaryFormat/DXContainer.h
    llvm/include/llvm/BinaryFormat/DXContainerConstants.def
    llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
    llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
    llvm/include/llvm/ObjectYAML/DXContainerYAML.h
    llvm/lib/BinaryFormat/DXContainer.cpp
    llvm/lib/Frontend/HLSL/CMakeLists.txt
    llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
    llvm/lib/ObjectYAML/DXContainerYAML.cpp
    llvm/lib/Target/DirectX/DXILRootSignature.cpp
    llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp

Removed: 
    


################################################################################
diff  --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h 
b/clang/include/clang/Parse/ParseHLSLRootSignature.h
index afa2c4d8cfe50..18cd1f379e62c 100644
--- a/clang/include/clang/Parse/ParseHLSLRootSignature.h
+++ b/clang/include/clang/Parse/ParseHLSLRootSignature.h
@@ -71,7 +71,7 @@ class RootSignatureParser {
   // expected, or, there is a lexing error
 
   /// Root Element parse methods:
-  std::optional<llvm::hlsl::rootsig::RootFlags> parseRootFlags();
+  std::optional<llvm::dxbc::RootFlags> parseRootFlags();
   std::optional<llvm::hlsl::rootsig::RootConstants> parseRootConstants();
   std::optional<llvm::hlsl::rootsig::RootDescriptor> parseRootDescriptor();
   std::optional<llvm::hlsl::rootsig::DescriptorTable> parseDescriptorTable();
@@ -86,15 +86,15 @@ class RootSignatureParser {
     std::optional<llvm::hlsl::rootsig::Register> Reg;
     std::optional<uint32_t> Num32BitConstants;
     std::optional<uint32_t> Space;
-    std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
+    std::optional<llvm::dxbc::ShaderVisibility> Visibility;
   };
   std::optional<ParsedConstantParams> parseRootConstantParams();
 
   struct ParsedRootDescriptorParams {
     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::ShaderVisibility> Visibility;
+    std::optional<llvm::dxbc::RootDescriptorFlags> Flags;
   };
   std::optional<ParsedRootDescriptorParams>
   parseRootDescriptorParams(RootSignatureToken::Kind RegType);
@@ -104,25 +104,25 @@ class RootSignatureParser {
     std::optional<uint32_t> NumDescriptors;
     std::optional<uint32_t> Space;
     std::optional<uint32_t> Offset;
-    std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags> Flags;
+    std::optional<llvm::dxbc::DescriptorRangeFlags> Flags;
   };
   std::optional<ParsedClauseParams>
   parseDescriptorTableClauseParams(RootSignatureToken::Kind RegType);
 
   struct ParsedStaticSamplerParams {
     std::optional<llvm::hlsl::rootsig::Register> Reg;
-    std::optional<llvm::hlsl::rootsig::SamplerFilter> Filter;
-    std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressU;
-    std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressV;
-    std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressW;
+    std::optional<llvm::dxbc::SamplerFilter> Filter;
+    std::optional<llvm::dxbc::TextureAddressMode> AddressU;
+    std::optional<llvm::dxbc::TextureAddressMode> AddressV;
+    std::optional<llvm::dxbc::TextureAddressMode> AddressW;
     std::optional<float> MipLODBias;
     std::optional<uint32_t> MaxAnisotropy;
-    std::optional<llvm::hlsl::rootsig::ComparisonFunc> CompFunc;
-    std::optional<llvm::hlsl::rootsig::StaticBorderColor> BorderColor;
+    std::optional<llvm::dxbc::ComparisonFunc> CompFunc;
+    std::optional<llvm::dxbc::StaticBorderColor> BorderColor;
     std::optional<float> MinLOD;
     std::optional<float> MaxLOD;
     std::optional<uint32_t> Space;
-    std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
+    std::optional<llvm::dxbc::ShaderVisibility> Visibility;
   };
   std::optional<ParsedStaticSamplerParams> parseStaticSamplerParams();
 
@@ -132,17 +132,13 @@ class RootSignatureParser {
   std::optional<float> parseFloatParam();
 
   /// Parsing methods of various enums
-  std::optional<llvm::hlsl::rootsig::ShaderVisibility> parseShaderVisibility();
-  std::optional<llvm::hlsl::rootsig::SamplerFilter> parseSamplerFilter();
-  std::optional<llvm::hlsl::rootsig::TextureAddressMode>
-  parseTextureAddressMode();
-  std::optional<llvm::hlsl::rootsig::ComparisonFunc> parseComparisonFunc();
-  std::optional<llvm::hlsl::rootsig::StaticBorderColor>
-  parseStaticBorderColor();
-  std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
-  parseRootDescriptorFlags();
-  std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
-  parseDescriptorRangeFlags();
+  std::optional<llvm::dxbc::ShaderVisibility> parseShaderVisibility();
+  std::optional<llvm::dxbc::SamplerFilter> parseSamplerFilter();
+  std::optional<llvm::dxbc::TextureAddressMode> parseTextureAddressMode();
+  std::optional<llvm::dxbc::ComparisonFunc> parseComparisonFunc();
+  std::optional<llvm::dxbc::StaticBorderColor> parseStaticBorderColor();
+  std::optional<llvm::dxbc::RootDescriptorFlags> parseRootDescriptorFlags();
+  std::optional<llvm::dxbc::DescriptorRangeFlags> parseDescriptorRangeFlags();
 
   /// Use NumericLiteralParser to convert CurToken.NumSpelling into a unsigned
   /// 32-bit integer

diff  --git a/clang/lib/Parse/ParseHLSLRootSignature.cpp 
b/clang/lib/Parse/ParseHLSLRootSignature.cpp
index e510302c3aae0..18d3644114eef 100644
--- a/clang/lib/Parse/ParseHLSLRootSignature.cpp
+++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp
@@ -76,7 +76,7 @@ static FlagType maybeOrFlag(std::optional<FlagType> Flags, 
FlagType Flag) {
                                llvm::to_underlying(Flag));
 }
 
-std::optional<RootFlags> RootSignatureParser::parseRootFlags() {
+std::optional<llvm::dxbc::RootFlags> RootSignatureParser::parseRootFlags() {
   assert(CurToken.TokKind == TokenKind::kw_RootFlags &&
          "Expects to only be invoked starting at given keyword");
 
@@ -84,7 +84,7 @@ std::optional<RootFlags> 
RootSignatureParser::parseRootFlags() {
                            CurToken.TokKind))
     return std::nullopt;
 
-  std::optional<RootFlags> Flags = RootFlags::None;
+  std::optional<llvm::dxbc::RootFlags> Flags = llvm::dxbc::RootFlags::None;
 
   // Handle the edge-case of '0' to specify no flags set
   if (tryConsumeExpectedToken(TokenKind::int_literal)) {
@@ -104,7 +104,8 @@ std::optional<RootFlags> 
RootSignatureParser::parseRootFlags() {
         switch (CurToken.TokKind) {
 #define ROOT_FLAG_ENUM(NAME, LIT)                                              
\
   case TokenKind::en_##NAME:                                                   
\
-    Flags = maybeOrFlag<RootFlags>(Flags, RootFlags::NAME);                    
\
+    Flags = maybeOrFlag<llvm::dxbc::RootFlags>(Flags,                          
\
+                                               llvm::dxbc::RootFlags::NAME);   
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
         default:
@@ -240,7 +241,7 @@ std::optional<DescriptorTable> 
RootSignatureParser::parseDescriptorTable() {
     return std::nullopt;
 
   DescriptorTable Table;
-  std::optional<ShaderVisibility> Visibility;
+  std::optional<llvm::dxbc::ShaderVisibility> Visibility;
 
   // Iterate as many Clauses as possible
   do {
@@ -983,7 +984,7 @@ std::optional<float> RootSignatureParser::parseFloatParam() 
{
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::ShaderVisibility>
+std::optional<llvm::dxbc::ShaderVisibility>
 RootSignatureParser::parseShaderVisibility() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -999,7 +1000,7 @@ RootSignatureParser::parseShaderVisibility() {
   switch (CurToken.TokKind) {
 #define SHADER_VISIBILITY_ENUM(NAME, LIT)                                      
\
   case TokenKind::en_##NAME:                                                   
\
-    return ShaderVisibility::NAME;                                             
\
+    return llvm::dxbc::ShaderVisibility::NAME;                                 
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   default:
@@ -1009,7 +1010,7 @@ RootSignatureParser::parseShaderVisibility() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::SamplerFilter>
+std::optional<llvm::dxbc::SamplerFilter>
 RootSignatureParser::parseSamplerFilter() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1025,7 +1026,7 @@ RootSignatureParser::parseSamplerFilter() {
   switch (CurToken.TokKind) {
 #define FILTER_ENUM(NAME, LIT)                                                 
\
   case TokenKind::en_##NAME:                                                   
\
-    return SamplerFilter::NAME;                                                
\
+    return llvm::dxbc::SamplerFilter::NAME;                                    
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   default:
@@ -1035,7 +1036,7 @@ RootSignatureParser::parseSamplerFilter() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::TextureAddressMode>
+std::optional<llvm::dxbc::TextureAddressMode>
 RootSignatureParser::parseTextureAddressMode() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1051,7 +1052,7 @@ RootSignatureParser::parseTextureAddressMode() {
   switch (CurToken.TokKind) {
 #define TEXTURE_ADDRESS_MODE_ENUM(NAME, LIT)                                   
\
   case TokenKind::en_##NAME:                                                   
\
-    return TextureAddressMode::NAME;                                           
\
+    return llvm::dxbc::TextureAddressMode::NAME;                               
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   default:
@@ -1061,7 +1062,7 @@ RootSignatureParser::parseTextureAddressMode() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::ComparisonFunc>
+std::optional<llvm::dxbc::ComparisonFunc>
 RootSignatureParser::parseComparisonFunc() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1077,7 +1078,7 @@ RootSignatureParser::parseComparisonFunc() {
   switch (CurToken.TokKind) {
 #define COMPARISON_FUNC_ENUM(NAME, LIT)                                        
\
   case TokenKind::en_##NAME:                                                   
\
-    return ComparisonFunc::NAME;                                               
\
+    return llvm::dxbc::ComparisonFunc::NAME;                                   
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   default:
@@ -1087,7 +1088,7 @@ RootSignatureParser::parseComparisonFunc() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::StaticBorderColor>
+std::optional<llvm::dxbc::StaticBorderColor>
 RootSignatureParser::parseStaticBorderColor() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1103,7 +1104,7 @@ RootSignatureParser::parseStaticBorderColor() {
   switch (CurToken.TokKind) {
 #define STATIC_BORDER_COLOR_ENUM(NAME, LIT)                                    
\
   case TokenKind::en_##NAME:                                                   
\
-    return StaticBorderColor::NAME;                                            
\
+    return llvm::dxbc::StaticBorderColor::NAME;                                
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   default:
@@ -1113,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");
@@ -1124,7 +1125,7 @@ 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[] = {
@@ -1132,15 +1133,15 @@ RootSignatureParser::parseRootDescriptorFlags() {
 #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:
@@ -1152,7 +1153,7 @@ RootSignatureParser::parseRootDescriptorFlags() {
   return Flags;
 }
 
-std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
+std::optional<llvm::dxbc::DescriptorRangeFlags>
 RootSignatureParser::parseDescriptorRangeFlags() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1163,7 +1164,7 @@ RootSignatureParser::parseDescriptorRangeFlags() {
       getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_non_zero_flag);
       return std::nullopt;
     }
-    return DescriptorRangeFlags::None;
+    return llvm::dxbc::DescriptorRangeFlags::None;
   }
 
   TokenKind Expected[] = {
@@ -1171,15 +1172,15 @@ RootSignatureParser::parseDescriptorRangeFlags() {
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
   };
 
-  std::optional<DescriptorRangeFlags> Flags;
+  std::optional<llvm::dxbc::DescriptorRangeFlags> Flags;
 
   do {
     if (tryConsumeExpectedToken(Expected)) {
       switch (CurToken.TokKind) {
 #define DESCRIPTOR_RANGE_FLAG_ENUM(NAME, LIT, ON)                              
\
   case TokenKind::en_##NAME:                                                   
\
-    Flags =                                                                    
\
-        maybeOrFlag<DescriptorRangeFlags>(Flags, DescriptorRangeFlags::NAME);  
\
+    Flags = maybeOrFlag<llvm::dxbc::DescriptorRangeFlags>(                     
\
+        Flags, llvm::dxbc::DescriptorRangeFlags::NAME);                        
\
     break;
 #include "clang/Lex/HLSLRootSignatureTokenKinds.def"
       default:

diff  --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index bad357b50929b..6061b0015a56b 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1200,10 +1200,9 @@ bool 
SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D,
   auto ReportOverlap = [this, Loc, &HadOverlap](const RangeInfo *Info,
                                                 const RangeInfo *OInfo) {
     HadOverlap = true;
-    auto CommonVis =
-        Info->Visibility == llvm::hlsl::rootsig::ShaderVisibility::All
-            ? OInfo->Visibility
-            : Info->Visibility;
+    auto CommonVis = Info->Visibility == llvm::dxbc::ShaderVisibility::All
+                         ? OInfo->Visibility
+                         : Info->Visibility;
     this->Diag(Loc, diag::err_hlsl_resource_range_overlap)
         << llvm::to_underlying(Info->Class) << Info->LowerBound
         << /*unbounded=*/(Info->UpperBound == RangeInfo::Unbounded)
@@ -1238,7 +1237,7 @@ bool 
SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D,
     // ResourceRanges in the former case and it will be an ArrayRef to just the
     // all visiblity ResourceRange in the latter case.
     ArrayRef<ResourceRange> OverlapRanges =
-        Info.Visibility == llvm::hlsl::rootsig::ShaderVisibility::All
+        Info.Visibility == llvm::dxbc::ShaderVisibility::All
             ? ArrayRef<ResourceRange>{Ranges}.drop_front()
             : ArrayRef<ResourceRange>{Ranges}.take_front();
 

diff  --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp 
b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
index 1e46ee35d5d49..8831198e4b9c2 100644
--- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
+++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
@@ -127,6 +127,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) {
 }
 
 TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
+  using llvm::dxbc::DescriptorRangeFlags;
   const llvm::StringLiteral Source = R"cc(
     DescriptorTable(
       CBV(b0),
@@ -205,20 +206,27 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseDTClausesTest) {
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset,
             DescriptorTableOffsetAppend);
+  auto ValidDescriptorRangeFlags =
+      DescriptorRangeFlags::DescriptorsVolatile |
+      DescriptorRangeFlags::DataVolatile |
+      DescriptorRangeFlags::DataStaticWhileSetAtExecute |
+      DescriptorRangeFlags::DataStatic |
+      DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags,
-            DescriptorRangeFlags::ValidFlags);
+            ValidDescriptorRangeFlags);
 
   Elem = Elements[4];
   ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
   ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, (uint32_t)4);
   ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility,
-            ShaderVisibility::Pixel);
+            llvm::dxbc::ShaderVisibility::Pixel);
 
   // Empty Descriptor Table
   Elem = Elements[5];
   ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
   ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, 0u);
-  ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, ShaderVisibility::All);
+  ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::All);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
@@ -258,19 +266,25 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseStaticSamplerTest) {
   ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem));
   ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg);
   ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).Filter, SamplerFilter::Anisotropic);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, TextureAddressMode::Wrap);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, TextureAddressMode::Wrap);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, TextureAddressMode::Wrap);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).Filter,
+            llvm::dxbc::SamplerFilter::Anisotropic);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
+            llvm::dxbc::TextureAddressMode::Wrap);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,
+            llvm::dxbc::TextureAddressMode::Wrap);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW,
+            llvm::dxbc::TextureAddressMode::Wrap);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f);
   ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 16u);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, ComparisonFunc::LessEqual);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc,
+            llvm::dxbc::ComparisonFunc::LessEqual);
   ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor,
-            StaticBorderColor::OpaqueWhite);
+            llvm::dxbc::StaticBorderColor::OpaqueWhite);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 0.f);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 3.402823466e+38f);
   ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 0u);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, ShaderVisibility::All);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::All);
 
   // Check values can be set as expected
   Elem = Elements[1];
@@ -278,19 +292,24 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseStaticSamplerTest) {
   ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg);
   ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u);
   ASSERT_EQ(std::get<StaticSampler>(Elem).Filter,
-            SamplerFilter::MaximumMinPointMagLinearMipPoint);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, 
TextureAddressMode::Mirror);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, 
TextureAddressMode::Border);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, TextureAddressMode::Clamp);
+            llvm::dxbc::SamplerFilter::MaximumMinPointMagLinearMipPoint);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
+            llvm::dxbc::TextureAddressMode::Mirror);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,
+            llvm::dxbc::TextureAddressMode::Border);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW,
+            llvm::dxbc::TextureAddressMode::Clamp);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 230.f);
   ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 3u);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, ComparisonFunc::NotEqual);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc,
+            llvm::dxbc::ComparisonFunc::NotEqual);
   ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor,
-            StaticBorderColor::OpaqueBlackUint);
+            llvm::dxbc::StaticBorderColor::OpaqueBlackUint);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 4.2f);
   ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 9000.f);
   ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 4u);
-  ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, 
ShaderVisibility::Domain);
+  ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::Domain);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
@@ -403,8 +422,9 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) {
   RootElement Elem = Elements[0];
   ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler);
-  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags,
-            DescriptorRangeFlags::ValidSamplerFlags);
+  auto ValidSamplerFlags =
+      llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;
+  ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidSamplerFlags);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
@@ -438,7 +458,8 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootConsantsTest) {
   ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg);
   ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 0u);
   ASSERT_EQ(std::get<RootConstants>(Elem).Space, 0u);
-  ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, ShaderVisibility::All);
+  ASSERT_EQ(std::get<RootConstants>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::All);
 
   Elem = Elements[1];
   ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem));
@@ -446,12 +467,14 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootConsantsTest) {
   ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg);
   ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 42u);
   ASSERT_EQ(std::get<RootConstants>(Elem).Space, 3u);
-  ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, ShaderVisibility::Hull);
+  ASSERT_EQ(std::get<RootConstants>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::Hull);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
 
 TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) {
+  using llvm::dxbc::RootFlags;
   const llvm::StringLiteral Source = R"cc(
     RootFlags(),
     RootFlags(0),
@@ -496,12 +519,25 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootFlagsTest) {
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem));
-  ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::ValidFlags);
+  auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout |
+                        RootFlags::DenyVertexShaderRootAccess |
+                        RootFlags::DenyHullShaderRootAccess |
+                        RootFlags::DenyDomainShaderRootAccess |
+                        RootFlags::DenyGeometryShaderRootAccess |
+                        RootFlags::DenyPixelShaderRootAccess |
+                        RootFlags::AllowStreamOutput |
+                        RootFlags::LocalRootSignature |
+                        RootFlags::DenyAmplificationShaderRootAccess |
+                        RootFlags::DenyMeshShaderRootAccess |
+                        RootFlags::CBVSRVUAVHeapDirectlyIndexed |
+                        RootFlags::SamplerHeapDirectlyIndexed;
+  ASSERT_EQ(std::get<RootFlags>(Elem), ValidRootFlags);
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
 
 TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
+  using llvm::dxbc::RootDescriptorFlags;
   const llvm::StringLiteral Source = R"cc(
     CBV(b0),
     SRV(space = 4, t42, visibility = SHADER_VISIBILITY_GEOMETRY,
@@ -532,7 +568,8 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootDescriptorsTest) {
   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).Visibility,
+            llvm::dxbc::ShaderVisibility::All);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
             RootDescriptorFlags::DataStaticWhileSetAtExecute);
 
@@ -543,9 +580,12 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 42u);
   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);
+            llvm::dxbc::ShaderVisibility::Geometry);
+  auto ValidRootDescriptorFlags =
+      RootDescriptorFlags::DataVolatile |
+      RootDescriptorFlags::DataStaticWhileSetAtExecute |
+      RootDescriptorFlags::DataStatic;
+  ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, ValidRootDescriptorFlags);
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
@@ -553,7 +593,8 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::UReg);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 34893247u);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
-  ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::Hull);
+  ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
+            llvm::dxbc::ShaderVisibility::Hull);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
             RootDescriptorFlags::DataVolatile);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
@@ -564,7 +605,8 @@ TEST_F(ParseHLSLRootSignatureTest, 
ValidParseRootDescriptorsTest) {
   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).Visibility,
+            llvm::dxbc::ShaderVisibility::All);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::None);
 
   ASSERT_TRUE(Consumer->isSatisfied());

diff  --git a/llvm/include/llvm/BinaryFormat/DXContainer.h 
b/llvm/include/llvm/BinaryFormat/DXContainer.h
index 45170f550faf1..89abca02efefa 100644
--- a/llvm/include/llvm/BinaryFormat/DXContainer.h
+++ b/llvm/include/llvm/BinaryFormat/DXContainer.h
@@ -157,23 +157,33 @@ enum class FeatureFlags : uint64_t {
 static_assert((uint64_t)FeatureFlags::NextUnusedBit <= 1ull << 63,
               "Shader flag bits exceed enum size.");
 
-#define ROOT_ELEMENT_FLAG(Num, Val) Val = Num,
-enum class RootElementFlag : uint32_t {
+#define ROOT_SIGNATURE_FLAG(Num, Val) Val = Num,
+enum class RootFlags : uint32_t {
 #include "DXContainerConstants.def"
+
+  LLVM_MARK_AS_BITMASK_ENUM(SamplerHeapDirectlyIndexed)
 };
 
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) Val = Num,
-enum class RootDescriptorFlag : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<RootFlags>> getRootFlags();
+
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) Enum = Num,
+enum class RootDescriptorFlags : uint32_t {
 #include "DXContainerConstants.def"
+
+  LLVM_MARK_AS_BITMASK_ENUM(DataStatic)
 };
 
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) Val = Num,
-enum class DescriptorRangeFlag : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<RootDescriptorFlags>> getRootDescriptorFlags();
+
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) Enum = Num,
+enum class DescriptorRangeFlags : uint32_t {
 #include "DXContainerConstants.def"
 
-  LLVM_MARK_AS_BITMASK_ENUM(DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+  LLVM_MARK_AS_BITMASK_ENUM(DescriptorsStaticKeepingBufferBoundsChecks)
 };
 
+LLVM_ABI ArrayRef<EnumEntry<DescriptorRangeFlags>> getDescriptorRangeFlags();
+
 #define ROOT_PARAMETER(Val, Enum) Enum = Val,
 enum class RootParameterType : uint32_t {
 #include "DXContainerConstants.def"
@@ -215,26 +225,34 @@ inline bool isValidShaderVisibility(uint32_t V) {
   return false;
 }
 
-#define STATIC_SAMPLER_FILTER(Val, Enum) Enum = Val,
-enum class StaticSamplerFilter : uint32_t {
+#define FILTER(Val, Enum) Enum = Val,
+enum class SamplerFilter : uint32_t {
 #include "DXContainerConstants.def"
 };
 
+LLVM_ABI ArrayRef<EnumEntry<SamplerFilter>> getSamplerFilters();
+
 #define TEXTURE_ADDRESS_MODE(Val, Enum) Enum = Val,
 enum class TextureAddressMode : uint32_t {
 #include "DXContainerConstants.def"
 };
 
-#define COMPARISON_FUNCTION(Val, Enum) Enum = Val,
-enum class SamplersComparisonFunction : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<TextureAddressMode>> getTextureAddressModes();
+
+#define COMPARISON_FUNC(Val, Enum) Enum = Val,
+enum class ComparisonFunc : uint32_t {
 #include "DXContainerConstants.def"
 };
 
+LLVM_ABI ArrayRef<EnumEntry<ComparisonFunc>> getComparisonFuncs();
+
 #define STATIC_BORDER_COLOR(Val, Enum) Enum = Val,
-enum class SamplersBorderColor : uint32_t {
+enum class StaticBorderColor : uint32_t {
 #include "DXContainerConstants.def"
 };
 
+LLVM_ABI ArrayRef<EnumEntry<StaticBorderColor>> getStaticBorderColors();
+
 LLVM_ABI PartType parsePartType(StringRef S);
 
 struct VertexPSVInfo {

diff  --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def 
b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
index a281256a44ae0..8730820dd8b06 100644
--- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
+++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
@@ -55,47 +55,52 @@ SHADER_FEATURE_FLAG(33, 39, NextUnusedBit, "Next reserved 
shader flag bit (not a
 #undef SHADER_FEATURE_FLAG
 #endif // SHADER_FEATURE_FLAG
 
-
-// ROOT_ELEMENT_FLAG(bit offset for the flag, name).
-#ifdef ROOT_ELEMENT_FLAG
-
-ROOT_ELEMENT_FLAG(0, NONE)
-ROOT_ELEMENT_FLAG(0x1, AllowInputAssemblerInputLayout)
-ROOT_ELEMENT_FLAG(0x2, DenyVertexShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x4, DenyHullShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x8, DenyDomainShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x10, DenyGeometryShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x20, DenyPixelShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x40, AllowStreamOutput)
-ROOT_ELEMENT_FLAG(0x80, LocalRootSignature)
-ROOT_ELEMENT_FLAG(0x100, DenyAmplificationShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x200, DenyMeshShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x400, CBVSRVUAVHeapDirectlyIndexed)
-ROOT_ELEMENT_FLAG(0x800, SamplerHeapDirectlyIndexed)
-#undef ROOT_ELEMENT_FLAG
-#endif // ROOT_ELEMENT_FLAG
-
+// Below is the definition of root signature enumerations and flags. The
+// definitions of all values here correspond to their description in the
+// d3d12.h header and are carried over from their values in DXC. For reference:
+// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
+
+// ROOT_SIGNATURE_FLAG(flag value, name).
+#ifdef ROOT_SIGNATURE_FLAG
+
+ROOT_SIGNATURE_FLAG(0, None)
+ROOT_SIGNATURE_FLAG(0x1, AllowInputAssemblerInputLayout)
+ROOT_SIGNATURE_FLAG(0x2, DenyVertexShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x4, DenyHullShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x8, DenyDomainShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x10, DenyGeometryShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x20, DenyPixelShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x40, AllowStreamOutput)
+ROOT_SIGNATURE_FLAG(0x80, LocalRootSignature)
+ROOT_SIGNATURE_FLAG(0x100, DenyAmplificationShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x200, DenyMeshShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x400, CBVSRVUAVHeapDirectlyIndexed)
+ROOT_SIGNATURE_FLAG(0x800, SamplerHeapDirectlyIndexed)
+
+#undef ROOT_SIGNATURE_FLAG
+#endif // ROOT_SIGNATURE_FLAG
  
-// ROOT_DESCRIPTOR_FLAG(bit offset for the flag, name).
+// ROOT_DESCRIPTOR_FLAG(flag value, name, flag).
 #ifdef ROOT_DESCRIPTOR_FLAG
 
-ROOT_DESCRIPTOR_FLAG(0, NONE)
-ROOT_DESCRIPTOR_FLAG(0x2, DATA_VOLATILE)
-ROOT_DESCRIPTOR_FLAG(0x4, DATA_STATIC_WHILE_SET_AT_EXECUTE)
-ROOT_DESCRIPTOR_FLAG(0x8, DATA_STATIC)
+ROOT_DESCRIPTOR_FLAG(0, None, NONE)
+ROOT_DESCRIPTOR_FLAG(0x2, DataVolatile, DATA_VOLATILE)
+ROOT_DESCRIPTOR_FLAG(0x4, DataStaticWhileSetAtExecute, 
DATA_STATIC_WHILE_SET_AT_EXECUTE)
+ROOT_DESCRIPTOR_FLAG(0x8, DataStatic, DATA_STATIC)
+
 #undef ROOT_DESCRIPTOR_FLAG
 #endif // ROOT_DESCRIPTOR_FLAG
 
-
-// DESCRIPTOR_RANGE_FLAG(bit offset for the flag, name).
+// DESCRIPTOR_RANGE_FLAG(flag value, name, flag).
 #ifdef DESCRIPTOR_RANGE_FLAG
 
-DESCRIPTOR_RANGE_FLAG(0, NONE)
-DESCRIPTOR_RANGE_FLAG(0x1, DESCRIPTORS_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(0x2, DATA_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(0x4, DATA_STATIC_WHILE_SET_AT_EXECUTE)
-DESCRIPTOR_RANGE_FLAG(0x8, DATA_STATIC)
-DESCRIPTOR_RANGE_FLAG(0x10000, DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+DESCRIPTOR_RANGE_FLAG(0, None, NONE)
+DESCRIPTOR_RANGE_FLAG(0x1, DescriptorsVolatile, DESCRIPTORS_VOLATILE)
+DESCRIPTOR_RANGE_FLAG(0x2, DataVolatile, DATA_VOLATILE)
+DESCRIPTOR_RANGE_FLAG(0x4, DataStaticWhileSetAtExecute, 
DATA_STATIC_WHILE_SET_AT_EXECUTE)
+DESCRIPTOR_RANGE_FLAG(0x8, DataStatic, DATA_STATIC)
+DESCRIPTOR_RANGE_FLAG(0x10000, DescriptorsStaticKeepingBufferBoundsChecks, 
DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+
 #undef DESCRIPTOR_RANGE_FLAG
 #endif // DESCRIPTOR_RANGE_FLAG
 
@@ -119,6 +124,7 @@ ROOT_PARAMETER(4, UAV)
 #undef ROOT_PARAMETER
 #endif // ROOT_PARAMETER
 
+// SHADER_VISIBILITY(value, enum).
 #ifdef SHADER_VISIBILITY
 
 SHADER_VISIBILITY(0, All)
@@ -129,79 +135,89 @@ SHADER_VISIBILITY(4, Geometry)
 SHADER_VISIBILITY(5, Pixel)
 SHADER_VISIBILITY(6, Amplification)
 SHADER_VISIBILITY(7, Mesh)
+
 #undef SHADER_VISIBILITY
 #endif // SHADER_VISIBILITY
 
-#ifdef STATIC_SAMPLER_FILTER
-
-STATIC_SAMPLER_FILTER(0, MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x1, MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x4, MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x5, MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x10, MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x11, MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x14, MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x15, MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x55, ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x80, COMPARISON_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x81, COMPARISON_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x84, COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x85, COMPARISON_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x90, COMPARISON_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x91, COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x94, COMPARISON_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x95, COMPARISON_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0xd5, COMPARISON_ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x100, MINIMUM_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x101, MINIMUM_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x104, MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x105, MINIMUM_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x110, MINIMUM_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x111, MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x114, MINIMUM_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x115, MINIMUM_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x155, MINIMUM_ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x180, MAXIMUM_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x181, MAXIMUM_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x184, MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x185, MAXIMUM_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x190, MAXIMUM_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x191, MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x194, MAXIMUM_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x195, MAXIMUM_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x1d5, MAXIMUM_ANISOTROPIC)
-#undef STATIC_SAMPLER_FILTER
-#endif // STATIC_SAMPLER_FILTER
-
+// FILTER(value, enum).
+#ifdef FILTER
+
+FILTER(0, MinMagMipPoint)
+FILTER(0x1, MinMagPointMipLinear)
+FILTER(0x4, MinPointMagLinearMipPoint)
+FILTER(0x5, MinPointMagMipLinear)
+FILTER(0x10, MinLinearMagMipPoint)
+FILTER(0x11, MinLinearMagPointMipLinear)
+FILTER(0x14, MinMagLinearMipPoint)
+FILTER(0x15, MinMagMipLinear)
+FILTER(0x55, Anisotropic)
+FILTER(0x80, ComparisonMinMagMipPoint)
+FILTER(0x81, ComparisonMinMagPointMipLinear)
+FILTER(0x84, ComparisonMinPointMagLinearMipPoint)
+FILTER(0x85, ComparisonMinPointMagMipLinear)
+FILTER(0x90, ComparisonMinLinearMagMipPoint)
+FILTER(0x91, ComparisonMinLinearMagPointMipLinear)
+FILTER(0x94, ComparisonMinMagLinearMipPoint)
+FILTER(0x95, ComparisonMinMagMipLinear)
+FILTER(0xd5, ComparisonAnisotropic)
+FILTER(0x100, MinimumMinMagMipPoint)
+FILTER(0x101, MinimumMinMagPointMipLinear)
+FILTER(0x104, MinimumMinPointMagLinearMipPoint)
+FILTER(0x105, MinimumMinPointMagMipLinear)
+FILTER(0x110, MinimumMinLinearMagMipPoint)
+FILTER(0x111, MinimumMinLinearMagPointMipLinear)
+FILTER(0x114, MinimumMinMagLinearMipPoint)
+FILTER(0x115, MinimumMinMagMipLinear)
+FILTER(0x155, MinimumAnisotropic)
+FILTER(0x180, MaximumMinMagMipPoint)
+FILTER(0x181, MaximumMinMagPointMipLinear)
+FILTER(0x184, MaximumMinPointMagLinearMipPoint)
+FILTER(0x185, MaximumMinPointMagMipLinear)
+FILTER(0x190, MaximumMinLinearMagMipPoint)
+FILTER(0x191, MaximumMinLinearMagPointMipLinear)
+FILTER(0x194, MaximumMinMagLinearMipPoint)
+FILTER(0x195, MaximumMinMagMipLinear)
+FILTER(0x1d5, MaximumAnisotropic)
+
+#undef FILTER
+#endif // FILTER
+
+// TEXTURE_ADDRESS_MODE(value, enum).
 #ifdef TEXTURE_ADDRESS_MODE
 
-TEXTURE_ADDRESS_MODE( 1,  Wrap)
-TEXTURE_ADDRESS_MODE( 2,  Mirror)
-TEXTURE_ADDRESS_MODE( 3,  Clamp)
-TEXTURE_ADDRESS_MODE( 4,  Border)
-TEXTURE_ADDRESS_MODE( 5,  MirrorOnce)
+TEXTURE_ADDRESS_MODE(1,  Wrap)
+TEXTURE_ADDRESS_MODE(2,  Mirror)
+TEXTURE_ADDRESS_MODE(3,  Clamp)
+TEXTURE_ADDRESS_MODE(4,  Border)
+TEXTURE_ADDRESS_MODE(5,  MirrorOnce)
+
 #undef TEXTURE_ADDRESS_MODE
 #endif // TEXTURE_ADDRESS_MODE
 
-#ifdef COMPARISON_FUNCTION
+// COMPARISON_FUNC(value, enum).
+#ifdef COMPARISON_FUNC
+
+COMPARISON_FUNC(1,  Never)
+COMPARISON_FUNC(2,  Less)
+COMPARISON_FUNC(3,  Equal)
+COMPARISON_FUNC(4,  LessEqual)
+COMPARISON_FUNC(5,  Greater)
+COMPARISON_FUNC(6,  NotEqual)
+COMPARISON_FUNC(7,  GreaterEqual)
+COMPARISON_FUNC(8,  Always)
 
-COMPARISON_FUNCTION( 1,  Never)
-COMPARISON_FUNCTION( 2,  Less)
-COMPARISON_FUNCTION( 3,  Equal)
-COMPARISON_FUNCTION( 4,  LessEqual)
-COMPARISON_FUNCTION( 5,  Greater)
-COMPARISON_FUNCTION( 6,  NotEqual)
-COMPARISON_FUNCTION( 7,  GreaterEqual)
-COMPARISON_FUNCTION( 8,  Always)
-#undef COMPARISON_FUNCTION
-#endif // COMPARISON_FUNCTION
+#undef COMPARISON_FUNC
+#endif // COMPARISON_FUNC
 
+// STATIC_BORDER_COLOR(value, enum).
 #ifdef STATIC_BORDER_COLOR
-STATIC_BORDER_COLOR( 0,  TransparentBlack)
-STATIC_BORDER_COLOR( 1,  OpaqueBlack)
-STATIC_BORDER_COLOR( 2,  OpaqueWhite)
-STATIC_BORDER_COLOR( 3,  OpaqueBlackUint)
-STATIC_BORDER_COLOR( 4,  OpaqueWhiteUint)
+
+STATIC_BORDER_COLOR(0,  TransparentBlack)
+STATIC_BORDER_COLOR(1,  OpaqueBlack)
+STATIC_BORDER_COLOR(2,  OpaqueWhite)
+STATIC_BORDER_COLOR(3,  OpaqueBlackUint)
+STATIC_BORDER_COLOR(4,  OpaqueWhiteUint)
+
 #undef STATIC_BORDER_COLOR
 #endif // STATIC_BORDER_COLOR
 

diff  --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h 
b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
index 9dfbd3cb68928..3e959829a20bf 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
@@ -14,6 +14,7 @@
 #ifndef LLVM_FRONTEND_HLSL_HLSLROOTSIGNATURE_H
 #define LLVM_FRONTEND_HLSL_HLSLROOTSIGNATURE_H
 
+#include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DXILABI.h"
 #include <limits>
@@ -23,126 +24,6 @@ namespace llvm {
 namespace hlsl {
 namespace rootsig {
 
-// Definition of the various enumerations and flags. The definitions of all
-// values here correspond to their description in the d3d12.h header and are
-// carried over from their values in DXC. For reference:
-// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
-
-enum class RootFlags : uint32_t {
-  None = 0,
-  AllowInputAssemblerInputLayout = 0x1,
-  DenyVertexShaderRootAccess = 0x2,
-  DenyHullShaderRootAccess = 0x4,
-  DenyDomainShaderRootAccess = 0x8,
-  DenyGeometryShaderRootAccess = 0x10,
-  DenyPixelShaderRootAccess = 0x20,
-  AllowStreamOutput = 0x40,
-  LocalRootSignature = 0x80,
-  DenyAmplificationShaderRootAccess = 0x100,
-  DenyMeshShaderRootAccess = 0x200,
-  CBVSRVUAVHeapDirectlyIndexed = 0x400,
-  SamplerHeapDirectlyIndexed = 0x800,
-  ValidFlags = 0x00000fff
-};
-
-enum class RootDescriptorFlags : unsigned {
-  None = 0,
-  DataVolatile = 0x2,
-  DataStaticWhileSetAtExecute = 0x4,
-  DataStatic = 0x8,
-  ValidFlags = 0xe,
-};
-
-enum class DescriptorRangeFlags : unsigned {
-  None = 0,
-  DescriptorsVolatile = 0x1,
-  DataVolatile = 0x2,
-  DataStaticWhileSetAtExecute = 0x4,
-  DataStatic = 0x8,
-  DescriptorsStaticKeepingBufferBoundsChecks = 0x10000,
-  ValidFlags = 0x1000f,
-  ValidSamplerFlags = DescriptorsVolatile,
-};
-
-enum class ShaderVisibility {
-  All = 0,
-  Vertex = 1,
-  Hull = 2,
-  Domain = 3,
-  Geometry = 4,
-  Pixel = 5,
-  Amplification = 6,
-  Mesh = 7,
-};
-
-// D3D12_FILTER enumeration:
-// 
https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_filter
-enum class SamplerFilter {
-  MinMagMipPoint = 0,
-  MinMagPointMipLinear = 0x1,
-  MinPointMagLinearMipPoint = 0x4,
-  MinPointMagMipLinear = 0x5,
-  MinLinearMagMipPoint = 0x10,
-  MinLinearMagPointMipLinear = 0x11,
-  MinMagLinearMipPoint = 0x14,
-  MinMagMipLinear = 0x15,
-  Anisotropic = 0x55,
-  ComparisonMinMagMipPoint = 0x80,
-  ComparisonMinMagPointMipLinear = 0x81,
-  ComparisonMinPointMagLinearMipPoint = 0x84,
-  ComparisonMinPointMagMipLinear = 0x85,
-  ComparisonMinLinearMagMipPoint = 0x90,
-  ComparisonMinLinearMagPointMipLinear = 0x91,
-  ComparisonMinMagLinearMipPoint = 0x94,
-  ComparisonMinMagMipLinear = 0x95,
-  ComparisonAnisotropic = 0xd5,
-  MinimumMinMagMipPoint = 0x100,
-  MinimumMinMagPointMipLinear = 0x101,
-  MinimumMinPointMagLinearMipPoint = 0x104,
-  MinimumMinPointMagMipLinear = 0x105,
-  MinimumMinLinearMagMipPoint = 0x110,
-  MinimumMinLinearMagPointMipLinear = 0x111,
-  MinimumMinMagLinearMipPoint = 0x114,
-  MinimumMinMagMipLinear = 0x115,
-  MinimumAnisotropic = 0x155,
-  MaximumMinMagMipPoint = 0x180,
-  MaximumMinMagPointMipLinear = 0x181,
-  MaximumMinPointMagLinearMipPoint = 0x184,
-  MaximumMinPointMagMipLinear = 0x185,
-  MaximumMinLinearMagMipPoint = 0x190,
-  MaximumMinLinearMagPointMipLinear = 0x191,
-  MaximumMinMagLinearMipPoint = 0x194,
-  MaximumMinMagMipLinear = 0x195,
-  MaximumAnisotropic = 0x1d5
-};
-
-enum class TextureAddressMode {
-  Wrap = 1,
-  Mirror = 2,
-  Clamp = 3,
-  Border = 4,
-  MirrorOnce = 5
-};
-
-enum class ComparisonFunc : unsigned {
-  Never = 1,
-  Less = 2,
-  Equal = 3,
-  LessEqual = 4,
-  Greater = 5,
-  NotEqual = 6,
-  GreaterEqual = 7,
-  Always = 8
-};
-
-enum class StaticBorderColor {
-  TransparentBlack = 0,
-  OpaqueBlack = 1,
-  OpaqueWhite = 2,
-  OpaqueBlackUint = 3,
-  OpaqueWhiteUint = 4
-};
-
 // Definitions of the in-memory data layout structures
 
 // Models the 
diff erent registers: bReg | tReg | uReg | sReg
@@ -157,7 +38,7 @@ struct RootConstants {
   uint32_t Num32BitConstants;
   Register Reg;
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
 };
 
 enum class DescriptorType : uint8_t { SRV = 0, UAV, CBuffer };
@@ -166,17 +47,17 @@ struct RootDescriptor {
   DescriptorType Type;
   Register Reg;
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
-  RootDescriptorFlags Flags;
+  dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
+  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;
     }
   }
@@ -184,7 +65,7 @@ struct RootDescriptor {
 
 // Models the end of a descriptor table and stores its visibility
 struct DescriptorTable {
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
   // Denotes that the previous NumClauses in the RootElement array
   // are the clauses in the table.
   uint32_t NumClauses = 0;
@@ -200,19 +81,19 @@ struct DescriptorTableClause {
   uint32_t NumDescriptors = 1;
   uint32_t Space = 0;
   uint32_t Offset = DescriptorTableOffsetAppend;
-  DescriptorRangeFlags Flags;
+  dxbc::DescriptorRangeFlags Flags;
 
   void setDefaultFlags() {
     switch (Type) {
     case ClauseType::CBuffer:
     case ClauseType::SRV:
-      Flags = DescriptorRangeFlags::DataStaticWhileSetAtExecute;
+      Flags = dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute;
       break;
     case ClauseType::UAV:
-      Flags = DescriptorRangeFlags::DataVolatile;
+      Flags = dxbc::DescriptorRangeFlags::DataVolatile;
       break;
     case ClauseType::Sampler:
-      Flags = DescriptorRangeFlags::None;
+      Flags = dxbc::DescriptorRangeFlags::None;
       break;
     }
   }
@@ -220,18 +101,18 @@ struct DescriptorTableClause {
 
 struct StaticSampler {
   Register Reg;
-  SamplerFilter Filter = SamplerFilter::Anisotropic;
-  TextureAddressMode AddressU = TextureAddressMode::Wrap;
-  TextureAddressMode AddressV = TextureAddressMode::Wrap;
-  TextureAddressMode AddressW = TextureAddressMode::Wrap;
+  dxbc::SamplerFilter Filter = dxbc::SamplerFilter::Anisotropic;
+  dxbc::TextureAddressMode AddressU = dxbc::TextureAddressMode::Wrap;
+  dxbc::TextureAddressMode AddressV = dxbc::TextureAddressMode::Wrap;
+  dxbc::TextureAddressMode AddressW = dxbc::TextureAddressMode::Wrap;
   float MipLODBias = 0.f;
   uint32_t MaxAnisotropy = 16;
-  ComparisonFunc CompFunc = ComparisonFunc::LessEqual;
-  StaticBorderColor BorderColor = StaticBorderColor::OpaqueWhite;
+  dxbc::ComparisonFunc CompFunc = dxbc::ComparisonFunc::LessEqual;
+  dxbc::StaticBorderColor BorderColor = dxbc::StaticBorderColor::OpaqueWhite;
   float MinLOD = 0.f;
   float MaxLOD = std::numeric_limits<float>::max();
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
 };
 
 /// Models RootElement : RootFlags | RootConstants | RootParam
@@ -251,8 +132,8 @@ struct StaticSampler {
 /// RootElements in the array, and it holds a data member for the Visibility
 /// parameter.
 using RootElement =
-    std::variant<RootFlags, RootConstants, RootDescriptor, DescriptorTable,
-                 DescriptorTableClause, StaticSampler>;
+    std::variant<dxbc::RootFlags, RootConstants, RootDescriptor,
+                 DescriptorTable, DescriptorTableClause, StaticSampler>;
 
 } // namespace rootsig
 } // namespace hlsl

diff  --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h 
b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
index 43c8805ce06b6..ed6e5e5447a61 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
@@ -28,7 +28,7 @@ class Metadata;
 namespace hlsl {
 namespace rootsig {
 
-LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const dxbc::RootFlags 
&Flags);
 
 LLVM_ABI raw_ostream &operator<<(raw_ostream &OS,
                                  const RootConstants &Constants);
@@ -61,7 +61,7 @@ class MetadataBuilder {
 
 private:
   /// Define the various builders for the 
diff erent metadata types
-  MDNode *BuildRootFlags(const RootFlags &Flags);
+  MDNode *BuildRootFlags(const dxbc::RootFlags &Flags);
   MDNode *BuildRootConstants(const RootConstants &Constants);
   MDNode *BuildRootDescriptor(const RootDescriptor &Descriptor);
   MDNode *BuildDescriptorTable(const DescriptorTable &Table);
@@ -83,7 +83,7 @@ struct RangeInfo {
   // Information retained for diagnostics
   llvm::dxil::ResourceClass Class;
   uint32_t Space;
-  ShaderVisibility Visibility;
+  dxbc::ShaderVisibility Visibility;
 };
 
 class ResourceRange {

diff  --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h 
b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
index c235112dacf7c..7e0a4c6b07039 100644
--- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
+++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
@@ -87,7 +87,7 @@ struct RootDescriptorYaml {
 
   LLVM_ABI uint32_t getEncodedFlags() const;
 
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) bool Val = false;
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) bool Enum = false;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 };
 
@@ -100,7 +100,7 @@ struct DescriptorRangeYaml {
 
   LLVM_ABI uint32_t getEncodedFlags() const;
 
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) bool Val = false;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) bool Enum = false;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 };
 
@@ -165,16 +165,16 @@ struct RootParameterYamlDesc {
 };
 
 struct StaticSamplerYamlDesc {
-  uint32_t Filter = 
llvm::to_underlying(dxbc::StaticSamplerFilter::ANISOTROPIC);
+  uint32_t Filter = llvm::to_underlying(dxbc::SamplerFilter::Anisotropic);
   uint32_t AddressU = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
   uint32_t AddressV = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
   uint32_t AddressW = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
   float MipLODBias = 0.f;
   uint32_t MaxAnisotropy = 16u;
   uint32_t ComparisonFunc =
-      llvm::to_underlying(dxbc::SamplersComparisonFunction::LessEqual);
+      llvm::to_underlying(dxbc::ComparisonFunc::LessEqual);
   uint32_t BorderColor =
-      llvm::to_underlying(dxbc::SamplersBorderColor::OpaqueWhite);
+      llvm::to_underlying(dxbc::StaticBorderColor::OpaqueWhite);
   float MinLOD = 0.f;
   float MaxLOD = std::numeric_limits<float>::max();
   uint32_t ShaderRegister;
@@ -203,7 +203,7 @@ struct RootSignatureYamlDesc {
   LLVM_ABI static llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
   create(const object::DirectX::RootSignature &Data);
 
-#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false;
+#define ROOT_SIGNATURE_FLAG(Num, Val) bool Val = false;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 };
 

diff  --git a/llvm/lib/BinaryFormat/DXContainer.cpp 
b/llvm/lib/BinaryFormat/DXContainer.cpp
index 8e7b7d313706a..36d10d0b63078 100644
--- a/llvm/lib/BinaryFormat/DXContainer.cpp
+++ b/llvm/lib/BinaryFormat/DXContainer.cpp
@@ -60,6 +60,35 @@ ArrayRef<EnumEntry<SigComponentType>> 
dxbc::getSigComponentTypes() {
   return ArrayRef(SigComponentTypes);
 }
 
+static const EnumEntry<RootFlags> RootFlagNames[] = {
+#define ROOT_SIGNATURE_FLAG(Val, Enum) {#Enum, RootFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootFlags>> dxbc::getRootFlags() {
+  return ArrayRef(RootFlagNames);
+}
+
+static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = {
+#define ROOT_DESCRIPTOR_FLAG(Val, Enum, Flag)                                  
\
+  {#Enum, RootDescriptorFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootDescriptorFlags>> dxbc::getRootDescriptorFlags() {
+  return ArrayRef(RootDescriptorFlagNames);
+}
+
+static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
+#define DESCRIPTOR_RANGE_FLAG(Val, Enum, Flag)                                 
\
+  {#Enum, DescriptorRangeFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<DescriptorRangeFlags>> dxbc::getDescriptorRangeFlags() {
+  return ArrayRef(DescriptorRangeFlagNames);
+}
+
 #define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibility::Enum},
 
 static const EnumEntry<ShaderVisibility> ShaderVisibilityValues[] = {
@@ -70,6 +99,46 @@ ArrayRef<EnumEntry<ShaderVisibility>> 
dxbc::getShaderVisibility() {
   return ArrayRef(ShaderVisibilityValues);
 }
 
+#define FILTER(Val, Enum) {#Enum, SamplerFilter::Enum},
+
+static const EnumEntry<SamplerFilter> SamplerFilterNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<SamplerFilter>> dxbc::getSamplerFilters() {
+  return ArrayRef(SamplerFilterNames);
+}
+
+#define TEXTURE_ADDRESS_MODE(Val, Enum) {#Enum, TextureAddressMode::Enum},
+
+static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<TextureAddressMode>> dxbc::getTextureAddressModes() {
+  return ArrayRef(TextureAddressModeNames);
+}
+
+#define COMPARISON_FUNC(Val, Enum) {#Enum, ComparisonFunc::Enum},
+
+static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<ComparisonFunc>> dxbc::getComparisonFuncs() {
+  return ArrayRef(ComparisonFuncNames);
+}
+
+#define STATIC_BORDER_COLOR(Val, Enum) {#Enum, StaticBorderColor::Enum},
+
+static const EnumEntry<StaticBorderColor> StaticBorderColorValues[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<StaticBorderColor>> dxbc::getStaticBorderColors() {
+  return ArrayRef(StaticBorderColorValues);
+}
+
 #define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum},
 
 static const EnumEntry<RootParameterType> RootParameterTypes[] = {

diff  --git a/llvm/lib/Frontend/HLSL/CMakeLists.txt 
b/llvm/lib/Frontend/HLSL/CMakeLists.txt
index dfebe354807bf..8928144730477 100644
--- a/llvm/lib/Frontend/HLSL/CMakeLists.txt
+++ b/llvm/lib/Frontend/HLSL/CMakeLists.txt
@@ -11,6 +11,7 @@ add_llvm_component_library(LLVMFrontendHLSL
   intrinsics_gen
 
   LINK_COMPONENTS
+  BinaryFormat
   Core
   Support
   )

diff  --git a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp 
b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
index 22a761ba3b135..67f512008b069 100644
--- a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
+++ b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
@@ -80,123 +80,37 @@ static raw_ostream &operator<<(raw_ostream &OS, const 
Register &Reg) {
   return OS;
 }
 
-static const EnumEntry<ShaderVisibility> VisibilityNames[] = {
-    {"All", ShaderVisibility::All},
-    {"Vertex", ShaderVisibility::Vertex},
-    {"Hull", ShaderVisibility::Hull},
-    {"Domain", ShaderVisibility::Domain},
-    {"Geometry", ShaderVisibility::Geometry},
-    {"Pixel", ShaderVisibility::Pixel},
-    {"Amplification", ShaderVisibility::Amplification},
-    {"Mesh", ShaderVisibility::Mesh},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const ShaderVisibility &Visibility) {
-  printEnum(OS, Visibility, ArrayRef(VisibilityNames));
+                               const llvm::dxbc::ShaderVisibility &Visibility) 
{
+  printEnum(OS, Visibility, dxbc::getShaderVisibility());
 
   return OS;
 }
 
-static const EnumEntry<SamplerFilter> SamplerFilterNames[] = {
-    {"MinMagMipPoint", SamplerFilter::MinMagMipPoint},
-    {"MinMagPointMipLinear", SamplerFilter::MinMagPointMipLinear},
-    {"MinPointMagLinearMipPoint", SamplerFilter::MinPointMagLinearMipPoint},
-    {"MinPointMagMipLinear", SamplerFilter::MinPointMagMipLinear},
-    {"MinLinearMagMipPoint", SamplerFilter::MinLinearMagMipPoint},
-    {"MinLinearMagPointMipLinear", SamplerFilter::MinLinearMagPointMipLinear},
-    {"MinMagLinearMipPoint", SamplerFilter::MinMagLinearMipPoint},
-    {"MinMagMipLinear", SamplerFilter::MinMagMipLinear},
-    {"Anisotropic", SamplerFilter::Anisotropic},
-    {"ComparisonMinMagMipPoint", SamplerFilter::ComparisonMinMagMipPoint},
-    {"ComparisonMinMagPointMipLinear",
-     SamplerFilter::ComparisonMinMagPointMipLinear},
-    {"ComparisonMinPointMagLinearMipPoint",
-     SamplerFilter::ComparisonMinPointMagLinearMipPoint},
-    {"ComparisonMinPointMagMipLinear",
-     SamplerFilter::ComparisonMinPointMagMipLinear},
-    {"ComparisonMinLinearMagMipPoint",
-     SamplerFilter::ComparisonMinLinearMagMipPoint},
-    {"ComparisonMinLinearMagPointMipLinear",
-     SamplerFilter::ComparisonMinLinearMagPointMipLinear},
-    {"ComparisonMinMagLinearMipPoint",
-     SamplerFilter::ComparisonMinMagLinearMipPoint},
-    {"ComparisonMinMagMipLinear", SamplerFilter::ComparisonMinMagMipLinear},
-    {"ComparisonAnisotropic", SamplerFilter::ComparisonAnisotropic},
-    {"MinimumMinMagMipPoint", SamplerFilter::MinimumMinMagMipPoint},
-    {"MinimumMinMagPointMipLinear", 
SamplerFilter::MinimumMinMagPointMipLinear},
-    {"MinimumMinPointMagLinearMipPoint",
-     SamplerFilter::MinimumMinPointMagLinearMipPoint},
-    {"MinimumMinPointMagMipLinear", 
SamplerFilter::MinimumMinPointMagMipLinear},
-    {"MinimumMinLinearMagMipPoint", 
SamplerFilter::MinimumMinLinearMagMipPoint},
-    {"MinimumMinLinearMagPointMipLinear",
-     SamplerFilter::MinimumMinLinearMagPointMipLinear},
-    {"MinimumMinMagLinearMipPoint", 
SamplerFilter::MinimumMinMagLinearMipPoint},
-    {"MinimumMinMagMipLinear", SamplerFilter::MinimumMinMagMipLinear},
-    {"MinimumAnisotropic", SamplerFilter::MinimumAnisotropic},
-    {"MaximumMinMagMipPoint", SamplerFilter::MaximumMinMagMipPoint},
-    {"MaximumMinMagPointMipLinear", 
SamplerFilter::MaximumMinMagPointMipLinear},
-    {"MaximumMinPointMagLinearMipPoint",
-     SamplerFilter::MaximumMinPointMagLinearMipPoint},
-    {"MaximumMinPointMagMipLinear", 
SamplerFilter::MaximumMinPointMagMipLinear},
-    {"MaximumMinLinearMagMipPoint", 
SamplerFilter::MaximumMinLinearMagMipPoint},
-    {"MaximumMinLinearMagPointMipLinear",
-     SamplerFilter::MaximumMinLinearMagPointMipLinear},
-    {"MaximumMinMagLinearMipPoint", 
SamplerFilter::MaximumMinMagLinearMipPoint},
-    {"MaximumMinMagMipLinear", SamplerFilter::MaximumMinMagMipLinear},
-    {"MaximumAnisotropic", SamplerFilter::MaximumAnisotropic},
-};
-
-static raw_ostream &operator<<(raw_ostream &OS, const SamplerFilter &Filter) {
-  printEnum(OS, Filter, ArrayRef(SamplerFilterNames));
+static raw_ostream &operator<<(raw_ostream &OS,
+                               const llvm::dxbc::SamplerFilter &Filter) {
+  printEnum(OS, Filter, dxbc::getSamplerFilters());
 
   return OS;
 }
 
-static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = {
-    {"Wrap", TextureAddressMode::Wrap},
-    {"Mirror", TextureAddressMode::Mirror},
-    {"Clamp", TextureAddressMode::Clamp},
-    {"Border", TextureAddressMode::Border},
-    {"MirrorOnce", TextureAddressMode::MirrorOnce},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const TextureAddressMode &Address) {
-  printEnum(OS, Address, ArrayRef(TextureAddressModeNames));
+                               const dxbc::TextureAddressMode &Address) {
+  printEnum(OS, Address, dxbc::getTextureAddressModes());
 
   return OS;
 }
 
-static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = {
-    {"Never", ComparisonFunc::Never},
-    {"Less", ComparisonFunc::Less},
-    {"Equal", ComparisonFunc::Equal},
-    {"LessEqual", ComparisonFunc::LessEqual},
-    {"Greater", ComparisonFunc::Greater},
-    {"NotEqual", ComparisonFunc::NotEqual},
-    {"GreaterEqual", ComparisonFunc::GreaterEqual},
-    {"Always", ComparisonFunc::Always},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const ComparisonFunc &CompFunc) {
-  printEnum(OS, CompFunc, ArrayRef(ComparisonFuncNames));
+                               const dxbc::ComparisonFunc &CompFunc) {
+  printEnum(OS, CompFunc, dxbc::getComparisonFuncs());
 
   return OS;
 }
 
-static const EnumEntry<StaticBorderColor> StaticBorderColorNames[] = {
-    {"TransparentBlack", StaticBorderColor::TransparentBlack},
-    {"OpaqueBlack", StaticBorderColor::OpaqueBlack},
-    {"OpaqueWhite", StaticBorderColor::OpaqueWhite},
-    {"OpaqueBlackUint", StaticBorderColor::OpaqueBlackUint},
-    {"OpaqueWhiteUint", StaticBorderColor::OpaqueWhiteUint},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const StaticBorderColor &BorderColor) {
-  printEnum(OS, BorderColor, ArrayRef(StaticBorderColorNames));
+                               const dxbc::StaticBorderColor &BorderColor) {
+  printEnum(OS, BorderColor, dxbc::getStaticBorderColors());
 
   return OS;
 }
@@ -215,57 +129,23 @@ 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;
 }
 
-static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
-    {"DescriptorsVolatile", DescriptorRangeFlags::DescriptorsVolatile},
-    {"DataVolatile", DescriptorRangeFlags::DataVolatile},
-    {"DataStaticWhileSetAtExecute",
-     DescriptorRangeFlags::DataStaticWhileSetAtExecute},
-    {"DataStatic", DescriptorRangeFlags::DataStatic},
-    {"DescriptorsStaticKeepingBufferBoundsChecks",
-     DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks},
-};
-
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const DescriptorRangeFlags &Flags) {
-  printFlags(OS, Flags, ArrayRef(DescriptorRangeFlagNames));
+                               const llvm::dxbc::DescriptorRangeFlags &Flags) {
+  printFlags(OS, Flags, dxbc::getDescriptorRangeFlags());
 
   return OS;
 }
 
-static const EnumEntry<RootFlags> RootFlagNames[] = {
-    {"AllowInputAssemblerInputLayout",
-     RootFlags::AllowInputAssemblerInputLayout},
-    {"DenyVertexShaderRootAccess", RootFlags::DenyVertexShaderRootAccess},
-    {"DenyHullShaderRootAccess", RootFlags::DenyHullShaderRootAccess},
-    {"DenyDomainShaderRootAccess", RootFlags::DenyDomainShaderRootAccess},
-    {"DenyGeometryShaderRootAccess", RootFlags::DenyGeometryShaderRootAccess},
-    {"DenyPixelShaderRootAccess", RootFlags::DenyPixelShaderRootAccess},
-    {"AllowStreamOutput", RootFlags::AllowStreamOutput},
-    {"LocalRootSignature", RootFlags::LocalRootSignature},
-    {"DenyAmplificationShaderRootAccess",
-     RootFlags::DenyAmplificationShaderRootAccess},
-    {"DenyMeshShaderRootAccess", RootFlags::DenyMeshShaderRootAccess},
-    {"CBVSRVUAVHeapDirectlyIndexed", RootFlags::CBVSRVUAVHeapDirectlyIndexed},
-    {"SamplerHeapDirectlyIndexed", RootFlags::SamplerHeapDirectlyIndexed},
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags) {
+raw_ostream &operator<<(raw_ostream &OS, const dxbc::RootFlags &Flags) {
   OS << "RootFlags(";
-  printFlags(OS, Flags, ArrayRef(RootFlagNames));
+  printFlags(OS, Flags, dxbc::getRootFlags());
   OS << ")";
 
   return OS;
@@ -341,7 +221,7 @@ template <class... Ts> OverloadedVisit(Ts...) -> 
OverloadedVisit<Ts...>;
 
 raw_ostream &operator<<(raw_ostream &OS, const RootElement &Element) {
   const auto Visitor = OverloadedVisit{
-      [&OS](const RootFlags &Flags) { OS << Flags; },
+      [&OS](const dxbc::RootFlags &Flags) { OS << Flags; },
       [&OS](const RootConstants &Constants) { OS << Constants; },
       [&OS](const RootDescriptor &Descriptor) { OS << Descriptor; },
       [&OS](const DescriptorTableClause &Clause) { OS << Clause; },
@@ -366,7 +246,7 @@ void dumpRootElements(raw_ostream &OS, 
ArrayRef<RootElement> Elements) {
 
 MDNode *MetadataBuilder::BuildRootSignature() {
   const auto Visitor = OverloadedVisit{
-      [this](const RootFlags &Flags) -> MDNode * {
+      [this](const dxbc::RootFlags &Flags) -> MDNode * {
         return BuildRootFlags(Flags);
       },
       [this](const RootConstants &Constants) -> MDNode * {
@@ -396,7 +276,7 @@ MDNode *MetadataBuilder::BuildRootSignature() {
   return MDNode::get(Ctx, GeneratedMetadata);
 }
 
-MDNode *MetadataBuilder::BuildRootFlags(const RootFlags &Flags) {
+MDNode *MetadataBuilder::BuildRootFlags(const dxbc::RootFlags &Flags) {
   IRBuilder<> Builder(Ctx);
   Metadata *Operands[] = {
       MDString::get(Ctx, "RootFlags"),

diff  --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp 
b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
index f6d0e5227e64a..263f7bdf37bca 100644
--- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp
+++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
@@ -63,9 +63,9 @@ readDescriptorRanges(DXContainerYAML::RootParameterHeaderYaml 
&Header,
     NewR.RangeType = R.RangeType;
     if constexpr (std::is_same_v<T, dxbc::RTS0::v2::DescriptorRange>) {
       // Set all flag fields for v2
-#define DESCRIPTOR_RANGE_FLAG(Num, Val)                                        
\
-  NewR.Val =                                                                   
\
-      (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) != 0;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag)                                 
\
+  NewR.Enum =                                                                  
\
+      (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlags::Enum)) != 0;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
     }
     TableYaml.Ranges.push_back(NewR);
@@ -140,10 +140,10 @@ DXContainerYAML::RootSignatureYamlDesc::create(
       YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister;
       YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace;
       if (Version > 1) {
-#define ROOT_DESCRIPTOR_FLAG(Num, Val)                                         
\
-  YamlDescriptor.Val =                                                         
\
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag)                                  
\
+  YamlDescriptor.Enum =                                                        
\
       (Descriptor.Flags &                                                      
\
-       llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0;
+       llvm::to_underlying(dxbc::RootDescriptorFlags::Enum)) > 0;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
       }
     } else if (auto *DTV =
@@ -180,38 +180,37 @@ DXContainerYAML::RootSignatureYamlDesc::create(
     RootSigDesc.StaticSamplers.push_back(NewS);
   }
 
-#define ROOT_ELEMENT_FLAG(Num, Val)                                            
\
-  RootSigDesc.Val =                                                            
\
-      (Flags & llvm::to_underlying(dxbc::RootElementFlag::Val)) > 0;
+#define ROOT_SIGNATURE_FLAG(Num, Val)                                          
\
+  RootSigDesc.Val = (Flags & llvm::to_underlying(dxbc::RootFlags::Val)) > 0;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
   return RootSigDesc;
 }
 
 uint32_t DXContainerYAML::RootDescriptorYaml::getEncodedFlags() const {
-  uint64_t Flag = 0;
-#define ROOT_DESCRIPTOR_FLAG(Num, Val)                                         
\
-  if (Val)                                                                     
\
-    Flag |= (uint32_t)dxbc::RootDescriptorFlag::Val;
+  uint64_t Flags = 0;
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag)                                  
\
+  if (Enum)                                                                    
\
+    Flags |= (uint32_t)dxbc::RootDescriptorFlags::Enum;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-  return Flag;
+  return Flags;
 }
 
 uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() {
   uint64_t Flag = 0;
-#define ROOT_ELEMENT_FLAG(Num, Val)                                            
\
+#define ROOT_SIGNATURE_FLAG(Num, Val)                                          
\
   if (Val)                                                                     
\
-    Flag |= (uint32_t)dxbc::RootElementFlag::Val;
+    Flag |= (uint32_t)dxbc::RootFlags::Val;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
   return Flag;
 }
 
 uint32_t DXContainerYAML::DescriptorRangeYaml::getEncodedFlags() const {
-  uint64_t Flag = 0;
-#define DESCRIPTOR_RANGE_FLAG(Num, Val)                                        
\
-  if (Val)                                                                     
\
-    Flag |= (uint32_t)dxbc::DescriptorRangeFlag::Val;
+  uint64_t Flags = 0;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag)                                 
\
+  if (Enum)                                                                    
\
+    Flags |= (uint32_t)dxbc::DescriptorRangeFlags::Enum;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
-  return Flag;
+  return Flags;
 }
 
 uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() {
@@ -382,7 +381,7 @@ void 
MappingTraits<DXContainerYAML::RootSignatureYamlDesc>::mapping(
   IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset);
   IO.mapRequired("Parameters", S.Parameters.Locations, S);
   IO.mapOptional("Samplers", S.StaticSamplers);
-#define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);
+#define ROOT_SIGNATURE_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
@@ -406,7 +405,8 @@ void 
MappingTraits<llvm::DXContainerYAML::DescriptorRangeYaml>::mapping(
   IO.mapRequired("RegisterSpace", R.RegisterSpace);
   IO.mapRequired("OffsetInDescriptorsFromTableStart",
                  R.OffsetInDescriptorsFromTableStart);
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) IO.mapOptional(#Val, R.Val, false);
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag)                                 
\
+  IO.mapOptional(#Flag, R.Enum, false);
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
@@ -459,7 +459,8 @@ void 
MappingTraits<llvm::DXContainerYAML::RootDescriptorYaml>::mapping(
     IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) {
   IO.mapRequired("RegisterSpace", D.RegisterSpace);
   IO.mapRequired("ShaderRegister", D.ShaderRegister);
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false);
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag)                                  
\
+  IO.mapOptional(#Flag, D.Enum, false);
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 

diff  --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp 
b/llvm/lib/Target/DirectX/DXILRootSignature.cpp
index 2dccc0d5b2b3e..5e0975736f90d 100644
--- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp
+++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp
@@ -431,7 +431,7 @@ static bool verifyRangeType(uint32_t Type) {
 
 static bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type,
                                       uint32_t FlagsVal) {
-  using FlagT = dxbc::DescriptorRangeFlag;
+  using FlagT = dxbc::DescriptorRangeFlags;
   FlagT Flags = FlagT(FlagsVal);
 
   const bool IsSampler =
@@ -441,61 +441,59 @@ static bool verifyDescriptorRangeFlag(uint32_t Version, 
uint32_t Type,
     // Since the metadata is unversioned, we expect to explicitly see the 
values
     // that map to the version 1 behaviour here.
     if (IsSampler)
-      return Flags == FlagT::DESCRIPTORS_VOLATILE;
-    return Flags == (FlagT::DATA_VOLATILE | FlagT::DESCRIPTORS_VOLATILE);
+      return Flags == FlagT::DescriptorsVolatile;
+    return Flags == (FlagT::DataVolatile | FlagT::DescriptorsVolatile);
   }
 
   // The data-specific flags are mutually exclusive.
-  FlagT DataFlags = FlagT::DATA_VOLATILE | FlagT::DATA_STATIC |
-                    FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+  FlagT DataFlags = FlagT::DataVolatile | FlagT::DataStatic |
+                    FlagT::DataStaticWhileSetAtExecute;
 
   if (popcount(llvm::to_underlying(Flags & DataFlags)) > 1)
     return false;
 
   // The descriptor-specific flags are mutually exclusive.
-  FlagT DescriptorFlags =
-      FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS |
-      FlagT::DESCRIPTORS_VOLATILE;
+  FlagT DescriptorFlags = FlagT::DescriptorsStaticKeepingBufferBoundsChecks |
+                          FlagT::DescriptorsVolatile;
   if (popcount(llvm::to_underlying(Flags & DescriptorFlags)) > 1)
     return false;
 
   // For volatile descriptors, DATA_STATIC is never valid.
-  if ((Flags & FlagT::DESCRIPTORS_VOLATILE) == FlagT::DESCRIPTORS_VOLATILE) {
-    FlagT Mask = FlagT::DESCRIPTORS_VOLATILE;
+  if ((Flags & FlagT::DescriptorsVolatile) == FlagT::DescriptorsVolatile) {
+    FlagT Mask = FlagT::DescriptorsVolatile;
     if (!IsSampler) {
-      Mask |= FlagT::DATA_VOLATILE;
-      Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+      Mask |= FlagT::DataVolatile;
+      Mask |= FlagT::DataStaticWhileSetAtExecute;
     }
-    return (Flags & ~Mask) == FlagT::NONE;
+    return (Flags & ~Mask) == FlagT::None;
   }
 
   // For "STATIC_KEEPING_BUFFER_BOUNDS_CHECKS" descriptors,
   // the other data-specific flags may all be set.
-  if ((Flags & FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) ==
-      FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) {
-    FlagT Mask = FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS;
+  if ((Flags & FlagT::DescriptorsStaticKeepingBufferBoundsChecks) ==
+      FlagT::DescriptorsStaticKeepingBufferBoundsChecks) {
+    FlagT Mask = FlagT::DescriptorsStaticKeepingBufferBoundsChecks;
     if (!IsSampler) {
-      Mask |= FlagT::DATA_VOLATILE;
-      Mask |= FlagT::DATA_STATIC;
-      Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+      Mask |= FlagT::DataVolatile;
+      Mask |= FlagT::DataStatic;
+      Mask |= FlagT::DataStaticWhileSetAtExecute;
     }
-    return (Flags & ~Mask) == FlagT::NONE;
+    return (Flags & ~Mask) == FlagT::None;
   }
 
   // When no descriptor flag is set, any data flag is allowed.
-  FlagT Mask = FlagT::NONE;
+  FlagT Mask = FlagT::None;
   if (!IsSampler) {
-    Mask |= FlagT::DATA_VOLATILE;
-    Mask |= FlagT::DATA_STATIC;
-    Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+    Mask |= FlagT::DataVolatile;
+    Mask |= FlagT::DataStaticWhileSetAtExecute;
+    Mask |= FlagT::DataStatic;
   }
-  return (Flags & ~Mask) == FlagT::NONE;
+  return (Flags & ~Mask) == FlagT::None;
 }
 
 static bool verifySamplerFilter(uint32_t Value) {
   switch (Value) {
-#define STATIC_SAMPLER_FILTER(Num, Val)                                        
\
-  case llvm::to_underlying(dxbc::StaticSamplerFilter::Val):
+#define FILTER(Num, Val) case llvm::to_underlying(dxbc::SamplerFilter::Val):
 #include "llvm/BinaryFormat/DXContainerConstants.def"
     return true;
   }
@@ -524,8 +522,8 @@ static bool verifyMaxAnisotropy(uint32_t MaxAnisotropy) {
 
 static bool verifyComparisonFunc(uint32_t ComparisonFunc) {
   switch (ComparisonFunc) {
-#define COMPARISON_FUNCTION(Num, Val)                                          
\
-  case llvm::to_underlying(dxbc::SamplersComparisonFunction::Val):
+#define COMPARISON_FUNC(Num, Val)                                              
\
+  case llvm::to_underlying(dxbc::ComparisonFunc::Val):
 #include "llvm/BinaryFormat/DXContainerConstants.def"
     return true;
   }
@@ -535,7 +533,7 @@ static bool verifyComparisonFunc(uint32_t ComparisonFunc) {
 static bool verifyBorderColor(uint32_t BorderColor) {
   switch (BorderColor) {
 #define STATIC_BORDER_COLOR(Num, Val)                                          
\
-  case llvm::to_underlying(dxbc::SamplersBorderColor::Val):
+  case llvm::to_underlying(dxbc::StaticBorderColor::Val):
 #include "llvm/BinaryFormat/DXContainerConstants.def"
     return true;
   }

diff  --git a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp 
b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
index dde82ac34ea28..ca2c296efc99b 100644
--- a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
+++ b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
@@ -37,7 +37,7 @@ TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
   Clause.NumDescriptors = NumDescriptorsUnbounded;
   Clause.Space = 42;
   Clause.Offset = 3;
-  Clause.Flags = DescriptorRangeFlags::None;
+  Clause.Flags = llvm::dxbc::DescriptorRangeFlags::None;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -50,13 +50,20 @@ TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
 }
 
 TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
+  using llvm::dxbc::DescriptorRangeFlags;
   DescriptorTableClause Clause;
   Clause.Type = ClauseType::UAV;
   Clause.Reg = {RegisterType::UReg, 92374};
   Clause.NumDescriptors = 3298;
   Clause.Space = 932847;
   Clause.Offset = 1;
-  Clause.Flags = DescriptorRangeFlags::ValidFlags;
+  auto ValidDescriptorRangeFlags =
+      DescriptorRangeFlags::DescriptorsVolatile |
+      DescriptorRangeFlags::DataVolatile |
+      DescriptorRangeFlags::DataStaticWhileSetAtExecute |
+      DescriptorRangeFlags::DataStatic |
+      DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
+  Clause.Flags = ValidDescriptorRangeFlags;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -80,7 +87,7 @@ TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
   Clause.NumDescriptors = 2;
   Clause.Space = 42;
   Clause.Offset = DescriptorTableOffsetAppend;
-  Clause.Flags = DescriptorRangeFlags::ValidSamplerFlags;
+  Clause.Flags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -96,7 +103,7 @@ TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
 TEST(HLSLRootSignatureTest, DescriptorTableDump) {
   DescriptorTable Table;
   Table.NumClauses = 4;
-  Table.Visibility = ShaderVisibility::Geometry;
+  Table.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -130,8 +137,8 @@ TEST(HLSLRootSignatureTest, RootSRVDump) {
   Descriptor.Type = DescriptorType::SRV;
   Descriptor.Reg = {RegisterType::TReg, 0};
   Descriptor.Space = 42;
-  Descriptor.Visibility = ShaderVisibility::Geometry;
-  Descriptor.Flags = RootDescriptorFlags::None;
+  Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
+  Descriptor.Flags = llvm::dxbc::RootDescriptorFlags::None;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -144,12 +151,17 @@ TEST(HLSLRootSignatureTest, RootSRVDump) {
 }
 
 TEST(HLSLRootSignatureTest, RootUAVDump) {
+  using llvm::dxbc::RootDescriptorFlags;
   RootDescriptor Descriptor;
   Descriptor.Type = DescriptorType::UAV;
   Descriptor.Reg = {RegisterType::UReg, 92374};
   Descriptor.Space = 932847;
-  Descriptor.Visibility = ShaderVisibility::Hull;
-  Descriptor.Flags = RootDescriptorFlags::ValidFlags;
+  Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Hull;
+  auto ValidRootDescriptorFlags =
+      RootDescriptorFlags::DataVolatile |
+      RootDescriptorFlags::DataStaticWhileSetAtExecute |
+      RootDescriptorFlags::DataStatic;
+  Descriptor.Flags = ValidRootDescriptorFlags;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -194,18 +206,18 @@ TEST(HLSLRootSignatureTest, DefinedStaticSamplerDump) {
   StaticSampler Sampler;
   Sampler.Reg = {RegisterType::SReg, 0};
 
-  Sampler.Filter = SamplerFilter::ComparisonMinMagLinearMipPoint;
-  Sampler.AddressU = TextureAddressMode::Mirror;
-  Sampler.AddressV = TextureAddressMode::Border;
-  Sampler.AddressW = TextureAddressMode::Clamp;
+  Sampler.Filter = llvm::dxbc::SamplerFilter::ComparisonMinMagLinearMipPoint;
+  Sampler.AddressU = llvm::dxbc::TextureAddressMode::Mirror;
+  Sampler.AddressV = llvm::dxbc::TextureAddressMode::Border;
+  Sampler.AddressW = llvm::dxbc::TextureAddressMode::Clamp;
   Sampler.MipLODBias = 4.8f;
   Sampler.MaxAnisotropy = 32;
-  Sampler.CompFunc = ComparisonFunc::NotEqual;
-  Sampler.BorderColor = StaticBorderColor::OpaqueBlack;
+  Sampler.CompFunc = llvm::dxbc::ComparisonFunc::NotEqual;
+  Sampler.BorderColor = llvm::dxbc::StaticBorderColor::OpaqueBlack;
   Sampler.MinLOD = 1.0f;
   Sampler.MaxLOD = 32.0f;
   Sampler.Space = 7;
-  Sampler.Visibility = ShaderVisibility::Domain;
+  Sampler.Visibility = llvm::dxbc::ShaderVisibility::Domain;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -249,7 +261,7 @@ TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
   Constants.Num32BitConstants = 983;
   Constants.Reg = {RegisterType::BReg, 34593};
   Constants.Space = 7;
-  Constants.Visibility = ShaderVisibility::Pixel;
+  Constants.Visibility = llvm::dxbc::ShaderVisibility::Pixel;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -262,7 +274,7 @@ TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
 }
 
 TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
-  RootFlags Flags = RootFlags::None;
+  llvm::dxbc::RootFlags Flags = llvm::dxbc::RootFlags::None;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -274,11 +286,23 @@ TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
 }
 
 TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
-  RootFlags Flags = RootFlags::ValidFlags;
+  using llvm::dxbc::RootFlags;
+  auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout |
+                        RootFlags::DenyVertexShaderRootAccess |
+                        RootFlags::DenyHullShaderRootAccess |
+                        RootFlags::DenyDomainShaderRootAccess |
+                        RootFlags::DenyGeometryShaderRootAccess |
+                        RootFlags::DenyPixelShaderRootAccess |
+                        RootFlags::AllowStreamOutput |
+                        RootFlags::LocalRootSignature |
+                        RootFlags::DenyAmplificationShaderRootAccess |
+                        RootFlags::DenyMeshShaderRootAccess |
+                        RootFlags::CBVSRVUAVHeapDirectlyIndexed |
+                        RootFlags::SamplerHeapDirectlyIndexed;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
-  OS << Flags;
+  OS << ValidRootFlags;
   OS.flush();
 
   std::string Expected = "RootFlags("


        
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits

Reply via email to