[yaml2obj] - Introduce the "NoHeaders" key for "SectionHeaderTable"

[grimar]

Summary

We have an issue currently. The following YAML piece just ignores the Excluded key.

SectionHeaderTable:
  Sections: []
  Excluded:
    - Name: .foo

Currently the meaning is: exclude the whole table.

The code checks that the Sections key is empty and doesn't catch/check
invalid/duplicated/missed Excluded entries.

Also there is no way to exclude all sections except the first null section,
because Sections: [] currently just excludes the whole the sections header table.

To fix it, I suggest a change of the behavior.

1. A new NoHeaders key is added. It provides an explicit syntax to drop the whole table.
2. The meaning of the following is changed:

SectionHeaderTable:
  Sections: []
  Excluded:
    - Name: .foo

Assuming there are 2 sections in the object (a null section and .foo), with this patch it
means: exclude the .foo section, keep the null section. The null section is an implicit
section and I think it is reasonable to make "Sections: []" to mean it is implicitly added.
It will be consistent with the global "Sections" tag that is used to describe sections.

3. SectionHeaderTable->Sections is now optional. No Sections is the same as Sections: [] (I think it avoids a confusion).
4. Using of NoHeaders together with Sections/Excluded is not allowed.
5. It is possible to use the Excluded key without the Sections key now (in this case Excluded must contain all sections).
6. SectionHeaderTable: or SectionHeaderTable: [] is not allowed.
7. When the SectionHeaderTable key is present, we still require all sections to be present in Sections and Excluded lists. No changes here, we are still strict.

[grimar]

Currently the test\ObjectYAML\MachO\DWARF-pubsections.yaml
fails with it (--docnum=2)

II happens because of the bug in ObjectYAML\MachOEmitter.cpp

It does:

IO.mapOptional("debug_pubnames", DWARF.PubNames);
IO.mapOptional("debug_pubtypes", DWARF.PubTypes);

where

Optional<PubSection> PubNames;
Optional<PubSection> PubTypes;

And since this patch fixes an issue mentioned in the description
(in YAMLTraits.cpp), the following code does not work anymore:

if (Obj.DWARF.PubNames)
  Err = DWARFYAML::emitPubSection(OS, *Obj.DWARF.PubNames, Obj.IsLittleEndian);

because Obj.DWARF.PubNames was never Optional::None previously, but now it is.
Seems previously it always wrote a piece of broken data.

I am going to investigate if I can fix it separatelly from this patch.

[grimar]

• Rebased. Now all tests pass.

[jhenderson]

Some mostly comment nits, otherwise LGTM.

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

80

section with -> section, with

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

82–102

an empty section header table.

86–87

Can these be -NEXT?

101

section header -> an empty section header table

to match above comment.

llvm/include/llvm/ObjectYAML/ELFYAML.h

struct FileHeader {
   Optional<llvm::yaml::Hex16> SHStrNdx;
 };
 
 struct SectionHeader {
   StringRef Name;
 };
 
 struct SectionHeaderTable {
-  std::vector<SectionHeader> Sections;
+  Optional<std::vector<SectionHeader>> Sections;
   Optional<std::vector<SectionHeader>> Excluded;
+  bool NoHeaders;
 };
 
 struct SectionName {
   StringRef Section;
 };
 
 struct Symbol {
   StringRef Name;

 
 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 StringRef 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);

llvm/lib/ObjectYAML/ELFEmitter.cpp

void ELFState<ELFT>::writeELFHeader(raw_ostream &OS, uint64_t SHOff) {
   Header.e_flags = Doc.Header.Flags;
   Header.e_ehsize = sizeof(Elf_Ehdr);
   Header.e_phentsize = Doc.ProgramHeaders.size() ? sizeof(Elf_Phdr) : 0;
   Header.e_phnum = Doc.ProgramHeaders.size();
 
   Header.e_shentsize =
       Doc.Header.SHEntSize ? (uint16_t)*Doc.Header.SHEntSize : sizeof(Elf_Shdr);
 
+  const bool NoShdrs = Doc.SectionHeaders && Doc.SectionHeaders->NoHeaders;
+
   if (Doc.Header.SHOff)
     Header.e_shoff = *Doc.Header.SHOff;
-  else if (Doc.SectionHeaders && Doc.SectionHeaders->Sections.empty())
+  else if (NoShdrs)
     Header.e_shoff = 0;
   else
     Header.e_shoff = SHOff;
 
   if (Doc.Header.SHNum)
     Header.e_shnum = *Doc.Header.SHNum;
   else if (!Doc.SectionHeaders)
     Header.e_shnum = Doc.getSections().size();
-  else if (Doc.SectionHeaders->Sections.empty())
+  else if (NoShdrs)
     Header.e_shnum = 0;
   else
-    Header.e_shnum = Doc.SectionHeaders->Sections.size() + /*Null section*/ 1;
+    Header.e_shnum =
+        (Doc.SectionHeaders->Sections ? Doc.SectionHeaders->Sections->size()
+                                      : 0) +
+        /*Null section*/ 1;
 
   if (Doc.Header.SHStrNdx)
     Header.e_shstrndx = *Doc.Header.SHStrNdx;
-  else if ((!Doc.SectionHeaders || !Doc.SectionHeaders->Sections.empty()) &&
-           !ExcludedSectionHeaders.count(".shstrtab"))
-    Header.e_shstrndx = SN2I.get(".shstrtab");
-  else
+  else if (NoShdrs || ExcludedSectionHeaders.count(".shstrtab"))
     Header.e_shstrndx = 0;
+  else
+    Header.e_shstrndx = SN2I.get(".shstrtab");
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initProgramHeaders(std::vector<Elf_Phdr> &PHeaders) {
   DenseMap<StringRef, ELFYAML::Fill *> NameToFill;
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks)
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->Excluded)
+  if (!Doc.SectionHeaders ||
+      (!Doc.SectionHeaders->NoHeaders && !Doc.SectionHeaders->Excluded))
     return Index;
 
-  assert(!Doc.SectionHeaders->Sections.empty());
-  if (Index >= Doc.SectionHeaders->Sections.size()) {
+  assert(!Doc.SectionHeaders->NoHeaders || !Doc.SectionHeaders->Sections);
+  size_t FirstExcluded =
+      Doc.SectionHeaders->Sections ? Doc.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 + "'");
   }
   return Index;
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->Sections.empty())
+  if (!Doc.SectionHeaders || Doc.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);
   };
 
-  for (const ELFYAML::SectionHeader &Hdr : Doc.SectionHeaders->Sections)
+  if (Doc.SectionHeaders->Sections)
+    for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Sections)
       AddSection(Hdr);
 
   if (Doc.SectionHeaders->Excluded)
     for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Excluded)
       AddSection(Hdr);
 
   for (const ELFYAML::Section *S : Doc.getSections()) {
     // Ignore special first SHT_NULL section.
     if (S == Doc.getSections().front())
template <class ELFT> void ELFState<ELFT>::buildSectionIndex() {
   // A YAML description can have an explicit section header declaration that
   // allows to change the order of section headers.
   DenseMap<StringRef, size_t> ReorderMap = buildSectionHeaderReorderMap();
 
   if (HasError)
     return;
 
   // Build excluded section headers map.
-  if (Doc.SectionHeaders && Doc.SectionHeaders->Excluded)
+  std::vector<ELFYAML::Section *> Sections = Doc.getSections();
+  if (Doc.SectionHeaders) {
+    if (Doc.SectionHeaders->Excluded)
       for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Excluded)
         if (!ExcludedSectionHeaders.insert(Hdr.Name).second)
           llvm_unreachable("buildSectionIndex() failed");
 
+    if (Doc.SectionHeaders->NoHeaders)
+      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 : Doc.getSections()) {
+  for (const ELFYAML::Section *S : Sections) {
     ++SecNdx;
 
     size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(S->Name);
     if (!SN2I.addName(S->Name, Index))
       llvm_unreachable("buildSectionIndex() failed");
 
     if (!ExcludedSectionHeaders.count(S->Name))
       DotShStrtab.add(ELFYAML::dropUniqueSuffix(S->Name));

llvm/lib/ObjectYAML/ELFYAML.cpp

 
 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.mapRequired("Sections", SectionHeader.Sections);
+  IO.mapOptional("Sections", SectionHeader.Sections);
   IO.mapOptional("Excluded", SectionHeader.Excluded);
+  IO.mapOptional("NoHeaders", SectionHeader.NoHeaders, false);
+}
+
+StringRef 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 StringRef();
 }
 
 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));

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

 SectionHeaderTable:
   Sections:
     - Name: .strtab
     - Name: .shstrtab
   Excluded:
     - Name: .strtab
     - Name: .strtab
 
-## Check we are able to exclude all sections.
+## 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 0 section headers, starting at offset 0x0:
+# 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
   Machine: EM_X86_64
 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
+  Machine: EM_X86_64
+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=4 -o /dev/null 2>&1 | \
+# 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
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=5 -DNAME=.symtab -DTYPE=SHT_SYMTAB -o /dev/null 2>&1 | \
+# 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=5 -DNAME=.dynsym -DTYPE=SHT_DYNSYM -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
 Sections:
   - Name:  [[NAME]]
     Type:  [[TYPE]]
     Link:  .foo
   - Name:  .foo
     Type:  SHT_PROGBITS
 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=6 -o %t4
-# RUN: llvm-readelf %t4 --section-headers | FileCheck %s --check-prefix=LINK-DYNSYM
+# 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
   Machine: EM_X86_64
 Sections:
   - Name:  .dynsym
     Type:  SHT_DYNSYM
   - Name:  .dynstr
     Type:  SHT_PROGBITS
 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=7 -o %t5
-# RUN: llvm-readelf %t5 --section-headers | FileCheck %s --check-prefix=LINK-SYMTAB
+# 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
   Machine: EM_X86_64
 Sections:
   - Name:  .symtab
     Type:  SHT_SYMTAB
   - Name:  .strtab
     Type:  SHT_PROGBITS
 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=8 -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
 Sections:
   - Name:  .debug_unknown
     Type:  SHT_PROGBITS
     Link:  .strtab
 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=9 -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
 Sections:
   - Name: .rela
     Type: SHT_RELA
     Info: .strtab
     Relocations: []
 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=10 -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
 Sections:
   - Name: .rela
     Type: SHT_RELA
     Link: .symtab
     Relocations: []
   - Name: .symtab
     Type: SHT_PROGBITS
 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=11 -o /dev/null 2>&1 | \
+# 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
Sections:
     - Name: .symtab
     - Name: .strtab
     - Name: .shstrtab
   Excluded:
     - Name: .foo
 
 ## Case F.1: check we report an error when a group section
 ##           contains an excluded section member.
-# RUN: not yaml2obj %s --docnum=12 -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
 Sections:
   - Name: .group
     Type: SHT_GROUP
     Members:
       - SectionOrType: .strtab
 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=13 -o /dev/null 2>&1 | \
+# 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
   Machine: EM_X86_64
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=14 -o %t6
-# RUN: llvm-readelf %t6 --section-headers | FileCheck %s --check-prefix=LINK-IMPLICIT
+# 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
 # LINK-IMPLICIT-NEXT: [ 2] .llvm_addrsig LLVM_ADDRSIG            0000000000000000 000040 000000 00      0   0  0
 # LINK-IMPLICIT-NEXT: [ 3] .group        GROUP                   0000000000000000 000040 000000 04      0   0  0
 # LINK-IMPLICIT-NEXT: [ 4] .rela         RELA                    0000000000000000 000040 000000 18      0   0  0
 
 --- !ELF
Sections:
     - 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=15 -o %t7
-# RUN: llvm-readelf %t7 --section-headers | FileCheck %s --check-prefix=LINK-HASH
+# 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 00      0   0  0
 # LINK-HASH-NEXT: [ 2] .gnu_hash GNU_HASH 0000000000000000 000040 000000 00      0   0  0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
SectionHeaderTable:
   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=16 -o /dev/null 2>&1 | FileCheck %s --check-prefix=CROSS-LINK
+# 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
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=17 %s -o %t9
+# 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
   Machine: EM_X86_64
 SectionHeaderTable:
   Sections:
     - Name: .strtab
   Excluded:
     - Name: .shstrtab
+
+## Check we do not allow using "Excluded" together with "NoHeaders".
+# RUN: not yaml2obj %s --docnum=19 -o /dev/null 2>&1 | FileCheck %s --check-prefix=NOHEADERS
+# NOHEADERS: NoHeaders can't be used together with Sections/Excluded
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+SectionHeaderTable:
+  NoHeaders: true
+  Excluded:  []

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

 
 # ERR2:      error: repeated section name: '.strtab' in the section header description
 # ERR2-NEXT: error: repeated section name: '.shstrtab' in the section header description
 # ERR2-NEXT: error: section '.section (1)' should be present in the 'Sections' or 'Excluded' lists
 # ERR2-NEXT: error: section '.section (2)' should be present in the 'Sections' or 'Excluded' lists
 # ERR2-NEXT: error: section '.section.foo' should be present in the 'Sections' or 'Excluded' lists
 # ERR2-NEXT: error: section header contains undefined section '.filler'
 
-## Test that we are able to specify an empty sections list for
-## the "SectionHeaderTable" tag to produce no section header.
-# RUN: yaml2obj %s --docnum=2 -o %t3
+## Check that when the an empty "Sections" list is used, we do not create an empty section header table.
+# RUN: not yaml2obj %s --docnum=2 -o /dev/null 2>&1 | FileCheck %s --check-prefix=EMPTY-SECTIONS
+
+# EMPTY-SECTIONS:      error: section '.foo' should be present in the 'Sections' or 'Excluded' lists
+# EMPTY-SECTIONS-NEXT: error: section '.strtab' should be present in the 'Sections' or 'Excluded' lists
+# EMPTY-SECTIONS-NEXT: error: section '.shstrtab' should be present in the 'Sections' or 'Excluded' lists
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections: []
+
+## Test that we are able to use "NoHeaders" property to produce an empty section header table.
+# RUN: yaml2obj %s --docnum=3 -o %t3
 # RUN: llvm-readelf --file-headers %t3 | FileCheck %s --check-prefix=NO-HEADERS
 
 # NO-HEADERS: Start of section headers:          0  (bytes into file)
 # NO-HEADERS: Size of section headers:           64 (bytes)
 # NO-HEADERS: Number of section headers:         0
 # NO-HEADERS: Section header string table index: 0
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 SectionHeaderTable:
-  Sections: []
+  NoHeaders: true
+
+## Check we do not allow using "Sections" together with "NoHeaders".
+# RUN: not yaml2obj %s --docnum=4 -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
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections:  []
+  NoHeaders: true
+
+## 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
+
+# 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
+  Machine: EM_X86_64
+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
 
 ## 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=3 -o %t4
+# RUN: yaml2obj %s --docnum=6 -o %t4
 # RUN: 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
   Machine:   EM_X86_64
   SHOff:     0x2
   SHNum:     0x3
   SHStrNdx:  0x4
 Sections:
   - Name: .foo
     Type: SHT_PROGBITS
 SectionHeaderTable:
-  Sections: []
+  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=4 -o %t5 -DSEC1=".foo" -DSEC2=".bar"
+# 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=4 -o %t6 -DSEC2=".foo" -DSEC1=".bar"
+# RUN: yaml2obj %s --docnum=7 -o %t6 -DSEC2=".foo" -DSEC1=".bar"
 # RUN: llvm-readelf --section-headers --symbols %t6 | FileCheck %s --check-prefix=INDICES-B
 
 # INDICES-A:      [Nr] Name       Type     Address          Off    Size   ES Flg Lk
 # INDICES-A:      [ 1] .foo       PROGBITS 0000000000000000 000040 000000 00      0
 # INDICES-A-NEXT: [ 2] .bar       PROGBITS 0000000000000000 000040 000000 00      0
 # INDICES-A-NEXT: [ 3] .another.1 PROGBITS 0000000000000000 000040 000000 00      1
 # INDICES-A-NEXT: [ 4] .another.2 PROGBITS 0000000000000000 000040 000000 00      2