Merge branch 'obj2yaml/root-constants' into metadata/root-constants

Author: joaosaffran

llvm/include/llvm/BinaryFormat/DXContainer.h

@@ -14,6 +14,7 @@
 #define LLVM_BINARYFORMAT_DXCONTAINER_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/TargetParser/Triple.h"
 
@@ -158,19 +159,39 @@ enum class RootElementFlag : uint32_t {
 };
 
 #define ROOT_PARAMETER(Val, Enum) Enum = Val,
-enum class RootParameterType : uint32_t {
+enum RootParameterType : uint32_t {
 #include "DXContainerConstants.def"
 };
 
 ArrayRef<EnumEntry<RootParameterType>> getRootParameterTypes();
 
+#define ROOT_PARAMETER(Val, Enum)                                              \
+  case Val:                                                                    \
+    return true;
+inline bool isValidParameterType(uint32_t V) {
+  switch (V) {
+#include "DXContainerConstants.def"
+  }
+  return false;
+}
+
 #define SHADER_VISIBILITY(Val, Enum) Enum = Val,
-enum class ShaderVisibility : uint32_t {
+enum ShaderVisibility : uint32_t {
 #include "DXContainerConstants.def"
 };
 
 ArrayRef<EnumEntry<ShaderVisibility>> getShaderVisibility();
 
+#define SHADER_VISIBILITY(Val, Enum)                                           \
+  case Val:                                                                    \
+    return true;
+inline bool isValidShaderVisibility(uint32_t V) {
+  switch (V) {
+#include "DXContainerConstants.def"
+  }
+  return false;
+}
+
 PartType parsePartType(StringRef S);
 
 struct VertexPSVInfo {
@@ -575,8 +596,8 @@ struct RootConstants {
 };
 
 struct RootParameterHeader {
-  RootParameterType ParameterType;
-  ShaderVisibility ShaderVisibility;
+  uint32_t ParameterType;
+  uint32_t ShaderVisibility;
   uint32_t ParameterOffset;
 
   void swapBytes() {

llvm/include/llvm/MC/DXContainerRootSignature.h

@@ -23,11 +23,9 @@ struct RootParameter {
 };
 struct RootSignatureDesc {
 
-  dxbc::RootSignatureHeader Header;
+  uint32_t Version = 2U;
+  uint32_t Flags = 0U;
   SmallVector<mcdxbc::RootParameter> Parameters;
-  RootSignatureDesc()
-      : Header(dxbc::RootSignatureHeader{
-            2, 0, sizeof(dxbc::RootSignatureHeader), 0, 0, 0}) {}
 
   void write(raw_ostream &OS) const;
 

llvm/include/llvm/Object/DXContainer.h

@@ -117,16 +117,6 @@ template <typename T> struct ViewArray {
 };
 
 namespace DirectX {
-
-struct RootParameter {
-  dxbc::RootParameterHeader Header;
-  union {
-    dxbc::RootConstants Constants;
-  };
-
-  RootParameter() = default;
-};
-
 struct RootParameterView {
   const dxbc::RootParameterHeader &Header;
   StringRef ParamData;
@@ -170,44 +160,43 @@ class RootSignature {
   uint32_t StaticSamplersOffset;
   uint32_t Flags;
   ViewArray<dxbc::RootParameterHeader> ParametersHeaders;
-  uint32_t ParameterSpaceOffset;
-  StringRef ParameterSpace;
+  StringRef PartData;
 
   using param_header_iterator = ViewArray<dxbc::RootParameterHeader>::iterator;
 
 public:
-  RootSignature() {}
+  RootSignature(StringRef PD) : PartData(PD) {}
 
-  Error parse(StringRef Data);
+  Error parse();
   uint32_t getVersion() const { return Version; }
   uint32_t getNumParameters() const { return NumParameters; }
   uint32_t getRootParametersOffset() const { return RootParametersOffset; }
   uint32_t getNumStaticSamplers() const { return NumStaticSamplers; }
   uint32_t getStaticSamplersOffset() const { return StaticSamplersOffset; }
-  llvm::iterator_range<param_header_iterator> param_header() const {
+  uint32_t getNumRootParameters() const { return ParametersHeaders.size(); }
+  llvm::iterator_range<param_header_iterator> param_headers() const {
     return llvm::make_range(ParametersHeaders.begin(), ParametersHeaders.end());
   }
   uint32_t getFlags() const { return Flags; }
 
   llvm::Expected<RootParameterView>
   getParameter(const dxbc::RootParameterHeader &Header) const {
-    assert(ParameterSpaceOffset != 0 &&
-           "This should be initialized before reading parameters");
-    size_t CorrectOffset = Header.ParameterOffset - ParameterSpaceOffset;
-    StringRef Data;
     size_t DataSize;
 
     switch (Header.ParameterType) {
     case dxbc::RootParameterType::Constants32Bit:
       DataSize = sizeof(dxbc::RootConstants);
       break;
     }
+    auto EndOfSectionByte = getNumStaticSamplers() == 0
+                                ? PartData.size()
+                                : getStaticSamplersOffset();
 
-    if (CorrectOffset + DataSize > ParameterSpace.size())
+    if (Header.ParameterOffset + DataSize > EndOfSectionByte)
       return parseFailed("Reading structure out of file bounds");
 
-    Data = ParameterSpace.substr(CorrectOffset, DataSize);
-    RootParameterView View = RootParameterView(Header, Data);
+    StringRef Buff = PartData.substr(Header.ParameterOffset, DataSize);
+    RootParameterView View = RootParameterView(Header, Buff);
     return View;
   }
 };

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

@@ -82,8 +82,8 @@ struct RootConstantsYaml {
 };
 
 struct RootParameterYamlDesc {
-  dxbc::RootParameterType Type;
-  dxbc::ShaderVisibility Visibility;
+  uint32_t Type;
+  uint32_t Visibility;
   uint32_t Offset;
 
   union {
@@ -93,16 +93,24 @@ struct RootParameterYamlDesc {
 
 struct RootSignatureYamlDesc {
   RootSignatureYamlDesc() = default;
-  RootSignatureYamlDesc(const object::DirectX::RootSignature &Data);
 
   uint32_t Version;
+  uint32_t NumRootParameters;
+  uint32_t RootParametersOffset;
   uint32_t NumStaticSamplers;
   uint32_t StaticSamplersOffset;
 
   SmallVector<RootParameterYamlDesc> Parameters;
 
   uint32_t getEncodedFlags();
 
+  iterator_range<RootParameterYamlDesc *> params() {
+    return make_range(Parameters.begin(), Parameters.end());
+  }
+
+  static llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
+  create(const object::DirectX::RootSignature &Data);
+
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 };
 
@@ -218,8 +226,6 @@ 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::ShaderVisibility)
 
 namespace llvm {
 

llvm/lib/MC/DXContainerRootSignature.cpp

@@ -51,13 +51,13 @@ void RootSignatureDesc::write(raw_ostream &OS) const {
   const uint32_t StaticSamplerOffset = 0u;
   const uint32_t NumStaticSamplers = 0u;
 
-  support::endian::write(BOS, Header.Version, llvm::endianness::little);
+  support::endian::write(BOS, Version, llvm::endianness::little);
   support::endian::write(BOS, NumParameters, llvm::endianness::little);
   support::endian::write(BOS, (uint32_t)sizeof(dxbc::RootSignatureHeader),
                          llvm::endianness::little);
   support::endian::write(BOS, StaticSamplerOffset, llvm::endianness::little);
   support::endian::write(BOS, NumStaticSamplers, llvm::endianness::little);
-  support::endian::write(BOS, Header.Flags, llvm::endianness::little);
+  support::endian::write(BOS, Flags, llvm::endianness::little);
 
   SmallVector<uint32_t> ParamsOffsets;
   for (const auto &P : Parameters) {

llvm/lib/Object/DXContainer.cpp

@@ -96,8 +96,8 @@ Error DXContainer::parseHash(StringRef Part) {
 Error DXContainer::parseRootSignature(StringRef Part) {
   if (RootSignature)
     return parseFailed("More than one RTS0 part is present in the file");
-  RootSignature = DirectX::RootSignature();
-  if (Error Err = RootSignature->parse(Part))
+  RootSignature = DirectX::RootSignature(Part);
+  if (Error Err = RootSignature->parse())
     return Err;
   return Error::success();
 }
@@ -242,12 +242,11 @@ void DXContainer::PartIterator::updateIteratorImpl(const uint32_t Offset) {
   IteratorState.Offset = Offset;
 }
 
-Error DirectX::RootSignature::parse(StringRef Data) {
-  const char *Begin = Data.begin();
-  const char *Current = Data.begin();
+Error DirectX::RootSignature::parse() {
+  const char *Current = PartData.begin();
 
   // Root Signature headers expects 6 integers to be present.
-  if (Data.size() < 6 * sizeof(uint32_t))
+  if (PartData.size() < 6 * sizeof(uint32_t))
     return parseFailed(
         "Invalid root signature, insufficient space for header.");
 
@@ -273,19 +272,11 @@ Error DirectX::RootSignature::parse(StringRef Data) {
   Flags = support::endian::read<uint32_t, llvm::endianness::little>(Current);
   Current += sizeof(uint32_t);
 
-  assert(Current == Begin + RootParametersOffset);
+  assert(Current == PartData.begin() + RootParametersOffset);
 
-  ParametersHeaders.Data = Data.substr(
+  ParametersHeaders.Data = PartData.substr(
       RootParametersOffset, NumParameters * sizeof(dxbc::RootParameterHeader));
 
-  ParameterSpaceOffset =
-      RootParametersOffset + NumParameters * sizeof(dxbc::RootParameterHeader);
-  size_t ParameterSpaceEnd =
-      (NumStaticSamplers == 0) ? Data.size() : StaticSamplersOffset;
-
-  ParameterSpace = Data.substr(ParameterSpaceOffset,
-                               ParameterSpaceEnd - ParameterSpaceOffset);
-
   return Error::success();
 }
 

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

@@ -267,8 +267,8 @@ void DXContainerWriter::writeParts(raw_ostream &OS) {
         continue;
 
       mcdxbc::RootSignatureDesc RS;
-      RS.Header.Flags = P.RootSignature->getEncodedFlags();
-      RS.Header.Version = P.RootSignature->Version;
+      RS.Flags = P.RootSignature->getEncodedFlags();
+      RS.Version = P.RootSignature->Version;
       for (const auto &Param : P.RootSignature->Parameters) {
         mcdxbc::RootParameter NewParam;
         NewParam.Header = dxbc::RootParameterHeader{

llvm/lib/ObjectYAML/DXContainerYAML.cpp

@@ -14,7 +14,9 @@
 #include "llvm/ObjectYAML/DXContainerYAML.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/ScopedPrinter.h"
+#include <system_error>
 
 namespace llvm {
 
@@ -29,39 +31,61 @@ DXContainerYAML::ShaderFeatureFlags::ShaderFeatureFlags(uint64_t FlagData) {
 #include "llvm/BinaryFormat/DXContainerConstants.def"
 }
 
-DXContainerYAML::RootSignatureYamlDesc::RootSignatureYamlDesc(
-    const object::DirectX::RootSignature &Data)
-    : Version(Data.getVersion()),
-      NumStaticSamplers(Data.getNumStaticSamplers()),
-      StaticSamplersOffset(Data.getStaticSamplersOffset()) {
+llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
+DXContainerYAML::RootSignatureYamlDesc::create(
+    const object::DirectX::RootSignature &Data) {
+
+  RootSignatureYamlDesc RootSigDesc;
+
+  RootSigDesc.Version = Data.getVersion();
+  RootSigDesc.NumStaticSamplers = Data.getNumStaticSamplers();
+  RootSigDesc.StaticSamplersOffset = Data.getStaticSamplersOffset();
+  RootSigDesc.NumRootParameters = Data.getNumRootParameters();
+  RootSigDesc.RootParametersOffset = Data.getRootParametersOffset();
+
   uint32_t Flags = Data.getFlags();
-  for (const auto &PH : Data.param_header()) {
+  for (const auto &PH : Data.param_headers()) {
 
     RootParameterYamlDesc NewP;
     NewP.Offset = PH.ParameterOffset;
+
+    if (!dxbc::isValidParameterType(PH.ParameterType))
+      return createStringError(std::errc::invalid_argument,
+                               "Invalid value for parameter type");
+
     NewP.Type = PH.ParameterType;
+
+    if (!dxbc::isValidShaderVisibility(PH.ShaderVisibility))
+      return createStringError(std::errc::invalid_argument,
+                               "Invalid value for shader visibility");
+
     NewP.Visibility = PH.ShaderVisibility;
 
-    llvm::Expected<object::DirectX::RootParameterView> ParamView =
+    llvm::Expected<object::DirectX::RootParameterView> ParamViewOrErr =
         Data.getParameter(PH);
-    if (!ParamView)
-      llvm::errs() << "Error: " << ParamView.takeError() << "\n";
-    auto PV = *ParamView;
-
-    if (auto *RCV = dyn_cast<object::DirectX::RootConstantView>(&PV)) {
-      auto Constants = RCV->read();
-      if (!Constants)
-        llvm::errs() << "Error: " << Constants.takeError() << "\n";
-
-      NewP.Constants.Num32BitValues = Constants->Num32BitValues;
-      NewP.Constants.ShaderRegister = Constants->ShaderRegister;
-      NewP.Constants.RegisterSpace = Constants->RegisterSpace;
+    if (Error E = ParamViewOrErr.takeError()) {
+      return std::move(E);
     }
-    Parameters.push_back(NewP);
+    object::DirectX::RootParameterView ParamView = ParamViewOrErr.get();
+
+    if (auto *RCV = dyn_cast<object::DirectX::RootConstantView>(&ParamView)) {
+      llvm::Expected<dxbc::RootConstants> ConstantsOrErr = RCV->read();
+      if (Error E = ConstantsOrErr.takeError()) {
+        return std::move(E);
+      }
+
+      auto Constants = *ConstantsOrErr;
+
+      NewP.Constants.Num32BitValues = Constants.Num32BitValues;
+      NewP.Constants.ShaderRegister = Constants.ShaderRegister;
+      NewP.Constants.RegisterSpace = Constants.RegisterSpace;
+    }
+    RootSigDesc.Parameters.push_back(NewP);
   }
 #define ROOT_ELEMENT_FLAG(Num, Val)                                            \
-  Val = (Flags & (uint32_t)dxbc::RootElementFlag::Val) > 0;
+  RootSigDesc.Val = (Flags & (uint32_t)dxbc::RootElementFlag::Val) > 0;
 #include "llvm/BinaryFormat/DXContainerConstants.def"
+  return RootSigDesc;
 }
 
 uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() {
@@ -235,6 +259,8 @@ void MappingTraits<DXContainerYAML::Signature>::mapping(
 void MappingTraits<DXContainerYAML::RootSignatureYamlDesc>::mapping(
     IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) {
   IO.mapRequired("Version", S.Version);
+  IO.mapRequired("NumRootParameters", S.NumRootParameters);
+  IO.mapRequired("RootParametersOffset", S.RootParametersOffset);
   IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers);
   IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset);
   IO.mapRequired("Parameters", S.Parameters);
@@ -363,18 +389,6 @@ 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::ShaderVisibility>::enumeration(
-    IO &IO, dxbc::ShaderVisibility &Value) {
-  for (const auto &E : dxbc::getShaderVisibility())
-    IO.enumCase(Value, E.Name.str().c_str(), E.Value);
-}
-
 } // namespace yaml
 
 void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) {