[yaml2obj, obj2yaml] - Implement section header table as a special Chunk.

[grimar]

Summary

This was discussed in D93678 thread.
Currently we have one special chunk - Fill.

This patch re implements the "SectionHeaderTable" key to become a special chunk too.
With that we are able to place the section header table at any location,
just like we place sections.

[jhenderson]

Generally looks fine to me. Is there testing for the obj2yaml side of things? It feels like there needs to be testing there for writing the section header table in the right place in the YAML (with Offset if needed), but I don't see that yet.

llvm/include/llvm/ObjectYAML/ELFYAML.h

197

Maybe add a new line above this comment to clearly split the two varieties.

207–208

I feel like this reads a bit better.

294

getNumHeaders or maybe simply` size.

715

llvm/lib/ObjectYAML/ELFEmitter.cpp

338–340

I think this comment now best belongs with the second if inside the loop, below the section header table bit, as it isn't relevant ot the section header table stuff.

391

405

712

It probably deserves a comment here saying something about the section header information isn't all known yet, so fill with zeroes as a placeholder.

1840

Do you actually need the IsImplicit check here? The default values of NoHeaders and Excluded should be such that the ifs inside don't trigger anyway.

1972

I think it would be more self-documenting if this was if(!SHT.NoHeaders). If I understand it correctly, SHT.Offset will always be set when NoHeaders is false. If NoHeaders is false, specifying Offset explicitly doesn't make sense, and is prohibited.

llvm/lib/ObjectYAML/ELFYAML.cpp

1325

llvm/test/tools/yaml2obj/ELF/section-headers.yaml

339

[grimar]

In D95140#2514914, @jhenderson wrote:

It feels like there needs to be testing there for writing the section header table in the right place in the YAML (with Offset if needed), but I don't see that yet.

It is not yet implemented. Currently obj2yaml can only emit the section header chunk at the end of the sections list (when the order of sections doesn't match the order in the section header table).
I supposed we can implement the dumping at a proper position in a follow-up(s). Does it sound OK for you?

[jhenderson]

In D95140#2514933, @grimar wrote:

In D95140#2514914, @jhenderson wrote:

It feels like there needs to be testing there for writing the section header table in the right place in the YAML (with Offset if needed), but I don't see that yet.

It is not yet implemented. Currently obj2yaml can only emit the section header chunk at the end of the sections list (when the order of sections doesn't match the order in the section header table).
I supposed we can implement the dumping at a proper position in a follow-up(s). Does it sound OK for you?

I suspected that was the case, but wasn't sure, so deferring is fine.

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1840

Right. Removed.

1972

Done.

[jhenderson]

Thanks, LGTM!

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct FileHeader {
   Optional<llvm::yaml::Hex16> EShNum;
   Optional<llvm::yaml::Hex16> EShStrNdx;
 };
 
 struct SectionHeader {
   StringRef Name;
 };
 
-struct SectionHeaderTable {
-  Optional<std::vector<SectionHeader>> Sections;
-  Optional<std::vector<SectionHeader>> Excluded;
-  Optional<bool> NoHeaders;
-};
-
 struct Symbol {
   StringRef Name;
   ELF_STT Type;
   Optional<StringRef> Section;
   Optional<ELF_SHN> Index;
   ELF_STB Binding;
   Optional<llvm::yaml::Hex64> Value;
   Optional<llvm::yaml::Hex64> Size;
enum class ChunkKind {
     Verdef,
     Verneed,
     StackSizes,
     SymtabShndxSection,
     Symver,
     ARMIndexTable,
     MipsABIFlags,
     Addrsig,
-    Fill,
     LinkerOptions,
     DependentLibraries,
     CallGraphProfile,
-    BBAddrMap
+    BBAddrMap,
+    // Special chunks.
+    SpecialChunksStart,
+    Fill = SpecialChunksStart,
+    SectionHeaderTable,
   };
 
   ChunkKind Kind;
   StringRef Name;
   Optional<llvm::yaml::Hex64> Offset;
 
-  Chunk(ChunkKind K) : Kind(K) {}
+  // Usually sections/special chunks are not created implicitly, but loaded from
+  // YAML. When they are, this flag is used to signal about that.
+  bool IsImplicit;
+
+  Chunk(ChunkKind K, bool Implicit) : Kind(K), IsImplicit(Implicit) {}
   virtual ~Chunk();
 };
 
 struct Section : public Chunk {
   ELF_SHT Type;
   Optional<ELF_SHF> Flags;
   Optional<llvm::yaml::Hex64> Address;
   Optional<StringRef> Link;
   llvm::yaml::Hex64 AddressAlign;
   Optional<llvm::yaml::Hex64> EntSize;
 
   Optional<yaml::BinaryRef> Content;
   Optional<llvm::yaml::Hex64> Size;
 
-  // Usually sections are not created implicitly, but loaded from YAML.
-  // When they are, this flag is used to signal about that.
-  bool IsImplicit;
-
   // Holds the original section index.
   unsigned OriginalSecNdx;
 
-  Section(ChunkKind Kind, bool IsImplicit = false)
-      : Chunk(Kind), IsImplicit(IsImplicit) {}
+  Section(ChunkKind Kind, bool IsImplicit = false) : Chunk(Kind, IsImplicit) {}
 
-  static bool classof(const Chunk *S) { return S->Kind != ChunkKind::Fill; }
+  static bool classof(const Chunk *S) {
+    return S->Kind < ChunkKind::SpecialChunksStart;
+  }
 
   // Some derived sections might have their own special entries. This method
   // returns a vector of <entry name, is used> pairs. It is used for section
   // validation.
   virtual std::vector<std::pair<StringRef, bool>> getEntries() const {
     return {};
   };
 

 
 // Fill is a block of data which is placed outside of sections. It is
 // not present in the sections header table, but it might affect the output file
 // size and program headers produced.
 struct Fill : Chunk {
   Optional<yaml::BinaryRef> Pattern;
   llvm::yaml::Hex64 Size;
 
-  Fill() : Chunk(ChunkKind::Fill) {}
+  Fill() : Chunk(ChunkKind::Fill, /*Implicit=*/false) {}
 
   static bool classof(const Chunk *S) { return S->Kind == ChunkKind::Fill; }
 };
 
+struct SectionHeaderTable : Chunk {
+  SectionHeaderTable(bool IsImplicit)
+      : Chunk(ChunkKind::SectionHeaderTable, IsImplicit) {}
+
+  static bool classof(const Chunk *S) {
+    return S->Kind == ChunkKind::SectionHeaderTable;
+  }
+
+  Optional<std::vector<SectionHeader>> Sections;
+  Optional<std::vector<SectionHeader>> Excluded;
+  Optional<bool> NoHeaders;
+
+  size_t getHeadersNum(size_t SectionsNum) const {
+    if (IsImplicit)
+      return SectionsNum;
+    if (NoHeaders)
+      return (*NoHeaders) ? 0 : SectionsNum;
+    return (Sections ? Sections->size() : 0) + /*Null section*/ 1;
+  }
+
+  static constexpr StringRef TypeStr = "SectionHeaderTable";
+};
+
 struct BBAddrMapSection : Section {
   Optional<std::vector<BBAddrMapEntry>> Entries;
 
   BBAddrMapSection() : Section(ChunkKind::BBAddrMap) {}
 
   std::vector<std::pair<StringRef, bool>> getEntries() const override {
     return {{"Entries", Entries.hasValue()}};
   };
struct ProgramHeader {
   Optional<StringRef> LastSec;
 
   // This vector contains all chunks from [FirstSec, LastSec].
   std::vector<Chunk *> Chunks;
 };
 
 struct Object {
   FileHeader Header;
-  Optional<SectionHeaderTable> SectionHeaders;
   std::vector<ProgramHeader> ProgramHeaders;
 
   // An object might contain output section descriptions as well as
   // custom data that does not belong to any section.
   std::vector<std::unique_ptr<Chunk>> Chunks;
 
   // Although in reality the symbols reside in a section, it is a lot
   // cleaner and nicer if we read them from the YAML as a separate
   // top-level key, which automatically ensures that invariants like there
   // being a single SHT_SYMTAB section are upheld.
   Optional<std::vector<Symbol>> Symbols;
   Optional<std::vector<Symbol>> DynamicSymbols;
   Optional<DWARFYAML::Data> DWARF;
 
   std::vector<Section *> getSections() {
     std::vector<Section *> Ret;
     for (const std::unique_ptr<Chunk> &Sec : Chunks)
       if (auto S = dyn_cast<ELFYAML::Section>(Sec.get()))
         Ret.push_back(S);
     return Ret;
   }
 
+  const SectionHeaderTable &getSectionHeaderTable() const {
+    for (const std::unique_ptr<Chunk> &C : Chunks)
+      if (auto *S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get()))
+        return *S;
+    llvm_unreachable("the section header table chunk must always present");
+  }
+
   unsigned getMachine() const;
 };
 
 bool shouldAllocateFileSpace(ArrayRef<ProgramHeader> Phdrs,
                              const NoBitsSection &S);
 
 } // end namespace ELFYAML
 } // end namespace llvm
struct ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1> {
   static void bitset(IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value);
 };
 
 template <>
 struct MappingTraits<ELFYAML::FileHeader> {
   static void mapping(IO &IO, ELFYAML::FileHeader &FileHdr);
 };
 
-template <> struct MappingTraits<ELFYAML::SectionHeaderTable> {
-  static void mapping(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
-  static std::string validate(IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable);
-};
-
 template <> struct MappingTraits<ELFYAML::SectionHeader> {
   static void mapping(IO &IO, ELFYAML::SectionHeader &SHdr);
 };
 
 template <> struct MappingTraits<ELFYAML::ProgramHeader> {
   static void mapping(IO &IO, ELFYAML::ProgramHeader &FileHdr);
   static std::string validate(IO &IO, ELFYAML::ProgramHeader &FileHdr);
 };

llvm/lib/ObjectYAML/ELFEmitter.cpp

if (!checkLimit(sizeof(uint64_t)))
       return 0;
     return encodeULEB128(Val, OS);
   }
 
   template <typename T> void write(T Val, support::endianness E) {
     if (checkLimit(sizeof(T)))
       support::endian::write<T>(OS, Val, E);
   }
+
+  void updateDataAt(uint64_t Pos, void *Data, size_t Size) {
+    assert(Pos >= InitialOffset && Pos + Size <= getOffset());
+    memcpy(&Buf[Pos - InitialOffset], Data, Size);
+  }
 };
 
 // Used to keep track of section and symbol names, so that in the YAML file
 // sections and symbols can be referenced by name instead of by index.
 class NameToIdxMap {
   StringMap<unsigned> Map;
 
 public:
template <class ELFT> class ELFState {
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
 
   std::vector<Fragment>
   getPhdrFragments(const ELFYAML::ProgramHeader &Phdr,
                    ArrayRef<typename ELFT::Shdr> SHeaders);
 
   void finalizeStrings();
-  void writeELFHeader(raw_ostream &OS, Optional<uint64_t> SHOff);
+  void writeELFHeader(raw_ostream &OS);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::NoBitsSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   void writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RelocationSection &Section,
ELFState<ELFT>::ELFState(ELFYAML::Object &D, yaml::ErrorHandler EH)
   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
   // Insert SHT_NULL section implicitly when it is not defined in YAML.
   if (Sections.empty() || Sections.front()->Type != ELF::SHT_NULL)
     Doc.Chunks.insert(
         Doc.Chunks.begin(),
         std::make_unique<ELFYAML::Section>(
             ELFYAML::Chunk::ChunkKind::RawContent, /*IsImplicit=*/true));
 
   // We add a technical suffix for each unnamed section/fill. It does not affect
   // the output, but allows us to map them by name in the code and report better
   // error messages.
   StringSet<> DocSections;
+  ELFYAML::SectionHeaderTable *SecHdrTable = nullptr;
   for (size_t I = 0; I < Doc.Chunks.size(); ++I) {
     const std::unique_ptr<ELFYAML::Chunk> &C = Doc.Chunks[I];
+
+    // We might have an explicit section header table declaration.
+    if (auto S = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
+      if (SecHdrTable)
+        reportError("multiple section header tables are not allowed");
+      SecHdrTable = S;
+      continue;
+    }
+
     if (C->Name.empty()) {
       std::string NewName = ELFYAML::appendUniqueSuffix(
           /*Name=*/"", "index " + Twine(I));
       C->Name = StringRef(NewName).copy(StringAlloc);
       assert(ELFYAML::dropUniqueSuffix(C->Name).empty());
     }
 
     if (!DocSections.insert(C->Name).second)
       reportError("repeated section/fill name: '" + C->Name +
                   "' at YAML section/fill number " + Twine(I));
   }
 
   std::vector<StringRef> ImplicitSections;
   if (Doc.DynamicSymbols)
     ImplicitSections.insert(ImplicitSections.end(), {".dynsym", ".dynstr"});
   if (Doc.Symbols)
     ImplicitSections.push_back(".symtab");
   if (Doc.DWARF)
     for (StringRef DebugSecName : Doc.DWARF->getNonEmptySectionNames()) {
       std::string SecName = ("." + DebugSecName).str();
       ImplicitSections.push_back(StringRef(SecName).copy(StringAlloc));
     }
   ImplicitSections.insert(ImplicitSections.end(), {".strtab"});
-  if (!Doc.SectionHeaders || !Doc.SectionHeaders->NoHeaders.getValueOr(false))
+  if (!SecHdrTable || !SecHdrTable->NoHeaders.getValueOr(false))
     ImplicitSections.insert(ImplicitSections.end(), {".shstrtab"});
 
   // Insert placeholders for implicit sections that are not
   // defined explicitly in YAML.
   for (StringRef SecName : ImplicitSections) {
     if (DocSections.count(SecName))
       continue;
 
     std::unique_ptr<ELFYAML::Chunk> Sec = std::make_unique<ELFYAML::Section>(
         ELFYAML::Chunk::ChunkKind::RawContent, true /*IsImplicit*/);
     Sec->Name = SecName;
+
+    // When the section header table is explicitly defined at the end of the
+    // sections list, it is reasonable to assume that user wants to reorder
+    // section headers, but still wants to place the section header table after
+    // all sections, like it normally happens. In this case we want to insert
+    // other implicit sections right before the section header table.
+    if (Doc.Chunks.back().get() == SecHdrTable)
+      Doc.Chunks.insert(Doc.Chunks.end() - 1, std::move(Sec));
+    else
       Doc.Chunks.push_back(std::move(Sec));
   }
+
+  // Insert the section header table implicitly at the end, when it is not
+  // explicitly defined.
+  if (!SecHdrTable)
+    Doc.Chunks.push_back(
+        std::make_unique<ELFYAML::SectionHeaderTable>(true /*IsImplicit*/));
 }
 
 template <class ELFT>
-void ELFState<ELFT>::writeELFHeader(raw_ostream &OS, Optional<uint64_t> SHOff) {
+void ELFState<ELFT>::writeELFHeader(raw_ostream &OS) {
   using namespace llvm::ELF;
 
   Elf_Ehdr Header;
   zero(Header);
   Header.e_ident[EI_MAG0] = 0x7f;
   Header.e_ident[EI_MAG1] = 'E';
   Header.e_ident[EI_MAG2] = 'L';
   Header.e_ident[EI_MAG3] = 'F';
void ELFState<ELFT>::writeELFHeader(raw_ostream &OS) {
   else if (!Doc.ProgramHeaders.empty())
     Header.e_phnum = Doc.ProgramHeaders.size();
   else
     Header.e_phnum = 0;
 
   Header.e_shentsize = Doc.Header.EShEntSize ? (uint16_t)*Doc.Header.EShEntSize
                                              : sizeof(Elf_Shdr);
 
+  const ELFYAML::SectionHeaderTable &SectionHeaders =
+      Doc.getSectionHeaderTable();
+
   if (Doc.Header.EShOff)
     Header.e_shoff = *Doc.Header.EShOff;
-  else if (SHOff)
-    Header.e_shoff = *SHOff;
+  else if (SectionHeaders.Offset)
+    Header.e_shoff = *SectionHeaders.Offset;
   else
     Header.e_shoff = 0;
 
   if (Doc.Header.EShNum)
     Header.e_shnum = *Doc.Header.EShNum;
-  else if (!Doc.SectionHeaders ||
-           (Doc.SectionHeaders->NoHeaders && !*Doc.SectionHeaders->NoHeaders))
-    Header.e_shnum = Doc.getSections().size();
-  else if (!SHOff)
-    Header.e_shnum = 0;
-  else
-    Header.e_shnum =
-        (Doc.SectionHeaders->Sections ? Doc.SectionHeaders->Sections->size()
-                                      : 0) +
-        /*Null section*/ 1;
+  else
+    Header.e_shnum = SectionHeaders.getHeadersNum(Doc.getSections().size());
 
   if (Doc.Header.EShStrNdx)
     Header.e_shstrndx = *Doc.Header.EShStrNdx;
-  else if (SHOff && !ExcludedSectionHeaders.count(".shstrtab"))
+  else if (SectionHeaders.Offset && !ExcludedSectionHeaders.count(".shstrtab"))
     Header.e_shstrndx = SN2I.get(".shstrtab");
   else
     Header.e_shstrndx = 0;
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
if (!LocSym.empty())
       reportError("unknown section referenced: '" + S + "' by YAML symbol '" +
                   LocSym + "'");
     else
       reportError("unknown section referenced: '" + S + "' by YAML section '" +
                   LocSec + "'");
     return 0;
   }
 
-  if (!Doc.SectionHeaders || (Doc.SectionHeaders->NoHeaders &&
-                              !Doc.SectionHeaders->NoHeaders.getValue()))
+  const ELFYAML::SectionHeaderTable &SectionHeaders =
+      Doc.getSectionHeaderTable();
+  if (SectionHeaders.IsImplicit ||
+      (SectionHeaders.NoHeaders && !SectionHeaders.NoHeaders.getValue()))
     return Index;
 
-  assert(!Doc.SectionHeaders->NoHeaders.getValueOr(false) ||
-         !Doc.SectionHeaders->Sections);
+  assert(!SectionHeaders.NoHeaders.getValueOr(false) ||
+         !SectionHeaders.Sections);
   size_t FirstExcluded =
-      Doc.SectionHeaders->Sections ? Doc.SectionHeaders->Sections->size() : 0;
+      SectionHeaders.Sections ? SectionHeaders.Sections->size() : 0;
   if (Index >= FirstExcluded) {
     if (LocSym.empty())
       reportError("unable to link '" + LocSec + "' to excluded section '" + S +
                   "'");
     else
       reportError("excluded section referenced: '" + S + "'  by symbol '" +
                   LocSym + "'");
   }
void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D.get())) {
       S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
       writeFill(*S, CBA);
       LocationCounter += S->Size;
       continue;
     }
 
+    if (ELFYAML::SectionHeaderTable *S =
+            dyn_cast<ELFYAML::SectionHeaderTable>(D.get())) {
+      if (S->NoHeaders.getValueOr(false))
+        continue;
+
+      if (!S->Offset)
+        S->Offset = alignToOffset(CBA, sizeof(typename ELFT::uint),
+                                  /*Offset=*/None);
+      else
+        S->Offset = alignToOffset(CBA, /*Align=*/1, S->Offset);
+
+      uint64_t Size = S->getHeadersNum(SHeaders.size()) * sizeof(Elf_Shdr);
+      CBA.writeZeros(Size);
+      LocationCounter += Size;
+      continue;
+    }
+
     ELFYAML::Section *Sec = cast<ELFYAML::Section>(D.get());
-    bool IsFirstUndefSection = D == Doc.Chunks.front();
+    bool IsFirstUndefSection = Sec == Doc.getSections().front();
     if (IsFirstUndefSection && Sec->IsImplicit)
       continue;
 
     // We have a few sections like string or symbol tables that are usually
     // added implicitly to the end. However, if they are explicitly specified
     // in the YAML, we need to write them here. This ensures the file offset
     // remains correct.
     Elf_Shdr &SHeader = SHeaders[SN2I.get(Sec->Name)];
void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
   uint64_t Written = 0;
   for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
     CBA.writeAsBinary(*Fill.Pattern);
   CBA.writeAsBinary(*Fill.Pattern, Fill.Size - Written);
 }
 
 template <class ELFT>
 DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
-  if (!Doc.SectionHeaders || Doc.SectionHeaders->NoHeaders)
+  const ELFYAML::SectionHeaderTable &SectionHeaders =
+      Doc.getSectionHeaderTable();
+  if (SectionHeaders.IsImplicit || SectionHeaders.NoHeaders)
     return DenseMap<StringRef, size_t>();
 
   DenseMap<StringRef, size_t> Ret;
   size_t SecNdx = 0;
   StringSet<> Seen;
 
   auto AddSection = [&](const ELFYAML::SectionHeader &Hdr) {
     if (!Ret.try_emplace(Hdr.Name, ++SecNdx).second)
       reportError("repeated section name: '" + Hdr.Name +
                   "' in the section header description");
     Seen.insert(Hdr.Name);
   };
 
-  if (Doc.SectionHeaders->Sections)
-    for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Sections)
+  if (SectionHeaders.Sections)
+    for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Sections)
       AddSection(Hdr);
 
-  if (Doc.SectionHeaders->Excluded)
-    for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Excluded)
+  if (SectionHeaders.Excluded)
+    for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
       AddSection(Hdr);
 
   for (const ELFYAML::Section *S : Doc.getSections()) {
     // Ignore special first SHT_NULL section.
     if (S == Doc.getSections().front())
       continue;
     if (!Seen.count(S->Name))
       reportError("section '" + S->Name +
template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
   // allows to change the order of section headers.
   DenseMap<StringRef, size_t> ReorderMap = buildSectionHeaderReorderMap();
 
   if (HasError)
     return;
 
   // Build excluded section headers map.
   std::vector<ELFYAML::Section *> Sections = Doc.getSections();
-  if (Doc.SectionHeaders) {
-    if (Doc.SectionHeaders->Excluded)
-      for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Excluded)
+  const ELFYAML::SectionHeaderTable &SectionHeaders = Doc.getSectionHeaderTable();
+  if (!SectionHeaders.IsImplicit) {
+    if (SectionHeaders.Excluded)
+      for (const ELFYAML::SectionHeader &Hdr : *SectionHeaders.Excluded)
         if (!ExcludedSectionHeaders.insert(Hdr.Name).second)
           llvm_unreachable("buildSectionIndex() failed");
 
-    if (Doc.SectionHeaders->NoHeaders.getValueOr(false))
+    if (SectionHeaders.NoHeaders.getValueOr(false))
       for (const ELFYAML::Section *S : Sections)
         if (!ExcludedSectionHeaders.insert(S->Name).second)
           llvm_unreachable("buildSectionIndex() failed");
   }
 
   size_t SecNdx = -1;
   for (const ELFYAML::Section *S : Sections) {
     ++SecNdx;
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset, MaxSize);
 
   std::vector<Elf_Shdr> SHeaders;
   State.initSectionHeaders(SHeaders, CBA);
 
   // Now we can decide segment offsets.
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
-  // If needed, align the start of the section header table, which is written
-  // after all section data.
-  const bool HasSectionHeaders =
-      !Doc.SectionHeaders || !Doc.SectionHeaders->NoHeaders.getValueOr(false);
-  Optional<uint64_t> SHOff;
-  if (HasSectionHeaders)
-    SHOff = State.alignToOffset(CBA, sizeof(typename ELFT::uint),
-                                /*Offset=*/None);
-  bool ReachedLimit = SHOff.getValueOr(CBA.getOffset()) +
-                          arrayDataSize(makeArrayRef(SHeaders)) >
-                      MaxSize;
+  bool ReachedLimit = CBA.getOffset() > MaxSize;
   if (Error E = CBA.takeLimitError()) {
     // We report a custom error message instead below.
     consumeError(std::move(E));
     ReachedLimit = true;
   }
 
   if (ReachedLimit)
     State.reportError(
         "the desired output size is greater than permitted. Use the "
         "--max-size option to change the limit");
 
   if (State.HasError)
     return false;
 
-  State.writeELFHeader(OS, SHOff);
+  State.writeELFHeader(OS);
   writeArrayData(OS, makeArrayRef(PHeaders));
+
+  const ELFYAML::SectionHeaderTable &SHT = Doc.getSectionHeaderTable();
+  if (SHT.Offset)
+    CBA.updateDataAt(*SHT.Offset, SHeaders.data(),
+                     SHT.getHeadersNum(SHeaders.size()) * sizeof(Elf_Shdr));
+
   CBA.writeBlobToStream(OS);
-  if (HasSectionHeaders)
-    writeArrayData(OS, makeArrayRef(SHeaders));
   return true;
 }
 
 namespace llvm {
 namespace yaml {
 
 bool yaml2elf(llvm::ELFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH,
               uint64_t MaxSize) {

llvm/lib/ObjectYAML/ELFYAML.cpp

 #undef BCase
 }
 
 void MappingTraits<ELFYAML::SectionHeader>::mapping(
     IO &IO, ELFYAML::SectionHeader &SHdr) {
   IO.mapRequired("Name", SHdr.Name);
 }
 
-void MappingTraits<ELFYAML::SectionHeaderTable>::mapping(
-    IO &IO, ELFYAML::SectionHeaderTable &SectionHeader) {
-  IO.mapOptional("Sections", SectionHeader.Sections);
-  IO.mapOptional("Excluded", SectionHeader.Excluded);
-  IO.mapOptional("NoHeaders", SectionHeader.NoHeaders);
-}
-
-std::string MappingTraits<ELFYAML::SectionHeaderTable>::validate(
-    IO &IO, ELFYAML::SectionHeaderTable &SecHdrTable) {
-  if (SecHdrTable.NoHeaders && (SecHdrTable.Sections || SecHdrTable.Excluded))
-    return "NoHeaders can't be used together with Sections/Excluded";
-  if (!SecHdrTable.NoHeaders && !SecHdrTable.Sections && !SecHdrTable.Excluded)
-    return "SectionHeaderTable can't be empty. Use 'NoHeaders' key to drop the "
-           "section header table";
-  return "";
-}
-
 void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
                                                  ELFYAML::FileHeader &FileHdr) {
   IO.mapRequired("Class", FileHdr.Class);
   IO.mapRequired("Data", FileHdr.Data);
   IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
   IO.mapOptional("ABIVersion", FileHdr.ABIVersion, Hex8(0));
   IO.mapRequired("Type", FileHdr.Type);
   IO.mapOptional("Machine", FileHdr.Machine);

 
 static void fillMapping(IO &IO, ELFYAML::Fill &Fill) {
   IO.mapOptional("Name", Fill.Name, StringRef());
   IO.mapOptional("Pattern", Fill.Pattern);
   IO.mapOptional("Offset", Fill.Offset);
   IO.mapRequired("Size", Fill.Size);
 }
 
+static void sectionHeaderTableMapping(IO &IO,
+                                      ELFYAML::SectionHeaderTable &SHT) {
+  IO.mapOptional("Offset", SHT.Offset);
+  IO.mapOptional("Sections", SHT.Sections);
+  IO.mapOptional("Excluded", SHT.Excluded);
+  IO.mapOptional("NoHeaders", SHT.NoHeaders);
+}
+
 static void sectionMapping(IO &IO, ELFYAML::LinkerOptionsSection &Section) {
   commonSectionMapping(IO, Section);
   IO.mapOptional("Options", Section.Options);
 }
 
 static void sectionMapping(IO &IO,
                            ELFYAML::DependentLibrariesSection &Section) {
   commonSectionMapping(IO, Section);

 }
 
 static StringRef getStringValue(IO &IO, const char *Key) {
   StringRef Val;
   IO.mapRequired(Key, Val);
   return Val;
 }
 
+static void setStringValue(IO &IO, const char *Key, StringRef Val) {
+  IO.mapRequired(Key, Val);
+}
+
+static bool isInteger(StringRef Val) {
+  APInt Tmp;
+  return !Val.getAsInteger(0, Tmp);
+}
+
 void MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::mapping(
     IO &IO, std::unique_ptr<ELFYAML::Chunk> &Section) {
   ELFYAML::ELF_SHT Type;
+  StringRef TypeStr;
   if (IO.outputting()) {
-    Type = cast<ELFYAML::Section>(Section.get())->Type;
+    if (auto *S = dyn_cast<ELFYAML::Section>(Section.get()))
+      Type = S->Type;
+    else if (auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(Section.get()))
+      TypeStr = SHT->TypeStr;
   } else {
     // When the Type string does not have a "SHT_" prefix, we know it is not a
-    // description of a regular ELF output section. Currently, we have one
-    // special type named "Fill". See comments for Fill.
-    if (getStringValue(IO, "Type") == "Fill") {
-      Section.reset(new ELFYAML::Fill());
-      fillMapping(IO, *cast<ELFYAML::Fill>(Section.get()));
-      return;
-    }
+    // description of a regular ELF output section.
+    TypeStr = getStringValue(IO, "Type");
+    if (TypeStr.startswith("SHT_") || isInteger(TypeStr))
+      IO.mapRequired("Type", Type);
+  }
+
+  if (TypeStr == "Fill") {
+    assert(!IO.outputting()); // We don't dump fills currently;
 
-    IO.mapRequired("Type", Type);
+  if (TypeStr == ELFYAML::SectionHeaderTable::TypeStr) {
+    if (IO.outputting())
+      setStringValue(IO, "Type", TypeStr);
+    else
+      Section.reset(new ELFYAML::SectionHeaderTable(/*IsImplicit=*/false));
+
+    sectionHeaderTableMapping(
+        IO, *cast<ELFYAML::SectionHeaderTable>(Section.get()));
+    return;
   }
 
   const auto &Obj = *static_cast<ELFYAML::Object *>(IO.getContext());
   if (Obj.getMachine() == ELF::EM_MIPS && Type == ELF::SHT_MIPS_ABIFLAGS) {
     if (!IO.outputting())
       Section.reset(new ELFYAML::MipsABIFlags());
     sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
     return;

 std::string MappingTraits<std::unique_ptr<ELFYAML::Chunk>>::validate(
     IO &io, std::unique_ptr<ELFYAML::Chunk> &C) {
   if (const auto *F = dyn_cast<ELFYAML::Fill>(C.get())) {
     if (F->Pattern && F->Pattern->binary_size() != 0 && !F->Size)
       return "\"Size\" can't be 0 when \"Pattern\" is not empty";
     return "";
   }
 
+  if (const auto *SHT = dyn_cast<ELFYAML::SectionHeaderTable>(C.get())) {
+    if (SHT->NoHeaders && (SHT->Sections || SHT->Excluded || SHT->Offset))
+      return "NoHeaders can't be used together with Offset/Sections/Excluded";
+    if (!SHT->NoHeaders && !SHT->Sections && !SHT->Excluded)
+      return "SectionHeaderTable can't be empty. Use 'NoHeaders' key to drop "
+             "the section header table";
+    return "";
+  }
+
   const ELFYAML::Section &Sec = *cast<ELFYAML::Section>(C.get());
   if (Sec.Size && Sec.Content &&
       (uint64_t)(*Sec.Size) < Sec.Content->binary_size())
     return "Section size must be greater than or equal to the content size";
 
   auto BuildErrPrefix = [](ArrayRef<std::pair<StringRef, bool>> EntV) {
     std::string Msg;
     for (size_t I = 0, E = EntV.size(); I != E; ++I) {
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
   IO.setContext(&Object);
   IO.mapTag("!ELF", true);
   IO.mapRequired("FileHeader", Object.Header);
   IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
   IO.mapOptional("Sections", Object.Chunks);
   IO.mapOptional("Symbols", Object.Symbols);
   IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
   IO.mapOptional("DWARF", Object.DWARF);
-  IO.mapOptional("SectionHeaderTable", Object.SectionHeaders);
   if (Object.DWARF) {
     Object.DWARF->IsLittleEndian =
         Object.Header.Data == ELFYAML::ELF_ELFDATA(ELF::ELFDATA2LSB);
     Object.DWARF->Is64BitAddrSize =
         Object.Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64);
   }
   IO.setContext(nullptr);
 }

llvm/test/Object/obj2yaml.test

 # ELF-MIPSEL-NEXT:         Symbol:          '$.str'
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_LO16
 # ELF-MIPSEL-NEXT:       - Offset:          0x20
 # ELF-MIPSEL-NEXT:         Symbol:          puts
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
 # ELF-MIPSEL-NEXT:       - Offset:          0x2C
 # ELF-MIPSEL-NEXT:         Symbol:          SomeOtherFunction
 # ELF-MIPSEL-NEXT:         Type:            R_MIPS_CALL16
+# ELF-MIPSEL-NEXT:   - Type: SectionHeaderTable
+# ELF-MIPSEL-NEXT:     Sections:
+# ELF-MIPSEL-NEXT:       - Name: .text
+# ELF-MIPSEL-NEXT:       - Name: .rel.text
+# ELF-MIPSEL-NEXT:       - Name: .data
+# ELF-MIPSEL-NEXT:       - Name: .bss
+# ELF-MIPSEL-NEXT:       - Name: .mdebug.abi32
+# ELF-MIPSEL-NEXT:       - Name: .rodata.str1.1
+# ELF-MIPSEL-NEXT:       - Name: .reginfo
+# ELF-MIPSEL-NEXT:       - Name: .MIPS.abiflags
+# ELF-MIPSEL-NEXT:       - Name: .shstrtab
+# ELF-MIPSEL-NEXT:       - Name: .symtab
+# ELF-MIPSEL-NEXT:       - Name: .strtab
 # ELF-MIPSEL-NEXT: Symbols:
 # ELF-MIPSEL-NEXT:     - Name:            trivial.ll
 # ELF-MIPSEL-NEXT:       Type:            STT_FILE
 # ELF-MIPSEL-NEXT:       Index:           SHN_ABS
 # ELF-MIPSEL-NEXT:     - Name:            '$.str'
 # ELF-MIPSEL-NEXT:       Type:            STT_OBJECT
 # ELF-MIPSEL-NEXT:       Section:         .rodata.str1.1
 # ELF-MIPSEL-NEXT:       Size:            0xD

 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:       Size:            0x4
 # ELF-MIPSEL-NEXT:     - Name:            SomeOtherFunction
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:     - Name:            _gp_disp
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
 # ELF-MIPSEL-NEXT:     - Name:            puts
 # ELF-MIPSEL-NEXT:       Binding:         STB_GLOBAL
-# ELF-MIPSEL-NEXT: SectionHeaderTable:
-# ELF-MIPSEL-NEXT:   Sections:
-# ELF-MIPSEL-NEXT:     - Name: .text
-# ELF-MIPSEL-NEXT:     - Name: .rel.text
-# ELF-MIPSEL-NEXT:     - Name: .data
-# ELF-MIPSEL-NEXT:     - Name: .bss
-# ELF-MIPSEL-NEXT:     - Name: .mdebug.abi32
-# ELF-MIPSEL-NEXT:     - Name: .rodata.str1.1
-# ELF-MIPSEL-NEXT:     - Name: .reginfo
-# ELF-MIPSEL-NEXT:     - Name: .MIPS.abiflags
-# ELF-MIPSEL-NEXT:     - Name: .shstrtab
-# ELF-MIPSEL-NEXT:     - Name: .symtab
-# ELF-MIPSEL-NEXT:     - Name: .strtab
 # ELF-MIPSEL-NEXT: ...
 
 # RUN: obj2yaml %p/Inputs/trivial-object-test.elf-mips64el | FileCheck %s --check-prefix ELF-MIPS64EL
 
 # ELF-MIPS64EL:      FileHeader:
 # ELF-MIPS64EL-NEXT:   Class:           ELFCLASS64
 # ELF-MIPS64EL-NEXT:   Data:            ELFDATA2LSB
 # ELF-MIPS64EL-NEXT:   Type:            ET_REL

 # ELF-MIPS64EL-NEXT:   - Name:            .rela.data
 # ELF-MIPS64EL-NEXT:     Type:            SHT_RELA
 # ELF-MIPS64EL-NEXT:     Link:            .symtab
 # ELF-MIPS64EL-NEXT:     AddressAlign:    0x8
 # ELF-MIPS64EL-NEXT:     Info:            .data
 # ELF-MIPS64EL-NEXT:     Relocations:
 # ELF-MIPS64EL-NEXT:       - Symbol:          zed
 # ELF-MIPS64EL-NEXT:         Type:            R_MIPS_64
+# ELF-MIPS64EL-NEXT:   - Type: SectionHeaderTable
+# ELF-MIPS64EL-NEXT:     Sections:
+# ELF-MIPS64EL-NEXT:       - Name: .text
+# ELF-MIPS64EL-NEXT:       - Name: .data
+# ELF-MIPS64EL-NEXT:       - Name: .rela.data
+# ELF-MIPS64EL-NEXT:       - Name: .bss
+# ELF-MIPS64EL-NEXT:       - Name: .MIPS.options
+# ELF-MIPS64EL-NEXT:       - Name: .pdr
+# ELF-MIPS64EL-NEXT:       - Name: .shstrtab
+# ELF-MIPS64EL-NEXT:       - Name: .symtab
+# ELF-MIPS64EL-NEXT:       - Name: .strtab
 # ELF-MIPS64EL-NEXT: Symbols:
 # ELF-MIPS64EL-NEXT:     - Name:            .text
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .text
 # ELF-MIPS64EL-NEXT:     - Name:            .data
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .data
 # ELF-MIPS64EL-NEXT:     - Name:            .bss
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .bss
 # ELF-MIPS64EL-NEXT:     - Name:            bar
 # ELF-MIPS64EL-NEXT:       Section:         .data
 # ELF-MIPS64EL-NEXT:     - Name:            .MIPS.options
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .MIPS.options
 # ELF-MIPS64EL-NEXT:     - Name:            .pdr
 # ELF-MIPS64EL-NEXT:       Type:            STT_SECTION
 # ELF-MIPS64EL-NEXT:       Section:         .pdr
 # ELF-MIPS64EL-NEXT:     - Name:            zed
 # ELF-MIPS64EL-NEXT:       Binding:         STB_GLOBAL
-# ELF-MIPS64EL-NEXT: SectionHeaderTable:
-# ELF-MIPS64EL-NEXT:   Sections:
-# ELF-MIPS64EL-NEXT:     - Name: .text
-# ELF-MIPS64EL-NEXT:     - Name: .data
-# ELF-MIPS64EL-NEXT:     - Name: .rela.data
-# ELF-MIPS64EL-NEXT:     - Name: .bss
-# ELF-MIPS64EL-NEXT:     - Name: .MIPS.options
-# ELF-MIPS64EL-NEXT:     - Name: .pdr
-# ELF-MIPS64EL-NEXT:     - Name: .shstrtab
-# ELF-MIPS64EL-NEXT:     - Name: .symtab
-# ELF-MIPS64EL-NEXT:     - Name: .strtab
 # ELF-MIPS64EL-NEXT: ...
 
 # RUN: yaml2obj %s -o %t-x86-64
 # RUN: obj2yaml %t-x86-64 | FileCheck %s --check-prefix ELF-X86-64
 
 # ELF-X86-64:      FileHeader:
 # ELF-X86-64-NEXT:   Class:           ELFCLASS64
 # ELF-X86-64-NEXT:   Data:            ELFDATA2LSB

llvm/test/tools/llvm-readobj/ELF/broken-dynamic-reloc.test

- Name: .strtab
     Type: SHT_STRTAB
   - Name: .shstrtab
     Type: SHT_STRTAB
   - Name:    .dynsym
     Type:    SHT_DYNSYM
     Flags:   [ SHF_ALLOC ]
     Address: 0x300
     Offset:  0x300
+  - Type: SectionHeaderTable
+    NoHeaders: true
 DynamicSymbols:
   - Name: foo
 ProgramHeaders:
   - Type:     PT_LOAD
     Offset:   0x0
     FirstSec: .dynamic
     LastSec:  .dynsym
   - Type:     PT_DYNAMIC
     FirstSec: .dynamic
     LastSec:  .dynamic
-SectionHeaderTable:
-  NoHeaders: true

llvm/test/tools/llvm-readobj/ELF/dynamic-reloc-no-section-headers.test

 ## Offset of .dynstr is 0x168. Offset of PT_LOAD is 0xb0.
 ## 0x168 - 0xb0 == 0xb8
       - Tag:   DT_STRTAB
         Value: 0xb8
       - Tag:   DT_NULL
         Value: 0x0
   - Name:    .dynsym
     Type:    SHT_DYNSYM
+  - Type: SectionHeaderTable
+    NoHeaders: true
 DynamicSymbols:
   - Name: foo
 ProgramHeaders:
   - Type:     PT_LOAD
     FirstSec: .rela.dyn
     LastSec:  .dynstr
   - Type:     PT_DYNAMIC
     FirstSec: .dynamic
     LastSec:  .dynamic
-SectionHeaderTable:
-  NoHeaders: true

llvm/test/tools/llvm-readobj/ELF/file-headers.test

 ## The section header table offset goes past the EOF.
   EShOff:    0x1000
 ## The number of section headers is too large, the file is
 ## too little to contain so many sections.
   EShNum:    [[SHNUM=0x2000]]
 ## The index of the section name string table is too large.
 ## The section would be past the EOF.
   EShStrNdx: [[SHSTRNDX=0x3000]]
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     NoHeaders: true
 
 ## Check we don't dump anything except the file header when the section header table can't be read.
 
 # RUN: not llvm-readobj -a %t.invalid1 2>&1 \
 # RUN:  | FileCheck %s -DFILE=%t.invalid1 -DSECHDRCOUNT=8192 -DSECHDRSTRTABINDEX=12288 --check-prefix=INVALID-LLVM
 # RUN: not llvm-readelf -a %t.invalid1 2>&1 \
 # RUN:  | FileCheck %s -DFILE=%t.invalid1 -DSECHDRCOUNT=8192 -DSECHDRSTRTABINDEX=12288 --check-prefix=INVALID-GNU
 
 ## Check what we print when e_shnum == 0, e_shstrndx == SHN_XINDEX and the section header table can't be read.
 
 # RUN: yaml2obj %s -DSHNUM=0 -DSHSTRNDX=0xffff --docnum=4 -o %t.invalid2
 # RUN: not llvm-readobj --file-headers %t.invalid2 2>&1 \
 # RUN:  | FileCheck %s -DFILE=%t.invalid2 -DSECHDRCOUNT="<?>" -DSECHDRSTRTABINDEX="<?>" --check-prefix=INVALID-LLVM
 # RUN: not llvm-readelf --file-headers %t.invalid2 2>&1 \
 # RUN:  | FileCheck %s -DFILE=%t.invalid2 -DSECHDRCOUNT="<?>" -DSECHDRSTRTABINDEX="<?>" --check-prefix=INVALID-GNU

llvm/test/tools/llvm-readobj/ELF/hash-table.test

Sections:
   - Name:  .dynamic
     Type:  SHT_DYNAMIC
     Flags: [ SHF_ALLOC ]
     Entries:
       - Tag:   [[DYNTAG=DT_HASH]]
         Value: 0x0
       - Tag:   DT_NULL
         Value: 0x0
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     NoHeaders: [[NOHEADERS=false]]
 ProgramHeaders:
   - Type:     PT_LOAD
     FirstSec: .hash
     LastSec:  .dynamic
   - Type:     PT_DYNAMIC
     VAddr:    0x10
     FirstSec: .dynamic
     LastSec:  .dynamic

llvm/test/tools/llvm-readobj/ELF/malformed-pt-dynamic.test

Sections:
   - Name:     .dynamic
     Type:     SHT_DYNAMIC
     Address:  0x1000
     Offset:   0x1000
     ShOffset: [[OFFSET=<none>]]
     Entries:
       - Tag:   DT_NULL
         Value: 0
+  - Type: SectionHeaderTable
+    NoHeaders: [[NOHEADERS=false]]
 ProgramHeaders:
   - Type:     PT_DYNAMIC
     FileSize: [[FILESIZE=<none>]]
     FirstSec: .dynamic
     LastSec:  .dynamic
-SectionHeaderTable:
-  NoHeaders: [[NOHEADERS=false]]

llvm/test/tools/llvm-readobj/ELF/symtab-shndx.test

## of dynamic symbols.
   - Name: .strtab
     Type: SHT_STRTAB
   - Name:    .symtab_shndx
     Type:    SHT_SYMTAB_SHNDX
     Flags:   [ SHF_ALLOC ]
     Entries: [ 0, 1 ]
     Offset:  0x2000
     Address: 0x2000
+  - Type:      SectionHeaderTable
+    NoHeaders: true
 DynamicSymbols:
   - Name:  dynsym1
     Index: SHN_XINDEX
   - Name:  dynsym2
     Index: SHN_XINDEX
 ProgramHeaders:
   - Type:     PT_LOAD
     VAddr:    0x1000
     FirstSec: .dynamic
     LastSec:  .symtab_shndx
   - Type:     PT_DYNAMIC
     VAddr:    0x1000
     FirstSec: .dynamic
     LastSec:  .dynamic
-SectionHeaderTable:
-  NoHeaders: true

llvm/test/tools/obj2yaml/ELF/offset.yaml

 #   BASIC-NEXT:   - Name:         .bar3
 #   BASIC-NEXT:     Type:         SHT_PROGBITS
 #   BASIC-NEXT:     AddressAlign: 0x10
 #   BASIC-NEXT:     Offset:       0x200
 #   BASIC-NEXT:   - Name:         .bar4
 #   BASIC-NEXT:     Type:         SHT_PROGBITS
 #   BASIC-NEXT:     AddressAlign: 0x100000000
 #   BASIC-NEXT:     Offset:       0x210
-# HEADERS-NEXT: SectionHeaderTable:
-# HEADERS-NEXT:   Sections:
-# HEADERS-NEXT:     - Name:            .bar4
-# HEADERS-NEXT:     - Name:            .bar3
-# HEADERS-NEXT:     - Name:            .bar2
-# HEADERS-NEXT:     - Name:            .bar1
-# HEADERS-NEXT:     - Name:            .foo3
-# HEADERS-NEXT:     - Name:            .foo2
-# HEADERS-NEXT:     - Name:            .foo1
-# HEADERS-NEXT:     - Name:            .strtab
-# HEADERS-NEXT:     - Name:            .shstrtab
+# HEADERS-NEXT:   - Type: SectionHeaderTable
+# HEADERS-NEXT:     Sections:
+# HEADERS-NEXT:       - Name: .bar4
+# HEADERS-NEXT:       - Name: .bar3
+# HEADERS-NEXT:       - Name: .bar2
+# HEADERS-NEXT:       - Name: .bar1
+# HEADERS-NEXT:       - Name: .foo3
+# HEADERS-NEXT:       - Name: .foo2
+# HEADERS-NEXT:       - Name: .foo1
+# HEADERS-NEXT:       - Name: .strtab
+# HEADERS-NEXT:       - Name: .shstrtab
 # BASIC-NEXT: ...
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
- Name:         .bar3
     AddressAlign: 0x10
     Offset:       0x200
 ## A case where AddressAlign > MAX_UINT32 and (uint32_t)AddressAlign == 0.
 ## Check we dump an offset in this case properly.
   - Name:         .bar4
     Type:         SHT_PROGBITS
     AddressAlign: 0x100000000
     Offset:       0x210
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
 ## By default we have the same order of sections as defined by the "Sections" key.
       - Name: [[SEC1=.foo1]]
       - Name: [[SEC2=.foo2]]
       - Name: [[SEC3=.foo3]]
       - Name: [[SEC4=.bar1]]
       - Name: [[SEC5=.bar2]]
       - Name: [[SEC6=.bar3]]
       - Name: [[SEC7=.bar4]]
       - Name: .strtab
       - Name: .shstrtab
 
 ## In this case we change the order of sections in the section header table.
 ## Check that we still dump offsets correctly.
 
 # RUN: yaml2obj %s -DSEC1=.bar4 -DSEC2=.bar3 -DSEC3=.bar2 \
 # RUN:   -DSEC4=.bar1 -DSEC5=.foo3 -DSEC6=.foo2 -DSEC7=.foo1 -o %t1-sechdr.o
 # RUN: obj2yaml %t1-sechdr.o | FileCheck --check-prefixes=BASIC,HEADERS %s
 

llvm/test/tools/yaml2obj/ELF/section-headers-exclude.yaml

FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
   - Name: .bar
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: [[INCLUDED]]
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: [[EXCLUDED]]
 
 ## Check we report an error when a section is in both the "Sections" and "Excluded" lists at the same time.
 ## Also check that we report an error if a section is missing from the lists.
 # RUN: not yaml2obj %s -DINCLUDED=.bar -DEXCLUDED=.strtab --docnum=1 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=EXCLUDE-INCLUDED
 
 # EXCLUDE-INCLUDED: error: repeated section name: '.strtab' in the section header description
 # EXCLUDE-INCLUDED: error: section '.foo' should be present in the 'Sections' or 'Excluded' lists

 # EXCLUDE-TWICE: error: repeated section name: '.strtab' in the section header description
 # EXCLUDE-TWICE: error: repeated section name: '.strtab' in the section header description
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .strtab
       - Name: .strtab
 
 ## Check that we are able to exclude all sections, except the implicit
 ## null section, with the use of the "Excluded" key.
 
 ## Case A: the "Sections" key is present, but empty.
 # RUN: yaml2obj %s --docnum=3 -o %t3
 # RUN: llvm-readelf --section-headers %t3 | FileCheck %s --check-prefix=NO-SECTIONS
 
 # NO-SECTIONS:      There are 1 section headers, starting at offset 0x48:
 # NO-SECTIONS:      Section Headers:
 # NO-SECTIONS-NEXT:  [Nr] Name         Type Address          Off    Size   ES Flg Lk Inf Al
 # NO-SECTIONS-NEXT:  [ 0] <no-strings> NULL 0000000000000000 000000 000000 00      0   0  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     Sections: []
     Excluded:
       - Name: .strtab
       - Name: .shstrtab
 
 ## Case B: the "Sections" key is not present.
 # RUN: yaml2obj %s --docnum=4 -o %t4
 # RUN: llvm-readelf --section-headers %t4 | FileCheck %s --check-prefix=NO-SECTIONS
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     Excluded:
       - Name: .strtab
       - Name: .shstrtab
 
 ## Check how we handle cases when a section is excluded, but its section index is needed.
 ## The general rule is: when a section is explicitly linked with another section, which is
 ## excluded, then we report an error. In the case when it is linked implicitly with an excluded
 ## section, we use 0 as index value.
 
 ## Case A: check we report an error when a regular section has a Link field which
 ##         points to an excluded section.
 # RUN: not yaml2obj %s --docnum=5 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.foo -DTARGET=.bar
 
 # LINK: error: unable to link '[[SEC]]' to excluded section '[[TARGET]]'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
     Link: .bar
   - Name: .bar
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .foo
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .bar
 
 ## Case B.1: check we report an error when a symbol table section has a Link field which
 ##           points to an excluded section.
 # RUN: not yaml2obj %s --docnum=6 -DNAME=.symtab -DTYPE=SHT_SYMTAB -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.symtab -DTARGET=.foo
 # RUN: not yaml2obj %s --docnum=6 -DNAME=.dynsym -DTYPE=SHT_DYNSYM -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.dynsym -DTARGET=.foo
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:  [[NAME]]
     Type:  [[TYPE]]
     Link:  .foo
   - Name:  .foo
     Type:  SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: [[NAME]]
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .foo
 
 ## Case B.2: check we do not link .dynsym with .dynstr implicitly when the latter is excluded.
 # RUN: yaml2obj %s --docnum=7 -o %t5
 # RUN: llvm-readelf %t5 --section-headers | FileCheck %s --check-prefix=LINK-DYNSYM
 
 # LINK-DYNSYM: [Nr] Name    Type   Address          Off    Size   ES Flg Lk
 # LINK-DYNSYM: [ 1] .dynsym DYNSYM 0000000000000000 000040 000018 18   A  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:  .dynsym
     Type:  SHT_DYNSYM
   - Name:  .dynstr
     Type:  SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .dynsym
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .dynstr
 
 ## Case B.3: check we do not link .symtab with .strtab implicitly when the latter is excluded.
 # RUN: yaml2obj %s --docnum=8 -o %t6
 # RUN: llvm-readelf %t6 --section-headers | FileCheck %s --check-prefix=LINK-SYMTAB
 
 # LINK-SYMTAB: [Nr] Name    Type   Address          Off    Size   ES Flg Lk Inf Al
 # LINK-SYMTAB: [ 1] .symtab SYMTAB 0000000000000000 000040 000018 18      0   1  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:  .symtab
     Type:  SHT_SYMTAB
   - Name:  .strtab
     Type:  SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .symtab
       - Name: .shstrtab
     Excluded:
       - Name: .strtab
 
 ## Case C: check we report an error when a debug section has a Link field which
 ##         points to an excluded section.
 # RUN: not yaml2obj %s --docnum=9 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.debug_unknown -DTARGET=.strtab
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_EXEC
 Sections:
   - Name:  .debug_unknown
     Type:  SHT_PROGBITS
     Link:  .strtab
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .debug_unknown
       - Name: .shstrtab
     Excluded:
       - Name: .strtab
 
 ## Case D.1: check we report an error when a relocatable section has an Info field which
 ##           points to an excluded section.
 # RUN: not yaml2obj %s --docnum=10 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.rela -DTARGET=.strtab
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .rela
     Type: SHT_RELA
     Info: .strtab
     Relocations: []
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .rela
       - Name: .shstrtab
     Excluded:
       - Name: .strtab
 
 ## Case D.2: check we report an error when the SHT_REL[A] section is linked
 ##           with an excluded section explicitly.
 # RUN: not yaml2obj %s --docnum=11 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.rela -DTARGET=.symtab
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .rela
     Type: SHT_RELA
     Link: .symtab
     Relocations: []
   - Name: .symtab
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .rela
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .symtab
 
 ## Case E: check we report an error when a symbol references an excluded section.
 # RUN: not yaml2obj %s --docnum=12 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=SYMBOL-SECTION
 
 # SYMBOL-SECTION: error: excluded section referenced: '.foo' by symbol 'foo'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-Symbols:
-  - Name:    foo
-    Type:    STT_OBJECT
-    Section: .foo
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .symtab
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .foo
+Symbols:
+  - Name:    foo
+    Type:    STT_OBJECT
+    Section: .foo
 
 ## Case F.1: check we report an error when a group section
 ##           contains an excluded section member.
 # RUN: not yaml2obj %s --docnum=13 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.group -DTARGET=.strtab
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .group
     Type: SHT_GROUP
     Members:
       - SectionOrType: .strtab
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .group
       - Name: .shstrtab
     Excluded:
       - Name: .strtab
 
 ## Case F.2: check we report an error when the group section is linked
 ##           to an excluded section explicitly.
 # RUN: not yaml2obj %s --docnum=14 -o /dev/null 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=LINK -DSEC=.group -DTARGET=.symtab
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .group
     Type: SHT_GROUP
     Link: .symtab
     Members: []
   - Name: .symtab
     Type: SHT_SYMTAB
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .group
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .symtab
 
 ## Case G: check we do not link SHT_LLVM_CALL_GRAPH_PROFILE/SHT_LLVM_ADDRSIG/SHT_GROUP/SHT_REL[A] sections
 ##         with .symtab implicitly when the latter is excluded.
 # RUN: yaml2obj %s --docnum=15 -o %t7
 # RUN: llvm-readelf %t7 --section-headers | FileCheck %s --check-prefix=LINK-IMPLICIT
 
 # LINK-IMPLICIT:      [Nr] Name          Type                    Address          Off    Size   ES Flg Lk Inf Al
 # LINK-IMPLICIT:      [ 1] .cgp          LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 10      0   0  0
Sections:
   - Name: .group
     Type: SHT_GROUP
     Members: []
   - Name: .rela
     Type: SHT_RELA
     Relocations: []
   - Name: .symtab
     Type: SHT_SYMTAB
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .cgp
       - Name: .llvm_addrsig
       - Name: .group
       - Name: .rela
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .symtab
 
 ## Case H: check we do not link SHT_HASH/SHT_GNU_HASH sections with .dynsym
 ##         implicitly when the latter is excluded.
 # RUN: yaml2obj %s --docnum=16 -o %t8
 # RUN: llvm-readelf %t8 --section-headers | FileCheck %s --check-prefix=LINK-HASH
 
 # LINK-HASH:      [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
 # LINK-HASH:      [ 1] .hash     HASH     0000000000000000 000040 000000 04      0   0  0
 # LINK-HASH-NEXT: [ 2] .gnu_hash GNU_HASH 0000000000000000 000040 000000 00      0   0  0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name:    .hash
     Type:    SHT_HASH
     Content: ""
   - Name:    .gnu_hash
     Type:    SHT_GNU_HASH
     Content: ""
   - Name: .dynsym
     Type: SHT_DYNSYM
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .hash
       - Name: .gnu_hash
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .dynsym
 
 ## Case I: document the case when an excluded section is explicitly linked to another excluded section.
 ##         We report an error in this case, because:
 ##         1) It is a reasonable behavior, as it is perhaps usually a result of a mistake
 ##            in a YAML description.
 ##         2) Helps to keep the code simpler.
 # RUN: not yaml2obj %s --docnum=17 -o /dev/null 2>&1 | FileCheck %s --check-prefix=CROSS-LINK
 
 # CROSS-LINK:      error: unable to link '.foo' to excluded section '.bar'
 # CROSS-LINK-NEXT: error: unable to link '.bar' to excluded section '.foo'
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
     Link: .bar
   - Name: .bar
     Type: SHT_PROGBITS
     Link: .foo
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .foo
       - Name: .bar
 
 ## Check we set e_shstrndx field to 0 when the section header string table is excluded.
 ## Check that the e_shnum field is adjusted properly when a section is removed.
 # RUN: yaml2obj --docnum=18 %s -o %t9
 # RUN: llvm-readelf --file-headers %t9 | FileCheck %s --check-prefix=SHSTRTAB
 
 # SHSTRTAB: Number of section headers:         2
 # SHSTRTAB: Section header string table index: 0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .strtab
     Excluded:
       - Name: .shstrtab
 
 ## Check we do not allow using "Excluded" together with "NoHeaders".
 # RUN: not yaml2obj %s --docnum=19 -DNOHEADERS=true -o /dev/null 2>&1 | FileCheck %s --check-prefix=NOHEADERS
 # RUN: not yaml2obj %s --docnum=19 -DNOHEADERS=false -o /dev/null 2>&1 | FileCheck %s --check-prefix=NOHEADERS
-# NOHEADERS: NoHeaders can't be used together with Sections/Excluded
+# NOHEADERS: NoHeaders can't be used together with Offset/Sections/Excluded
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
-SectionHeaderTable:
+Sections:
+  - Type: SectionHeaderTable
     NoHeaders: [[NOHEADERS]]
     Excluded:  []

llvm/test/tools/yaml2obj/ELF/section-headers.yaml

- Name: .section (2)
     Size: 0x20
   - Type:    Fill
     Name:    .filler
     Size:    0x30
     Pattern: ""
   - Name: .section.foo
     Type: SHT_PROGBITS
     Size: 0x40
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: [[SEC1]]
       - Name: [[SEC2]]
       - Name: [[SEC3]]
       - Name: .strtab
       - Name: .shstrtab
 
 ## Show we are able to reorder sections.
 # RUN: yaml2obj %s -o %t2 -DSEC3=".section (1)" -DSEC2=".section (2)" -DSEC1=".section.foo"
 # RUN: llvm-readelf --section-headers %t2 | FileCheck %s --check-prefix=REORDERED
 
 # REORDERED:      Section Headers:
 # REORDERED-NEXT:   [Nr] Name         Type     Address          Off    Size   ES Flg Lk Inf Al
 # REORDERED-NEXT:   [ 0]              NULL     0000000000000000 000000 000000 00      0   0  0

 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections: []
 
 ## Test that we are able to use "NoHeaders" property to produce an empty section header table.
 # RUN: yaml2obj %s --docnum=3 -DNOHEADERS=true -o %t3.1
 # RUN: llvm-readelf --file-headers %t3.1 | FileCheck %s --check-prefix=NO-HEADERS-TRUE
 
 # NO-HEADERS-TRUE: Start of section headers:          0  (bytes into file)
 # NO-HEADERS-TRUE: Size of section headers:           64 (bytes)
 # NO-HEADERS-TRUE: Number of section headers:         0
 # NO-HEADERS-TRUE: Section header string table index: 0
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     NoHeaders: [[NOHEADERS]]
 
 ## Test that we are able to set NoHeaders to false. In this case the tool produces an output
 ## as if there were no `SectionHeaderTable` key at all.
 # RUN: yaml2obj %s --docnum=3 -DNOHEADERS=false -o %t3.2
 # RUN: llvm-readelf --file-headers --sections %t3.2 | FileCheck %s --check-prefix=NO-HEADERS-FALSE
 
 # NO-HEADERS-FALSE: Start of section headers:          96 (bytes into file)
 # NO-HEADERS-FALSE: Size of section headers:           64 (bytes)
 # NO-HEADERS-FALSE: Number of section headers:         4
 # NO-HEADERS-FALSE: Section header string table index: 3
 
 # NO-HEADERS-FALSE:      Section Headers:
 # NO-HEADERS-FALSE-NEXT:  [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
 # NO-HEADERS-FALSE-NEXT:  [ 0]           NULL     0000000000000000 000000 000000 00      0   0  0
 # NO-HEADERS-FALSE-NEXT:  [ 1] .foo      PROGBITS 0000000000000000 000040 000000 00      0   0  0
 # NO-HEADERS-FALSE-NEXT:  [ 2] .strtab   STRTAB   0000000000000000 000040 000001 00      0   0  1
 # NO-HEADERS-FALSE-NEXT:  [ 3] .shstrtab STRTAB   0000000000000000 000041 000018 00      0   0  1
 
 ## Check we do not allow using "Sections" together with "NoHeaders".
 # RUN: not yaml2obj %s --docnum=4 -DNOHEADERS=true -o /dev/null 2>&1 | FileCheck %s --check-prefix=SECTIONS-NO-HEADERS
 # RUN: not yaml2obj %s --docnum=4 -DNOHEADERS=false -o /dev/null 2>&1 | FileCheck %s --check-prefix=SECTIONS-NO-HEADERS
 
-# SECTIONS-NO-HEADERS: error: NoHeaders can't be used together with Sections/Excluded
+# SECTIONS-NO-HEADERS: error: NoHeaders can't be used together with Offset/Sections/Excluded
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:  []
     NoHeaders: [[NOHEADERS]]
 
 ## Check that we do not allow an empty SectionHeaderTable tag and suggest to use an explicit syntax instead.
-# RUN: not yaml2obj %s --docnum=5 -DVAL="" -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-VALUE
+# RUN: not yaml2obj %s --docnum=5 -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-VALUE
 
 # NO-VALUE: SectionHeaderTable can't be empty. Use 'NoHeaders' key to drop the section header table
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_REL
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
-SectionHeaderTable: [[VAL]]
-
-## An empty mapping is also not allowed for the SectionHeaderTable tag.
-# RUN: not yaml2obj %s --docnum=5 -DVAL="[]" -o /dev/null 2>&1 | FileCheck %s --check-prefix=NOT-A-MAPPING
-
-# NOT-A-MAPPING: error: not a mapping
+  - Type: SectionHeaderTable
 
 ## Test that we are still able to override e_shoff, e_shnum and e_shstrndx
 ## fields even when we do not produce section headers.
 # RUN: yaml2obj %s --docnum=6 -o %t4
 # RUN: not llvm-readelf --file-headers %t4 | FileCheck %s --check-prefix=NO-HEADERS-OVERRIDE
 
 # NO-HEADERS-OVERRIDE: Start of section headers:          2 (bytes into file)
 # NO-HEADERS-OVERRIDE: Number of section headers:         3
 # NO-HEADERS-OVERRIDE: Section header string table index: 4
 
 --- !ELF
 FileHeader:
   Class:     ELFCLASS64
   Data:      ELFDATA2LSB
   Type:      ET_REL
   EShOff:    0x2
   EShNum:    0x3
   EShStrNdx: 0x4
-SectionHeaderTable:
+Sections:
+  - Type:      SectionHeaderTable
     NoHeaders: true
 
 ## Check that section indices are updated properly in other places when we
 ## reorder sections in the section header table.
 # RUN: yaml2obj %s --docnum=7 -o %t5 -DSEC1=".foo" -DSEC2=".bar"
 # RUN: llvm-readelf --section-headers --symbols %t5 | FileCheck %s --check-prefix=INDICES-A
 # RUN: yaml2obj %s --docnum=7 -o %t6 -DSEC2=".foo" -DSEC1=".bar"
 # RUN: llvm-readelf --section-headers --symbols %t6 | FileCheck %s --check-prefix=INDICES-B
 
Sections:
   - Name: .bar
     Type: SHT_PROGBITS
   - Name: .another.1
     Link: .foo
     Type: SHT_PROGBITS
   - Name: .another.2
     Link: .bar
     Type: SHT_PROGBITS
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: [[SEC1]]
       - Name: [[SEC2]]
       - Name: .another.1
       - Name: .another.2
       - Name: .symtab
       - Name: .strtab
       - Name: .shstrtab
 Symbols:
   - Name:    foo
     Section: .foo
   - Name:    bar
     Section: .bar
 
 ## Check that when "NoHeaders" is set to "true" then we don't emit
 ## the .shstrtab section implicitly and don't write the data of the

 ## Nothing should be emitted after the following section.
 ## So we know that the expected file size is 0x100 + 0xFF == 0x1FF == 511.
   - Name:   .foo
     Type:   SHT_PROGBITS
 ## Unaligned size. Used to make sure that we don't try to align the file offset
 ## for writing the section header table.
     Size:   0xFF
     Offset: 0x100
-SectionHeaderTable:
+  - Type:      SectionHeaderTable
     NoHeaders: true
+
+## Check we do not allow using "Offset" together with "NoHeaders".
+# RUN: not yaml2obj %s --docnum=9 -DNOHEADERS=true -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-HEADERS-OFFSET
+# RUN: not yaml2obj %s --docnum=9 -DNOHEADERS=false -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-HEADERS-OFFSET
+
+# NO-HEADERS-OFFSET: error: NoHeaders can't be used together with Offset/Sections/Excluded
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+  - Type:      SectionHeaderTable
+    Offset:    0x1000
+    NoHeaders: [[NOHEADERS]]
+
+## Check we can place the section header table before other sections.
+
+# RUN: yaml2obj %s --docnum=10 -o %t10
+# RUN: llvm-readelf --file-headers --sections %t10 | FileCheck %s --check-prefix=PLACE-BEFORE
+
+# PLACE-BEFORE: Start of section headers:  64 (bytes into file)
+# PLACE-BEFORE: Size of section headers:   64 (bytes)
+# PLACE-BEFORE: Number of section headers: 4
+
+# PLACE-BEFORE: Section Headers:
+# PLACE-BEFORE:   [Nr] Name Type     Address          Off    Size
+## 0x140 == Start of section headers (64) + Size of section headers (64) * Number of section headers (4);
+# PLACE-BEFORE:   [ 1] .foo PROGBITS 0000000000000000 000140 000000
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Type:   SectionHeaderTable
+    Offset: [[OFFSET=<none>]]
+    Sections:
+      - Name: .foo
+      - Name: .strtab
+      - Name: .shstrtab
+  - Name: .foo
+    Type: SHT_PROGBITS
+
+## Check we can use the Offset key to place the section header table at a different location.
+
+# RUN: yaml2obj %s --docnum=10 -DOFFSET=0x1000 -o %t10.offset
+# RUN: llvm-readelf --file-headers --sections %t10.offset | \
+# RUN:   FileCheck %s --check-prefix=PLACE-BEFORE-OFFSET
+
+# PLACE-BEFORE-OFFSET: Start of section headers:          4096 (bytes into file)
+# PLACE-BEFORE-OFFSET: Size of section headers:           64 (bytes)
+# PLACE-BEFORE-OFFSET: Number of section headers:         4
+
+# PLACE-BEFORE-OFFSET: Section Headers:
+# PLACE-BEFORE-OFFSET:   [Nr] Name Type     Address          Off    Size
+## 0x1100 == Start of section headers (0x1000) + Size of section headers (64) * Number of section headers (4);
+# PLACE-BEFORE-OFFSET:   [ 1] .foo PROGBITS 0000000000000000 001100 000000
+
+## Check we can place the section header table somewhere to the middle of sections list.
+
+# RUN: yaml2obj %s --docnum=11 -o %t11
+# RUN: llvm-readelf --sections %t11 | FileCheck %s --check-prefix=PLACE-AT-MIDDLE
+
+# PLACE-AT-MIDDLE: There are 5 section headers, starting at offset 0x140:
+# PLACE-AT-MIDDLE:      [Nr] Name      Type     Address          Off    Size
+# PLACE-AT-MIDDLE:      [ 1] .foo      PROGBITS 0000000000000000 000040 000100
+## The section header table is placed here, at 0x40 + 0x100 == 0x140.
+## The size of the table is 5 * 64 == 320 == 0x140.
+## 0x140 + 0x140 == offset of the .bar section.
+# PLACE-AT-MIDDLE-NEXT: [ 2] .bar      PROGBITS 0000000000000000 000280 000200
+# PLACE-AT-MIDDLE-NEXT: [ 3] .strtab   STRTAB   0000000000000000 000480 000001
+# PLACE-AT-MIDDLE-NEXT: [ 4] .shstrtab STRTAB   0000000000000000 000481 00001d
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Size: 0x100
+  - Type: SectionHeaderTable
+    Sections:
+      - Name: .foo
+      - Name: .bar
+      - Name: .strtab
+      - Name: .shstrtab
+  - Name: .bar
+    Type: SHT_PROGBITS
+    Size: 0x200
+
+## Check we don`t allow having multiple SectionHeaderTable chunks.
+
+# RUN: not yaml2obj %s --docnum=12 -o /dev/null 2>&1 | FileCheck %s --check-prefix=MULTIPLE
+
+# MULTIPLE: error: multiple section header tables are not allowed
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Type:     SectionHeaderTable
+    Sections: []
+  - Type:     SectionHeaderTable
+    Sections: []
+
+## Check that we place implicit sections before the section header table
+## when it is placed at the end explicitly.
+
+# RUN: yaml2obj %s --docnum=13 -o %t13
+# RUN: llvm-readelf --sections %t13 | FileCheck %s --check-prefix=IMPLICIT
+
+# IMPLICIT:      There are 3 section headers, starting at offset 0x58:
+# IMPLICIT:      [Nr] Name      Type   Address          Off    Size
+# IMPLICIT:      [ 1] .strtab   STRTAB 0000000000000000 000040 000001
+# IMPLICIT-NEXT: [ 2] .shstrtab STRTAB 0000000000000000 000041 000013
+## The section header table is placed here, at 0x58.
+## alignTo(8, 0x41 + 0x13) == 0x58.
+
+--- !ELF
+FileHeader:
+  Class: ELFCLASS64
+  Data:  ELFDATA2LSB
+  Type:  ET_REL
+Sections:
+  - Type: SectionHeaderTable
+    Sections:
+      - Name: .strtab
+      - Name: .shstrtab

llvm/test/tools/yaml2obj/ELF/verdef-section.yaml

FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .gnu.version_d
     Type: SHT_GNU_verdef
   - Name: .dynstr
     Type: SHT_STRTAB
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .gnu.version_d
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .dynstr

llvm/test/tools/yaml2obj/ELF/verneed-section.yaml

FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .gnu.version_r
     Type: SHT_GNU_verneed
   - Name: .dynstr
     Type: SHT_STRTAB
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .gnu.version_r
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .dynstr

llvm/test/tools/yaml2obj/ELF/versym-section.yaml

FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB
   Type:  ET_DYN
 Sections:
   - Name: .gnu.version
     Type: SHT_GNU_versym
   - Name: .dynsym
     Type: SHT_DYNSYM
-SectionHeaderTable:
+  - Type: SectionHeaderTable
     Sections:
       - Name: .gnu.version
       - Name: .strtab
       - Name: .shstrtab
     Excluded:
       - Name: .dynsym

llvm/tools/obj2yaml/elf2yaml.cpp

template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   // sections header table doesn't match the file order.
   const bool SectionsSorted =
       llvm::is_sorted(Chunks, [&](const std::unique_ptr<ELFYAML::Chunk> &A,
                                   const std::unique_ptr<ELFYAML::Chunk> &B) {
         return cast<ELFYAML::Section>(A.get())->OriginalSecNdx <
                cast<ELFYAML::Section>(B.get())->OriginalSecNdx;
       });
   if (!SectionsSorted) {
-    Y->SectionHeaders.emplace();
-    Y->SectionHeaders->Sections.emplace();
+    std::unique_ptr<ELFYAML::SectionHeaderTable> SHT =
+        std::make_unique<ELFYAML::SectionHeaderTable>(/*IsImplicit=*/false);
+    SHT->Sections.emplace();
     for (ELFYAML::Section *S : OriginalOrder)
-      Y->SectionHeaders->Sections->push_back({S->Name});
+      SHT->Sections->push_back({S->Name});
+    Chunks.push_back(std::move(SHT));
   }
 
   llvm::erase_if(Chunks, [this, &Y](const std::unique_ptr<ELFYAML::Chunk> &C) {
+    if (isa<ELFYAML::SectionHeaderTable>(*C.get()))
+      return false;
+
     const ELFYAML::Section &S = cast<ELFYAML::Section>(*C.get());
     return !shouldPrintSection(S, Sections[S.OriginalSecNdx], Y->DWARF);
   });
 
   Y->Chunks = std::move(Chunks);
   return Y.release();
 }