[DX] [ObjectYAML] Support DX shader feature flags

[beanz]

Summary

DXContainers contain a feature flag part, which stores a bitfield used
to denote what underlying hardware features the shader requires. This
change adds feature flags to the DXContainer YAML tooling to enable
testing generating feature flags during HLSL code generation.

Depends on D133980

[lhames]

LGTM.

llvm/include/llvm/BinaryFormat/DXContainer.h

 static_assert(sizeof(ProgramHeader) == 24, "ProgramHeader Size incorrect!");
 
 #define CONTAINER_PART(Part) Part,
 enum class PartType {
   Unknown = 0,
 #include "DXContainerConstants.def"
 };
 
+#define SHADER_FLAG(Num, Val, Str) Val = 1ull << Num,
+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);
 
 } // namespace dxbc
 } // namespace llvm
 
 #endif // LLVM_BINARYFORMAT_DXCONTAINER_H

llvm/include/llvm/BinaryFormat/DXContainerConstants.def

 
 #ifdef CONTAINER_PART
 CONTAINER_PART(DXIL)
+CONTAINER_PART(SFI0)
 
 #undef CONTAINER_PART
 #endif 
+
+#ifdef SHADER_FLAG
+
+SHADER_FLAG(0, Doubles, "Double-precision floating point")
+SHADER_FLAG(1, ComputeShadersPlusRawAndStructuredBuffers, "Raw and Structured buffers")
+SHADER_FLAG(2, UAVsAtEveryStage, "UAVs at every shader stage")
+SHADER_FLAG(3, Max64UAVs, "64 UAV slots")
+SHADER_FLAG(4, MinimumPrecision, "Minimum-precision data types")
+SHADER_FLAG(5, DX11_1_DoubleExtensions, "Double-precision extensions for 11.1")
+SHADER_FLAG(6, DX11_1_ShaderExtensions, "Shader extensions for 11.1")
+SHADER_FLAG(7, LEVEL9ComparisonFiltering, "Comparison filtering for feature level 9")
+SHADER_FLAG(8, TiledResources, "Tiled resources")
+SHADER_FLAG(9, StencilRef, "PS Output Stencil Ref")
+SHADER_FLAG(10, InnerCoverage, "PS Inner Coverage")
+SHADER_FLAG(11, TypedUAVLoadAdditionalFormats, "Typed UAV Load Additional Formats")
+SHADER_FLAG(12, ROVs, "Raster Ordered UAVs")
+SHADER_FLAG(13, ViewportAndRTArrayIndexFromAnyShaderFeedingRasterizer, "SV_RenderTargetArrayIndex or SV_ViewportArrayIndex from any shader feeding rasterizer")
+SHADER_FLAG(14, WaveOps, "Wave level operations")
+SHADER_FLAG(15, Int64Ops, "64-Bit integer")
+SHADER_FLAG(16, ViewID, "View Instancing")
+SHADER_FLAG(17, Barycentrics, "Barycentrics")
+SHADER_FLAG(18, NativeLowPrecision, "Use native low precision")
+SHADER_FLAG(19, ShadingRate, "Shading Rate")
+SHADER_FLAG(20, Raytracing_Tier_1_1, "Raytracing tier 1.1 features")
+SHADER_FLAG(21, SamplerFeedback, "Sampler feedback")
+SHADER_FLAG(22, AtomicInt64OnTypedResource, "64-bit Atomics on Typed Resources")
+SHADER_FLAG(23, AtomicInt64OnGroupShared, "64-bit Atomics on Group Shared")
+SHADER_FLAG(24, DerivativesInMeshAndAmpShaders, "Derivatives in mesh and amplification shaders")
+SHADER_FLAG(25, ResourceDescriptorHeapIndexing, "Resource descriptor heap indexing")
+SHADER_FLAG(26, SamplerDescriptorHeapIndexing, "Sampler descriptor heap indexing")
+SHADER_FLAG(27, RESERVED, "<RESERVED>")
+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

llvm/include/llvm/Object/DXContainer.h

 
 private:
   DXContainer(MemoryBufferRef O);
 
   MemoryBufferRef Data;
   dxbc::Header Header;
   SmallVector<uint32_t, 4> PartOffsets;
   Optional<DXILData> DXIL;
+  Optional<uint64_t> ShaderFlags;
 
   Error parseHeader();
   Error parsePartOffsets();
   Error parseDXILHeader(uint32_t Offset);
+  Error parseShaderFlags(uint32_t Offset);
   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; }
 
   Optional<DXILData> getDXIL() const { return DXIL; }
+
+  Optional<uint64_t> getShaderFlags() const { return ShaderFlags; }
 };
 
 } // namespace object
 } // namespace llvm
 
 #endif // LLVM_OBJECT_DXCONTAINER_H

llvm/include/llvm/ObjectYAML/DXContainerYAML.h

struct DXILProgram {
   Optional<uint32_t> Size;
   uint16_t DXILMajorVersion;
   uint16_t DXILMinorVersion;
   Optional<uint32_t> DXILOffset;
   Optional<uint32_t> DXILSize;
   Optional<std::vector<llvm::yaml::Hex8>> DXIL;
 };
 
+#define SHADER_FLAG(Num, Val, Str) bool Val = false;
+struct ShaderFlags {
+  ShaderFlags() = default;
+  ShaderFlags(uint64_t FlagData);
+  uint64_t getEncodedFlags();
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
 struct Part {
   Part() = default;
   Part(std::string N, uint32_t S) : Name(N), Size(S) {}
   std::string Name;
   uint32_t Size;
   Optional<DXILProgram> Program;
+  Optional<ShaderFlags> Flags;
 };
 
 struct Object {
   FileHeader Header;
   std::vector<Part> Parts;
 };
 
 } // namespace DXContainerYAML

 template <> struct MappingTraits<DXContainerYAML::FileHeader> {
   static void mapping(IO &IO, DXContainerYAML::FileHeader &Header);
 };
 
 template <> struct MappingTraits<DXContainerYAML::DXILProgram> {
   static void mapping(IO &IO, DXContainerYAML::DXILProgram &Program);
 };
 
+template <> struct MappingTraits<DXContainerYAML::ShaderFlags> {
+  static void mapping(IO &IO, DXContainerYAML::ShaderFlags &Flags);
+};
+
 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/Object/DXContainer.cpp

if (sys::IsBigEndianHost)
     Struct.swapBytes();
   return Error::success();
 }
 
 template <typename T>
 static Error readInteger(StringRef Buffer, const char *Src, T &Val) {
   static_assert(std::is_integral<T>::value,
                 "Cannot call readInteger on non-integral type.");
-  assert(reinterpret_cast<uintptr_t>(Src) % alignof(T) == 0 &&
-         "Unaligned read of value from buffer!");
   // Don't read before the beginning or past the end of the file
   if (Src < Buffer.begin() || Src + sizeof(T) > Buffer.end())
     return parseFailed("Reading structure out of file bounds");
 
+  // The DXContainer offset table is comprised of uint32_t values but not padded
+  // to a 64-bit boundary. So Parts may start unaligned if there is an odd
+  // number of parts and part data itself is not required to be padded.
+  if (reinterpret_cast<uintptr_t>(Src) % alignof(T) != 0)
+    memcpy(reinterpret_cast<char *>(&Val), Src, sizeof(T));
+  else
     Val = *reinterpret_cast<const T *>(Src);
   // DXContainer is always little endian
   if (sys::IsBigEndianHost)
     sys::swapByteOrder(Val);
   return Error::success();
 }
 
 DXContainer::DXContainer(MemoryBufferRef O) : Data(O) {}
 
 Error DXContainer::parseHeader() {
   return readStruct(Data.getBuffer(), Data.getBuffer().data(), Header);
 }
 
 Error DXContainer::parseDXILHeader(uint32_t Offset) {
   if (DXIL)
     return parseFailed("More than one DXIL part is present in the file");
   const char *Current = Data.getBuffer().data() + Offset;
   dxbc::ProgramHeader Header;
   if (Error Err = readStruct(Data.getBuffer(), Current, Header))
     return Err;
   Current += offsetof(dxbc::ProgramHeader, Bitcode) + Header.Bitcode.Offset;
   DXIL.emplace(std::make_pair(Header, Current));
   return Error::success();
 }
 
+Error DXContainer::parseShaderFlags(uint32_t Offset) {
+  if (ShaderFlags)
+    return parseFailed("More than one SFI0 part is present in the file");
+  const char *Current = Data.getBuffer().data() + Offset;
+  uint64_t FlagValue = 0;
+  if (Error Err = readInteger(Data.getBuffer(), Current, FlagValue))
+    return Err;
+  ShaderFlags = FlagValue;
+  return Error::success();
+}
+
 Error DXContainer::parsePartOffsets() {
   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;
     Current += sizeof(uint32_t);
     // We need to ensure that each part offset leaves enough space for a part
     // header. To prevent overflow, we subtract the part header size from the
     // buffer size, rather than adding to the offset. Since the file header is
     // larger than the part header we can't reach this code unless the buffer
     // is larger than the part header, so this can't underflow.
     if (PartOffset > Data.getBufferSize() - sizeof(dxbc::PartHeader))
       return parseFailed("Part offset points beyond boundary of the file");
     PartOffsets.push_back(PartOffset);
 
     dxbc::PartType PT =
         dxbc::parsePartType(Data.getBuffer().substr(PartOffset, 4));
     switch (PT) {
     case dxbc::PartType::DXIL:
       if (Error Err = parseDXILHeader(PartOffset + sizeof(dxbc::PartHeader)))
         return Err;
       break;
+    case dxbc::PartType::SFI0:
+      if (Error Err = parseShaderFlags(PartOffset + sizeof(dxbc::PartHeader)))
+        return Err;
+      break;
     case dxbc::PartType::Unknown:
       break;
     }
   }
   return Error::success();
 }
 
 Expected<DXContainer> DXContainer::create(MemoryBufferRef Object) {

llvm/lib/ObjectYAML/DXContainerEmitter.cpp

void DXContainerWriter::writeParts(raw_ostream &OS) {
   uint32_t RollingOffset =
       sizeof(dxbc::Header) + (ObjectFile.Header.PartCount * sizeof(uint32_t));
   for (auto I : llvm::zip(ObjectFile.Parts, *ObjectFile.Header.PartOffsets)) {
     if (RollingOffset < std::get<1>(I)) {
       uint32_t PadBytes = std::get<1>(I) - RollingOffset;
       OS.write_zeros(PadBytes);
     }
     DXContainerYAML::Part P = std::get<0>(I);
+    RollingOffset = std::get<1>(I) + sizeof(dxbc::PartHeader);
+    uint32_t PartSize = P.Size;
+
     OS.write(P.Name.c_str(), 4);
     if (sys::IsBigEndianHost)
       sys::swapByteOrder(P.Size);
     OS.write(reinterpret_cast<const char *>(&P.Size), sizeof(uint32_t));
-    RollingOffset = std::get<1>(I) + sizeof(dxbc::PartHeader);
 
-    if (P.Name == "DXIL" && P.Program) {
+    dxbc::PartType PT = dxbc::parsePartType(P.Name);
+
+    uint64_t DataStart = OS.tell();
+    if (PT == dxbc::PartType::DXIL) {
+      if (!P.Program)
+        continue;
       dxbc::ProgramHeader Header;
       Header.MajorVersion = P.Program->MajorVersion;
       Header.MinorVersion = P.Program->MinorVersion;
       Header.Unused = 0;
       Header.ShaderKind = P.Program->ShaderKind;
       memcpy(Header.Bitcode.Magic, "DXIL", 4);
       Header.Bitcode.MajorVersion = P.Program->DXILMajorVersion;
       Header.Bitcode.MinorVersion = P.Program->DXILMinorVersion;
if (PT == dxbc::PartType::DXIL) {
       if (P.Program->DXIL) {
         if (BitcodeOffset > sizeof(dxbc::BitcodeHeader)) {
           uint32_t PadBytes = BitcodeOffset - sizeof(dxbc::BitcodeHeader);
           OS.write_zeros(PadBytes);
         }
         OS.write(reinterpret_cast<char *>(P.Program->DXIL->data()),
                  P.Program->DXIL->size());
       }
+    } else if (PT == dxbc::PartType::SFI0) {
+      // If we don't have any flags we can continue here and the data will be
+      // zeroed out.
+      if (!P.Flags.has_value())
+        continue;
+      uint64_t Flags = P.Flags->getEncodedFlags();
+      if (sys::IsBigEndianHost)
+        sys::swapByteOrder(Flags);
+      OS.write(reinterpret_cast<char *>(&Flags), sizeof(uint64_t));
     }
+    uint64_t BytesWritten = OS.tell() - DataStart;
+    RollingOffset += BytesWritten;
+    if (BytesWritten < PartSize)
+      OS.write_zeros(PartSize - BytesWritten);
+    RollingOffset += PartSize;
   }
 }
 
 Error DXContainerWriter::write(raw_ostream &OS) {
   if (Error Err = computePartOffsets())
     return Err;
   writeHeader(OS);
   writeParts(OS);

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/BinaryFormat/DXContainer.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.");
+
+DXContainerYAML::ShaderFlags::ShaderFlags(uint64_t FlagData) {
+#define SHADER_FLAG(Num, Val, Str)                                             \
+  Val = (FlagData & (uint64_t)dxbc::FeatureFlags::Val) > 0;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+}
+
+uint64_t DXContainerYAML::ShaderFlags::getEncodedFlags() {
+  uint64_t Flag = 0;
+#define SHADER_FLAG(Num, Val, Str)                                             \
+  if (Val)                                                                     \
+    Flag |= (uint64_t)dxbc::FeatureFlags::Val;
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+  return Flag;
+}
+
 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::DXILProgram>::mapping(
   IO.mapRequired("ShaderKind", Program.ShaderKind);
   IO.mapOptional("Size", Program.Size);
   IO.mapRequired("DXILMajorVersion", Program.DXILMajorVersion);
   IO.mapRequired("DXILMinorVersion", Program.DXILMinorVersion);
   IO.mapOptional("DXILSize", Program.DXILSize);
   IO.mapOptional("DXIL", Program.DXIL);
 }
 
+void MappingTraits<DXContainerYAML::ShaderFlags>::mapping(
+    IO &IO, DXContainerYAML::ShaderFlags &Flags) {
+#define SHADER_FLAG(Num, Val, Str) IO.mapRequired(#Val, Flags.Val);
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+}
+
 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::Object>::mapping(
     IO &IO, DXContainerYAML::Object &Obj) {
   IO.mapTag("!dxcontainer", true);
   IO.mapRequired("Header", Obj.Header);
   IO.mapRequired("Parts", Obj.Parts);
 }
 
 } // namespace yaml
 } // namespace llvm

llvm/test/tools/obj2yaml/DXContainer/ShaderFlags.yaml

+# RUN: yaml2obj %s | obj2yaml | FileCheck %s 
+
+# This test verifies that shader flags are omitted if they are all off.
+--- !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:       7
+Parts:
+  - Name:            SFI0
+    Size:            8
+    Flags:
+      Doubles:         true
+      ComputeShadersPlusRawAndStructuredBuffers: false
+      UAVsAtEveryStage: true
+      Max64UAVs:       false
+      MinimumPrecision: true
+      DX11_1_DoubleExtensions: false
+      DX11_1_ShaderExtensions: true
+      LEVEL9ComparisonFiltering: true
+      TiledResources:  false
+      StencilRef:      true
+      InnerCoverage:   true
+      TypedUAVLoadAdditionalFormats: false
+      ROVs:            false
+      ViewportAndRTArrayIndexFromAnyShaderFeedingRasterizer: true
+      WaveOps:         false
+      Int64Ops:        false
+      ViewID:          true
+      Barycentrics:    false
+      NativeLowPrecision: false
+      ShadingRate:     false
+      Raytracing_Tier_1_1: true
+      SamplerFeedback: false
+      AtomicInt64OnTypedResource: false
+      AtomicInt64OnGroupShared: false
+      DerivativesInMeshAndAmpShaders: true
+      ResourceDescriptorHeapIndexing: false
+      SamplerDescriptorHeapIndexing: false
+      RESERVED:        true
+      AtomicInt64OnHeapResource: false
+      AdvancedTextureOps: true
+      WriteableMSAATextures: false
+      NextUnusedBit:   true
+  - Name:            ISG1
+    Size:            8
+  - Name:            OSG1
+    Size:            8
+  - Name:            PSV0
+    Size:            8
+  - Name:            STAT
+    Size:            8
+  - Name:            HASH
+    Size:            8
+  - Name:            CXIL
+    Size:            8
+...
+
+# CHECK: Parts:
+# CHECK-NEXT:   - Name:            SFI0
+# CHECK-NEXT:     Size:            8
+# CHECK-NEXT:     Flags:
+# CHECK-NEXT:       Doubles:         true
+# CHECK-NEXT:       ComputeShadersPlusRawAndStructuredBuffers: false
+# CHECK-NEXT:       UAVsAtEveryStage: true
+# CHECK-NEXT:       Max64UAVs:       false
+# CHECK-NEXT:       MinimumPrecision: true
+# CHECK-NEXT:       DX11_1_DoubleExtensions: false
+# CHECK-NEXT:       DX11_1_ShaderExtensions: true
+# CHECK-NEXT:       LEVEL9ComparisonFiltering: true
+# CHECK-NEXT:       TiledResources:  false
+# CHECK-NEXT:       StencilRef:      true
+# CHECK-NEXT:       InnerCoverage:   true
+# CHECK-NEXT:       TypedUAVLoadAdditionalFormats: false
+# CHECK-NEXT:       ROVs:            false
+# CHECK-NEXT:       ViewportAndRTArrayIndexFromAnyShaderFeedingRasterizer: true
+# CHECK-NEXT:       WaveOps:         false
+# CHECK-NEXT:       Int64Ops:        false
+# CHECK-NEXT:       ViewID:          true
+# CHECK-NEXT:       Barycentrics:    false
+# CHECK-NEXT:       NativeLowPrecision: false
+# CHECK-NEXT:       ShadingRate:     false
+# CHECK-NEXT:       Raytracing_Tier_1_1: true
+# CHECK-NEXT:       SamplerFeedback: false
+# CHECK-NEXT:       AtomicInt64OnTypedResource: false
+# CHECK-NEXT:       AtomicInt64OnGroupShared: false
+# CHECK-NEXT:       DerivativesInMeshAndAmpShaders: true
+# CHECK-NEXT:       ResourceDescriptorHeapIndexing: false
+# CHECK-NEXT:       SamplerDescriptorHeapIndexing: false
+# CHECK-NEXT:       RESERVED:        true
+# CHECK-NEXT:       AtomicInt64OnHeapResource: false
+# CHECK-NEXT:       AdvancedTextureOps: true
+# CHECK-NEXT:       WriteableMSAATextures: false
+# CHECK-NEXT:       NextUnusedBit:   true

llvm/test/tools/obj2yaml/DXContainer/ShaderFlagsEmpty.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:       7
+Parts:
+  - Name:            SFI0
+    Size:            8
+    Flags:
+      Doubles:         false
+      ComputeShadersPlusRawAndStructuredBuffers: false
+      UAVsAtEveryStage: false
+      Max64UAVs:       false
+      MinimumPrecision: false
+      DX11_1_DoubleExtensions: false
+      DX11_1_ShaderExtensions: false
+      LEVEL9ComparisonFiltering: false
+      TiledResources:  false
+      StencilRef:      false
+      InnerCoverage:   false
+      TypedUAVLoadAdditionalFormats: false
+      ROVs:            false
+      ViewportAndRTArrayIndexFromAnyShaderFeedingRasterizer: false
+      WaveOps:         false
+      Int64Ops:        false
+      ViewID:          false
+      Barycentrics:    false
+      NativeLowPrecision: false
+      ShadingRate:     false
+      Raytracing_Tier_1_1: false
+      SamplerFeedback: false
+      AtomicInt64OnTypedResource: false
+      AtomicInt64OnGroupShared: false
+      DerivativesInMeshAndAmpShaders: false
+      ResourceDescriptorHeapIndexing: false
+      SamplerDescriptorHeapIndexing: false
+      RESERVED:        false
+      AtomicInt64OnHeapResource: false
+      AdvancedTextureOps: false
+      WriteableMSAATextures: false
+      NextUnusedBit:   false
+  - Name:            ISG1
+    Size:            8
+  - Name:            OSG1
+    Size:            8
+  - Name:            PSV0
+    Size:            8
+  - Name:            STAT
+    Size:            8
+  - Name:            HASH
+    Size:            8
+  - Name:            CXIL
+    Size:            8
+...
+
+# CHECK: Parts:
+# CHECK-NEXT:   - Name:            SFI0
+# CHECK-NEXT:     Size:            8
+# CHECK-NOT:      Flags:
+# CHECK-NEXT:   - Name:            ISG1

llvm/tools/obj2yaml/dxcontainer2yaml.cpp

case dxbc::PartType::DXIL: {
           DXIL->first.Bitcode.MajorVersion,
           DXIL->first.Bitcode.MinorVersion,
           DXIL->first.Bitcode.Offset,
           DXIL->first.Bitcode.Size,
           std::vector<llvm::yaml::Hex8>(
               DXIL->second, DXIL->second + DXIL->first.Bitcode.Size)};
       break;
     }
+    case dxbc::PartType::SFI0: {
+      Optional<uint64_t> Flags = Container.getShaderFlags();
+      // Omit the flags in the YAML if they are missing or zero.
+      if (Flags && *Flags > 0)
+        NewPart.Flags = DXContainerYAML::ShaderFlags(*Flags);
+      break;
+    }
     case dxbc::PartType::Unknown:
       break;
     }
   }
 
   return Obj.release();
 }