[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?

522

it's -> its

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

1616

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

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

3

Perhaps "from the section header table."

5

sections header table -> section header table

6

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.

8

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

14–17

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

43

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.

78

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?

105

it's -> its

110

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

114–115

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

140

We probably want a SHT_DYNSYM version of this same case.

216

What's the purpose of the debug section case?

238

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

246

has the -> has a

272

Case E?

Similar issues below.

276

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

322–323

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

350–351

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<>.

522

Thanks!

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

14–17

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

78

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

114–115

Probably we can go with only one. Done.

140

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

216

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

238

I've added D.3

246

has an?

350–351

All done.

[jhenderson]

LGTM, with nits.

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

3

Nit: too many full stops

246

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;
 
+  StringSet<> 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;
+
+  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 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 its 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;
   }
 

 template <class ELFT>
 DenseMap<StringRef, size_t> ELFState<ELFT>::buildSectionHeaderReorderMap() {
   if (!Doc.SectionHeaders || Doc.SectionHeaders->Sections.empty())
     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).second)
+        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 header table.
+
+## Check we can use the "Excluded" key to omit a section from the section header table.
+## Check we do not include the name of the excluded section in the string table.
+# RUN: yaml2obj %s -DINCLUDED=.foo -DEXCLUDED=.bar --docnum=1 -o %t1
+# RUN: llvm-readelf --section-headers -p .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 -p .shstrtab %t2 | \
+# RUN:   FileCheck %s -DSEC=.bar --check-prefixes=INCLUDE-SEC,INCLUDE-BAR
+
+# INCLUDE-SEC:      [Nr] Name
+# INCLUDE-SEC:      [ 1] [[SEC]]
+# INCLUDE-SEC-NEXT: [ 2] .strtab
+# INCLUDE-SEC-NEXT: [ 3] .shstrtab
+
+# INCLUDE-SEC:      String dump of section '.shstrtab':
+# INCLUDE-FOO-NEXT: [     1] .foo
+# INCLUDE-BAR-NEXT: [     1] .bar
+# INCLUDE-SEC-NEXT: [     6] .shstrtab
+# INCLUDE-SEC-NEXT: [    10] .strtab
+# INCLUDE-SEC-NOT:  {{.}}
+
+--- !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 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
+
+## 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 are able to exclude all sections.
+# 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:
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+SectionHeaderTable:
+  Sections: []
+  Excluded:
+    - Name: .strtab
+
+## 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:   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
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Link: .bar
+  - Name: .bar
+    Type: SHT_PROGBITS
+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=5 -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:   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
+
+# 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
+
+# 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:   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:   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:   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:   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
+  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 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:   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:   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
+    Type: SHT_GROUP
+    Link: .symtab
+    Members: []
+  - Name: .symtab
+    Type: SHT_SYMTAB
+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=14 -o %t6
+# RUN: llvm-readelf %t6 --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
+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: .group
+    Type: SHT_GROUP
+    Members: []
+  - Name: .rela
+    Type: SHT_RELA
+    Relocations: []
+  - Name: .symtab
+    Type: SHT_SYMTAB
+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=15 -o %t7
+# RUN: llvm-readelf %t7 --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
+  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
+
+## 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
+
+# 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
+  Machine: EM_X86_64
+Sections:
+  - Name: .foo
+    Type: SHT_PROGBITS
+    Link: .bar
+  - Name: .bar
+    Type: SHT_PROGBITS
+    Link: .foo
+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=17 %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

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)