[yaml2obj] - Add a way to exclude specified sections from the section header.

[grimar]

Summary

This implements the new "Excluded" key that can be used
to exclude entries from section header:

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

[jhenderson]

Perhaps worth an additional test case for excluded sections linking to other excluded sections.

llvm/lib/ObjectYAML/ELFEmitter.cpp

131

I might have missed something, but what's the benefit of making this a SetVector rather than some form of unordered_map?

523

it's -> its

(it's == it is, its == belonging to it)

1618

"Sections" and "Excluded" are using different markers for their formatting.

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

2

Perhaps "from the section header table."

4

sections header table -> section header table

5

include ... to the -> include ... in the

I'd probably just delete the "sections" from "sections string table". I think it's fairly obvious what we're referring to here.

7

Use -p .shstrtab for a string dump of the string table here and below. I think that would be cleaner.

13–16

Can we get rid of the ES and onwards columns? I'm not sure they add much value (but could be persuaded otherwise).

42

the both -> both the

Perhaps also worth mentioning: "Also check that we report an error if a section is missing from the lists." or something like that.

77

section header -> section header table (?)

Assuming I've understood this correctly, why should this be an error? Perhaps a user wants to omit ALL section headers except the implicit null one?

104

it's -> its

109

Here and below: "has the Link" -> "has a Link"

113–114

Do we really need both cases? It seems unnecessary to me.

139

We probably want a SHT_DYNSYM version of this same case.

215

What's the purpose of the debug section case?

237

We probably want a case for an explicit .symtab reference when .symtab has been excluded.

245

has the -> has a

271

Case E?

Similar issues below.

275

We probably don't need the "YAML" part of this message.

321–322

Similar to above, we also probably want a test case for an explicit Link reference to an excluded section.

349–350

Similar to above, we also probably want a test case for an explicit Link references to an excluded section.

Could all these implicit cases linking to .symtab be folded together into one?

Here and below: "the latter one" -> "the latter" (feels more natural to me).

[grimar]

• Addressed review comments.

llvm/lib/ObjectYAML/ELFEmitter.cpp

131

You're right. I've experimented with different ways to implement this patch and at some point wanted to iterate over headers in an insertion order using this variable.
(I've tried to make it a member of SectionHeaderTable I think). There is no need to require it to be vector with the current code.

I can't use srd::unordered_set, because it wants a std::hash function for StringRef which we do not have I think:
"error C2280: 'std::hash<_Kty>::hash(const std::hash<_Kty> &)': attempting to reference a deleted function"

I've used StringSet<>.

523

Thanks!

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

13–16

I've removed all columns except the "Name" one.

77

Hmm. Yes, I've missed this case. Fixed.

113–114

Probably we can go with only one. Done.

139

Ok. Though the related code is in the initSymtabSectionHeader(), and it is shared for both cases.

215

To test the code I've changed in initDWARFSectionHeader().
It is the same (i.e. shared) for all .debug_* sections currently.

237

I've added D.3

245

has an?

349–350

All done.

[jhenderson]

LGTM, with nits.

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

3

Nit: too many full stops

245

Oops, yeah, thanks :)

328–329

linked with -> linked to

(it's a one-way relationship typically, so I think this phrasing expresses it better)

llvm/include/llvm/ObjectYAML/ELFYAML.h

 };
 
 struct SectionHeader {
   StringRef Name;
 };
 
 struct SectionHeaderTable {
   std::vector<SectionHeader> Sections;
+  Optional<std::vector<SectionHeader>> Excluded;
 };
 
 struct SectionName {
   StringRef Section;
 };
 
 struct Symbol {
   StringRef Name;

llvm/lib/ObjectYAML/ELFEmitter.cpp

template <class ELFT> class ELFState {
   /// The future ".dynstr" section.
   StringTableBuilder DotDynstr{StringTableBuilder::ELF};
 
   NameToIdxMap SN2I;
   NameToIdxMap SymN2I;
   NameToIdxMap DynSymN2I;
   ELFYAML::Object &Doc;
 
+  llvm::SetVector<StringRef> ExcludedSectionHeaders;
+
   uint64_t LocationCounter = 0;
   bool HasError = false;
   yaml::ErrorHandler ErrHandler;
   void reportError(const Twine &Msg);
 
   std::vector<Elf_Sym> toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
                                     const StringTableBuilder &Strtab);
   unsigned toSectionIndex(StringRef S, StringRef LocSec, StringRef LocSym = "");
template <class ELFT> class ELFState {
   void assignSectionAddress(Elf_Shdr &SHeader, ELFYAML::Section *YAMLSec);
 
   DenseMap<StringRef, size_t> buildSectionHeaderReorderMap();
 
   BumpPtrAllocator StringAlloc;
   uint64_t alignToOffset(ContiguousBlobAccumulator &CBA, uint64_t Align,
                          llvm::Optional<llvm::yaml::Hex64> Offset);
 
+  uint64_t getSectionNameOffset(StringRef Name);
+
 public:
   static bool writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
                        yaml::ErrorHandler EH);
 };
 } // end anonymous namespace
 
 template <class T> static size_t arrayDataSize(ArrayRef<T> A) {
   return A.size() * sizeof(T);
else if (!Doc.SectionHeaders)
     Header.e_shnum = Doc.getSections().size();
   else if (Doc.SectionHeaders->Sections.empty())
     Header.e_shnum = 0;
   else
     Header.e_shnum = Doc.SectionHeaders->Sections.size() + /*Null section*/ 1;
 
   if (Doc.Header.SHStrNdx)
     Header.e_shstrndx = *Doc.Header.SHStrNdx;
-  else if (!Doc.SectionHeaders || !Doc.SectionHeaders->Sections.empty())
+  else if ((!Doc.SectionHeaders || !Doc.SectionHeaders->Sections.empty()) &&
+           !ExcludedSectionHeaders.count(".shstrtab"))
     Header.e_shstrndx = SN2I.get(".shstrtab");
   else
     Header.e_shstrndx = 0;
 
   OS.write((const char *)&Header, sizeof(Header));
 }
 
 template <class ELFT>
for (const ELFYAML::SectionName &SecName : YamlPhdr.Sections) {
                   "' by program header");
     }
   }
 }
 
 template <class ELFT>
 unsigned ELFState<ELFT>::toSectionIndex(StringRef S, StringRef LocSec,
                                         StringRef LocSym) {
-  unsigned Index;
-  if (SN2I.lookup(S, Index) || to_integer(S, Index))
-    return Index;
-
   assert(LocSec.empty() || LocSym.empty());
+
+  unsigned Index;
+  if (!SN2I.lookup(S, Index) && !to_integer(S, Index)) {
     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)
+    return Index;
+
+  StringRef Name = LocSec.empty() ? LocSym : LocSec;
+  assert(!Doc.SectionHeaders->Sections.empty());
+  if (Index >= Doc.SectionHeaders->Sections.size()) {
+    if (LocSym.empty())
+      reportError("unable to link '" + LocSec + "' to excluded section '" + S +
+                  "'");
+    else
+      reportError("excluded section referenced: '" + S + "'  by YAML symbol '" +
+                  LocSym + "'");
+  }
+  return Index;
+}
+
 template <class ELFT>
 unsigned ELFState<ELFT>::toSymbolIndex(StringRef S, StringRef LocSec,
                                        bool IsDynamic) {
   const NameToIdxMap &SymMap = IsDynamic ? DynSymN2I : SymN2I;
   unsigned Index;
   // Here we try to look up S in the symbol table. If it is not there,
   // treat its value as a symbol index.
   if (!SymMap.lookup(S, Index) && !to_integer(S, Index)) {
if (SuffixPos == 0)
     return "";
 
   if (SuffixPos == StringRef::npos || S[SuffixPos - 1] != ' ')
     return S;
   return S.substr(0, SuffixPos - 1);
 }
 
 template <class ELFT>
+uint64_t ELFState<ELFT>::getSectionNameOffset(StringRef Name) {
+  // If a section is excluded from section headers, we do not save it's name in
+  // the string table.
+  if (ExcludedSectionHeaders.count(Name))
+    return 0;
+  return DotShStrtab.getOffset(Name);
+}
+
+template <class ELFT>
 void ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
                                         ContiguousBlobAccumulator &CBA) {
   // Ensure SHN_UNDEF entry is present. An all-zero section header is a
   // valid SHN_UNDEF entry since SHT_NULL == 0.
   SHeaders.resize(Doc.getSections().size());
 
   for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     if (ELFYAML::Fill *S = dyn_cast<ELFYAML::Fill>(D.get())) {
for (const std::unique_ptr<ELFYAML::Chunk> &D : Doc.Chunks) {
     if (initImplicitHeader(CBA, SHeader, Sec->Name,
                            Sec->IsImplicit ? nullptr : Sec))
       continue;
 
     assert(Sec && "It can't be null unless it is an implicit section. But all "
                   "implicit sections should already have been handled above.");
 
     SHeader.sh_name =
-        DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
+        getSectionNameOffset(ELFYAML::dropUniqueSuffix(Sec->Name));
     SHeader.sh_type = Sec->Type;
     if (Sec->Flags)
       SHeader.sh_flags = *Sec->Flags;
     SHeader.sh_addralign = Sec->AddressAlign;
 
     // Set the offset for all sections, except the SHN_UNDEF section with index
     // 0 when not explicitly requested.
     if (!IsFirstUndefSection || Sec->Offset)
if (HasSymbolsDescription) {
       if (RawSec->Size)
         reportError("cannot specify both `Size` and " + Property +
                     " for symbol table section '" + RawSec->Name + "'");
       return;
     }
   }
 
   zero(SHeader);
-  SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
+  SHeader.sh_name = getSectionNameOffset(IsStatic ? ".symtab" : ".dynsym");
 
   if (YAMLSec)
     SHeader.sh_type = YAMLSec->Type;
   else
     SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
 
   if (RawSec && !RawSec->Link.empty()) {
     // If the Link field is explicitly defined in the document,
     // we should use it.
     SHeader.sh_link = toSectionIndex(RawSec->Link, RawSec->Name);
   } else {
     // When we describe the .dynsym section in the document explicitly, it is
     // allowed to omit the "DynamicSymbols" tag. In this case .dynstr is not
     // added implicitly and we should be able to leave the Link zeroed if
     // .dynstr is not defined.
     unsigned Link = 0;
-    if (IsStatic)
+    if (IsStatic) {
+      if (!ExcludedSectionHeaders.count(".strtab"))
         Link = SN2I.get(".strtab");
-    else
+    } else {
+      if (!ExcludedSectionHeaders.count(".dynstr"))
         SN2I.lookup(".dynstr", Link);
+    }
     SHeader.sh_link = Link;
   }
 
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (!IsStatic)
     SHeader.sh_flags = ELF::SHF_ALLOC;
 

 }
 
 template <class ELFT>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
                                              ContiguousBlobAccumulator &CBA,
                                              ELFYAML::Section *YAMLSec) {
   zero(SHeader);
-  SHeader.sh_name = DotShStrtab.getOffset(Name);
+  SHeader.sh_name = getSectionNameOffset(Name);
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_STRTAB;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
 
   SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign, /*Offset=*/None);
   raw_ostream &OS = CBA.getOS();
uint64_t emitDWARF(typename ELFT::Shdr &SHeader, StringRef Name,
   return OS.tell() - BeginOffset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                             ContiguousBlobAccumulator &CBA,
                                             ELFYAML::Section *YAMLSec) {
   zero(SHeader);
-  SHeader.sh_name = DotShStrtab.getOffset(ELFYAML::dropUniqueSuffix(Name));
+  SHeader.sh_name = getSectionNameOffset(ELFYAML::dropUniqueSuffix(Name));
   SHeader.sh_type = YAMLSec ? YAMLSec->Type : ELF::SHT_PROGBITS;
   SHeader.sh_addralign = YAMLSec ? (uint64_t)YAMLSec->AddressAlign : 1;
   SHeader.sh_offset = alignToOffset(CBA, SHeader.sh_addralign,
                                     YAMLSec ? YAMLSec->Offset : None);
 
   ELFYAML::RawContentSection *RawSec =
       dyn_cast_or_null<ELFYAML::RawContentSection>(YAMLSec);
   if (Doc.DWARF && shouldEmitDWARF(*Doc.DWARF, Name)) {
void ELFState<ELFT>::initDWARFSectionHeader(Elf_Shdr &SHeader, StringRef Name,
   if (RawSec && RawSec->Info)
     SHeader.sh_info = *RawSec->Info;
 
   if (YAMLSec && YAMLSec->Flags)
     SHeader.sh_flags = *YAMLSec->Flags;
   else if (Name == ".debug_str")
     SHeader.sh_flags = ELF::SHF_MERGE | ELF::SHF_STRINGS;
 
-  unsigned Link = 0;
-  if (YAMLSec && !YAMLSec->Link.empty() && SN2I.lookup(YAMLSec->Link, Link))
-    SHeader.sh_link = Link;
+  if (YAMLSec && !YAMLSec->Link.empty())
+    SHeader.sh_link = toSectionIndex(YAMLSec->Link, Name);
 
   assignSectionAddress(SHeader, YAMLSec);
 }
 
 template <class ELFT> void ELFState<ELFT>::reportError(const Twine &Msg) {
   ErrHandler(Msg);
   HasError = true;
 }
if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   SHeader.sh_size = (IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel)) *
                     Section.Relocations.size();
 
   // For relocation section set link to .symtab by default.
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+      SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   if (!Section.RelocatableSec.empty())
     SHeader.sh_info = toSectionIndex(Section.RelocatableSec, Section.Name);
 
   raw_ostream &OS = CBA.getOS();
   for (const auto &Rel : Section.Relocations) {
     unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,

 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::Group &Section,
                                          ContiguousBlobAccumulator &CBA) {
   assert(Section.Type == llvm::ELF::SHT_GROUP &&
          "Section type is not SHT_GROUP");
 
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+      SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   SHeader.sh_entsize = 4;
   SHeader.sh_size = SHeader.sh_entsize * Section.Members.size();
 
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::CallGraphProfileSection &Section,
     ContiguousBlobAccumulator &CBA) {
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = 16;
 
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+      SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
void ELFState<ELFT>::writeSectionContent(
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::HashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
+      SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
   raw_ostream &OS = CBA.getOS();
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
if (Section.Content)
     Section.Content->writeAsBinary(OS);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".symtab", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
+      SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
   raw_ostream &OS = CBA.getOS();
   if (Section.Content || Section.Size) {
     SHeader.sh_size = writeContent(OS, Section.Content, Section.Size);
     return;
   }
 
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   SHeader.sh_size = OS.tell() - Offset;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
-  if (Section.Link.empty() && SN2I.lookup(".dynsym", Link))
+  if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
+      SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
   raw_ostream &OS = CBA.getOS();
   if (Section.Content) {
     SHeader.sh_size = writeContent(OS, Section.Content, None);
     return;
   }
 
void ELFState<ELFT>::writeFill(ELFYAML::Fill &Fill,
   uint64_t Written = 0;
   for (; Written + PatternSize <= Fill.Size; Written += PatternSize)
     Fill.Pattern->writeAsBinary(OS);
   Fill.Pattern->writeAsBinary(OS, 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->Sections.empty()) {
+    if (Doc.SectionHeaders && Doc.SectionHeaders->Excluded)
+      reportError("'Excluded' can't be used with an empty `Sections` list");
     return DenseMap<StringRef, size_t>();
+  }
 
   DenseMap<StringRef, size_t> Ret;
   size_t SecNdx = 0;
   StringSet<> Seen;
-  for (const ELFYAML::SectionHeader &Hdr : Doc.SectionHeaders->Sections) {
+
+  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)
+    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())
       continue;
     if (!Seen.count(S->Name))
       reportError("section '" + S->Name +
-                  "' should be present in the 'Sections' list");
+                  "' should be present in the 'Sections' or `Excluded` lists");
     Seen.erase(S->Name);
   }
 
   for (const auto &It : Seen)
     reportError("section header contains undefined section '" + It.getKey() +
                 "'");
   return Ret;
 }
 
+static bool hasSectionHeader(const ELFYAML::Object &Doc, size_t SecNdx) {
+  if (!Doc.SectionHeaders)
+    return true;
+  return SecNdx < Doc.SectionHeaders->Sections.size();
+}
+
 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.
+  // 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)
+    for (const ELFYAML::SectionHeader &Hdr : *Doc.SectionHeaders->Excluded)
+      if (!ExcludedSectionHeaders.insert(Hdr.Name))
+        llvm_unreachable("buildSectionIndex() failed");
+
   size_t SecNdx = -1;
-  for (const std::unique_ptr<ELFYAML::Chunk> &C : Doc.Chunks) {
-    if (!isa<ELFYAML::Section>(C.get()))
-      continue;
+  for (const ELFYAML::Section *S : Doc.getSections()) {
     ++SecNdx;
 
-    size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(C->Name);
-    if (!SN2I.addName(C->Name, Index))
+    size_t Index = ReorderMap.empty() ? SecNdx : ReorderMap.lookup(S->Name);
+    if (!SN2I.addName(S->Name, Index))
       llvm_unreachable("buildSectionIndex() failed");
-    DotShStrtab.add(ELFYAML::dropUniqueSuffix(C->Name));
+
+    if (!ExcludedSectionHeaders.count(S->Name))
+      DotShStrtab.add(ELFYAML::dropUniqueSuffix(S->Name));
   }
 
   DotShStrtab.finalize();
 }
 
 template <class ELFT> void ELFState<ELFT>::buildSymbolIndexes() {
   auto Build = [this](ArrayRef<ELFYAML::Symbol> V, NameToIdxMap &Map) {
     for (size_t I = 0, S = V.size(); I < S; ++I) {
bool ELFState<ELFT>::writeELF(raw_ostream &OS, ELFYAML::Object &Doc,
   // Finalize .strtab and .dynstr sections. We do that early because want to
   // finalize the string table builders before writing the content of the
   // sections that might want to use them.
   State.finalizeStrings();
 
   State.buildSectionIndex();
   State.buildSymbolIndexes();
 
+  if (State.HasError)
+    return false;
+
   std::vector<Elf_Phdr> PHeaders;
   State.initProgramHeaders(PHeaders);
 
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
   const size_t SectionContentBeginOffset =
       sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * Doc.ProgramHeaders.size();
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset);

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("Excluded", SectionHeader.Excluded);
 }
 
 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

+## Check how we can use the "Excluded" key of the "SectionHeaderTable" tag to exclude
+## entries from the section headers.
+
+## Check we can use the "Excluded" key to omit a section from the sections header table.
+## Check we do not include the name of the excluded section to the sections string table.
+# RUN: yaml2obj %s -DINCLUDED=.foo -DEXCLUDED=.bar --docnum=1 -o %t1
+# RUN: llvm-readelf --section-headers -x .shstrtab %t1 | \
+# RUN:   FileCheck %s -DSEC=.foo --check-prefixes=INCLUDE-SEC,INCLUDE-FOO
+# RUN: yaml2obj %s -DINCLUDED=.bar -DEXCLUDED=.foo --docnum=1 -o %t2
+# RUN: llvm-readelf --section-headers -x .shstrtab %t2 | \
+# RUN:   FileCheck %s -DSEC=.bar --check-prefixes=INCLUDE-SEC,INCLUDE-BAR
+
+# INCLUDE-SEC:      [Nr] Name      Type     Address          Off    Size   ES Flg Lk Inf Al
+# INCLUDE-SEC:      [ 1] [[SEC]]   PROGBITS 0000000000000000 000040 000000 00 0   0  0
+# INCLUDE-SEC-NEXT: [ 2] .strtab   STRTAB   0000000000000000 000040 000001 00 0   0  1
+# INCLUDE-SEC-NEXT: [ 3] .shstrtab STRTAB   0000000000000000 000041 000018 00 0   0  1
+
+# INCLUDE-SEC:      Hex dump of section '.shstrtab':
+# INCLUDE-FOO-NEXT: 0x00000000 002e666f 6f002e73 68737472 74616200 ..foo..shstrtab.
+# INCLUDE-BAR-NEXT: 0x00000000 002e6261 72002e73 68737472 74616200 ..bar..shstrtab.
+# INCLUDE-SEC-NEXT: 0x00000010 2e737472 74616200                   .strtab.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+  - Name: .bar
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections:
+    - Name: [[INCLUDED]]
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: [[EXCLUDED]]
+
+## Check we report an error when a section is in the both "Sections" and "Excluded" lists at the same time.
+# 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
+
+## Check we report an error when the `Excluded` key mentions an unknown section.
+# RUN: not yaml2obj %s -DINCLUDED=.bar -DEXCLUDED=.unknown --docnum=1 -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=EXCLUDE-UNKNOWN
+
+# EXCLUDE-UNKNOWN: error: section '.foo' should be present in the 'Sections' or `Excluded` lists
+# EXCLUDE-UNKNOWN: error: section header contains undefined section '.unknown'
+
+## Check we report an error when the `Excluded` key mentions a section more than once.
+# RUN: not yaml2obj %s --docnum=2 -o /dev/null 2>&1 | FileCheck %s --check-prefix=EXCLUDE-TWICE
+
+# 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
+  Machine: EM_X86_64
+SectionHeaderTable:
+  Sections:
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .strtab
+    - Name: .strtab
+
+## Check we report an error when the `Excluded` key is used, but an empty
+## section header is requested.
+# RUN: not yaml2obj %s --docnum=3 -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-SECTIONS
+# RUN: not yaml2obj %s --docnum=4 -o /dev/null 2>&1 | FileCheck %s --check-prefix=NO-SECTIONS
+
+# NO-SECTIONS: error: 'Excluded' can't be used with an empty `Sections` list
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+SectionHeaderTable:
+  Sections: []
+  Excluded:
+    - Name: .strtab
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+SectionHeaderTable:
+  Sections: []
+  Excluded: []
+
+## Check how we handle cases when a section is excluded, but it's 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 the Link field which
+##         points to an excluded section.
+# RUN: not yaml2obj %s --docnum=5 -DINCLUDED=.foo -DEXCLUDED=.bar -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=LINK -DSEC=.foo -DTARGET=.bar
+# RUN: not yaml2obj %s --docnum=5 -DINCLUDED=.bar -DEXCLUDED=.foo -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=LINK -DSEC=.bar -DTARGET=.foo
+
+# LINK: error: unable to link '[[SEC]]' to excluded section '[[TARGET]]'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Link: .bar
+  - Name: .bar
+    Type: SHT_PROGBITS
+    Link: .foo
+SectionHeaderTable:
+  Sections:
+    - Name: [[INCLUDED]]
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: [[EXCLUDED]]
+
+## Case B.1: check we report an error when a symbol table section has the Link field which
+##           points to an excluded section.
+# RUN: not yaml2obj %s --docnum=6 -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=LINK -DSEC=.symtab -DTARGET=.foo
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:  .symtab
+    Type:  SHT_SYMTAB
+    Link:  .foo
+  - Name:  .foo
+    Type:  SHT_PROGBITS
+SectionHeaderTable:
+  Sections:
+    - Name: .symtab
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .foo
+
+## Case B.2: check we do not link .dynsym with .dynstr implicitly when the latter one is excluded.
+# RUN: yaml2obj %s --docnum=7 -o %t7
+# RUN: llvm-readelf %t7 --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 one is excluded.
+# RUN: yaml2obj %s --docnum=8 -o %t8
+# RUN: llvm-readelf %t8 --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 the 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
+  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 do not link the SHT_REL[A] section with .symtab implicitly
+##           when the latter one is excluded.
+# RUN: yaml2obj %s --docnum=10 -o %t10 -DINCLUDED=.strtab -DEXCLUDED=.symtab
+# RUN: llvm-readelf %t10 --section-headers | FileCheck %s --check-prefix=LINK-REL
+
+# LINK-REL: [Nr] Name  Type Address          Off    Size   ES Flg Lk Inf Al
+# LINK-REL: [ 1] .rela RELA 0000000000000000 000040 000000 18      0   2  0
+
+## Case D.2: check we report an error when a relocatable section has the Info field which
+##           points to an excluded section.
+# RUN: not yaml2obj %s --docnum=10 -DINCLUDED=.symtab -DEXCLUDED=.strtab -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: []
+  - Name: .symtab
+    Type: SHT_PROGBITS
+SectionHeaderTable:
+  Sections:
+    - Name: .rela
+    - Name: [[INCLUDED]]
+    - Name: .shstrtab
+  Excluded:
+    - Name: [[EXCLUDED]]
+
+## Case C: check we report an error when a symbol references an excluded section.
+# RUN: not yaml2obj %s --docnum=11 -o /dev/null 2>&1 | \
+# RUN:   FileCheck %s --check-prefix=SYMBOL-SECTION
+
+# SYMBOL-SECTION: error: excluded section referenced: '.foo' by YAML symbol 'foo'
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+Symbols:
+  - Name:    foo
+    Type:    STT_OBJECT
+    Section: .foo
+SectionHeaderTable:
+  Sections:
+    - Name: .symtab
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .foo
+
+## Case D.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:   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 D.2: check we do not link the SHT_GROUP section with .symtab
+##           implicitly when the latter one is excluded.
+# RUN: yaml2obj %s --docnum=13 -o %t9
+# RUN: llvm-readelf %t9 --section-headers | FileCheck %s --check-prefix=LINK-GROUP
+
+# LINK-GROUP: [Nr] Name   Type  Address          Off    Size   ES Flg Lk Inf Al
+# LINK-GROUP: [ 1] .group GROUP 0000000000000000 000040 000000 04      0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name: .group
+    Type: SHT_GROUP
+    Members: []
+  - Name: .symtab
+    Type: SHT_SYMTAB
+SectionHeaderTable:
+  Sections:
+    - Name: .group
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .symtab
+
+## Case E: check we do not link SHT_LLVM_CALL_GRAPH_PROFILE/SHT_LLVM_ADDRSIG sections
+##         with .symtab implicitly when the latter one is excluded.
+# RUN: yaml2obj %s --docnum=14 -o %t10
+# RUN: llvm-readelf %t10 --section-headers | FileCheck %s --check-prefix=LINK-CGP
+
+# LINK-CGP: [Nr] Name          Type                    Address          Off    Size   ES Flg Lk Inf Al
+# LINK-CGP: [ 1] .cgp          LLVM_CALL_GRAPH_PROFILE 0000000000000000 000040 000000 10      0   0  0
+# LINK-CGP: [ 2] .llvm_addrsig LLVM_ADDRSIG            0000000000000000 000040 000000 00      0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .cgp
+    Type:    SHT_LLVM_CALL_GRAPH_PROFILE
+    Content: ""
+  - Name:    .llvm_addrsig
+    Type:    SHT_LLVM_ADDRSIG
+    Content: ""
+  - Name: .symtab
+    Type: SHT_SYMTAB
+SectionHeaderTable:
+  Sections:
+    - Name: .cgp
+    - Name: .llvm_addrsig
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .symtab
+
+## Case F: check we do not link SHT_HASH/SHT_GNU_HASH sections with .dynsym
+##         implicitly when the latter one is excluded.
+# RUN: yaml2obj %s --docnum=15 -o %t11
+# RUN: llvm-readelf %t11 --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: [ 2] .gnu_hash GNU_HASH 0000000000000000 000040 000000 00      0   0  0
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .hash
+    Type:    SHT_HASH
+    Content: ""
+  - Name:    .gnu_hash
+    Type:    SHT_GNU_HASH
+    Content: ""
+  - Name: .dynsym
+    Type: SHT_DYNSYM
+SectionHeaderTable:
+  Sections:
+    - Name: .hash
+    - Name: .gnu_hash
+    - Name: .strtab
+    - Name: .shstrtab
+  Excluded:
+    - Name: .dynsym
+
+## 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=16 %s -o %t12
+# RUN: llvm-readelf --file-headers %t12 | 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

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

 # RUN: not yaml2obj %s -o /dev/null -DSEC1=".section.foo" -DSEC2="unknown" -DSEC3=".section.foo" 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ERR1
 #   d) contains a repeated implicit section name.
 #   e) contains a fill name.
 # RUN: not yaml2obj %s -o /dev/null -DSEC1=".strtab" -DSEC2=".shstrtab" -DSEC3=".filler" 2>&1 | \
 # RUN:   FileCheck %s --check-prefix=ERR2
 
 # ERR1:      error: repeated section name: '.section.foo' in the section header description
-# ERR1-NEXT: error: section '.section (1)' should be present in the 'Sections' list
-# ERR1-NEXT: error: section '.section (2)' should be present in the 'Sections' list
+# ERR1-NEXT: error: section '.section (1)' should be present in the 'Sections' or `Excluded` lists
+# ERR1-NEXT: error: section '.section (2)' should be present in the 'Sections' or `Excluded` lists
 # ERR1-NEXT: error: section header contains undefined section 'unknown'
 
 # 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' list
-# ERR2-NEXT: error: section '.section (2)' should be present in the 'Sections' list
-# ERR2-NEXT: error: section '.section.foo' should be present in the 'Sections' list
+# 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
 # RUN: llvm-readelf --file-headers %t3 | FileCheck %s --check-prefix=NO-HEADERS
 
 # NO-HEADERS: Start of section headers:          0  (bytes into file)