[DX] Add support for PSV signature elements

[beanz]

Summary

The pipeline state data captured in the PSV0 section of the DXContainer
file encodes signature elements which are read by the runtime to map
inputs and outputs from the GPU program.

This change adds support for generating and parsing signature elements
with testing driven through the ObjectYAML tooling.

[bogner]

llvm/include/llvm/BinaryFormat/DXContainer.h

281

Please undef SEMANTIC_KIND after the include here (and similarly below). That's generally a good practice and avoids leaking the define into a later include.

llvm/include/llvm/MC/DXContainerPSVInfo.h

71

Probably not for this change, but it would be nice to clean up all of this swapBytes stuff to use the helpers in llvm/Endian.h instead

[beanz]

llvm/include/llvm/BinaryFormat/DXContainer.h

281

I do the #undef in the header since I can't imagine a case where you'd include the .def file and not want to immediately undef the macro.

[MaskRay]

llvm/lib/MC/DXContainerPSVInfo.cpp

40

const auto &? PSVSignatureElement is large.

[beanz]

Use const auto & instead of auto

[bogner]

llvm/include/llvm/BinaryFormat/DXContainer.h

281

Makes sense. Thanks!

llvm/include/llvm/BinaryFormat/DXContainer.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SwapByteOrder.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include <stdint.h>
 
 namespace llvm {
+template <typename T> struct EnumEntry;
 
 // The DXContainer file format is arranged as a header and "parts". Semantically
 // parts are similar to sections in other object file formats. The File format
 // structure is roughly:
 
 // ┌────────────────────────────────┐
 // │             Header             │
 // ├────────────────────────────────┤
union PipelinePSVInfo {
   }
 };
 
 static_assert(sizeof(PipelinePSVInfo) == 4 * sizeof(uint32_t),
               "Pipeline-specific PSV info must fit in 16 bytes.");
 
 namespace PSV {
 
+#define SEMANTIC_KIND(Val, Enum) Enum = Val,
+enum class SemanticKind : uint8_t {
+#include "DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<SemanticKind>> getSemanticKinds();
+
+#define COMPONENT_TYPE(Val, Enum) Enum = Val,
+enum class ComponentType : uint8_t {
+#include "DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<ComponentType>> getComponentTypes();
+
+#define INTERPOLATION_MODE(Val, Enum) Enum = Val,
+enum class InterpolationMode : uint8_t {
+#include "DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<InterpolationMode>> getInterpolationModes();
+
 namespace v0 {
 struct RuntimeInfo {
   PipelinePSVInfo StageInfo;
   uint32_t MinimumWaveLaneCount; // minimum lane count required, 0 if unused
   uint32_t MaximumWaveLaneCount; // maximum lane count required,
                                  // 0xffffffff if unused
   void swapBytes() {
     // Skip the union because we don't know which field it has
struct ResourceBindInfo {
   void swapBytes() {
     sys::swapByteOrder(Type);
     sys::swapByteOrder(Space);
     sys::swapByteOrder(LowerBound);
     sys::swapByteOrder(UpperBound);
   }
 };
 
+struct SignatureElement {
+  uint32_t NameOffset;
+  uint32_t IndicesOffset;
+
+  uint8_t Rows;
+  uint8_t StartRow;
+  uint8_t Cols : 4;
+  uint8_t StartCol : 2;
+  uint8_t Allocated : 1;
+  uint8_t Unused : 1;
+  SemanticKind Kind;
+
+  ComponentType Type;
+  InterpolationMode Mode;
+  uint8_t DynamicMask : 4;
+  uint8_t Stream : 2;
+  uint8_t Unused2 : 2;
+  uint8_t Reserved;
+
+  void swapBytes() {
+    sys::swapByteOrder(NameOffset);
+    sys::swapByteOrder(IndicesOffset);
+  }
+};
+
+static_assert(sizeof(SignatureElement) == 4 * sizeof(uint32_t),
+              "PSV Signature elements must fit in 16 bytes.");
+
 } // namespace v0
 
 namespace v1 {
 
 struct MeshRuntimeInfo {
   uint8_t SigPrimVectors; // Primitive output for MS
   uint8_t MeshOutputTopology;
 };
 
 union GeometryExtraInfo {
   uint16_t MaxVertexCount;            // MaxVertexCount for GS only (max 1024)
   uint8_t SigPatchConstOrPrimVectors; // Output for HS; Input for DS;
                                       // Primitive output for MS (overlaps
                                       // MeshInfo::SigPrimVectors)
   MeshRuntimeInfo MeshInfo;
 };
 struct RuntimeInfo : public v0::RuntimeInfo {
   uint8_t ShaderStage; // PSVShaderKind
   uint8_t UsesViewID;
   GeometryExtraInfo GeomData;
 
   // PSVSignatureElement counts
   uint8_t SigInputElements;
   uint8_t SigOutputElements;
-  uint8_t SigPatchConstOrPrimElements;
+  uint8_t SigPatchOrPrimElements;
 
   // Number of packed vectors per signature
   uint8_t SigInputVectors;
   uint8_t SigOutputVectors[4];
 
   void swapBytes() {
     // nothing to swap since everything is single-byte or a union field
   }

llvm/include/llvm/BinaryFormat/DXContainerConstants.def

 SHADER_FLAG(28, AtomicInt64OnHeapResource, "64-bit Atomics on Heap Resources")
 SHADER_FLAG(29, AdvancedTextureOps, "Advanced Texture Ops")
 SHADER_FLAG(30, WriteableMSAATextures, "Writeable MSAA Textures")
 
 SHADER_FLAG(31, NextUnusedBit, "Next reserved shader flag bit (not a flag)")
 
 #undef SHADER_FLAG
 #endif
+
+#ifdef SEMANTIC_KIND
+
+SEMANTIC_KIND(0, Arbitrary)
+SEMANTIC_KIND(1, VertexID)
+SEMANTIC_KIND(2, InstanceID)
+SEMANTIC_KIND(3, Position)
+SEMANTIC_KIND(4, RenderTargetArrayIndex)
+SEMANTIC_KIND(5, ViewPortArrayIndex)
+SEMANTIC_KIND(6, ClipDistance)
+SEMANTIC_KIND(7, CullDistance)
+SEMANTIC_KIND(8, OutputControlPointID)
+SEMANTIC_KIND(9, DomainLocation)
+SEMANTIC_KIND(10, PrimitiveID)
+SEMANTIC_KIND(11, GSInstanceID)
+SEMANTIC_KIND(12, SampleIndex)
+SEMANTIC_KIND(13, IsFrontFace)
+SEMANTIC_KIND(14, Coverage)
+SEMANTIC_KIND(15, InnerCoverage)
+SEMANTIC_KIND(16, Target)
+SEMANTIC_KIND(17, Depth)
+SEMANTIC_KIND(18, DepthLessEqual)
+SEMANTIC_KIND(19, DepthGreaterEqual)
+SEMANTIC_KIND(20, StencilRef)
+SEMANTIC_KIND(21, DispatchThreadID)
+SEMANTIC_KIND(22, GroupID)
+SEMANTIC_KIND(23, GroupIndex)
+SEMANTIC_KIND(24, GroupThreadID)
+SEMANTIC_KIND(25, TessFactor)
+SEMANTIC_KIND(26, InsideTessFactor)
+SEMANTIC_KIND(27, ViewID)
+SEMANTIC_KIND(28, Barycentrics)
+SEMANTIC_KIND(29, ShadingRate)
+SEMANTIC_KIND(30, CullPrimitive)
+SEMANTIC_KIND(30, Invalid)
+
+#undef SEMANTIC_KIND
+#endif
+
+#ifdef COMPONENT_TYPE
+
+COMPONENT_TYPE(0, Unknown)
+COMPONENT_TYPE(1, UInt32)
+COMPONENT_TYPE(2, SInt32)
+COMPONENT_TYPE(3, Float32)
+COMPONENT_TYPE(4, UInt16)
+COMPONENT_TYPE(5, SInt16)
+COMPONENT_TYPE(6, Float16)
+COMPONENT_TYPE(7, UInt64)
+COMPONENT_TYPE(8, SInt64)
+COMPONENT_TYPE(9, Float64)
+
+#undef COMPONENT_TYPE
+#endif
+
+#ifdef INTERPOLATION_MODE
+
+INTERPOLATION_MODE(0, Undefined)
+INTERPOLATION_MODE(1, Constant)
+INTERPOLATION_MODE(2, Linear)
+INTERPOLATION_MODE(3, LinearCentroid)
+INTERPOLATION_MODE(4, LinearNoperspective)
+INTERPOLATION_MODE(5, LinearNoperspectiveCentroid)
+INTERPOLATION_MODE(6, LinearSample)
+INTERPOLATION_MODE(7, LinearNoperspectiveSample)
+INTERPOLATION_MODE(8, Invalid)
+
+#undef INTERPOLATION_MODE
+#endif

llvm/include/llvm/MC/DXContainerPSVInfo.h

 //===- llvm/MC/DXContainerPSVInfo.h - DXContainer PSVInfo -*- C++ -------*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_DXCONTAINERPSVINFO_H
 #define LLVM_MC_DXCONTAINERPSVINFO_H
 
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/TargetParser/Triple.h"
 
 #include <numeric>
 #include <stdint.h>
-#include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 namespace mcdxbc {
+
+struct PSVSignatureElement {
+  StringRef Name;
+  SmallVector<uint32_t> Indices;
+  uint8_t StartRow;
+  uint8_t Cols;
+  uint8_t StartCol;
+  bool Allocated;
+  dxbc::PSV::SemanticKind Kind;
+  dxbc::PSV::ComponentType Type;
+  dxbc::PSV::InterpolationMode Mode;
+  uint8_t DynamicMask;
+  uint8_t Stream;
+};
+
 // This data structure is a helper for reading and writing PSV RuntimeInfo data.
 // It is implemented in the BinaryFormat library so that it can be used by both
 // the MC layer and Object tools.
 // This structure is used to represent the extracted data in an inspectable and
 // modifiable format, and can be used to serialize the data back into valid PSV
 // RuntimeInfo.
 struct PSVRuntimeInfo {
+  bool IsFinalized = false;
   dxbc::PSV::v2::RuntimeInfo BaseData;
-  std::vector<dxbc::PSV::v2::ResourceBindInfo> Resources;
+  SmallVector<dxbc::PSV::v2::ResourceBindInfo> Resources;
+  SmallVector<PSVSignatureElement> InputElements;
+  SmallVector<PSVSignatureElement> OutputElements;
+  SmallVector<PSVSignatureElement> PatchOrPrimElements;
 
   // Serialize PSVInfo into the provided raw_ostream. The version field
   // specifies the data version to encode, the default value specifies encoding
   // the highest supported version.
   void write(raw_ostream &OS,
              uint32_t Version = std::numeric_limits<uint32_t>::max()) const;
 
-  void swapBytes(Triple::EnvironmentType Stage) {
+  void finalize(Triple::EnvironmentType Stage) {
+    IsFinalized = true;
+    BaseData.SigInputElements = static_cast<uint32_t>(InputElements.size());
+    BaseData.SigOutputElements = static_cast<uint32_t>(OutputElements.size());
+    BaseData.SigPatchOrPrimElements =
+        static_cast<uint32_t>(PatchOrPrimElements.size());
+    if (!sys::IsBigEndianHost)
+      return;
     BaseData.swapBytes();
     BaseData.swapBytes(Stage);
     for (auto &Res : Resources)
       Res.swapBytes();
   }
 };
 
 } // namespace mcdxbc
 } // namespace llvm
 
 #endif // LLVM_MC_DXCONTAINERPSVINFO_H

llvm/include/llvm/MC/StringTableBuilder.h

enum Kind {
     ELF,
     WinCOFF,
     MachO,
     MachO64,
     MachOLinked,
     MachO64Linked,
     RAW,
     DWARF,
-    XCOFF
+    XCOFF,
+    DXContainer
   };
 
 private:
   DenseMap<CachedHashStringRef, size_t> StringIndexMap;
   size_t Size = 0;
   Kind K;
   Align Alignment;
   bool Finalized = false;

llvm/include/llvm/Object/DXContainer.h

 
 namespace DirectX {
 class PSVRuntimeInfo {
 
   // This class provides a view into the underlying resource array. The Resource
   // data is little-endian encoded and may not be properly aligned to read
   // directly from. The dereference operator creates a copy of the data and byte
   // swaps it as appropriate.
-  struct ResourceArray {
+  template <typename T> struct ViewArray {
     StringRef Data;
     uint32_t Stride; // size of each element in the list.
 
-    ResourceArray() = default;
-    ResourceArray(StringRef D, size_t S) : Data(D), Stride(S) {}
+    ViewArray() = default;
+    ViewArray(StringRef D, size_t S) : Data(D), Stride(S) {}
 
-    using value_type = dxbc::PSV::v2::ResourceBindInfo;
+    using value_type = T;
     static constexpr uint32_t MaxStride() {
       return static_cast<uint32_t>(sizeof(value_type));
     }
 
     struct iterator {
       StringRef Data;
       uint32_t Stride; // size of each element in the list.
       const char *Current;
 
-      iterator(const ResourceArray &A, const char *C)
+      iterator(const ViewArray &A, const char *C)
           : Data(A.Data), Stride(A.Stride), Current(C) {}
       iterator(const iterator &) = default;
 
       value_type operator*() {
         // Explicitly zero the structure so that unused fields are zeroed. It is
         // up to the user to know if the fields are used by verifying the PSV
         // version.
-        value_type Val = {{0, 0, 0, 0}, 0, 0};
+        value_type Val;
+        std::memset(&Val, 0, sizeof(value_type));
         if (Current >= Data.end())
           return Val;
         memcpy(static_cast<void *>(&Val), Current,
                std::min(Stride, MaxStride()));
         if (sys::IsBigEndianHost)
           Val.swapBytes();
         return Val;
       }
template <typename T> struct ViewArray {
 
     iterator begin() const { return iterator(*this, Data.begin()); }
 
     iterator end() const { return iterator(*this, Data.end()); }
 
     size_t size() const { return Data.size() / Stride; }
   };
 
+  using ResourceArray = ViewArray<dxbc::PSV::v2::ResourceBindInfo>;
+  using SigElementArray = ViewArray<dxbc::PSV::v0::SignatureElement>;
+
   StringRef Data;
   uint32_t Size;
   using InfoStruct =
       std::variant<std::monostate, dxbc::PSV::v0::RuntimeInfo,
                    dxbc::PSV::v1::RuntimeInfo, dxbc::PSV::v2::RuntimeInfo>;
   InfoStruct BasicInfo;
   ResourceArray Resources;
+  StringRef StringTable;
+  SmallVector<uint32_t> SemanticIndexTable;
+  SigElementArray SigInputElements;
+  SigElementArray SigOutputElements;
+  SigElementArray SigPatchOrPrimElements;
 
 public:
   PSVRuntimeInfo(StringRef D) : Data(D), Size(0) {}
 
   // Parsing depends on the shader kind
   Error parse(uint16_t ShaderKind);
 
   uint32_t getSize() const { return Size; }
   uint32_t getResourceCount() const { return Resources.size(); }
   ResourceArray getResources() const { return Resources; }
 
   uint32_t getVersion() const {
     return Size >= sizeof(dxbc::PSV::v2::RuntimeInfo)
                ? 2
                : (Size >= sizeof(dxbc::PSV::v1::RuntimeInfo) ? 1 : 0);
   }
 
   uint32_t getResourceStride() const { return Resources.Stride; }
 
   const InfoStruct &getInfo() const { return BasicInfo; }
+
+  StringRef getStringTable() const { return StringTable; }
+  ArrayRef<uint32_t> getSemanticIndexTable() const {
+    return SemanticIndexTable;
+  }
+
+  uint8_t getSigInputCount() const;
+  uint8_t getSigOutputCount() const;
+  uint8_t getSigPatchOrPrimCount() const;
+
+  SigElementArray getSigInputElements() const { return SigInputElements; }
+  SigElementArray getSigOutputElements() const { return SigOutputElements; }
+  SigElementArray getSigPatchOrPrimElements() const {
+    return SigPatchOrPrimElements;
+  }
+
+  uint32_t getSigElementStride() const { return SigInputElements.Stride; }
 };
 
 } // namespace DirectX
 
 class DXContainer {
 public:
   using DXILData = std::pair<dxbc::ProgramHeader, const char *>;
 

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

struct ShaderHash {
   ShaderHash(const dxbc::ShaderHash &Data);
 
   bool IncludesSource;
   std::vector<llvm::yaml::Hex8> Digest;
 };
 
 using ResourceBindInfo = dxbc::PSV::v2::ResourceBindInfo;
 
+struct SignatureElement {
+  SignatureElement() = default;
+
+  SignatureElement(dxbc::PSV::v0::SignatureElement El, StringRef StringTable,
+                   ArrayRef<uint32_t> IdxTable)
+      : Name(StringTable.substr(El.NameOffset,
+                                StringTable.find('\0', El.NameOffset) -
+                                    El.NameOffset)),
+        Indices(IdxTable.slice(El.IndicesOffset, El.Rows)),
+        StartRow(El.StartRow), Cols(El.Cols), StartCol(El.StartCol),
+        Allocated(El.Allocated != 0), Kind(El.Kind), Type(El.Type),
+        Mode(El.Mode), DynamicMask(El.DynamicMask), Stream(El.Stream) {}
+  StringRef Name;
+  SmallVector<uint32_t> Indices;
+
+  uint8_t StartRow;
+  uint8_t Cols;
+  uint8_t StartCol;
+  bool Allocated;
+  dxbc::PSV::SemanticKind Kind;
+
+  dxbc::PSV::ComponentType Type;
+  dxbc::PSV::InterpolationMode Mode;
+  llvm::yaml::Hex8 DynamicMask;
+  uint8_t Stream;
+};
+
 struct PSVInfo {
   // The version field isn't actually encoded in the file, but it is inferred by
   // the size of data regions. We include it in the yaml because it simplifies
   // the format.
   uint32_t Version;
 
   dxbc::PSV::v2::RuntimeInfo Info;
   uint32_t ResourceStride;
-  std::vector<ResourceBindInfo> Resources;
+  SmallVector<ResourceBindInfo> Resources;
+  SmallVector<SignatureElement> SigInputElements;
+  SmallVector<SignatureElement> SigOutputElements;
+  SmallVector<SignatureElement> SigPatchOrPrimElements;
 
   void mapInfoForVersion(yaml::IO &IO);
 
   PSVInfo();
   PSVInfo(const dxbc::PSV::v0::RuntimeInfo *P, uint16_t Stage);
   PSVInfo(const dxbc::PSV::v1::RuntimeInfo *P);
   PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P);
 };
struct Object {
   std::vector<Part> Parts;
 };
 
 } // namespace DXContainerYAML
 } // namespace llvm
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::Part)
 LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::ResourceBindInfo)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureElement)
+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)
+
 namespace llvm {
 
 class raw_ostream;
 
 namespace yaml {
 
 template <> struct MappingTraits<DXContainerYAML::VersionTuple> {
   static void mapping(IO &IO, DXContainerYAML::VersionTuple &Version);

 template <> struct MappingTraits<DXContainerYAML::Object> {
   static void mapping(IO &IO, DXContainerYAML::Object &Obj);
 };
 
 template <> struct MappingTraits<DXContainerYAML::ResourceBindInfo> {
   static void mapping(IO &IO, DXContainerYAML::ResourceBindInfo &Res);
 };
 
+template <> struct MappingTraits<DXContainerYAML::SignatureElement> {
+  static void mapping(IO &IO, llvm::DXContainerYAML::SignatureElement &El);
+};
+
 } // namespace yaml
 
 } // namespace llvm
 
 #endif // LLVM_OBJECTYAML_DXCONTAINERYAML_H

llvm/lib/BinaryFormat/DXContainer.cpp

 
 //===-- llvm/BinaryFormat/DXContainer.cpp - DXContainer Utils ----*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains utility functions for working with DXContainers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ScopedPrinter.h"
 
 using namespace llvm;
 using namespace llvm::dxbc;
 
 dxbc::PartType dxbc::parsePartType(StringRef S) {
 #define CONTAINER_PART(PartName) .Case(#PartName, PartType::PartName)
   return StringSwitch<dxbc::PartType>(S)
 #include "llvm/BinaryFormat/DXContainerConstants.def"
       .Default(dxbc::PartType::Unknown);
 }
 
 bool ShaderHash::isPopulated() {
   static uint8_t Zeros[16] = {0};
   return Flags > 0 || 0 != memcmp(&Digest, &Zeros, 16);
 }
+
+#define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum},
+
+static const EnumEntry<PSV::SemanticKind> SemanticKindNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<PSV::SemanticKind>> PSV::getSemanticKinds() {
+  return ArrayRef(SemanticKindNames);
+}
+
+#define COMPONENT_TYPE(Val, Enum) {#Enum, PSV::ComponentType::Enum},
+
+static const EnumEntry<PSV::ComponentType> ComponentTypeNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<PSV::ComponentType>> PSV::getComponentTypes() {
+  return ArrayRef(ComponentTypeNames);
+}
+
+#define INTERPOLATION_MODE(Val, Enum) {#Enum, PSV::InterpolationMode::Enum},
+
+static const EnumEntry<PSV::InterpolationMode> InterpolationModeNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<PSV::InterpolationMode>> PSV::getInterpolationModes() {
+  return ArrayRef(InterpolationModeNames);
+}

llvm/lib/MC/DXContainerPSVInfo.cpp

 //===- llvm/MC/DXContainerPSVInfo.cpp - DXContainer PSVInfo -----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/DXContainerPSVInfo.h"
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::mcdxbc;
 using namespace llvm::dxbc::PSV;
 
+static constexpr size_t npos = StringRef::npos;
+
+static size_t FindSequence(ArrayRef<uint32_t> Buffer,
+                           ArrayRef<uint32_t> Sequence) {
+  if (Buffer.size() < Sequence.size())
+    return npos;
+  for (size_t Idx = 0; Idx <= Buffer.size() - Sequence.size(); ++Idx) {
+    if (0 == memcmp(static_cast<const void *>(&Buffer[Idx]),
+                    static_cast<const void *>(Sequence.begin()),
+                    Sequence.size() * sizeof(uint32_t)))
+      return Idx;
+  }
+  return npos;
+}
+
+static void
+ProcessElementList(StringTableBuilder &StrTabBuilder,
+                   SmallVectorImpl<uint32_t> &IndexBuffer,
+                   SmallVectorImpl<v0::SignatureElement> &FinalElements,
+                   SmallVectorImpl<StringRef> &SemanticNames,
+                   ArrayRef<PSVSignatureElement> Elements) {
+  for (const auto &El : Elements) {
+    // Put the name in the string table and the name list.
+    StrTabBuilder.add(El.Name);
+    SemanticNames.push_back(El.Name);
+
+    v0::SignatureElement FinalElement;
+    memset(&FinalElement, 0, sizeof(v0::SignatureElement));
+    FinalElement.Rows = static_cast<uint8_t>(El.Indices.size());
+    FinalElement.StartRow = El.StartRow;
+    FinalElement.Cols = El.Cols;
+    FinalElement.StartCol = El.StartCol;
+    FinalElement.Allocated = El.Allocated;
+    FinalElement.Kind = El.Kind;
+    FinalElement.Type = El.Type;
+    FinalElement.Mode = El.Mode;
+    FinalElement.DynamicMask = El.DynamicMask;
+    FinalElement.Stream = El.Stream;
+
+    size_t Idx = FindSequence(IndexBuffer, El.Indices);
+    if (Idx == npos) {
+      FinalElement.IndicesOffset = static_cast<uint32_t>(IndexBuffer.size());
+      IndexBuffer.insert(IndexBuffer.end(), El.Indices.begin(),
+                         El.Indices.end());
+    } else
+      FinalElement.IndicesOffset = static_cast<uint32_t>(Idx);
+    FinalElements.push_back(FinalElement);
+  }
+}
+
 void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
+  assert(IsFinalized && "finalize must be called before write");
+
   uint32_t InfoSize;
   uint32_t BindingSize;
   switch (Version) {
   case 0:
     InfoSize = sizeof(dxbc::PSV::v0::RuntimeInfo);
     BindingSize = sizeof(dxbc::PSV::v0::ResourceBindInfo);
     break;
   case 1:
void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
 
   support::endian::write(OS, InfoSize, support::little);
   // Write the info itself.
   OS.write(reinterpret_cast<const char *>(&BaseData), InfoSize);
 
   uint32_t ResourceCount = static_cast<uint32_t>(Resources.size());
 
   support::endian::write(OS, ResourceCount, support::little);
+  if (ResourceCount > 0)
     support::endian::write(OS, BindingSize, support::little);
 
   for (const auto &Res : Resources)
     OS.write(reinterpret_cast<const char *>(&Res), BindingSize);
+
+  StringTableBuilder StrTabBuilder((StringTableBuilder::DXContainer));
+  SmallVector<uint32_t, 64> IndexBuffer;
+  SmallVector<v0::SignatureElement, 32> SignatureElements;
+  SmallVector<StringRef, 32> SemanticNames;
+
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, InputElements);
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, OutputElements);
+  ProcessElementList(StrTabBuilder, IndexBuffer, SignatureElements,
+                     SemanticNames, PatchOrPrimElements);
+
+  StrTabBuilder.finalize();
+  for (auto ElAndName : zip(SignatureElements, SemanticNames)) {
+    v0::SignatureElement &El = std::get<0>(ElAndName);
+    StringRef Name = std::get<1>(ElAndName);
+    El.NameOffset = static_cast<uint32_t>(StrTabBuilder.getOffset(Name));
+    if (sys::IsBigEndianHost)
+      El.swapBytes();
+  }
+
+  support::endian::write(OS, static_cast<uint32_t>(StrTabBuilder.getSize()),
+                         support::little);
+
+  // Write the string table.
+  StrTabBuilder.write(OS);
+
+  // Write the index table size, then table.
+  support::endian::write(OS, static_cast<uint32_t>(IndexBuffer.size()),
+                         support::little);
+  for (auto I : IndexBuffer)
+    support::endian::write(OS, I, support::little);
+
+  // write the size of the signature elements.
+  support::endian::write(
+      OS, static_cast<uint32_t>(sizeof(v0::SignatureElement)), support::little);
+
+  // write the signature elements.
+  OS.write(reinterpret_cast<const char *>(&SignatureElements[0]),
+           SignatureElements.size() * sizeof(v0::SignatureElement));
 }

llvm/lib/MC/StringTableBuilder.cpp

case DWARF:
     break;
   case MachOLinked:
   case MachO64Linked:
     Size = 2;
     break;
   case MachO:
   case MachO64:
   case ELF:
+  case DXContainer:
     // Start the table with a NUL byte.
     Size = 1;
     break;
   case XCOFF:
   case WinCOFF:
     // Make room to write the table size later.
     Size = 4;
     break;
for (StringPair *P : Strings) {
 
       Size += S.size();
       if (K != RAW)
         ++Size;
       Previous = S;
     }
   }
 
-  if (K == MachO || K == MachOLinked)
+  if (K == MachO || K == MachOLinked || K == DXContainer)
     Size = alignTo(Size, 4); // Pad to multiple of 4.
   if (K == MachO64 || K == MachO64Linked)
     Size = alignTo(Size, 8); // Pad to multiple of 8.
 
   // According to ld64 the string table of a final linked Mach-O binary starts
   // with " ", i.e. the first byte is ' ' and the second byte is zero. In
   // 'initSize()' we reserved the first two bytes for holding this string.
   if (K == MachOLinked || K == MachO64Linked)

llvm/lib/Object/DXContainer.cpp

 //===- DXContainer.cpp - DXContainer object file implementation -----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Object/DXContainer.h"
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/Object/Error.h"
+#include "llvm/Support/Alignment.h"
 #include "llvm/Support/FormatVariadic.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 static Error parseFailed(const Twine &Msg) {
   return make_error<GenericBinaryError>(Msg.str(), object_error::parse_failed);
 }
if (PSVVersion == 2) {
     BasicInfo = Info;
   } else if (PSVVersion == 1) {
     v1::RuntimeInfo Info;
     if (Error Err = readStruct(PSVInfoData, Current, Info))
       return Err;
     if (sys::IsBigEndianHost)
       Info.swapBytes(ShaderStage);
     BasicInfo = Info;
-  } else {
+  } else if (PSVVersion == 0) {
     v0::RuntimeInfo Info;
     if (Error Err = readStruct(PSVInfoData, Current, Info))
       return Err;
     if (sys::IsBigEndianHost)
       Info.swapBytes(ShaderStage);
     BasicInfo = Info;
-  }
+  } else
+    return parseFailed(
+        "Cannot read PSV Runtime Info, unsupported PSV version.");
+
   Current += Size;
 
   uint32_t ResourceCount = 0;
   if (Error Err = readInteger(Data, Current, ResourceCount))
     return Err;
   Current += sizeof(uint32_t);
 
   if (ResourceCount > 0) {
     if (Error Err = readInteger(Data, Current, Resources.Stride))
       return Err;
     Current += sizeof(uint32_t);
 
     size_t BindingDataSize = Resources.Stride * ResourceCount;
     Resources.Data = Data.substr(Current - Data.begin(), BindingDataSize);
 
     if (Resources.Data.size() < BindingDataSize)
       return parseFailed(
           "Resource binding data extends beyond the bounds of the part");
 
     Current += BindingDataSize;
+  } else
+    Resources.Stride = sizeof(v2::ResourceBindInfo);
+
+  // PSV version 0 ends after the resource bindings.
+  if (PSVVersion == 0)
+    return Error::success();
+
+  // String table starts at a 4-byte offset.
+  Current = reinterpret_cast<const char *>(
+      alignTo<4>(reinterpret_cast<const uintptr_t>(Current)));
+
+  uint32_t StringTableSize = 0;
+  if (Error Err = readInteger(Data, Current, StringTableSize))
+    return Err;
+  if (StringTableSize % 4 != 0)
+    return parseFailed("String table misaligned");
+  Current += sizeof(uint32_t);
+  StringTable = StringRef(Current, StringTableSize);
+
+  Current += StringTableSize;
+
+  uint32_t SemanticIndexTableSize = 0;
+  if (Error Err = readInteger(Data, Current, SemanticIndexTableSize))
+    return Err;
+  Current += sizeof(uint32_t);
+
+  SemanticIndexTable.reserve(SemanticIndexTableSize);
+  for (uint32_t I = 0; I < SemanticIndexTableSize; ++I) {
+    uint32_t Index = 0;
+    if (Error Err = readInteger(Data, Current, Index))
+      return Err;
+    Current += sizeof(uint32_t);
+    SemanticIndexTable.push_back(Index);
+  }
+
+  uint8_t InputCount = getSigInputCount();
+  uint8_t OutputCount = getSigOutputCount();
+  uint8_t PatchOrPrimCount = getSigPatchOrPrimCount();
+
+  uint32_t ElementCount = InputCount + OutputCount + PatchOrPrimCount;
+
+  if (ElementCount > 0) {
+    if (Error Err = readInteger(Data, Current, SigInputElements.Stride))
+      return Err;
+    Current += sizeof(uint32_t);
+    // Assign the stride to all the arrays.
+    SigOutputElements.Stride = SigPatchOrPrimElements.Stride =
+        SigInputElements.Stride;
+
+    if (Data.end() - Current < ElementCount * SigInputElements.Stride)
+      return parseFailed(
+          "Signature elements extend beyond the size of the part");
+
+    size_t InputSize = SigInputElements.Stride * InputCount;
+    SigInputElements.Data = Data.substr(Current - Data.begin(), InputSize);
+    Current += InputSize;
+
+    size_t OutputSize = SigOutputElements.Stride * OutputCount;
+    SigOutputElements.Data = Data.substr(Current - Data.begin(), OutputSize);
+    Current += OutputSize;
+
+    size_t PSize = SigPatchOrPrimElements.Stride * PatchOrPrimCount;
+    SigPatchOrPrimElements.Data = Data.substr(Current - Data.begin(), PSize);
+    Current += PSize;
   }
 
   return Error::success();
 }
+
+uint8_t DirectX::PSVRuntimeInfo::getSigInputCount() const {
+  if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
+    return P->SigInputElements;
+  if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
+    return P->SigInputElements;
+  return 0;
+}
+
+uint8_t DirectX::PSVRuntimeInfo::getSigOutputCount() const {
+  if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
+    return P->SigOutputElements;
+  if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
+    return P->SigOutputElements;
+  return 0;
+}
+
+uint8_t DirectX::PSVRuntimeInfo::getSigPatchOrPrimCount() const {
+  if (const auto *P = std::get_if<dxbc::PSV::v2::RuntimeInfo>(&BasicInfo))
+    return P->SigPatchOrPrimElements;
+  if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(&BasicInfo))
+    return P->SigPatchOrPrimElements;
+  return 0;
+}

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

for (auto I : llvm::zip(ObjectFile.Parts, *ObjectFile.Header.PartOffsets)) {
     }
     case dxbc::PartType::PSV0: {
       if (!P.Info.has_value())
         continue;
       mcdxbc::PSVRuntimeInfo PSV;
       memcpy(&PSV.BaseData, &P.Info->Info, sizeof(dxbc::PSV::v2::RuntimeInfo));
       PSV.Resources = P.Info->Resources;
 
-      if (sys::IsBigEndianHost)
-        PSV.swapBytes(static_cast<Triple::EnvironmentType>(
-            Triple::Pixel + P.Info->Info.ShaderStage));
+      for (auto El : P.Info->SigInputElements)
+        PSV.InputElements.push_back(mcdxbc::PSVSignatureElement{
+            El.Name, El.Indices, El.StartRow, El.Cols, El.StartCol,
+            El.Allocated, El.Kind, El.Type, El.Mode, El.DynamicMask,
+            El.Stream});
+
+      for (auto El : P.Info->SigOutputElements)
+        PSV.OutputElements.push_back(mcdxbc::PSVSignatureElement{
+            El.Name, El.Indices, El.StartRow, El.Cols, El.StartCol,
+            El.Allocated, El.Kind, El.Type, El.Mode, El.DynamicMask,
+            El.Stream});
+
+      for (auto El : P.Info->SigPatchOrPrimElements)
+        PSV.PatchOrPrimElements.push_back(mcdxbc::PSVSignatureElement{
+            El.Name, El.Indices, El.StartRow, El.Cols, El.StartCol,
+            El.Allocated, El.Kind, El.Type, El.Mode, El.DynamicMask,
+            El.Stream});
+
+      PSV.finalize(static_cast<Triple::EnvironmentType>(
       PSV.write(OS, P.Info->Version);
       break;
     }
     case dxbc::PartType::Unknown:
       break; // Skip any handling for unrecognized parts.
     }
     uint64_t BytesWritten = OS.tell() - DataStart;
     RollingOffset += BytesWritten;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

 //===- DXContainerYAML.cpp - DXContainer YAMLIO implementation ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines classes for handling the YAML representation of
 // DXContainerYAML.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ObjectYAML/DXContainerYAML.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/Support/ScopedPrinter.h"
 
 namespace llvm {
 
 // This assert is duplicated here to leave a breadcrumb of the places that need
 // to be updated if flags grow past 64-bits.
 static_assert((uint64_t)dxbc::FeatureFlags::NextUnusedBit <= 1ull << 63,
               "Shader flag bits exceed enum size.");
 
void MappingTraits<DXContainerYAML::PSVInfo>::mapping(
     IO &IO, DXContainerYAML::PSVInfo &PSV) {
   IO.mapRequired("Version", PSV.Version);
 
   // Store the PSV version in the YAML context.
   void *OldContext = IO.getContext();
   uint32_t Version = PSV.Version;
   IO.setContext(&Version);
 
+  // Restore the YAML context on function exit.
+  auto RestoreContext = make_scope_exit([&]() { IO.setContext(OldContext); });
+
   // Shader stage is only included in binaries for v1 and later, but we always
   // include it since it simplifies parsing and file construction.
   IO.mapRequired("ShaderStage", PSV.Info.ShaderStage);
   PSV.mapInfoForVersion(IO);
 
   IO.mapRequired("ResourceStride", PSV.ResourceStride);
   IO.mapRequired("Resources", PSV.Resources);
-
-  // Restore the YAML context.
-  IO.setContext(OldContext);
+  if (PSV.Version == 0)
+    return;
+  IO.mapRequired("SigInputElements", PSV.SigInputElements);
+  IO.mapRequired("SigOutputElements", PSV.SigOutputElements);
+  IO.mapRequired("SigPatchOrPrimElements", PSV.SigPatchOrPrimElements);
 }
 
 void MappingTraits<DXContainerYAML::Part>::mapping(IO &IO,
                                                    DXContainerYAML::Part &P) {
   IO.mapRequired("Name", P.Name);
   IO.mapRequired("Size", P.Size);
   IO.mapOptional("Program", P.Program);
   IO.mapOptional("Flags", P.Flags);
void MappingTraits<DXContainerYAML::ResourceBindInfo>::mapping(
   const uint32_t *PSVVersion = static_cast<uint32_t *>(IO.getContext());
   if (*PSVVersion < 2)
     return;
 
   IO.mapRequired("Kind", Res.Kind);
   IO.mapRequired("Flags", Res.Flags);
 }
 
+void MappingTraits<DXContainerYAML::SignatureElement>::mapping(
+    IO &IO, DXContainerYAML::SignatureElement &El) {
+  IO.mapRequired("Name", El.Name);
+  IO.mapRequired("Indices", El.Indices);
+  IO.mapRequired("StartRow", El.StartRow);
+  IO.mapRequired("Cols", El.Cols);
+  IO.mapRequired("StartCol", El.StartCol);
+  IO.mapRequired("Allocated", El.Allocated);
+  IO.mapRequired("Kind", El.Kind);
+  IO.mapRequired("ComponentType", El.Type);
+  IO.mapRequired("Interpolation", El.Mode);
+  IO.mapRequired("DynamicMask", El.DynamicMask);
+  IO.mapRequired("Stream", El.Stream);
+}
+
+void ScalarEnumerationTraits<dxbc::PSV::SemanticKind>::enumeration(
+    IO &IO, dxbc::PSV::SemanticKind &Value) {
+  for (const auto &E : dxbc::PSV::getSemanticKinds())
+    IO.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+
+void ScalarEnumerationTraits<dxbc::PSV::ComponentType>::enumeration(
+    IO &IO, dxbc::PSV::ComponentType &Value) {
+  for (const auto &E : dxbc::PSV::getComponentTypes())
+    IO.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+
+void ScalarEnumerationTraits<dxbc::PSV::InterpolationMode>::enumeration(
+    IO &IO, dxbc::PSV::InterpolationMode &Value) {
+  for (const auto &E : dxbc::PSV::getInterpolationModes())
+    IO.enumCase(Value, E.Name.str().c_str(), E.Value);
+}
+
 } // namespace yaml
 
 void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) {
   dxbc::PipelinePSVInfo &StageInfo = Info.StageInfo;
   Triple::EnvironmentType Stage = dxbc::getShaderStage(Info.ShaderStage);
 
   switch (Stage) {
   case Triple::EnvironmentType::Pixel:
case Triple::EnvironmentType::Mesh:
     IO.mapRequired("SigPrimVectors", Info.GeomData.MeshInfo.SigPrimVectors);
     IO.mapRequired("MeshOutputTopology",
                    Info.GeomData.MeshInfo.MeshOutputTopology);
     break;
   default:
     break;
   }
 
-  IO.mapRequired("SigInputElements", Info.SigInputElements);
-  IO.mapRequired("SigOutputElements", Info.SigOutputElements);
-  IO.mapRequired("SigPatchConstOrPrimElements",
-                 Info.SigPatchConstOrPrimElements);
   IO.mapRequired("SigInputVectors", Info.SigInputVectors);
   MutableArrayRef<uint8_t> Vec(Info.SigOutputVectors);
   IO.mapRequired("SigOutputVectors", Vec);
 
   if (Version == 1)
     return;
 
   IO.mapRequired("NumThreadsX", Info.NumThreadsX);
   IO.mapRequired("NumThreadsY", Info.NumThreadsY);
   IO.mapRequired("NumThreadsZ", Info.NumThreadsZ);
 }
 
 } // namespace llvm

llvm/test/ObjectYAML/DXContainer/PSVv1-amplification.yaml

- Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         1
       ShaderStage:     14
       PayloadSizeInBytes: 4092
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      14
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     14
 # CHECK-NEXT: PayloadSizeInBytes: 4092
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-compute.yaml

Parts:
   - Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         1
       ShaderStage:     5
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      5
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     5
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-domain.yaml

PSVInfo:
       ShaderStage:     4
       InputControlPointCount: 1024
       OutputPositionPresent: 1
       TessellatorDomain: 2056
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPatchConstOrPrimVectors:  128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      4
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     4
 # CHECK-NEXT: InputControlPointCount: 1024
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: TessellatorDomain: 2056
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPatchConstOrPrimVectors:  128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-geometry.yaml

PSVInfo:
       InputPrimitive: 1024
       OutputTopology: 4096
       OutputStreamMask: 2056
       OutputPositionPresent: 1
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       MaxVertexCount:  4096
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      2
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     2
 # CHECK-NEXT: InputPrimitive: 1024
 # CHECK-NEXT: OutputTopology: 4096
 # CHECK-NEXT: OutputStreamMask: 2056
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: MaxVertexCount:  4096
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-hull.yaml

PSVInfo:
       InputControlPointCount: 1024
       OutputControlPointCount: 4096
       TessellatorDomain: 2056
       TessellatorOutputPrimitive: 8192
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPatchConstOrPrimVectors:  128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      3
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     3
 # CHECK-NEXT: InputControlPointCount: 1024
 # CHECK-NEXT: OutputControlPointCount: 4096
 # CHECK-NEXT: TessellatorDomain: 2056
 # CHECK-NEXT: TessellatorOutputPrimitive: 8192
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPatchConstOrPrimVectors:  128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-mesh.yaml

PSVInfo:
       PayloadSizeInBytes: 4092
       MaxOutputVertices: 8196
       MaxOutputPrimitives: 4092
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPrimVectors:  128
       MeshOutputTopology: 16
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      13
       Size:            6
       DXILMajorVersion: 0

 # CHECK-NEXT: PayloadSizeInBytes: 4092
 # CHECK-NEXT: MaxOutputVertices: 8196
 # CHECK-NEXT: MaxOutputPrimitives: 4092
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPrimVectors:  128
 # CHECK-NEXT: MeshOutputTopology: 16
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-pixel.yaml

- Name:            PSV0
     PSVInfo:
       Version:         1
       ShaderStage:     0
       DepthOutput:     7
       SampleFrequency: 96
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      0
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     0
 # CHECK-NEXT: DepthOutput:     7
 # CHECK-NEXT: SampleFrequency: 96
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-vertex.yaml

- Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         1
       ShaderStage:     1
       OutputPositionPresent: 1
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       ResourceStride:       16
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      1
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         1
 # CHECK-NEXT: ShaderStage:     1
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: ResourceStride: 16
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-amplification.yaml

- Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         2
       ShaderStage:     14
       PayloadSizeInBytes: 4092
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      14
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     14
 # CHECK-NEXT: PayloadSizeInBytes: 4092
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-compute.yaml

Parts:
   - Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         2
       ShaderStage:     5
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      5
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     5
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-domain.yaml

PSVInfo:
       ShaderStage:     4
       InputControlPointCount: 1024
       OutputPositionPresent: 1
       TessellatorDomain: 2056
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPatchConstOrPrimVectors:  128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      4
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     4
 # CHECK-NEXT: InputControlPointCount: 1024
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: TessellatorDomain: 2056
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPatchConstOrPrimVectors:  128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-geometry.yaml

PSVInfo:
       InputPrimitive: 1024
       OutputTopology: 4096
       OutputStreamMask: 2056
       OutputPositionPresent: 1
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       MaxVertexCount:  4096
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      2
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     2
 # CHECK-NEXT: InputPrimitive: 1024
 # CHECK-NEXT: OutputTopology: 4096
 # CHECK-NEXT: OutputStreamMask: 2056
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: MaxVertexCount:  4096
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-hull.yaml

PSVInfo:
       InputControlPointCount: 1024
       OutputControlPointCount: 4096
       TessellatorDomain: 2056
       TessellatorOutputPrimitive: 8192
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPatchConstOrPrimVectors:  128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      3
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     3
 # CHECK-NEXT: InputControlPointCount: 1024
 # CHECK-NEXT: OutputControlPointCount: 4096
 # CHECK-NEXT: TessellatorDomain: 2056
 # CHECK-NEXT: TessellatorOutputPrimitive: 8192
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPatchConstOrPrimVectors:  128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-mesh.yaml

PSVInfo:
       PayloadSizeInBytes: 4092
       MaxOutputVertices: 8196
       MaxOutputPrimitives: 4092
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
       SigPrimVectors:  128
       MeshOutputTopology: 16
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      13
       Size:            6
       DXILMajorVersion: 0

 # CHECK-NEXT: PayloadSizeInBytes: 4092
 # CHECK-NEXT: MaxOutputVertices: 8196
 # CHECK-NEXT: MaxOutputPrimitives: 4092
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
 # CHECK-NEXT: SigPrimVectors:  128
 # CHECK-NEXT: MeshOutputTopology: 16
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-pixel.yaml

- Name:            PSV0
     PSVInfo:
       Version:         2
       ShaderStage:     0
       DepthOutput:     7
       SampleFrequency: 96
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      0
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     0
 # CHECK-NEXT: DepthOutput:     7
 # CHECK-NEXT: SampleFrequency: 96
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-vertex.yaml

- Name:            PSV0
     Size:            144
     PSVInfo:
       Version:         2
       ShaderStage:     1
       OutputPositionPresent: 1
       MinimumWaveLaneCount: 0
       MaximumWaveLaneCount: 4294967295
       UsesViewID:      128
-      SigInputElements: 8
-      SigOutputElements: 16
-      SigPatchConstOrPrimElements: 32
       SigInputVectors: 64
       SigOutputVectors: [ 8, 16, 32, 64 ]
       NumThreadsX:     512
       NumThreadsY:     1024
       NumThreadsZ:     2048
       ResourceStride:       24
       Resources:
         - Type:            1
           Space:           2
           LowerBound:      3
           UpperBound:      4
           Kind:            5
           Flags:           6
         - Type:            128
           Space:           32768
           LowerBound:      8388608
           UpperBound:      2147483648
           Kind:            65535
           Flags:           16776960
+      SigInputElements: []
+      SigOutputElements: []
+      SigPatchOrPrimElements: []
   - Name:            DXIL
     Size:            24
     Program:
       MajorVersion:    6
       MinorVersion:    0
       ShaderKind:      1
       Size:            6
       DXILMajorVersion: 0
       DXILMinorVersion: 1
       DXILSize:        0
 ...
 
 # CHECK: Name:            PSV0
 # CHECK: PSVInfo:
 # CHECK-NEXT: Version:         2
 # CHECK-NEXT: ShaderStage:     1
 # CHECK-NEXT: OutputPositionPresent: 1
 # CHECK-NEXT: MinimumWaveLaneCount: 0
 # CHECK-NEXT: MaximumWaveLaneCount: 4294967295
 # CHECK-NEXT: UsesViewID:      128
-# CHECK-NEXT: SigInputElements: 8
-# CHECK-NEXT: SigOutputElements: 16
-# CHECK-NEXT: SigPatchConstOrPrimElements: 32
 # CHECK-NEXT: SigInputVectors: 64
 # CHECK-NEXT: SigOutputVectors: [ 8, 16, 32, 64 ]
 # CHECK-NEXT: NumThreadsX:     512
 # CHECK-NEXT: NumThreadsY:     1024
 # CHECK-NEXT: NumThreadsZ:     2048
 # CHECK-NEXT: ResourceStride: 24
 # CHECK-NEXT: Resources:
 # CHECK-NEXT: - Type:            1
 # CHECK-NEXT: Space:           2
 # CHECK-NEXT: LowerBound:      3
 # CHECK-NEXT: UpperBound:      4
 # CHECK-NEXT: Kind:            5
 # CHECK-NEXT: Flags:           6
 # CHECK-NEXT: - Type:            128
 # CHECK-NEXT: Space:           32768
 # CHECK-NEXT: LowerBound:      8388608
 # CHECK-NEXT: UpperBound:      2147483648
 # CHECK-NEXT: Kind:            65535
 # CHECK-NEXT: Flags:           16776960
+# CHECK-NEXT: SigInputElements: []
+# CHECK-NEXT: SigOutputElements: []
+# CHECK-NEXT: SigPatchOrPrimElements: []
 # CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/SigElements.yaml

+# 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:       2
+Parts:
+  - Name:            PSV0
+    Size:            250
+    PSVInfo:
+      Version:         1
+      ShaderStage:     0
+      DepthOutput:     7
+      SampleFrequency: 96
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+      UsesViewID:      128
+      SigInputVectors: 64
+      SigOutputVectors: [ 8, 16, 32, 64 ]
+      ResourceStride:       16
+      Resources:
+        - Type:            1
+          Space:           2
+          LowerBound:      3
+          UpperBound:      4
+        - Type:            128
+          Space:           32768
+          LowerBound:      8388608
+          UpperBound:      2147483648
+      SigInputElements:
+        - Name:            IN
+          Indices:         [ 0, 1 ]
+          StartRow:        0
+          Cols:            2
+          StartCol:        0
+          Allocated:       true
+          Kind:            Arbitrary
+          ComponentType:   SInt32
+          Interpolation:   Undefined
+          DynamicMask:     0x0
+          Stream:          0
+      SigOutputElements:
+        - Name:            OUT
+          Indices:         [ 0, 1 ]
+          StartRow:        0
+          Cols:            2
+          StartCol:        0
+          Allocated:       true
+          Kind:            Arbitrary
+          ComponentType:   Float32
+          Interpolation:   Linear
+          DynamicMask:     0x0
+          Stream:          1
+      SigPatchOrPrimElements:
+        - Name:            Patch
+          Indices:         [ 0 ]
+          StartRow:        0
+          Cols:            1
+          StartCol:        0
+          Allocated:       true
+          Kind:            Arbitrary
+          ComponentType:   Float32
+          Interpolation:   Linear
+          DynamicMask:     0x1
+          Stream:          2
+        - Name:            Patch1
+          Indices:         [ 2 ]
+          StartRow:        0
+          Cols:            1
+          StartCol:        0
+          Allocated:       true
+          Kind:            Arbitrary
+          ComponentType:   Float64
+          Interpolation:   LinearSample
+          DynamicMask:     0x2
+          Stream:          3
+  - Name:            DXIL
+    Size:            24
+    Program:
+      MajorVersion:    6
+      MinorVersion:    0
+      ShaderKind:      0
+      Size:            6
+      DXILMajorVersion: 0
+      DXILMinorVersion: 1
+      DXILSize:        0
+...
+
+# CHECK: Name:            PSV0
+# CHECK: PSVInfo:
+# CHECK-NEXT: Version:         1
+# CHECK-NEXT: ShaderStage:     0
+
+# CHECK: SigInputElements:
+# CHECK-NEXT:   - Name:            IN
+# CHECK-NEXT:     Indices:         [ 0, 1 ]
+# CHECK-NEXT:     StartRow:        0
+# CHECK-NEXT:     Cols:            2
+# CHECK-NEXT:     StartCol:        0
+# CHECK-NEXT:     Allocated:       true
+# CHECK-NEXT:     Kind:            Arbitrary
+# CHECK-NEXT:     ComponentType:   SInt32
+# CHECK-NEXT:     Interpolation:   Undefined
+# CHECK-NEXT:     DynamicMask:     0x0
+# CHECK-NEXT:     Stream:          0
+# CHECK-NEXT: SigOutputElements:
+# CHECK-NEXT:   - Name:            OUT
+# CHECK-NEXT:     Indices:         [ 0, 1 ]
+# CHECK-NEXT:     StartRow:        0
+# CHECK-NEXT:     Cols:            2
+# CHECK-NEXT:     StartCol:        0
+# CHECK-NEXT:     Allocated:       true
+# CHECK-NEXT:     Kind:            Arbitrary
+# CHECK-NEXT:     ComponentType:   Float32
+# CHECK-NEXT:     Interpolation:   Linear
+# CHECK-NEXT:     DynamicMask:     0x0
+# CHECK-NEXT:     Stream:          1
+# CHECK-NEXT: SigPatchOrPrimElements:
+# CHECK-NEXT:   - Name:            Patch
+# CHECK-NEXT:     Indices:         [ 0 ]
+# CHECK-NEXT:     StartRow:        0
+# CHECK-NEXT:     Cols:            1
+# CHECK-NEXT:     StartCol:        0
+# CHECK-NEXT:     Allocated:       true
+# CHECK-NEXT:     Kind:            Arbitrary
+# CHECK-NEXT:     ComponentType:   Float32
+# CHECK-NEXT:     Interpolation:   Linear
+# CHECK-NEXT:     DynamicMask:     0x1
+# CHECK-NEXT:     Stream:          2
+# CHECK-NEXT:   - Name:            Patch1
+# CHECK-NEXT:     Indices:         [ 2 ]
+# CHECK-NEXT:     StartRow:        0
+# CHECK-NEXT:     Cols:            1
+# CHECK-NEXT:     StartCol:        0
+# CHECK-NEXT:     Allocated:       true
+# CHECK-NEXT:     Kind:            Arbitrary
+# CHECK-NEXT:     ComponentType:   Float64
+# CHECK-NEXT:     Interpolation:   LinearSample
+# CHECK-NEXT:     DynamicMask:     0x2
+# CHECK-NEXT:     Stream:          3

llvm/tools/obj2yaml/dxcontainer2yaml.cpp

case dxbc::PartType::PSV0: {
                      &PSVInfo->getInfo()))
         NewPart.Info = DXContainerYAML::PSVInfo(P);
       else if (const auto *P =
                    std::get_if<dxbc::PSV::v2::RuntimeInfo>(&PSVInfo->getInfo()))
         NewPart.Info = DXContainerYAML::PSVInfo(P);
       NewPart.Info->ResourceStride = PSVInfo->getResourceStride();
       for (auto Res : PSVInfo->getResources())
         NewPart.Info->Resources.push_back(Res);
+
+      for (auto El : PSVInfo->getSigInputElements())
+        NewPart.Info->SigInputElements.push_back(
+            DXContainerYAML::SignatureElement(
+                El, PSVInfo->getStringTable(),
+                PSVInfo->getSemanticIndexTable()));
+      for (auto El : PSVInfo->getSigOutputElements())
+        NewPart.Info->SigOutputElements.push_back(
+            DXContainerYAML::SignatureElement(
+                El, PSVInfo->getStringTable(),
+                PSVInfo->getSemanticIndexTable()));
+      for (auto El : PSVInfo->getSigPatchOrPrimElements())
+        NewPart.Info->SigPatchOrPrimElements.push_back(
+            DXContainerYAML::SignatureElement(
+                El, PSVInfo->getStringTable(),
+                PSVInfo->getSemanticIndexTable()));
       break;
     }
     case dxbc::PartType::Unknown:
       break;
     }
   }
 
   return Obj.release();

llvm/unittests/Object/DXContainerTest.cpp

TEST(DXCFile, PSVResourceIteratorsStride) {
   Binding = *It;
 
   EXPECT_TRUE(It == PSVInfo->getResources().end());
   EXPECT_FALSE(It != PSVInfo->getResources().end());
 
   EXPECT_EQ(Binding.Type, 0u);
   EXPECT_EQ(Binding.Flags, 0u);
 }
+
+// This test binary is created using mutations of the yaml in the SigElements
+// test found under test/ObjectYAML/DXContainer/SigElements.yaml.
+
+TEST(DXCFile, MisalignedStringTable) {
+  uint8_t Buffer[] = {
+      0x44, 0x58, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+      0xb4, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+      0x48, 0x00, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x18, 0x00, 0x00, 0x00,
+      0x60, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+      0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x50, 0x53, 0x56, 0x30, 0x68, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+      0x05, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x08, 0x10, 0x20, 0x40,
+      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
+  EXPECT_THAT_EXPECTED(DXContainer::create(getMemoryBuffer<168>(Buffer)),
+                       FailedWithMessage("String table misaligned"));
+}
+
+// This test binary is created using mutations of the yaml in the SigElements
+// test found under test/ObjectYAML/DXContainer/SigElements.yaml.
+TEST(DXCFile, SigElementsExtendBeyondPart) {
+  uint8_t Buffer[] = {
+      0x44, 0x58, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+      0xb4, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00,
+      0x48, 0x00, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c, 0x18, 0x00, 0x00, 0x00,
+      0x60, 0x00, 0x0e, 0x00, 0x06, 0x00, 0x00, 0x00, 0x44, 0x58, 0x49, 0x4c,
+      0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x50, 0x53, 0x56, 0x30, 0x54, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+      0x05, 0x80, 0x00, 0x00, 0x02, 0x00, 0x00, 0x40, 0x08, 0x10, 0x20, 0x40,
+      0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x49, 0x4e, 0x00,
+      0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+      0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+      0x02, 0x00, 0x42, 0x00, 0x02, 0x00, 0x03, 0x00};
+  EXPECT_THAT_EXPECTED(
+      DXContainer::create(getMemoryBuffer<164>(Buffer)),
+      FailedWithMessage(
+          "Signature elements extend beyond the size of the part"));
+}