nfc:: move SamplerFilter

Author: inbelic

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -111,7 +111,7 @@ class RootSignatureParser {
 
   struct ParsedStaticSamplerParams {
     std::optional<llvm::hlsl::rootsig::Register> Reg;
-    std::optional<llvm::hlsl::rootsig::SamplerFilter> Filter;
+    std::optional<llvm::dxbc::SamplerFilter> Filter;
     std::optional<llvm::dxbc::TextureAddressMode> AddressU;
     std::optional<llvm::dxbc::TextureAddressMode> AddressV;
     std::optional<llvm::dxbc::TextureAddressMode> AddressW;
@@ -133,7 +133,7 @@ class RootSignatureParser {
 
   /// Parsing methods of various enums
   std::optional<llvm::dxbc::ShaderVisibility> parseShaderVisibility();
-  std::optional<llvm::hlsl::rootsig::SamplerFilter> parseSamplerFilter();
+  std::optional<llvm::dxbc::SamplerFilter> parseSamplerFilter();
   std::optional<llvm::dxbc::TextureAddressMode> parseTextureAddressMode();
   std::optional<llvm::dxbc::ComparisonFunc> parseComparisonFunc();
   std::optional<llvm::dxbc::StaticBorderColor> parseStaticBorderColor();

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -1010,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");
@@ -1026,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:

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -260,7 +260,8 @@ 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).Filter,
+            llvm::dxbc::SamplerFilter::Anisotropic);
   ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
             llvm::dxbc::TextureAddressMode::Wrap);
   ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,
@@ -285,7 +286,7 @@ 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);
+            llvm::dxbc::SamplerFilter::MaximumMinPointMagLinearMipPoint);
   ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
             llvm::dxbc::TextureAddressMode::Mirror);
   ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,

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

@@ -29,47 +29,6 @@ namespace rootsig {
 // carried over from their values in DXC. For reference:
 // https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
 
-// 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
-};
-
 // Definitions of the in-memory data layout structures
 
 // Models the different registers: bReg | tReg | uReg | sReg
@@ -147,7 +106,7 @@ struct DescriptorTableClause {
 
 struct StaticSampler {
   Register Reg;
-  SamplerFilter Filter = SamplerFilter::Anisotropic;
+  dxbc::SamplerFilter Filter = dxbc::SamplerFilter::Anisotropic;
   dxbc::TextureAddressMode AddressU = dxbc::TextureAddressMode::Wrap;
   dxbc::TextureAddressMode AddressV = dxbc::TextureAddressMode::Wrap;
   dxbc::TextureAddressMode AddressW = dxbc::TextureAddressMode::Wrap;

llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp

@@ -87,57 +87,9 @@ static raw_ostream &operator<<(raw_ostream &OS,
   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;
 }

llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp

@@ -194,7 +194,7 @@ TEST(HLSLRootSignatureTest, DefinedStaticSamplerDump) {
   StaticSampler Sampler;
   Sampler.Reg = {RegisterType::SReg, 0};
 
-  Sampler.Filter = SamplerFilter::ComparisonMinMagLinearMipPoint;
+  Sampler.Filter = llvm::dxbc::SamplerFilter::ComparisonMinMagLinearMipPoint;
   Sampler.AddressU = llvm::dxbc::TextureAddressMode::Mirror;
   Sampler.AddressV = llvm::dxbc::TextureAddressMode::Border;
   Sampler.AddressW = llvm::dxbc::TextureAddressMode::Clamp;