[DX] Begin adding support for pipeline state

[beanz]

Summary

DirectX shader pipeline state validation information is a fairly
complicated to serialize data structure. This patch adds the first bit
of support for reading and writing the runtime info structure which
comes first in the encoded data.

Subsequent patches will flesh out the remaining fields of the data
structure.

There is no official documentation for the format, but the format is
roughly documented in the code comment here:
https://github.com/microsoft/DirectXShaderCompiler/blob/main/include/dxc
/DxilContainer/DxilPipelineStateValidation.h#L731

[python3kgae]

So no resource support in this PR?

[beanz]

In D141649#4050286, @python3kgae wrote:

So no resource support in this PR?

This is a fairly large change which adds support for the first bits of the PSV info. I have more changes locally, but to put it all in one change is against the developer policy (see: https://llvm.org/docs/DeveloperPolicy.html#incremental-development).

As I said in the description, subsequent patches will continue to fill out the data structure.

[python3kgae]

llvm/include/llvm/BinaryFormat/DXContainer.h

203

Why we need Unused here?
If we need 32bit align, VertexPSVInfo need Unused too.

287

Both swapBytes() and swapBytes(Stage) changed data.
Do we call both of them?

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

29

amplification shader needs shader model 6.5

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

33

mesh shader needs shader model 6.5

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

30

Only mesh/compute/amplification shader set NumThreadX/Y/Z.

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

30

We cannot have NumThreadsX and Signature at the same time.

[beanz]

llvm/include/llvm/BinaryFormat/DXContainer.h

287

Yes, proper byte swapping of the union requires knowing the shader stage. The default swapBytes method gets called generically when reading the structures, but the version that needs to know the shader stage has to be called explicitly.

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

33

The point of these tests is to verify the testing infrastructure's ability to deconstruct and re-construct the data structures. They do not (and should not) validate the data itself. The testing infrastructure needs to be able to generate invalid data so that we can test for error cases in the tools that do validate.

[beanz]

Adding Unused to VertexPSVInfo

[beanz]

A little bit of code cleanup. While working on the next patch in the series I refactored some of this code and thought I should just bring the refactoring back.

I also discovered a bug encoding data on big endian systems because I missed a stage-specific byte swap call. I've fixed that here too.

[python3kgae]

LGTM.
Will next PR add resource support?

llvm/include/llvm/BinaryFormat/DXContainer.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_BINARYFORMAT_DXCONTAINER_H
 #define LLVM_BINARYFORMAT_DXCONTAINER_H
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/SwapByteOrder.h"
+#include "llvm/TargetParser/Triple.h"
 
 #include <stdint.h>
 
 namespace llvm {
 
 // 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             │
 // ├────────────────────────────────┤
 // │              Part              │
 // ├────────────────────────────────┤
 // │              Part              │
 // ├────────────────────────────────┤
 // │              ...               │
 // └────────────────────────────────┘
 
 namespace dxbc {
 
+inline Triple::EnvironmentType getShaderStage(uint32_t Kind) {
+  assert(Kind <= Triple::Amplification - Triple::Pixel &&
+         "Shader kind out of expected range.");
+  return static_cast<Triple::EnvironmentType>(Triple::Pixel + Kind);
+}
+
 struct Hash {
   uint8_t Digest[16];
 };
 
 enum class HashFlags : uint32_t {
   None = 0,           // No flags defined.
   IncludesSource = 1, // This flag indicates that the shader hash was computed
                       // taking into account source information (-Zss)

 enum class FeatureFlags : uint64_t {
 #include "DXContainerConstants.def"
 };
 static_assert((uint64_t)FeatureFlags::NextUnusedBit <= 1ull << 63,
               "Shader flag bits exceed enum size.");
 
 PartType parsePartType(StringRef S);
 
+struct VertexPSVInfo {
+  uint8_t OutputPositionPresent;
+  uint8_t Unused[3];
+
+  void swapBytes() {
+    // nothing to swap
+  }
+};
+
+struct HullPSVInfo {
+  uint32_t InputControlPointCount;
+  uint32_t OutputControlPointCount;
+  uint32_t TessellatorDomain;
+  uint32_t TessellatorOutputPrimitive;
+
+  void swapBytes() {
+    sys::swapByteOrder(InputControlPointCount);
+    sys::swapByteOrder(OutputControlPointCount);
+    sys::swapByteOrder(TessellatorDomain);
+    sys::swapByteOrder(TessellatorOutputPrimitive);
+  }
+};
+
+struct DomainPSVInfo {
+  uint32_t InputControlPointCount;
+  uint8_t OutputPositionPresent;
+  uint8_t Unused[3];
+  uint32_t TessellatorDomain;
+
+  void swapBytes() {
+    sys::swapByteOrder(InputControlPointCount);
+    sys::swapByteOrder(TessellatorDomain);
+  }
+};
+
+struct GeometryPSVInfo {
+  uint32_t InputPrimitive;
+  uint32_t OutputTopology;
+  uint32_t OutputStreamMask;
+  uint8_t OutputPositionPresent;
+  uint8_t Unused[3];
+
+  void swapBytes() {
+    sys::swapByteOrder(InputPrimitive);
+    sys::swapByteOrder(OutputTopology);
+    sys::swapByteOrder(OutputStreamMask);
+  }
+};
+
+struct PixelPSVInfo {
+  uint8_t DepthOutput;
+  uint8_t SampleFrequency;
+  uint8_t Unused[2];
+
+  void swapBytes() {
+    // nothing to swap
+  }
+};
+
+struct MeshPSVInfo {
+  uint32_t GroupSharedBytesUsed;
+  uint32_t GroupSharedBytesDependentOnViewID;
+  uint32_t PayloadSizeInBytes;
+  uint16_t MaxOutputVertices;
+  uint16_t MaxOutputPrimitives;
+
+  void swapBytes() {
+    sys::swapByteOrder(GroupSharedBytesUsed);
+    sys::swapByteOrder(GroupSharedBytesDependentOnViewID);
+    sys::swapByteOrder(PayloadSizeInBytes);
+    sys::swapByteOrder(MaxOutputVertices);
+    sys::swapByteOrder(MaxOutputPrimitives);
+  }
+};
+
+struct AmplificationPSVInfo {
+  uint32_t PayloadSizeInBytes;
+
+  void swapBytes() { sys::swapByteOrder(PayloadSizeInBytes); }
+};
+
+union PipelinePSVInfo {
+  VertexPSVInfo VS;
+  HullPSVInfo HS;
+  DomainPSVInfo DS;
+  GeometryPSVInfo GS;
+  PixelPSVInfo PS;
+  MeshPSVInfo MS;
+  AmplificationPSVInfo AS;
+
+  void swapBytes(Triple::EnvironmentType Stage) {
+    switch (Stage) {
+    case Triple::EnvironmentType::Pixel:
+      PS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Vertex:
+      VS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Geometry:
+      GS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Hull:
+      HS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Domain:
+      DS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Mesh:
+      MS.swapBytes();
+      break;
+    case Triple::EnvironmentType::Amplification:
+      AS.swapBytes();
+      break;
+    default:
+      break;
+    }
+  }
+};
+
+static_assert(sizeof(PipelinePSVInfo) == 4 * sizeof(uint32_t),
+              "Pipeline-specific PSV info must fit in 16 bytes.");
+
+namespace PSV {
+
+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
+    sys::swapByteOrder(MinimumWaveLaneCount);
+    sys::swapByteOrder(MaximumWaveLaneCount);
+  }
+
+  void swapBytes(Triple::EnvironmentType Stage) { StageInfo.swapBytes(Stage); }
+};
+
+} // 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;
+
+  // 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
+  }
+
+  void swapBytes(Triple::EnvironmentType Stage) {
+    v0::RuntimeInfo::swapBytes(Stage);
+    if (Stage == Triple::EnvironmentType::Geometry)
+      sys::swapByteOrder(GeomData.MaxVertexCount);
+  }
+};
+
+} // namespace v1
+
+namespace v2 {
+struct RuntimeInfo : public v1::RuntimeInfo {
+  uint32_t NumThreadsX;
+  uint32_t NumThreadsY;
+  uint32_t NumThreadsZ;
+
+  void swapBytes() {
+    sys::swapByteOrder(NumThreadsX);
+    sys::swapByteOrder(NumThreadsY);
+    sys::swapByteOrder(NumThreadsZ);
+  }
+
+  void swapBytes(Triple::EnvironmentType Stage) {
+    v1::RuntimeInfo::swapBytes(Stage);
+  }
+};
+
+} // namespace v2
+} // namespace PSV
+
 } // namespace dxbc
 } // namespace llvm
 
 #endif // LLVM_BINARYFORMAT_DXCONTAINER_H

llvm/include/llvm/BinaryFormat/DXContainerConstants.def

 
 #ifdef CONTAINER_PART
 CONTAINER_PART(DXIL)
 CONTAINER_PART(SFI0)
 CONTAINER_PART(HASH)
+CONTAINER_PART(PSV0)
 
 #undef CONTAINER_PART
 #endif 
 
 #ifdef SHADER_FLAG
 
 SHADER_FLAG(0, Doubles, "Double-precision floating point")
 SHADER_FLAG(1, ComputeShadersPlusRawAndStructuredBuffers, "Raw and Structured buffers")

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/BinaryFormat/DXContainer.h"
+#include "llvm/TargetParser/Triple.h"
+
+#include <numeric>
+#include <stdint.h>
+#include <vector>
+
+namespace llvm {
+
+class raw_ostream;
+
+namespace mcdxbc {
+// 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 {
+  dxbc::PSV::v2::RuntimeInfo BaseData;
+
+  // 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) {
+    BaseData.swapBytes();
+    BaseData.swapBytes(Stage);
+  }
+};
+
+} // namespace mcdxbc
+} // namespace llvm
+
+#endif // LLVM_MC_DXCONTAINERPSVINFO_H

llvm/include/llvm/Object/DXContainer.h

 #ifndef LLVM_OBJECT_DXCONTAINER_H
 #define LLVM_OBJECT_DXCONTAINER_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/DXContainer.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MemoryBufferRef.h"
+#include "llvm/TargetParser/Triple.h"
 
 namespace llvm {
 namespace object {
+
+namespace DirectX {
+class PSVRuntimeInfo {
+  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;
+
+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 getVersion() const {
+    return Size >= sizeof(dxbc::PSV::v2::RuntimeInfo)
+               ? 2
+               : (Size >= sizeof(dxbc::PSV::v1::RuntimeInfo) ? 1 : 0);
+  }
+
+  const InfoStruct &getInfo() const { return BasicInfo; }
+};
+
+} // namespace DirectX
+
 class DXContainer {
 public:
   using DXILData = std::pair<dxbc::ProgramHeader, const char *>;
 
 private:
   DXContainer(MemoryBufferRef O);
 
   MemoryBufferRef Data;
   dxbc::Header Header;
   SmallVector<uint32_t, 4> PartOffsets;
   std::optional<DXILData> DXIL;
   std::optional<uint64_t> ShaderFlags;
   std::optional<dxbc::ShaderHash> Hash;
+  std::optional<DirectX::PSVRuntimeInfo> PSVInfo;
 
   Error parseHeader();
   Error parsePartOffsets();
   Error parseDXILHeader(StringRef Part);
   Error parseShaderFlags(StringRef Part);
   Error parseHash(StringRef Part);
+  Error parsePSVInfo(StringRef Part);
   friend class PartIterator;
 
 public:
   // The PartIterator is a wrapper around the iterator for the PartOffsets
   // member of the DXContainer. It contains a refernce to the container, and the
   // current iterator value, as well as storage for a parsed part header.
   class PartIterator {
     const DXContainer &Container;
public:
 
   PartIterator end() const { return PartIterator(*this, PartOffsets.end()); }
 
   StringRef getData() const { return Data.getBuffer(); }
   static Expected<DXContainer> create(MemoryBufferRef Object);
 
   const dxbc::Header &getHeader() const { return Header; }
 
-  std::optional<DXILData> getDXIL() const { return DXIL; }
+  const std::optional<DXILData> &getDXIL() const { return DXIL; }
 
   std::optional<uint64_t> getShaderFlags() const { return ShaderFlags; }
 
   std::optional<dxbc::ShaderHash> getShaderHash() const { return Hash; }
+
+  const std::optional<DirectX::PSVRuntimeInfo> &getPSVInfo() const {
+    return PSVInfo;
+  };
 };
 
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_DXCONTAINER_H

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

 struct ShaderHash {
   ShaderHash() = default;
   ShaderHash(const dxbc::ShaderHash &Data);
 
   bool IncludesSource;
   std::vector<llvm::yaml::Hex8> Digest;
 };
 
+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;
+
+  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 Part {
   Part() = default;
   Part(std::string N, uint32_t S) : Name(N), Size(S) {}
   std::string Name;
   uint32_t Size;
   std::optional<DXILProgram> Program;
   std::optional<ShaderFlags> Flags;
   std::optional<ShaderHash> Hash;
+  std::optional<PSVInfo> Info;
 };
 
 struct Object {
   FileHeader Header;
   std::vector<Part> Parts;
 };
 
 } // namespace DXContainerYAML

 template <> struct MappingTraits<DXContainerYAML::ShaderFlags> {
   static void mapping(IO &IO, DXContainerYAML::ShaderFlags &Flags);
 };
 
 template <> struct MappingTraits<DXContainerYAML::ShaderHash> {
   static void mapping(IO &IO, DXContainerYAML::ShaderHash &Hash);
 };
 
+template <> struct MappingTraits<DXContainerYAML::PSVInfo> {
+  static void mapping(IO &IO, DXContainerYAML::PSVInfo &PSV);
+};
+
 template <> struct MappingTraits<DXContainerYAML::Part> {
   static void mapping(IO &IO, DXContainerYAML::Part &Version);
 };
 
 template <> struct MappingTraits<DXContainerYAML::Object> {
   static void mapping(IO &IO, DXContainerYAML::Object &Obj);
 };
 
 } // namespace yaml
 
 } // namespace llvm
 
 #endif // LLVM_OBJECTYAML_DXCONTAINERYAML_H

llvm/lib/MC/CMakeLists.txt

 add_llvm_component_library(LLVMMC
   ConstantPools.cpp
+  DXContainerPSVInfo.cpp
   ELFObjectWriter.cpp
   MCAsmBackend.cpp
   MCAsmInfo.cpp
   MCAsmInfoCOFF.cpp
   MCAsmInfoDarwin.cpp
   MCAsmInfoELF.cpp
   MCAsmInfoGOFF.cpp
   MCAsmInfoWasm.cpp

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/Support/raw_ostream.h"
+
+using namespace llvm;
+using namespace llvm::mcdxbc;
+
+void PSVRuntimeInfo::write(raw_ostream &OS, uint32_t Version) const {
+  uint32_t InfoSize;
+  switch (Version) {
+  case 0:
+    InfoSize = sizeof(dxbc::PSV::v0::RuntimeInfo);
+    break;
+  case 1:
+    InfoSize = sizeof(dxbc::PSV::v1::RuntimeInfo);
+    break;
+  case 2:
+  default:
+    InfoSize = sizeof(dxbc::PSV::v2::RuntimeInfo);
+  }
+  // Write the size of the info.
+  OS.write(reinterpret_cast<const char *>(&InfoSize), sizeof(uint32_t));
+  // Write the info itself.
+  OS.write(reinterpret_cast<const char *>(&BaseData), InfoSize);
+}

llvm/lib/Object/DXContainer.cpp

if (Hash)
     return parseFailed("More than one HASH part is present in the file");
   dxbc::ShaderHash ReadHash;
   if (Error Err = readStruct(Part, Part.begin(), ReadHash))
     return Err;
   Hash = ReadHash;
   return Error::success();
 }
 
+Error DXContainer::parsePSVInfo(StringRef Part) {
+  if (PSVInfo)
+    return parseFailed("More than one PSV0 part is present in the file");
+  PSVInfo = DirectX::PSVRuntimeInfo(Part);
+  // Parsing the PSVRuntime info occurs late because we need to read data from
+  // other parts first.
+  return Error::success();
+}
+
 Error DXContainer::parsePartOffsets() {
   uint32_t LastOffset =
       sizeof(dxbc::Header) + (Header.PartCount * sizeof(uint32_t));
   const char *Current = Data.getBuffer().data() + sizeof(dxbc::Header);
   for (uint32_t Part = 0; Part < Header.PartCount; ++Part) {
     uint32_t PartOffset;
     if (Error Err = readInteger(Data.getBuffer(), Current, PartOffset))
       return Err;
for (uint32_t Part = 0; Part < Header.PartCount; ++Part) {
     case dxbc::PartType::SFI0:
       if (Error Err = parseShaderFlags(PartData))
         return Err;
       break;
     case dxbc::PartType::HASH:
       if (Error Err = parseHash(PartData))
         return Err;
       break;
+    case dxbc::PartType::PSV0:
+      if (Error Err = parsePSVInfo(PartData))
+        return Err;
+      break;
     case dxbc::PartType::Unknown:
       break;
     }
   }
+
+  // Fully parsing the PSVInfo requires knowing the shader kind which we read
+  // out of the program header in the DXIL part.
+  if (PSVInfo) {
+    if (!DXIL)
+      return parseFailed("Cannot fully parse pipeline state validation "
+                         "information without DXIL part.");
+    if (Error Err = PSVInfo->parse(DXIL->first.ShaderKind))
+      return Err;
+  }
   return Error::success();
 }
 
 Expected<DXContainer> DXContainer::create(MemoryBufferRef Object) {
   DXContainer Container(Object);
   if (Error Err = Container.parseHeader())
     return std::move(Err);
   if (Error Err = Container.parsePartOffsets())
     return std::move(Err);
   return Container;
 }
 
 void DXContainer::PartIterator::updateIteratorImpl(const uint32_t Offset) {
   StringRef Buffer = Container.Data.getBuffer();
   const char *Current = Buffer.data() + Offset;
   // Offsets are validated during parsing, so all offsets in the container are
   // valid and contain enough readable data to read a header.
   cantFail(readStruct(Buffer, Current, IteratorState.Part));
   IteratorState.Data =
       StringRef(Current + sizeof(dxbc::PartHeader), IteratorState.Part.Size);
   IteratorState.Offset = Offset;
 }
+
+Error DirectX::PSVRuntimeInfo::parse(uint16_t ShaderKind) {
+  Triple::EnvironmentType ShaderStage = dxbc::getShaderStage(ShaderKind);
+
+  const char *Current = Data.begin();
+  if (Error Err = readInteger(Data, Current, Size))
+    return Err;
+  Current += sizeof(uint32_t);
+
+  StringRef PSVInfoData = Data.substr(sizeof(uint32_t), Size);
+
+  using namespace dxbc::PSV;
+
+  const uint32_t PSVVersion = getVersion();
+
+  // Detect the PSVVersion by looking at the size field.
+  if (PSVVersion == 2) {
+    v2::RuntimeInfo Info;
+    if (Error Err = readStruct(PSVInfoData, Current, Info))
+      return Err;
+    if (sys::IsBigEndianHost)
+      Info.swapBytes(ShaderStage);
+    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 {
+    v0::RuntimeInfo Info;
+    if (Error Err = readStruct(PSVInfoData, Current, Info))
+      return Err;
+    if (sys::IsBigEndianHost)
+      Info.swapBytes(ShaderStage);
+    BasicInfo = Info;
+  }
+  Current += Size;
+
+  return Error::success();
+}

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

 //===- DXContainerEmitter.cpp - Convert YAML to a DXContainer -------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// Binary emitter for yaml to DXContainer binary
 ///
 //===----------------------------------------------------------------------===//
 
 #include "llvm/BinaryFormat/DXContainer.h"
+#include "llvm/MC/DXContainerPSVInfo.h"
 #include "llvm/ObjectYAML/ObjectYAML.h"
 #include "llvm/ObjectYAML/yaml2obj.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
case dxbc::PartType::HASH: {
       if (P.Hash->IncludesSource)
         Hash.Flags |= static_cast<uint32_t>(dxbc::HashFlags::IncludesSource);
       memcpy(&Hash.Digest[0], &P.Hash->Digest[0], 16);
       if (sys::IsBigEndianHost)
         Hash.swapBytes();
       OS.write(reinterpret_cast<char *>(&Hash), sizeof(dxbc::ShaderHash));
       break;
     }
+    case dxbc::PartType::PSV0: {
+      if (!P.Info.has_value())
+        continue;
+      mcdxbc::PSVRuntimeInfo PSV;
+      memcpy(&PSV.BaseData, &P.Info->Info, sizeof(dxbc::PSV::v2::RuntimeInfo));
+
+      if (sys::IsBigEndianHost)
+        PSV.swapBytes(static_cast<Triple::EnvironmentType>(
+            Triple::Pixel + P.Info->Info.ShaderStage));
+      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;
     if (BytesWritten < PartSize)
       OS.write_zeros(PartSize - BytesWritten);
     RollingOffset += PartSize;

llvm/lib/ObjectYAML/DXContainerYAML.cpp

 
 DXContainerYAML::ShaderHash::ShaderHash(const dxbc::ShaderHash &Data)
     : IncludesSource((Data.Flags & static_cast<uint32_t>(
                                        dxbc::HashFlags::IncludesSource)) != 0),
       Digest(16, 0) {
   memcpy(Digest.data(), &Data.Digest[0], 16);
 }
 
+DXContainerYAML::PSVInfo::PSVInfo() : Version(0) {
+  memset(&Info, 0, sizeof(Info));
+}
+
+DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v0::RuntimeInfo *P,
+                                  uint16_t Stage)
+    : Version(0) {
+  memset(&Info, 0, sizeof(Info));
+  memcpy(&Info, P, sizeof(dxbc::PSV::v0::RuntimeInfo));
+
+  assert(Stage < std::numeric_limits<uint8_t>::max() &&
+         "Stage should be a very small number");
+  // We need to bring the stage in separately since it isn't part of the v1 data
+  // structure.
+  Info.ShaderStage = static_cast<uint8_t>(Stage);
+}
+
+DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v1::RuntimeInfo *P)
+    : Version(1) {
+  memset(&Info, 0, sizeof(Info));
+  memcpy(&Info, P, sizeof(dxbc::PSV::v1::RuntimeInfo));
+}
+
+DXContainerYAML::PSVInfo::PSVInfo(const dxbc::PSV::v2::RuntimeInfo *P)
+    : Version(2) {
+  memset(&Info, 0, sizeof(Info));
+  memcpy(&Info, P, sizeof(dxbc::PSV::v2::RuntimeInfo));
+}
+
 namespace yaml {
 
 void MappingTraits<DXContainerYAML::VersionTuple>::mapping(
     IO &IO, DXContainerYAML::VersionTuple &Version) {
   IO.mapRequired("Major", Version.Major);
   IO.mapRequired("Minor", Version.Minor);
 }
 

 }
 
 void MappingTraits<DXContainerYAML::ShaderHash>::mapping(
     IO &IO, DXContainerYAML::ShaderHash &Hash) {
   IO.mapRequired("IncludesSource", Hash.IncludesSource);
   IO.mapRequired("Digest", Hash.Digest);
 }
 
+void MappingTraits<DXContainerYAML::PSVInfo>::mapping(
+    IO &IO, DXContainerYAML::PSVInfo &PSV) {
+  IO.mapRequired("Version", PSV.Version);
+
+  // 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);
+}
+
 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);
   IO.mapOptional("Hash", P.Hash);
+  IO.mapOptional("PSVInfo", P.Info);
 }
 
 void MappingTraits<DXContainerYAML::Object>::mapping(
     IO &IO, DXContainerYAML::Object &Obj) {
   IO.mapTag("!dxcontainer", true);
   IO.mapRequired("Header", Obj.Header);
   IO.mapRequired("Parts", Obj.Parts);
 }
 
 } // 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:
+    IO.mapRequired("DepthOutput", StageInfo.PS.DepthOutput);
+    IO.mapRequired("SampleFrequency", StageInfo.PS.SampleFrequency);
+    break;
+  case Triple::EnvironmentType::Vertex:
+    IO.mapRequired("OutputPositionPresent", StageInfo.VS.OutputPositionPresent);
+    break;
+  case Triple::EnvironmentType::Geometry:
+    IO.mapRequired("InputPrimitive", StageInfo.GS.InputPrimitive);
+    IO.mapRequired("OutputTopology", StageInfo.GS.OutputTopology);
+    IO.mapRequired("OutputStreamMask", StageInfo.GS.OutputStreamMask);
+    IO.mapRequired("OutputPositionPresent", StageInfo.GS.OutputPositionPresent);
+    break;
+  case Triple::EnvironmentType::Hull:
+    IO.mapRequired("InputControlPointCount",
+                   StageInfo.HS.InputControlPointCount);
+    IO.mapRequired("OutputControlPointCount",
+                   StageInfo.HS.OutputControlPointCount);
+    IO.mapRequired("TessellatorDomain", StageInfo.HS.TessellatorDomain);
+    IO.mapRequired("TessellatorOutputPrimitive",
+                   StageInfo.HS.TessellatorOutputPrimitive);
+    break;
+  case Triple::EnvironmentType::Domain:
+    IO.mapRequired("InputControlPointCount",
+                   StageInfo.DS.InputControlPointCount);
+    IO.mapRequired("OutputPositionPresent", StageInfo.DS.OutputPositionPresent);
+    IO.mapRequired("TessellatorDomain", StageInfo.DS.TessellatorDomain);
+    break;
+  case Triple::EnvironmentType::Mesh:
+    IO.mapRequired("GroupSharedBytesUsed", StageInfo.MS.GroupSharedBytesUsed);
+    IO.mapRequired("GroupSharedBytesDependentOnViewID",
+                   StageInfo.MS.GroupSharedBytesDependentOnViewID);
+    IO.mapRequired("PayloadSizeInBytes", StageInfo.MS.PayloadSizeInBytes);
+    IO.mapRequired("MaxOutputVertices", StageInfo.MS.MaxOutputVertices);
+    IO.mapRequired("MaxOutputPrimitives", StageInfo.MS.MaxOutputPrimitives);
+    break;
+  case Triple::EnvironmentType::Amplification:
+    IO.mapRequired("PayloadSizeInBytes", StageInfo.AS.PayloadSizeInBytes);
+    break;
+  default:
+    break;
+  }
+
+  IO.mapRequired("MinimumWaveLaneCount", Info.MinimumWaveLaneCount);
+  IO.mapRequired("MaximumWaveLaneCount", Info.MaximumWaveLaneCount);
+
+  if (Version == 0)
+    return;
+
+  IO.mapRequired("UsesViewID", Info.UsesViewID);
+
+  switch (Stage) {
+  case Triple::EnvironmentType::Geometry:
+    IO.mapRequired("MaxVertexCount", Info.GeomData.MaxVertexCount);
+    break;
+  case Triple::EnvironmentType::Hull:
+  case Triple::EnvironmentType::Domain:
+    IO.mapRequired("SigPatchConstOrPrimVectors",
+                   Info.GeomData.SigPatchConstOrPrimVectors);
+    break;
+  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/PSVv0-amplification.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     14
+      PayloadSizeInBytes: 4092
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# CHECK-NEXT: ShaderStage:     14
+# CHECK-NEXT: PayloadSizeInBytes: 4092
+# CHECK-NEXT: MinimumWaveLaneCount: 0
+# CHECK-NEXT: MaximumWaveLaneCount: 4294967295
+# CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-compute.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     5
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# CHECK-NEXT: ShaderStage:     5
+# CHECK-NEXT: MinimumWaveLaneCount: 0
+# CHECK-NEXT: MaximumWaveLaneCount: 4294967295
+# CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-domain.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     4
+      InputControlPointCount: 1024
+      OutputPositionPresent: 1
+      TessellatorDomain: 2056
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-geometry.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     2
+      InputPrimitive: 1024
+      OutputTopology: 4096
+      OutputStreamMask: 2056
+      OutputPositionPresent: 1
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-hull.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     3
+      InputControlPointCount: 1024
+      OutputControlPointCount: 4096
+      TessellatorDomain: 2056
+      TessellatorOutputPrimitive: 8192
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-mesh.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     13
+      GroupSharedBytesUsed: 1024
+      GroupSharedBytesDependentOnViewID: 2056
+      PayloadSizeInBytes: 4092
+      MaxOutputVertices: 8196
+      MaxOutputPrimitives: 4092
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - Name:            DXIL
+    Size:            24
+    Program:
+      MajorVersion:    6
+      MinorVersion:    0
+      ShaderKind:      13
+      Size:            6
+      DXILMajorVersion: 0
+      DXILMinorVersion: 1
+      DXILSize:        0
+...
+
+# CHECK: Name:            PSV0
+# CHECK: PSVInfo:
+# CHECK-NEXT: Version:         0
+# CHECK-NEXT: ShaderStage:     13
+# CHECK-NEXT: GroupSharedBytesUsed: 1024
+# CHECK-NEXT: GroupSharedBytesDependentOnViewID: 2056
+# CHECK-NEXT: PayloadSizeInBytes: 4092
+# CHECK-NEXT: MaxOutputVertices: 8196
+# CHECK-NEXT: MaxOutputPrimitives: 4092
+# CHECK-NEXT: MinimumWaveLaneCount: 0
+# CHECK-NEXT: MaximumWaveLaneCount: 4294967295
+# CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-pixel.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     0
+      DepthOutput:     7
+      SampleFrequency: 96
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# CHECK-NEXT: ShaderStage:     0
+# CHECK-NEXT: DepthOutput:     7
+# CHECK-NEXT: SampleFrequency: 96
+# CHECK-NEXT: MinimumWaveLaneCount: 0
+# CHECK-NEXT: MaximumWaveLaneCount: 4294967295
+# CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv0-vertex.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:            144
+    PSVInfo:
+      Version:         0
+      ShaderStage:     1
+      OutputPositionPresent: 1
+      MinimumWaveLaneCount: 0
+      MaximumWaveLaneCount: 4294967295
+  - 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:         0
+# CHECK-NEXT: ShaderStage:     1
+# CHECK-NEXT: OutputPositionPresent: 1
+# CHECK-NEXT: MinimumWaveLaneCount: 0
+# CHECK-NEXT: MaximumWaveLaneCount: 4294967295
+# CHECK-NEXT: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-amplification.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:            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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-compute.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:            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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-domain.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:            144
+    PSVInfo:
+      Version:         1
+      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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-geometry.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:            144
+    PSVInfo:
+      Version:         1
+      ShaderStage:     2
+      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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-hull.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:            144
+    PSVInfo:
+      Version:         1
+      ShaderStage:     3
+      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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-mesh.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:            144
+    PSVInfo:
+      Version:         1
+      ShaderStage:     13
+      GroupSharedBytesUsed: 1024
+      GroupSharedBytesDependentOnViewID: 2056
+      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 ]
+  - Name:            DXIL
+    Size:            24
+    Program:
+      MajorVersion:    6
+      MinorVersion:    0
+      ShaderKind:      13
+      Size:            6
+      DXILMajorVersion: 0
+      DXILMinorVersion: 1
+      DXILSize:        0
+...
+
+# CHECK: Name:            PSV0
+# CHECK: PSVInfo:
+# CHECK-NEXT: Version:         1
+# CHECK-NEXT: ShaderStage:     13
+# CHECK-NEXT: GroupSharedBytesUsed: 1024
+# CHECK-NEXT: GroupSharedBytesDependentOnViewID: 2056
+# 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-pixel.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:            144
+    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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv1-vertex.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:            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 ]
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-amplification.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:            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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-compute.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:            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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-domain.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:            144
+    PSVInfo:
+      Version:         2
+      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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-geometry.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:            144
+    PSVInfo:
+      Version:         2
+      ShaderStage:     2
+      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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-hull.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:            144
+    PSVInfo:
+      Version:         2
+      ShaderStage:     3
+      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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-mesh.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:            144
+    PSVInfo:
+      Version:         2
+      ShaderStage:     13
+      GroupSharedBytesUsed: 1024
+      GroupSharedBytesDependentOnViewID: 2056
+      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
+  - Name:            DXIL
+    Size:            24
+    Program:
+      MajorVersion:    6
+      MinorVersion:    0
+      ShaderKind:      13
+      Size:            6
+      DXILMajorVersion: 0
+      DXILMinorVersion: 1
+      DXILSize:        0
+...
+
+# CHECK: Name:            PSV0
+# CHECK: PSVInfo:
+# CHECK-NEXT: Version:         2
+# CHECK-NEXT: ShaderStage:     13
+# CHECK-NEXT: GroupSharedBytesUsed: 1024
+# CHECK-NEXT: GroupSharedBytesDependentOnViewID: 2056
+# 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-pixel.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:            144
+    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
+  - 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: Name

llvm/test/ObjectYAML/DXContainer/PSVv2-vertex.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:            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
+  - 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: Name

llvm/tools/obj2yaml/dxcontainer2yaml.cpp

case dxbc::PartType::SFI0: {
       break;
     }
     case dxbc::PartType::HASH: {
       std::optional<dxbc::ShaderHash> Hash = Container.getShaderHash();
       if (Hash && Hash->isPopulated())
         NewPart.Hash = DXContainerYAML::ShaderHash(*Hash);
       break;
     }
+    case dxbc::PartType::PSV0: {
+      const auto &PSVInfo = Container.getPSVInfo();
+      if (!PSVInfo)
+        break;
+      if (const auto *P =
+              std::get_if<dxbc::PSV::v0::RuntimeInfo>(&PSVInfo->getInfo())) {
+        if (!Container.getDXIL())
+          break;
+        NewPart.Info =
+            DXContainerYAML::PSVInfo(P, Container.getDXIL()->first.ShaderKind);
+      } else if (const auto *P = std::get_if<dxbc::PSV::v1::RuntimeInfo>(
+                     &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);
+      break;
+    }
     case dxbc::PartType::Unknown:
       break;
     }
   }
 
   return Obj.release();
 }