[DirectX] Adding support for static samplers in yaml2obj/obj2yaml (#139963)

- Adds support for static samplers ins dxcontainer binary format.
- Adds writing logic to mcdxbc
- adds reading logic to Object
- adds tests
Closes: [126636](#126636)

---------

Co-authored-by: joaosaffran <joao.saffran@microsoft.com>

Author: joaosaffran

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -209,6 +209,26 @@ inline bool isValidShaderVisibility(uint32_t V) {
   return false;
 }
 
+#define STATIC_SAMPLER_FILTER(Val, Enum) Enum = Val,
+enum class StaticSamplerFilter : uint32_t {
+#include "DXContainerConstants.def"
+};
+
+#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 {
+#include "DXContainerConstants.def"
+};
+
+#define STATIC_BORDER_COLOR(Val, Enum) Enum = Val,
+enum class SamplersBorderColor : uint32_t {
+#include "DXContainerConstants.def"
+};
+
 PartType parsePartType(StringRef S);
 
 struct VertexPSVInfo {
@@ -600,6 +620,37 @@ static_assert(sizeof(ProgramSignatureElement) == 32,
 
 namespace RTS0 {
 namespace v1 {
+struct StaticSampler {
+  uint32_t Filter;
+  uint32_t AddressU;
+  uint32_t AddressV;
+  uint32_t AddressW;
+  float MipLODBias;
+  uint32_t MaxAnisotropy;
+  uint32_t ComparisonFunc;
+  uint32_t BorderColor;
+  float MinLOD;
+  float MaxLOD;
+  uint32_t ShaderRegister;
+  uint32_t RegisterSpace;
+  uint32_t ShaderVisibility;
+  void swapBytes() {
+    sys::swapByteOrder(Filter);
+    sys::swapByteOrder(AddressU);
+    sys::swapByteOrder(AddressV);
+    sys::swapByteOrder(AddressW);
+    sys::swapByteOrder(MipLODBias);
+    sys::swapByteOrder(MaxAnisotropy);
+    sys::swapByteOrder(ComparisonFunc);
+    sys::swapByteOrder(BorderColor);
+    sys::swapByteOrder(MinLOD);
+    sys::swapByteOrder(MaxLOD);
+    sys::swapByteOrder(ShaderRegister);
+    sys::swapByteOrder(RegisterSpace);
+    sys::swapByteOrder(ShaderVisibility);
+  };
+};
+
 struct DescriptorRange {
   uint32_t RangeType;
   uint32_t NumDescriptors;

llvm/include/llvm/BinaryFormat/DXContainerConstants.def

@@ -121,6 +121,79 @@ 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
+
+#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)
+#undef TEXTURE_ADDRESS_MODE
+#endif // TEXTURE_ADDRESS_MODE
+
+#ifdef COMPARISON_FUNCTION
+
+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
+
+#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)
+#undef STATIC_BORDER_COLOR
+#endif // STATIC_BORDER_COLOR
+
 #ifdef DXIL_MODULE_FLAG
 
 // Only save DXIL module flags which not map to feature flags here.

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -108,6 +108,7 @@ struct RootSignatureDesc {
   uint32_t StaticSamplersOffset = 0u;
   uint32_t NumStaticSamplers = 0u;
   mcdxbc::RootParametersContainer ParametersContainer;
+  SmallVector<dxbc::RTS0::v1::StaticSampler> StaticSamplers;
 
   void write(raw_ostream &OS) const;
 

llvm/include/llvm/Object/DXContainer.h

@@ -236,9 +236,11 @@ class RootSignature {
   uint32_t Flags;
   ViewArray<dxbc::RTS0::v1::RootParameterHeader> ParametersHeaders;
   StringRef PartData;
+  ViewArray<dxbc::RTS0::v1::StaticSampler> StaticSamplers;
 
   using param_header_iterator =
       ViewArray<dxbc::RTS0::v1::RootParameterHeader>::iterator;
+  using samplers_iterator = ViewArray<dxbc::RTS0::v1::StaticSampler>::iterator;
 
 public:
   RootSignature(StringRef PD) : PartData(PD) {}
@@ -253,6 +255,9 @@ class RootSignature {
   llvm::iterator_range<param_header_iterator> param_headers() const {
     return llvm::make_range(ParametersHeaders.begin(), ParametersHeaders.end());
   }
+  llvm::iterator_range<samplers_iterator> samplers() const {
+    return llvm::make_range(StaticSamplers.begin(), StaticSamplers.end());
+  }
   uint32_t getFlags() const { return Flags; }
 
   llvm::Expected<RootParameterView>

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -163,6 +163,24 @@ struct RootParameterYamlDesc {
   }
 };
 
+struct StaticSamplerYamlDesc {
+  uint32_t Filter = llvm::to_underlying(dxbc::StaticSamplerFilter::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);
+  uint32_t BorderColor =
+      llvm::to_underlying(dxbc::SamplersBorderColor::OpaqueWhite);
+  float MinLOD = 0.f;
+  float MaxLOD = std::numeric_limits<float>::max();
+  uint32_t ShaderRegister;
+  uint32_t RegisterSpace;
+  uint32_t ShaderVisibility;
+};
+
 struct RootSignatureYamlDesc {
   RootSignatureYamlDesc() = default;
 
@@ -173,9 +191,14 @@ struct RootSignatureYamlDesc {
   uint32_t StaticSamplersOffset;
 
   RootParameterYamlDesc Parameters;
+  SmallVector<StaticSamplerYamlDesc> StaticSamplers;
 
   uint32_t getEncodedFlags();
 
+  iterator_range<StaticSamplerYamlDesc *> samplers() {
+    return make_range(StaticSamplers.begin(), StaticSamplers.end());
+  }
+
   static llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
   create(const object::DirectX::RootSignature &Data);
 
@@ -288,6 +311,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::PSVInfo::MaskVector)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureParameter)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::RootParameterLocationYaml)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::DescriptorRangeYaml)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::StaticSamplerYamlDesc)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::SemanticKind)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ComponentType)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::InterpolationMode)
@@ -384,6 +408,10 @@ template <> struct MappingTraits<llvm::DXContainerYAML::DescriptorRangeYaml> {
   static void mapping(IO &IO, llvm::DXContainerYAML::DescriptorRangeYaml &D);
 };
 
+template <> struct MappingTraits<llvm::DXContainerYAML::StaticSamplerYamlDesc> {
+  static void mapping(IO &IO, llvm::DXContainerYAML::StaticSamplerYamlDesc &S);
+};
+
 } // namespace yaml
 
 } // namespace llvm

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -31,7 +31,8 @@ static void rewriteOffsetToCurrentByte(raw_svector_ostream &Stream,
 size_t RootSignatureDesc::getSize() const {
   size_t Size =
       sizeof(dxbc::RTS0::v1::RootSignatureHeader) +
-      ParametersContainer.size() * sizeof(dxbc::RTS0::v1::RootParameterHeader);
+      ParametersContainer.size() * sizeof(dxbc::RTS0::v1::RootParameterHeader) +
+      StaticSamplers.size() * sizeof(dxbc::RTS0::v1::StaticSampler);
 
   for (const RootParameterInfo &I : ParametersContainer) {
     switch (I.Header.ParameterType) {
@@ -141,6 +142,21 @@ void RootSignatureDesc::write(raw_ostream &OS) const {
     }
     }
   }
+  for (const auto &S : StaticSamplers) {
+    support::endian::write(BOS, S.Filter, llvm::endianness::little);
+    support::endian::write(BOS, S.AddressU, llvm::endianness::little);
+    support::endian::write(BOS, S.AddressV, llvm::endianness::little);
+    support::endian::write(BOS, S.AddressW, llvm::endianness::little);
+    support::endian::write(BOS, S.MipLODBias, llvm::endianness::little);
+    support::endian::write(BOS, S.MaxAnisotropy, llvm::endianness::little);
+    support::endian::write(BOS, S.ComparisonFunc, llvm::endianness::little);
+    support::endian::write(BOS, S.BorderColor, llvm::endianness::little);
+    support::endian::write(BOS, S.MinLOD, llvm::endianness::little);
+    support::endian::write(BOS, S.MaxLOD, llvm::endianness::little);
+    support::endian::write(BOS, S.ShaderRegister, llvm::endianness::little);
+    support::endian::write(BOS, S.RegisterSpace, llvm::endianness::little);
+    support::endian::write(BOS, S.ShaderVisibility, llvm::endianness::little);
+  }
   assert(Storage.size() == getSize());
   OS.write(Storage.data(), Storage.size());
 }

llvm/lib/Object/DXContainer.cpp

@@ -276,6 +276,11 @@ Error DirectX::RootSignature::parse() {
       RootParametersOffset,
       NumParameters * sizeof(dxbc::RTS0::v1::RootParameterHeader));
 
+  StaticSamplers.Stride = sizeof(dxbc::RTS0::v1::StaticSampler);
+  StaticSamplers.Data = PartData.substr(
+      StaticSamplersOffset,
+      NumStaticSamplers * sizeof(dxbc::RTS0::v1::StaticSampler));
+
   return Error::success();
 }
 

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -331,6 +331,25 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
         }
       }
 
+      for (const auto &Param : P.RootSignature->samplers()) {
+        dxbc::RTS0::v1::StaticSampler NewSampler;
+        NewSampler.Filter = Param.Filter;
+        NewSampler.AddressU = Param.AddressU;
+        NewSampler.AddressV = Param.AddressV;
+        NewSampler.AddressW = Param.AddressW;
+        NewSampler.MipLODBias = Param.MipLODBias;
+        NewSampler.MaxAnisotropy = Param.MaxAnisotropy;
+        NewSampler.ComparisonFunc = Param.ComparisonFunc;
+        NewSampler.BorderColor = Param.BorderColor;
+        NewSampler.MinLOD = Param.MinLOD;
+        NewSampler.MaxLOD = Param.MaxLOD;
+        NewSampler.ShaderRegister = Param.ShaderRegister;
+        NewSampler.RegisterSpace = Param.RegisterSpace;
+        NewSampler.ShaderVisibility = Param.ShaderVisibility;
+
+        RS.StaticSamplers.push_back(NewSampler);
+      }
+
       RS.write(OS);
       break;
     }

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -139,6 +139,26 @@ DXContainerYAML::RootSignatureYamlDesc::create(
       }
     }
   }
+
+  for (const auto &S : Data.samplers()) {
+    StaticSamplerYamlDesc NewS;
+    NewS.Filter = S.Filter;
+    NewS.AddressU = S.AddressU;
+    NewS.AddressV = S.AddressV;
+    NewS.AddressW = S.AddressW;
+    NewS.MipLODBias = S.MipLODBias;
+    NewS.MaxAnisotropy = S.MaxAnisotropy;
+    NewS.ComparisonFunc = S.ComparisonFunc;
+    NewS.BorderColor = S.BorderColor;
+    NewS.MinLOD = S.MinLOD;
+    NewS.MaxLOD = S.MaxLOD;
+    NewS.ShaderRegister = S.ShaderRegister;
+    NewS.RegisterSpace = S.RegisterSpace;
+    NewS.ShaderVisibility = S.ShaderVisibility;
+
+    RootSigDesc.StaticSamplers.push_back(NewS);
+  }
+
 #define ROOT_ELEMENT_FLAG(Num, Val)                                            \
   RootSigDesc.Val =                                                            \
       (Flags & llvm::to_underlying(dxbc::RootElementFlag::Val)) > 0;
@@ -340,6 +360,7 @@ void MappingTraits<DXContainerYAML::RootSignatureYamlDesc>::mapping(
   IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers);
   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);
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
@@ -421,6 +442,24 @@ void MappingTraits<llvm::DXContainerYAML::RootDescriptorYaml>::mapping(
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
+void MappingTraits<llvm::DXContainerYAML::StaticSamplerYamlDesc>::mapping(
+    IO &IO, llvm::DXContainerYAML::StaticSamplerYamlDesc &S) {
+
+  IO.mapOptional("Filter", S.Filter);
+  IO.mapOptional("AddressU", S.AddressU);
+  IO.mapOptional("AddressV", S.AddressV);
+  IO.mapOptional("AddressW", S.AddressW);
+  IO.mapOptional("MipLODBias", S.MipLODBias);
+  IO.mapOptional("MaxAnisotropy", S.MaxAnisotropy);
+  IO.mapOptional("ComparisonFunc", S.ComparisonFunc);
+  IO.mapOptional("BorderColor", S.BorderColor);
+  IO.mapOptional("MinLOD", S.MinLOD);
+  IO.mapOptional("MaxLOD", S.MaxLOD);
+  IO.mapRequired("ShaderRegister", S.ShaderRegister);
+  IO.mapRequired("RegisterSpace", S.RegisterSpace);
+  IO.mapRequired("ShaderVisibility", S.ShaderVisibility);
+}
+
 void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
                                                    DXContainerYAML::Part &P) {
   IO.mapRequired("Name", P.Name);