Merge branch 'users/joaosaffran/123147' into obj2yaml/root-constants

Author: joaosaffran

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/BinaryFormat/DXContainer.h"
 #include <cstdint>
 #include <limits>
@@ -15,36 +16,36 @@ namespace llvm {
 class raw_ostream;
 
 namespace mcdxbc {
+  
+  struct RootConstants {
+    uint32_t ShaderRegister;
+    uint32_t RegisterSpace;
+    uint32_t Num32BitValues;
 
+    void write(raw_ostream &OS) const;
+  };
+
+struct RootParameter {
+  dxbc::RootParameterType ParameterType;
+  union {
+    RootConstants Constants;
+  };
+  dxbc::ShaderVisibilityFlag ShaderVisibility;
 
+  void write(raw_ostream &OS) const;
+};
 
-struct RootSignatureHeader {
+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;
 
-  void write(raw_ostream &OS);
-};
+  SmallVector<RootParameter> Parameters;
 
-struct RootConstants {
-  uint32_t ShaderRegister;
-  uint32_t RegisterSpace;
-  uint32_t Num32BitValues;
-
-  void write(raw_ostream &OS);
+  void write(raw_ostream &OS) const;
 };
-
-struct RootParameter {
-  dxbc::RootParameterType ParameterType;
-  union {
-    RootConstants Constants;
-  };
-  dxbc::ShaderVisibilityFlag ShaderVisibility;
-
-  void write(raw_ostream &OS);
-}; 
 } // namespace mcdxbc
 } // namespace llvm

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -74,9 +74,9 @@ struct ShaderHash {
 };
 
 #define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false;
-struct RootSignatureDesc {
-  RootSignatureDesc() = default;
-  RootSignatureDesc(const object::DirectX::RootSignature &Data);
+struct RootSignatureYamlDesc {
+  RootSignatureYamlDesc() = default;
+  RootSignatureYamlDesc(const object::DirectX::RootSignature &Data);
 
   uint32_t Version;
   uint32_t NumParameters;
@@ -176,7 +176,7 @@ struct Part {
   std::optional<ShaderHash> Hash;
   std::optional<PSVInfo> Info;
   std::optional<DXContainerYAML::Signature> Signature;
-  std::optional<DXContainerYAML::RootSignatureDesc> RootSignature;
+  std::optional<DXContainerYAML::RootSignatureYamlDesc> RootSignature;
 };
 
 struct Object {
@@ -259,9 +259,9 @@ template <> struct MappingTraits<DXContainerYAML::Signature> {
   static void mapping(IO &IO, llvm::DXContainerYAML::Signature &El);
 };
 
-template <> struct MappingTraits<DXContainerYAML::RootSignatureDesc> {
+template <> struct MappingTraits<DXContainerYAML::RootSignatureYamlDesc> {
   static void mapping(IO &IO,
-                      DXContainerYAML::RootSignatureDesc &RootSignature);
+                      DXContainerYAML::RootSignatureYamlDesc &RootSignature);
 };
 
 } // namespace yaml

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -13,16 +13,20 @@
 using namespace llvm;
 using namespace llvm::mcdxbc;
 
-void RootSignatureHeader::write(raw_ostream &OS) {
+void RootSignatureDesc::write(raw_ostream &OS) const {
+
   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);
+
+  for (const auto &P : Parameters)
+    P.write(OS);
 }
 
-void RootParameter::write(raw_ostream &OS) {
+void RootParameter::write(raw_ostream &OS) const {
   support::endian::write(OS, ParameterType, llvm::endianness::little);
   support::endian::write(OS, ShaderVisibility, llvm::endianness::little);
 
@@ -33,7 +37,7 @@ void RootParameter::write(raw_ostream &OS) {
   }
 }
 
-void RootConstants::write(raw_ostream &OS) {
+void RootConstants::write(raw_ostream &OS) const {
   support::endian::write(OS, Num32BitValues, llvm::endianness::little);
   support::endian::write(OS, RegisterSpace, llvm::endianness::little);
   support::endian::write(OS, ShaderRegister, llvm::endianness::little);

llvm/lib/Object/DXContainer.cpp

@@ -20,6 +20,10 @@ static Error parseFailed(const Twine &Msg) {
   return make_error<GenericBinaryError>(Msg.str(), object_error::parse_failed);
 }
 
+static Error validationFailed(const Twine &Msg) {
+  return make_error<StringError>(Msg.str(), inconvertibleErrorCode());
+}
+
 template <typename T>
 static Error readStruct(StringRef Buffer, const char *Src, T &Struct) {
   // Don't read before the beginning or past the end of the file
@@ -255,7 +259,8 @@ Error DirectX::RootSignature::parse(StringRef Data) {
   Current += sizeof(uint32_t);
 
   if (!dxbc::RootSignatureValidations::isValidVersion(VValue))
-    return make_error<GenericBinaryError>("Invalid Root Signature Version");
+    return validationFailed("unsupported root signature version read: " +
+                            llvm::Twine(VValue));
   Version = VValue;
 
   NumParameters =
@@ -279,7 +284,8 @@ Error DirectX::RootSignature::parse(StringRef Data) {
   Current += sizeof(uint32_t);
 
   if (!dxbc::RootSignatureValidations::isValidRootFlag(FValue))
-    return make_error<GenericBinaryError>("Invalid Root Signature flag");
+    return validationFailed("unsupported root signature flag value read: " +
+                            llvm::Twine(FValue));
   Flags = FValue;
 
   return Error::success();

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -266,15 +266,15 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
       if (!P.RootSignature.has_value())
         continue;
 
-      mcdxbc::RootSignatureHeader Header;
-      Header.Flags = P.RootSignature->getEncodedFlags();
-      Header.Version = P.RootSignature->Version;
-      Header.NumParameters = P.RootSignature->NumParameters;
-      Header.RootParametersOffset = P.RootSignature->RootParametersOffset;
-      Header.NumStaticSamplers = P.RootSignature->NumStaticSamplers;
-      Header.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset;
-
-      Header.write(OS);
+      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.write(OS);
       break;
     }
     uint64_t BytesWritten = OS.tell() - DataStart;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -29,7 +29,7 @@ DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
-DXContainerYAML::RootSignatureDesc::RootSignatureDesc(
+DXContainerYAML::RootSignatureYamlDesc::RootSignatureYamlDesc(
     const object::DirectX::RootSignature &Data)
     : Version(Data.getVersion()), NumParameters(Data.getNumParameters()),
       RootParametersOffset(Data.getRootParametersOffset()),
@@ -41,7 +41,7 @@ DXContainerYAML::RootSignatureDesc::RootSignatureDesc(
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
-uint32_t DXContainerYAML::RootSignatureDesc::getEncodedFlags() {
+uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() {
   uint64_t Flag = 0;
 #define ROOT_ELEMENT_FLAG(Num, Val)                                            \
   if (Val)                                                                     \
@@ -209,8 +209,8 @@ void MappingTraits<DXContainerYAML::Signature>::mapping(
   IO.mapRequired("Parameters", S.Parameters);
 }
 
-void MappingTraits<DXContainerYAML::RootSignatureDesc>::mapping(
-    IO &IO, DXContainerYAML::RootSignatureDesc &S) {
+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);

llvm/lib/Target/DirectX/CMakeLists.txt

@@ -34,6 +34,7 @@ add_llvm_target(DirectXCodeGen
   DXILShaderFlags.cpp
   DXILTranslateMetadata.cpp
   DXILRootSignature.cpp
+  
   LINK_COMPONENTS
   Analysis
   AsmPrinter

llvm/lib/Target/DirectX/DXContainerGlobals.cpp

@@ -24,9 +24,9 @@
 #include "llvm/IR/Module.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/MC/DXContainerPSVInfo.h"
-#include "llvm/MC/DXContainerRootSignature.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/MD5.h"
+#include "llvm/TargetParser/Triple.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 #include <optional>
 
@@ -153,19 +153,27 @@ void DXContainerGlobals::addSignature(Module &M,
 void DXContainerGlobals::addRootSignature(Module &M,
                                           SmallVector<GlobalValue *> &Globals) {
 
+  dxil::ModuleMetadataInfo &MMI =
+      getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata();
+
+  // Root Signature in Library don't compile to DXContainer.
+  if (MMI.ShaderProfile == llvm::Triple::Library)
+    return;
+
+  assert(MMI.EntryPropertyVec.size() == 1);
+
   auto &RSA = getAnalysis<RootSignatureAnalysisWrapper>();
+  const Function *EntryFunction = MMI.EntryPropertyVec[0].Entry;
+  const auto &FuncRs = RSA.find(EntryFunction);
 
-  if (!RSA.getResult())
+  if (FuncRs == RSA.end())
     return;
 
-  const ModuleRootSignature &MRS = RSA.getResult().value();
+  const RootSignatureDesc &RS = FuncRs->second;
   SmallString<256> Data;
   raw_svector_ostream OS(Data);
 
-  RootSignatureHeader RSH;
-  RSH.Flags = MRS.Flags;
-
-  RSH.write(OS);
+  RS.write(OS);
 
   Constant *Constant =
       ConstantDataArray::getString(M.getContext(), Data, /*AddNull*/ false);