diff --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h
index afa2c4d8cfe50..e769d657a0e7f 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::dxil::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::dxil::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::dxil::ShaderVisibility> Visibility;
+    std::optional<llvm::dxil::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::dxil::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::dxil::SamplerFilter> Filter;
+    std::optional<llvm::dxil::TextureAddressMode> AddressU;
+    std::optional<llvm::dxil::TextureAddressMode> AddressV;
+    std::optional<llvm::dxil::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::dxil::ComparisonFunc> CompFunc;
+    std::optional<llvm::dxil::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::dxil::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::dxil::ShaderVisibility> parseShaderVisibility();
+  std::optional<llvm::dxil::SamplerFilter> parseSamplerFilter();
+  std::optional<llvm::dxil::TextureAddressMode> parseTextureAddressMode();
+  std::optional<llvm::dxil::ComparisonFunc> parseComparisonFunc();
+  std::optional<llvm::dxil::StaticBorderColor> parseStaticBorderColor();
+  std::optional<llvm::dxil::RootDescriptorFlags> parseRootDescriptorFlags();
+  std::optional<llvm::dxil::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..b6370917bcb3a 100644
--- a/clang/lib/Parse/ParseHLSLRootSignature.cpp
+++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp
@@ -11,6 +11,7 @@
 #include "clang/Lex/LiteralSupport.h"
 
 using namespace llvm::hlsl::rootsig;
+using namespace llvm::dxil;
 
 namespace clang {
 namespace hlsl {
@@ -983,8 +984,7 @@ std::optional<float> RootSignatureParser::parseFloatParam() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::ShaderVisibility>
-RootSignatureParser::parseShaderVisibility() {
+std::optional<ShaderVisibility> RootSignatureParser::parseShaderVisibility() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
 
@@ -1009,8 +1009,7 @@ RootSignatureParser::parseShaderVisibility() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::SamplerFilter>
-RootSignatureParser::parseSamplerFilter() {
+std::optional<SamplerFilter> RootSignatureParser::parseSamplerFilter() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
 
@@ -1035,7 +1034,7 @@ RootSignatureParser::parseSamplerFilter() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::TextureAddressMode>
+std::optional<TextureAddressMode>
 RootSignatureParser::parseTextureAddressMode() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1061,8 +1060,7 @@ RootSignatureParser::parseTextureAddressMode() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::ComparisonFunc>
-RootSignatureParser::parseComparisonFunc() {
+std::optional<ComparisonFunc> RootSignatureParser::parseComparisonFunc() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
 
@@ -1087,8 +1085,7 @@ RootSignatureParser::parseComparisonFunc() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::StaticBorderColor>
-RootSignatureParser::parseStaticBorderColor() {
+std::optional<StaticBorderColor> RootSignatureParser::parseStaticBorderColor() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
 
@@ -1113,7 +1110,7 @@ RootSignatureParser::parseStaticBorderColor() {
   return std::nullopt;
 }
 
-std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
+std::optional<RootDescriptorFlags>
 RootSignatureParser::parseRootDescriptorFlags() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
@@ -1152,7 +1149,7 @@ RootSignatureParser::parseRootDescriptorFlags() {
   return Flags;
 }
 
-std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
+std::optional<DescriptorRangeFlags>
 RootSignatureParser::parseDescriptorRangeFlags() {
   assert(CurToken.TokKind == TokenKind::pu_equal &&
          "Expects to only be invoked starting at given keyword");
diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
index 1e46ee35d5d49..e9fef6aa42623 100644
--- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
+++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
@@ -25,6 +25,7 @@
 #include "gtest/gtest.h"
 
 using namespace clang;
+using namespace llvm::dxil;
 using namespace llvm::hlsl::rootsig;
 
 namespace {
@@ -206,7 +207,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset,
             DescriptorTableOffsetAppend);
   ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags,
-            DescriptorRangeFlags::ValidFlags);
+            DescriptorRangeFlags(0x1000f)); // All valid flags
 
   Elem = Elements[4];
   ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
@@ -404,7 +405,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) {
   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);
+            DescriptorRangeFlags::DescriptorsVolatile); // Valid sampler flags
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
@@ -496,7 +497,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) {
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem));
-  ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::ValidFlags);
+  ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags(0xfff)); // Valid flags
 
   ASSERT_TRUE(Consumer->isSatisfied());
 }
@@ -545,7 +546,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
             ShaderVisibility::Geometry);
   ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
-            RootDescriptorFlags::ValidFlags);
+            RootDescriptorFlags(0xe)); // All valid flags
 
   Elem = Elements[2];
   ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
diff --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
index 2f028817b45b6..2d1e62ea092f3 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
@@ -22,126 +22,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 different registers: bReg | tReg | uReg | sReg
@@ -156,7 +36,7 @@ struct RootConstants {
   uint32_t Num32BitConstants;
   Register Reg;
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxil::ShaderVisibility Visibility = dxil::ShaderVisibility::All;
 };
 
 enum class DescriptorType : uint8_t { SRV = 0, UAV, CBuffer };
@@ -165,17 +45,17 @@ struct RootDescriptor {
   DescriptorType Type;
   Register Reg;
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
-  RootDescriptorFlags Flags;
+  dxil::ShaderVisibility Visibility = dxil::ShaderVisibility::All;
+  dxil::RootDescriptorFlags Flags;
 
   void setDefaultFlags() {
     switch (Type) {
     case DescriptorType::CBuffer:
     case DescriptorType::SRV:
-      Flags = RootDescriptorFlags::DataStaticWhileSetAtExecute;
+      Flags = dxil::RootDescriptorFlags::DataStaticWhileSetAtExecute;
       break;
     case DescriptorType::UAV:
-      Flags = RootDescriptorFlags::DataVolatile;
+      Flags = dxil::RootDescriptorFlags::DataVolatile;
       break;
     }
   }
@@ -183,7 +63,7 @@ struct RootDescriptor {
 
 // Models the end of a descriptor table and stores its visibility
 struct DescriptorTable {
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxil::ShaderVisibility Visibility = dxil::ShaderVisibility::All;
   // Denotes that the previous NumClauses in the RootElement array
   // are the clauses in the table.
   uint32_t NumClauses = 0;
@@ -199,19 +79,19 @@ struct DescriptorTableClause {
   uint32_t NumDescriptors = 1;
   uint32_t Space = 0;
   uint32_t Offset = DescriptorTableOffsetAppend;
-  DescriptorRangeFlags Flags;
+  dxil::DescriptorRangeFlags Flags;
 
   void setDefaultFlags() {
     switch (Type) {
     case ClauseType::CBuffer:
     case ClauseType::SRV:
-      Flags = DescriptorRangeFlags::DataStaticWhileSetAtExecute;
+      Flags = dxil::DescriptorRangeFlags::DataStaticWhileSetAtExecute;
       break;
     case ClauseType::UAV:
-      Flags = DescriptorRangeFlags::DataVolatile;
+      Flags = dxil::DescriptorRangeFlags::DataVolatile;
       break;
     case ClauseType::Sampler:
-      Flags = DescriptorRangeFlags::None;
+      Flags = dxil::DescriptorRangeFlags::None;
       break;
     }
   }
@@ -219,18 +99,18 @@ struct DescriptorTableClause {
 
 struct StaticSampler {
   Register Reg;
-  SamplerFilter Filter = SamplerFilter::Anisotropic;
-  TextureAddressMode AddressU = TextureAddressMode::Wrap;
-  TextureAddressMode AddressV = TextureAddressMode::Wrap;
-  TextureAddressMode AddressW = TextureAddressMode::Wrap;
+  dxil::SamplerFilter Filter = dxil::SamplerFilter::Anisotropic;
+  dxil::TextureAddressMode AddressU = dxil::TextureAddressMode::Wrap;
+  dxil::TextureAddressMode AddressV = dxil::TextureAddressMode::Wrap;
+  dxil::TextureAddressMode AddressW = dxil::TextureAddressMode::Wrap;
   float MipLODBias = 0.f;
   uint32_t MaxAnisotropy = 16;
-  ComparisonFunc CompFunc = ComparisonFunc::LessEqual;
-  StaticBorderColor BorderColor = StaticBorderColor::OpaqueWhite;
+  dxil::ComparisonFunc CompFunc = dxil::ComparisonFunc::LessEqual;
+  dxil::StaticBorderColor BorderColor = dxil::StaticBorderColor::OpaqueWhite;
   float MinLOD = 0.f;
   float MaxLOD = std::numeric_limits<float>::max();
   uint32_t Space = 0;
-  ShaderVisibility Visibility = ShaderVisibility::All;
+  dxil::ShaderVisibility Visibility = dxil::ShaderVisibility::All;
 };
 
 /// Models RootElement : RootFlags | RootConstants | RootParam
@@ -250,8 +130,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<dxil::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 6d959ad5bdc7f..865d8d3f5bf09 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
@@ -47,7 +47,7 @@ class MetadataBuilder {
 
 private:
   /// Define the various builders for the different metadata types
-  MDNode *BuildRootFlags(const RootFlags &Flags);
+  MDNode *BuildRootFlags(const dxil::RootFlags &Flags);
   MDNode *BuildRootConstants(const RootConstants &Constants);
   MDNode *BuildRootDescriptor(const RootDescriptor &Descriptor);
   MDNode *BuildDescriptorTable(const DescriptorTable &Table);
diff --git a/llvm/include/llvm/Support/DXILABI.h b/llvm/include/llvm/Support/DXILABI.h
index b479f7c73eba3..7b4c5452c4850 100644
--- a/llvm/include/llvm/Support/DXILABI.h
+++ b/llvm/include/llvm/Support/DXILABI.h
@@ -99,6 +99,128 @@ enum class SamplerFeedbackType : uint32_t {
 const unsigned MinWaveSize = 4;
 const unsigned MaxWaveSize = 128;
 
+// Definition of the various d3d12.h 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/
+
+// D3D12_ROOT_SIGNATURE_FLAGS
+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,
+};
+
+// D3D12_ROOT_DESCRIPTOR_FLAGS
+enum class RootDescriptorFlags : unsigned {
+  None = 0,
+  DataVolatile = 0x2,
+  DataStaticWhileSetAtExecute = 0x4,
+  DataStatic = 0x8,
+};
+
+// D3D12_DESCRIPTOR_RANGE_FLAGS
+enum class DescriptorRangeFlags : unsigned {
+  None = 0,
+  DescriptorsVolatile = 0x1,
+  DataVolatile = 0x2,
+  DataStaticWhileSetAtExecute = 0x4,
+  DataStatic = 0x8,
+  DescriptorsStaticKeepingBufferBoundsChecks = 0x10000,
+};
+
+// D3D12_SHADER_VISIBILITY
+enum class ShaderVisibility {
+  All = 0,
+  Vertex = 1,
+  Hull = 2,
+  Domain = 3,
+  Geometry = 4,
+  Pixel = 5,
+  Amplification = 6,
+  Mesh = 7,
+};
+
+// 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
+};
+
+// D3D12_TEXTURE_ADDRESS_MODE
+enum class TextureAddressMode {
+  Wrap = 1,
+  Mirror = 2,
+  Clamp = 3,
+  Border = 4,
+  MirrorOnce = 5
+};
+
+// D3D12_COMPARISON_FUNC
+enum class ComparisonFunc : unsigned {
+  Never = 1,
+  Less = 2,
+  Equal = 3,
+  LessEqual = 4,
+  Greater = 5,
+  NotEqual = 6,
+  GreaterEqual = 7,
+  Always = 8
+};
+
+// D3D12_STATIC_BORDER_COLOR
+enum class StaticBorderColor {
+  TransparentBlack = 0,
+  OpaqueBlack = 1,
+  OpaqueWhite = 2,
+  OpaqueBlackUint = 3,
+  OpaqueWhiteUint = 4
+};
+
 } // namespace dxil
 } // namespace llvm
 
diff --git a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
index 765a3bcbed7e2..9cefcfb7a240f 100644
--- a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
+++ b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
@@ -40,30 +40,30 @@ static raw_ostream &operator<<(raw_ostream &OS, const Register &Reg) {
 }
 
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const ShaderVisibility &Visibility) {
+                               const dxil::ShaderVisibility &Visibility) {
   switch (Visibility) {
-  case ShaderVisibility::All:
+  case dxil::ShaderVisibility::All:
     OS << "All";
     break;
-  case ShaderVisibility::Vertex:
+  case dxil::ShaderVisibility::Vertex:
     OS << "Vertex";
     break;
-  case ShaderVisibility::Hull:
+  case dxil::ShaderVisibility::Hull:
     OS << "Hull";
     break;
-  case ShaderVisibility::Domain:
+  case dxil::ShaderVisibility::Domain:
     OS << "Domain";
     break;
-  case ShaderVisibility::Geometry:
+  case dxil::ShaderVisibility::Geometry:
     OS << "Geometry";
     break;
-  case ShaderVisibility::Pixel:
+  case dxil::ShaderVisibility::Pixel:
     OS << "Pixel";
     break;
-  case ShaderVisibility::Amplification:
+  case dxil::ShaderVisibility::Amplification:
     OS << "Amplification";
     break;
-  case ShaderVisibility::Mesh:
+  case dxil::ShaderVisibility::Mesh:
     OS << "Mesh";
     break;
   }
@@ -91,7 +91,7 @@ static raw_ostream &operator<<(raw_ostream &OS, const ClauseType &Type) {
 }
 
 static raw_ostream &operator<<(raw_ostream &OS,
-                               const DescriptorRangeFlags &Flags) {
+                               const dxil::DescriptorRangeFlags &Flags) {
   bool FlagSet = false;
   unsigned Remaining = llvm::to_underlying(Flags);
   while (Remaining) {
@@ -100,20 +100,21 @@ static raw_ostream &operator<<(raw_ostream &OS,
       if (FlagSet)
         OS << " | ";
 
-      switch (static_cast<DescriptorRangeFlags>(Bit)) {
-      case DescriptorRangeFlags::DescriptorsVolatile:
+      switch (static_cast<dxil::DescriptorRangeFlags>(Bit)) {
+      case dxil::DescriptorRangeFlags::DescriptorsVolatile:
         OS << "DescriptorsVolatile";
         break;
-      case DescriptorRangeFlags::DataVolatile:
+      case dxil::DescriptorRangeFlags::DataVolatile:
         OS << "DataVolatile";
         break;
-      case DescriptorRangeFlags::DataStaticWhileSetAtExecute:
+      case dxil::DescriptorRangeFlags::DataStaticWhileSetAtExecute:
         OS << "DataStaticWhileSetAtExecute";
         break;
-      case DescriptorRangeFlags::DataStatic:
+      case dxil::DescriptorRangeFlags::DataStatic:
         OS << "DataStatic";
         break;
-      case DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks:
+      case dxil::DescriptorRangeFlags::
+          DescriptorsStaticKeepingBufferBoundsChecks:
         OS << "DescriptorsStaticKeepingBufferBoundsChecks";
         break;
       default:
@@ -182,7 +183,7 @@ template <class... Ts> OverloadedBuild(Ts...) -> OverloadedBuild<Ts...>;
 
 MDNode *MetadataBuilder::BuildRootSignature() {
   const auto Visitor = OverloadedBuild{
-      [this](const RootFlags &Flags) -> MDNode * {
+      [this](const dxil::RootFlags &Flags) -> MDNode * {
         return BuildRootFlags(Flags);
       },
       [this](const RootConstants &Constants) -> MDNode * {
@@ -212,7 +213,7 @@ MDNode *MetadataBuilder::BuildRootSignature() {
   return MDNode::get(Ctx, GeneratedMetadata);
 }
 
-MDNode *MetadataBuilder::BuildRootFlags(const RootFlags &Flags) {
+MDNode *MetadataBuilder::BuildRootFlags(const dxil::RootFlags &Flags) {
   IRBuilder<> Builder(Ctx);
   Metadata *Operands[] = {
       MDString::get(Ctx, "RootFlags"),
diff --git a/llvm/lib/Transforms/Utils/ModuleUtils.cpp b/llvm/lib/Transforms/Utils/ModuleUtils.cpp
index 596849ecab742..05470b5cdbfe6 100644
--- a/llvm/lib/Transforms/Utils/ModuleUtils.cpp
+++ b/llvm/lib/Transforms/Utils/ModuleUtils.cpp
@@ -11,8 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/ModuleUtils.h"
-#include "llvm/Analysis/VectorUtils.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
diff --git a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
index 90e6cd0a80d6b..75f0a8a06040e 100644
--- a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
+++ b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
@@ -9,6 +9,7 @@
 #include "llvm/Frontend/HLSL/HLSLRootSignatureUtils.h"
 #include "gtest/gtest.h"
 
+using namespace llvm::dxil;
 using namespace llvm::hlsl::rootsig;
 
 namespace {
@@ -56,7 +57,7 @@ TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
   Clause.NumDescriptors = 3298;
   Clause.Space = 932847;
   Clause.Offset = 1;
-  Clause.Flags = DescriptorRangeFlags::ValidFlags;
+  Clause.Flags = DescriptorRangeFlags(0x1000f); // Valid flags
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);
@@ -80,7 +81,7 @@ TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
   Clause.NumDescriptors = 2;
   Clause.Space = 42;
   Clause.Offset = DescriptorTableOffsetAppend;
-  Clause.Flags = DescriptorRangeFlags::ValidSamplerFlags;
+  Clause.Flags = DescriptorRangeFlags::DescriptorsVolatile;
 
   std::string Out;
   llvm::raw_string_ostream OS(Out);