[DXIL] Adding support to RootSignatureFlags in obj2yaml

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -63,6 +63,15 @@ struct ShaderHash {
   void swapBytes() { sys::swapByteOrder(Flags); }
 };
 
+struct RootSignatureDesc {
+  uint32_t Version;
+  uint32_t Flags;
+  void swapBytes() {
+    sys::swapByteOrder(Version);
+    sys::swapByteOrder(Flags);
+  }
+};
+
 struct ContainerVersion {
   uint16_t Major;
   uint16_t Minor;
@@ -152,6 +161,11 @@ 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 = 1ull << Num,
+enum class RootElementFlag : uint32_t {
+#include "DXContainerConstants.def"
+};
+
 PartType parsePartType(StringRef S);
 
 struct VertexPSVInfo {

llvm/include/llvm/BinaryFormat/DXContainerConstants.def

@@ -4,6 +4,7 @@ CONTAINER_PART(DXIL)
 CONTAINER_PART(SFI0)
 CONTAINER_PART(HASH)
 CONTAINER_PART(PSV0)
+CONTAINER_PART(RTS0)
 CONTAINER_PART(ISG1)
 CONTAINER_PART(OSG1)
 CONTAINER_PART(PSG1)
@@ -52,6 +53,25 @@ SHADER_FEATURE_FLAG(31, 36, NextUnusedBit, "Next reserved shader flag bit (not a
 #undef SHADER_FEATURE_FLAG
 #endif // SHADER_FEATURE_FLAG
 
+#ifdef ROOT_ELEMENT_FLAG
+
+
+ROOT_ELEMENT_FLAG(0, AllowInputAssemblerInputLayout)
+ROOT_ELEMENT_FLAG(1, DenyVertexShaderRootAccess)
+ROOT_ELEMENT_FLAG(2, DenyHullShaderRootAccess)
+ROOT_ELEMENT_FLAG(3, DenyDomainShaderRootAccess)
+ROOT_ELEMENT_FLAG(4, DenyGeometryShaderRootAccess)
+ROOT_ELEMENT_FLAG(5, DenyPixelShaderRootAccess)
+ROOT_ELEMENT_FLAG(6, AllowStreamOutput)
+ROOT_ELEMENT_FLAG(7, LocalRootSignature)
+ROOT_ELEMENT_FLAG(8, DenyAmplificationShaderRootAccess)
+ROOT_ELEMENT_FLAG(9, DenyMeshShaderRootAccess)
+ROOT_ELEMENT_FLAG(10, CBVSRVUAVHeapDirectlyIndexed)
+ROOT_ELEMENT_FLAG(11, SamplerHeapDirectlyIndexed)
+#undef ROOT_ELEMENT_FLAG
+#endif // ROOT_ELEMENT_FLAG
+
+
 #ifdef DXIL_MODULE_FLAG
 
 // Only save DXIL module flags which not map to feature flags here.

llvm/include/llvm/Object/DXContainer.h

@@ -287,6 +287,7 @@ class DXContainer {
   std::optional<uint64_t> ShaderFeatureFlags;
   std::optional<dxbc::ShaderHash> Hash;
   std::optional<DirectX::PSVRuntimeInfo> PSVInfo;
+  std::optional<dxbc::RootSignatureDesc> RootSignature;
   DirectX::Signature InputSignature;
   DirectX::Signature OutputSignature;
   DirectX::Signature PatchConstantSignature;
@@ -296,6 +297,7 @@ class DXContainer {
   Error parseDXILHeader(StringRef Part);
   Error parseShaderFeatureFlags(StringRef Part);
   Error parseHash(StringRef Part);
+  Error parseRootSignature(StringRef Part);
   Error parsePSVInfo(StringRef Part);
   Error parseSignature(StringRef Part, DirectX::Signature &Array);
   friend class PartIterator;
@@ -382,6 +384,10 @@ class DXContainer {
 
   std::optional<dxbc::ShaderHash> getShaderHash() const { return Hash; }
 
+  std::optional<dxbc::RootSignatureDesc> getRootSignature() const {
+    return RootSignature;
+  }
+
   const std::optional<DirectX::PSVRuntimeInfo> &getPSVInfo() const {
     return PSVInfo;
   };

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -72,6 +72,16 @@ struct ShaderHash {
   std::vector<llvm::yaml::Hex8> Digest;
 };
 
+#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false;
+struct RootSignatureDesc {
+  RootSignatureDesc() = default;
+  RootSignatureDesc(const dxbc::RootSignatureDesc &Data);
+
+  uint32_t getEncodedFlags();
+  uint32_t Version;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
 using ResourceFlags = dxbc::PSV::ResourceFlags;
 using ResourceBindInfo = dxbc::PSV::v2::ResourceBindInfo;
 
@@ -159,6 +169,7 @@ struct Part {
   std::optional<ShaderHash> Hash;
   std::optional<PSVInfo> Info;
   std::optional<DXContainerYAML::Signature> Signature;
+  std::optional<DXContainerYAML::RootSignatureDesc> RootSignature;
 };
 
 struct Object {
@@ -241,6 +252,11 @@ template <> struct MappingTraits<DXContainerYAML::Signature> {
   static void mapping(IO &IO, llvm::DXContainerYAML::Signature &El);
 };
 
+template <> struct MappingTraits<DXContainerYAML::RootSignatureDesc> {
+  static void mapping(IO &IO,
+                      DXContainerYAML::RootSignatureDesc &RootSignature);
+};
+
 } // namespace yaml
 
 } // namespace llvm

llvm/lib/Object/DXContainer.cpp

@@ -92,6 +92,16 @@ Error DXContainer::parseHash(StringRef Part) {
   return Error::success();
 }
 
+Error DXContainer::parseRootSignature(StringRef Part) {
+  if (RootSignature)
+    return parseFailed("More than one RTS0 part is present in the file");
+  dxbc::RootSignatureDesc Desc;
+  if (Error Err = readStruct(Part, Part.begin(), Desc))
+    return Err;
+  RootSignature = Desc;
+  return Error::success();
+}
+
 Error DXContainer::parsePSVInfo(StringRef Part) {
   if (PSVInfo)
     return parseFailed("More than one PSV0 part is present in the file");
@@ -192,6 +202,11 @@ Error DXContainer::parsePartOffsets() {
         return Err;
       break;
     case dxbc::PartType::Unknown:
+      break;
+    case dxbc::PartType::RTS0:
+      if (Error Err = parseRootSignature(PartData))
+        return Err;
+
       break;
     }
   }

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -261,6 +261,17 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
     }
     case dxbc::PartType::Unknown:
       break; // Skip any handling for unrecognized parts.
+    case dxbc::PartType::RTS0:
+      if (!P.RootSignature.has_value())
+        continue;
+      uint32_t Flags = P.RootSignature->getEncodedFlags();
+      if (sys::IsBigEndianHost)
+        sys::swapByteOrder(Flags);
+      dxbc::RootSignatureDesc RS = {P.RootSignature->Version, Flags};
+      if (sys::IsBigEndianHost)
+        RS.swapBytes();
+      OS.write(reinterpret_cast<char *>(&RS), sizeof(dxbc::RootSignatureDesc));
+      break;
     }
     uint64_t BytesWritten = OS.tell() - DataStart;
     RollingOffset += BytesWritten;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -15,6 +15,7 @@
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include <cstdint>
 
 namespace llvm {
 
@@ -29,6 +30,23 @@ DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
+DXContainerYAML::RootSignatureDesc::RootSignatureDesc(
+    const dxbc::RootSignatureDesc &Data)
+    : Version(Data.Version) {
+#define ROOT_ELEMENT_FLAG(Num, Val)                                            \
+  Val = (Data.Flags & (uint32_t)dxbc::RootElementFlag::Val) > 0;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+}
+
+uint32_t DXContainerYAML::RootSignatureDesc::getEncodedFlags() {
+  uint64_t Flag = 0;
+#define ROOT_ELEMENT_FLAG(Num, Val)                                            \
+  if (Val)                                                                     \
+    Flag |= (uint32_t)dxbc::RootElementFlag::Val;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+  return Flag;
+}
+
 uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() {
   uint64_t Flag = 0;
 #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str)                      \
@@ -188,6 +206,13 @@ void MappingTraits<DXContainerYAML::Signature>::mapping(
   IO.mapRequired("Parameters", S.Parameters);
 }
 
+void MappingTraits<DXContainerYAML::RootSignatureDesc>::mapping(
+    IO &IO, DXContainerYAML::RootSignatureDesc &S) {
+  IO.mapRequired("Version", S.Version);
+#define ROOT_ELEMENT_FLAG(Num, Val) IO.mapRequired(#Val, S.Val);
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+}
+
 void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
                                                    DXContainerYAML::Part &P) {
   IO.mapRequired("Name", P.Name);
@@ -197,6 +222,7 @@ void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
   IO.mapOptional("Hash", P.Hash);
   IO.mapOptional("PSVInfo", P.Info);
   IO.mapOptional("Signature", P.Signature);
+  IO.mapOptional("RootSignature", P.RootSignature);
 }
 
 void MappingTraits<DXContainerYAML::Object>::mapping(

llvm/test/ObjectYAML/DXContainer/RootSignature-Flags.yaml

@@ -0,0 +1,44 @@
+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+--- !dxcontainer
+Header:
+  Hash:            [ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 
+                     0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]
+  Version:
+    Major:           1
+    Minor:           0
+  PartCount:       1
+  PartOffsets:     [ 60 ]
+Parts:
+  - Name:            RTS0
+    Size:            8
+    RootSignature:
+      Version:         1
+      AllowInputAssemblerInputLayout: true
+      DenyVertexShaderRootAccess: false
+      DenyHullShaderRootAccess: false
+      DenyDomainShaderRootAccess: false
+      DenyGeometryShaderRootAccess: false
+      DenyPixelShaderRootAccess: false
+      AllowStreamOutput: false
+      LocalRootSignature: false
+      DenyAmplificationShaderRootAccess: false
+      DenyMeshShaderRootAccess: false
+      CBVSRVUAVHeapDirectlyIndexed: false
+      SamplerHeapDirectlyIndexed: false
+
+#CHECK:    - Name: RTS0
+#CHECK-NEXT: Size: 8
+#CHECK-NEXT: RootSignature:
+#CHECK-NEXT:   Version: 1
+#CHECK-NEXT:   AllowInputAssemblerInputLayout: true
+#CHECK-NEXT:   DenyVertexShaderRootAccess: false
+#CHECK-NEXT:   DenyHullShaderRootAccess: false
+#CHECK-NEXT:   DenyDomainShaderRootAccess: false
+#CHECK-NEXT:   DenyGeometryShaderRootAccess: false
+#CHECK-NEXT:   DenyPixelShaderRootAccess: false
+#CHECK-NEXT:   AllowStreamOutput: false
+#CHECK-NEXT:   LocalRootSignature: false
+#CHECK-NEXT:   DenyAmplificationShaderRootAccess: false
+#CHECK-NEXT:   DenyMeshShaderRootAccess: false
+#CHECK-NEXT:   CBVSRVUAVHeapDirectlyIndexed: false
+#CHECK-NEXT:   SamplerHeapDirectlyIndexed: false

llvm/tools/obj2yaml/dxcontainer2yaml.cpp

@@ -153,6 +153,12 @@ dumpDXContainer(MemoryBufferRef Source) {
       break;
     case dxbc::PartType::Unknown:
       break;
+    case dxbc::PartType::RTS0:
+      std::optional<dxbc::RootSignatureDesc> RS = Container.getRootSignature();
+      if (RS && RS.has_value())
+        NewPart.RootSignature = DXContainerYAML::RootSignatureDesc(*RS);
+      break;
+      break;
     }
   }