adding yaml2obj support

Author: joaosaffran

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -160,14 +160,14 @@ enum class RootElementFlag : uint32_t {
 };
 
 #define ROOT_PARAMETER(Val, Enum) Enum = Val,
-enum class RootParameterType : uint8_t {
+enum class RootParameterType: uint32_t {
 #include "DXContainerConstants.def"
 };
 
 ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
 
 #define SHADER_VISIBILITY(Val, Enum) Enum = Val,
-enum class ShaderVisibilityFlag : uint8_t {
+enum class ShaderVisibilityFlag: uint32_t {
 #include "DXContainerConstants.def"
 };
 
@@ -562,6 +562,26 @@ struct ProgramSignatureElement {
 static_assert(sizeof(ProgramSignatureElement) == 32,
               "ProgramSignatureElement is misaligned");
 
+struct RootConstants {
+  uint32_t ShaderRegister;
+  uint32_t RegisterSpace;
+  uint32_t Num32BitValues;
+};
+
+struct RootParameter {
+dxbc::RootParameterType ParameterType;
+union {
+  RootConstants Constants;
+};
+dxbc::ShaderVisibilityFlag ShaderVisibility;
+};
+
+struct RootSignatureHeader {
+  uint32_t Version = 2;
+  uint32_t Flags = 0;
+};
+            
+
 struct RootSignatureValidations {
 
   static bool isValidRootFlag(uint32_t Flags) { return (Flags & ~0xfff) == 0; }

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -15,13 +15,10 @@ namespace llvm {
 class raw_ostream;
 
 namespace mcdxbc {
+  
 struct RootSignatureDesc {
-  uint32_t Version = 2;
-  uint32_t NumParameters = 0;
-  uint32_t RootParametersOffset = 0;
-  uint32_t NumStaticSamplers = 0;
-  uint32_t StaticSamplersOffset = 0;
-  uint32_t Flags = 0;
+  dxbc::RootSignatureHeader Header;
+  SmallVector<dxbc::RootParameter> Parameters;
 
   void write(raw_ostream &OS) const;
 };

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -79,11 +79,12 @@ struct RootSignatureYamlDesc {
   RootSignatureYamlDesc(const object::DirectX::RootSignature &Data);
 
   uint32_t Version;
-  uint32_t NumParameters;
-  uint32_t RootParametersOffset;
   uint32_t NumStaticSamplers;
   uint32_t StaticSamplersOffset;
 
+  SmallVector<dxbc::RootParameter> Parameters;
+
+
   uint32_t getEncodedFlags();
 
 #include "llvm/BinaryFormat/DXContainerConstants.def"
@@ -192,6 +193,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::ResourceBindInfo)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureElement)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::PSVInfo::MaskVector)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureParameter)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::dxbc::RootParameter)
 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)
@@ -200,6 +202,8 @@ LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ResourceKind)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::D3DSystemValue)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigComponentType)
 LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigMinPrecision)
+LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::RootParameterType)
+LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::ShaderVisibilityFlag)
 
 namespace llvm {
 
@@ -264,6 +268,16 @@ template <> struct MappingTraits<DXContainerYAML::RootSignatureYamlDesc> {
                       DXContainerYAML::RootSignatureYamlDesc &RootSignature);
 };
 
+template <> struct MappingTraits<dxbc::RootParameter> {
+  static void mapping(IO &IO,
+    dxbc::RootParameter &P);
+};
+
+template <> struct MappingTraits<dxbc::RootConstants> {
+  static void mapping(IO &IO,
+    dxbc::RootConstants &C);
+};
+
 } // namespace yaml
 
 } // namespace llvm

llvm/lib/BinaryFormat/DXContainer.cpp

@@ -60,6 +60,26 @@ ArrayRef<EnumEntry<SigComponentType>> dxbc::getSigComponentTypes() {
   return ArrayRef(SigComponentTypes);
 }
 
+#define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibilityFlag::Enum},
+
+static const EnumEntry<ShaderVisibilityFlag> ShaderVisibilityFlags[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<ShaderVisibilityFlag>> dxbc::getShaderVisibilityFlags() {
+  return ArrayRef(ShaderVisibilityFlags);
+}
+
+#define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum},
+
+static const EnumEntry<RootParameterType> RootParameterTypes[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootParameterType>> dxbc::getRootParameterTypes() {
+  return ArrayRef(RootParameterTypes);
+}
+
 #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum},
 
 static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = {

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -8,34 +8,64 @@
 
 #include "llvm/MC/DXContainerRootSignature.h"
 #include "llvm/ADT/bit.h"
+#include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/Support/EndianStream.h"
+#include <cstdint>
+#include <sys/types.h>
 
 using namespace llvm;
 using namespace llvm::mcdxbc;
 
+template <typename T>
+static uint32_t getSizeOf () {
+    return static_cast<uint32_t>(sizeof(T));
+}
+
+
+
 void RootSignatureDesc::write(raw_ostream &OS) const {
+  uint32_t Offset = 16;
+  const uint32_t ParametersOffset = getSizeOf<dxbc::RootSignatureHeader>() + Offset;
+  const uint32_t ParameterByteSize = Parameters.size_in_bytes();
 
-  support::endian::write(OS, Version, llvm::endianness::little);
-  support::endian::write(OS, NumParameters, llvm::endianness::little);
-  support::endian::write(OS, RootParametersOffset, llvm::endianness::little);
-  support::endian::write(OS, NumStaticSamplers, llvm::endianness::little);
-  support::endian::write(OS, StaticSamplersOffset, llvm::endianness::little);
-  support::endian::write(OS, Flags, llvm::endianness::little);
-}
 
-void RootParameter::write(raw_ostream &OS) {
-  support::endian::write(OS, ParameterType, llvm::endianness::little);
-  support::endian::write(OS, ShaderVisibility, llvm::endianness::little);
+  // Writing header information
+  support::endian::write(OS, Header.Version, llvm::endianness::little);
+  Offset += getSizeOf<uint32_t>();    
 
-  switch(ParameterType){
-  case dxbc::RootParameterType::Constants32Bit:
-    Constants.write(OS);
-    break;
-  }
-}
+  support::endian::write(OS, (uint32_t)Parameters.size(), llvm::endianness::little);
+  Offset += getSizeOf<uint32_t>();    
 
-void RootConstants::write(raw_ostream &OS) {
-  support::endian::write(OS, Num32BitValues, llvm::endianness::little);
-  support::endian::write(OS, RegisterSpace, llvm::endianness::little);
-  support::endian::write(OS, ShaderRegister, llvm::endianness::little);
+  support::endian::write(OS, ParametersOffset, llvm::endianness::little);
+  Offset += getSizeOf<uint32_t>();    
+
+  support::endian::write(OS, ((uint32_t)0), llvm::endianness::little);
+  Offset += getSizeOf<uint32_t>();    
+
+  support::endian::write(OS, ParameterByteSize + ParametersOffset, llvm::endianness::little);
+  Offset += getSizeOf<uint32_t>();    
+
+  support::endian::write(OS, Header.Flags, llvm::endianness::little);
+
+  for (const dxbc::RootParameter &P : Parameters){
+    support::endian::write(OS, P.ParameterType, llvm::endianness::little);    
+    support::endian::write(OS, P.ShaderVisibility, llvm::endianness::little);
+    support::endian::write(OS, Offset, llvm::endianness::little);
+    Offset += getSizeOf<uint32_t>();    
+
+    
+    switch(P.ParameterType){
+      case dxbc::RootParameterType::Constants32Bit:{
+        support::endian::write(OS, P.Constants.ShaderRegister, llvm::endianness::little);
+        Offset += getSizeOf<uint32_t>();
+        
+        support::endian::write(OS, P.Constants.RegisterSpace, llvm::endianness::little);
+        Offset += getSizeOf<uint32_t>();
+        
+        support::endian::write(OS, P.Constants.Num32BitValues, llvm::endianness::little);
+        Offset += getSizeOf<uint32_t>();
+
+      } break;
+      }
+  }
 }

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -19,6 +19,7 @@
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
+#include <utility>
 
 using namespace llvm;
 
@@ -267,12 +268,9 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
         continue;
 
       mcdxbc::RootSignatureDesc RS;
-      RS.Flags = P.RootSignature->getEncodedFlags();
-      RS.Version = P.RootSignature->Version;
-      RS.NumParameters = P.RootSignature->NumParameters;
-      RS.RootParametersOffset = P.RootSignature->RootParametersOffset;
-      RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers;
-      RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset;
+      RS.Header.Flags = P.RootSignature->getEncodedFlags();
+      RS.Header.Version = P.RootSignature->Version;
+      RS.Parameters = std::move(P.RootSignature->Parameters);
 
       RS.write(OS);
       break;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -31,8 +31,7 @@ DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
 
 DXContainerYAML::RootSignatureYamlDesc::RootSignatureYamlDesc(
     const object::DirectX::RootSignature &Data)
-    : Version(Data.getVersion()), NumParameters(Data.getNumParameters()),
-      RootParametersOffset(Data.getRootParametersOffset()),
+    : Version(Data.getVersion()),
       NumStaticSamplers(Data.getNumStaticSamplers()),
       StaticSamplersOffset(Data.getStaticSamplersOffset()) {
   uint32_t Flags = Data.getFlags();
@@ -212,14 +211,34 @@ void MappingTraits<DXContainerYAML::Signature>::mapping(
 void MappingTraits<DXContainerYAML::RootSignatureYamlDesc>::mapping(
     IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) {
   IO.mapRequired("Version", S.Version);
-  IO.mapRequired("NumParameters", S.NumParameters);
-  IO.mapRequired("RootParametersOffset", S.RootParametersOffset);
   IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers);
   IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset);
+  IO.mapRequired("Parameters", S.Parameters);
 #define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
+void MappingTraits<dxbc::RootConstants>::mapping(
+  IO &IO, dxbc::RootConstants &C) {
+    IO.mapRequired("Num32BitValues", C.Num32BitValues);
+    IO.mapRequired("RegisterSpace", C.RegisterSpace);
+    IO.mapRequired("ShaderRegister", C.ShaderRegister);
+
+  }
+
+void MappingTraits<dxbc::RootParameter>::mapping(
+  IO &IO, dxbc::RootParameter &P) {
+    IO.mapRequired("ParameterType", P.ParameterType);
+    IO.mapRequired("ShaderVisibility", P.ShaderVisibility);
+    switch (P.ParameterType) {
+
+    case dxbc::RootParameterType::Constants32Bit:
+      IO.mapRequired("Constants", P.Constants);
+
+      break;
+    }
+  }
+
 void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
                                                    DXContainerYAML::Part &P) {
   IO.mapRequired("Name", P.Name);
@@ -323,6 +342,18 @@ void ScalarEnumerationTraits<dxbc::SigComponentType>::enumeration(
     IO.enumCase(Value, E.Name.str().c_str(), E.Value);
 }
 
+void ScalarEnumerationTraits<dxbc::RootParameterType>::enumeration(
+  IO &IO, dxbc::RootParameterType &Value) {
+for (const auto &E : dxbc::getRootParameterTypes())
+  IO.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+
+void ScalarEnumerationTraits<dxbc::ShaderVisibilityFlag>::enumeration(
+  IO &IO, dxbc::ShaderVisibilityFlag &Value) {
+for (const auto &E : dxbc::getShaderVisibilityFlags())
+  IO.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+
 } // namespace yaml
 
 void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) {

llvm/lib/Target/DirectX/DXILRootSignature.cpp

@@ -47,7 +47,7 @@ static bool parseRootFlags(LLVMContext *Ctx, mcdxbc::RootSignatureDesc &RSD,
     return reportError(Ctx, "Invalid format for RootFlag Element");
 
   auto *Flag = mdconst::extract<ConstantInt>(RootFlagNode->getOperand(1));
-  RSD.Flags = Flag->getZExtValue();
+  RSD.Header.Flags = Flag->getZExtValue();
 
   return false;
 }
@@ -93,7 +93,7 @@ static bool parse(LLVMContext *Ctx, mcdxbc::RootSignatureDesc &RSD,
 }
 
 static bool validate(LLVMContext *Ctx, const mcdxbc::RootSignatureDesc &RSD) {
-  if (!dxbc::RootSignatureValidations::isValidRootFlag(RSD.Flags)) {
+  if (!dxbc::RootSignatureValidations::isValidRootFlag(RSD.Header.Flags)) {
     return reportError(Ctx, "Invalid Root Signature flag value");
   }
   return false;
@@ -198,14 +198,14 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M,
 
     // start root signature header
     Space++;
-    OS << indent(Space) << "Flags: " << format_hex(RSD.Flags, 8) << ":\n";
-    OS << indent(Space) << "Version: " << RSD.Version << ":\n";
-    OS << indent(Space) << "NumParameters: " << RSD.NumParameters << ":\n";
-    OS << indent(Space) << "RootParametersOffset: " << RSD.RootParametersOffset
+    OS << indent(Space) << "Flags: " << format_hex(RS.Header.Flags, 8) << ":\n";
+    OS << indent(Space) << "Version: " << RS.Header.Version << ":\n";
+    OS << indent(Space) << "NumParameters: " << RS.Parameters.size() << ":\n";
+    OS << indent(Space) << "RootParametersOffset: " << RS.Parameters.size_in_bytes()
        << ":\n";
-    OS << indent(Space) << "NumStaticSamplers: " << RSD.NumStaticSamplers
+    OS << indent(Space) << "NumStaticSamplers: " << 0
        << ":\n";
-    OS << indent(Space) << "StaticSamplersOffset: " << RSD.StaticSamplersOffset
+    OS << indent(Space) << "StaticSamplersOffset: " << sizeof(RS.Header) + RS.Parameters.size_in_bytes()
        << ":\n";
     Space--;
     // end root signature header