[lib/ObjectYAML] - Simplify the code that handles Content/Size fields.

[grimar]

Summary

This is a follow-up for D89039 patch, which adds a support for
Content/Size for all sections.

Assuming that all of sections have a support of these 2 fields,
we can simplify and generalize the code.

Depends on D89039

[MaskRay]

Looks great!

[jhenderson]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1304–1306

I can see why this is needed, but why wasn't it needed before, and what's the impact of adding it? Same applies in a few other places too.

[grimar]

llvm/lib/ObjectYAML/ELFEmitter.cpp

1304–1306

Previously when we had either Content or Size, the code on the left wrote some data and returned.
And we report an error when both Entries and Content/Size are used together much earlier, it is a normal situation.

After this patch we handle Content/Size for all types of sections in a single common place before writeSectionContent method is called.
But we still have to call writeSectionContent to set section fields (e.g sh_entsize/sh_link etc) and/or
handle section specific Entries (like here). Without this condition we just crash when trying to access an empty Entries in a loop below.

Perhaps worth to rename writeSectionContent to finalizeSection or alike.

[jhenderson]

LGTM.

llvm/lib/ObjectYAML/ELFEmitter.cpp

1304–1306

Got it, thanks!

llvm/lib/ObjectYAML/ELFEmitter.cpp

 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);
 }
 
+static uint64_t writeContent(ContiguousBlobAccumulator &CBA,
+                             const Optional<yaml::BinaryRef> &Content,
+                             const Optional<llvm::yaml::Hex64> &Size) {
+  size_t ContentSize = 0;
+  if (Content) {
+    CBA.writeAsBinary(*Content);
+    ContentSize = Content->binary_size();
+  }
+
+  if (!Size)
+    return ContentSize;
+
+  CBA.writeZeros(*Size - ContentSize);
+  return *Size;
+}
+
 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 (IsFirstUndefSection) {
         // We do not write any content for special SHN_UNDEF section.
         if (RawSec->Size)
           SHeader.sh_size = *RawSec->Size;
         if (RawSec->Info)
           SHeader.sh_info = *RawSec->Info;
       }
       if (Sec->EntSize)
         SHeader.sh_entsize = *Sec->EntSize;
-    } else if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
+
+      LocationCounter += SHeader.sh_size;
+      overrideFields<ELFT>(Sec, SHeader);
+      continue;
+    }
+
+    if (!isa<ELFYAML::NoBitsSection>(Sec) && (Sec->Content || Sec->Size))
+      SHeader.sh_size = writeContent(CBA, Sec->Content, Sec->Size);
+
+    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::SymtabShndxSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::RelrSection>(Sec)) {
       writeSectionContent(SHeader, *S, CBA);
     } else if (auto S = dyn_cast<ELFYAML::GroupSection>(Sec)) {

 
 static size_t findFirstNonGlobal(ArrayRef<ELFYAML::Symbol> Symbols) {
   for (size_t I = 0; I < Symbols.size(); ++I)
     if (Symbols[I].Binding.value != ELF::STB_LOCAL)
       return I;
   return Symbols.size();
 }
 
-static uint64_t writeContent(ContiguousBlobAccumulator &CBA,
-                             const Optional<yaml::BinaryRef> &Content,
-                             const Optional<llvm::yaml::Hex64> &Size) {
-  size_t ContentSize = 0;
-  if (Content) {
-    CBA.writeAsBinary(*Content);
-    ContentSize = Content->binary_size();
-  }
-
-  if (!Size)
-    return ContentSize;
-
-  CBA.writeZeros(*Size - ContentSize);
-  return *Size;
-}
-
 template <class ELFT>
 std::vector<typename ELFT::Sym>
 ELFState<ELFT>::toELFSymbols(ArrayRef<ELFYAML::Symbol> Symbols,
                              const StringTableBuilder &Strtab) {
   std::vector<Elf_Sym> Ret;
   Ret.resize(Symbols.size() + 1);
 
   size_t I = 0;
static bool shouldAllocateFileSpace(ArrayRef<ELFYAML::ProgramHeader> Phdrs,
   }
   return false;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoBitsSection &S,
                                          ContiguousBlobAccumulator &CBA) {
-  // SHT_NOBITS sections do not have any content to write.
-  SHeader.sh_entsize = 0;
-
   if (!S.Size)
     return;
 
   SHeader.sh_size = *S.Size;
 
   // When a nobits section is followed by a non-nobits section or fill
   // in the same segment, we allocate the file space for it. This behavior
   // matches linkers.
   if (shouldAllocateFileSpace(Doc.ProgramHeaders, S))
     CBA.writeZeros(*S.Size);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::RawContentSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
 
   if (Section.Info)
     SHeader.sh_info = *Section.Info;
 }
 
 static bool isMips64EL(const ELFYAML::Object &Obj) {
void ELFState<ELFT>::writeSectionContent(
   unsigned Link = 0;
   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);
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Relocations)
     return;
 
   for (const ELFYAML::Relocation &Rel : *Section.Relocations) {
     unsigned SymIdx = Rel.Symbol ? toSymbolIndex(*Rel.Symbol, Section.Name,
                                                  Section.Link == ".dynsym")
                                  : 0;
     if (IsRela) {

 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::RelrSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   SHeader.sh_entsize =
       Section.EntSize ? uint64_t(*Section.EntSize) : sizeof(Elf_Relr);
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   for (llvm::yaml::Hex64 E : *Section.Entries) {
     if (!ELFT::Is64Bits && E > UINT32_MAX)
       reportError(Section.Name + ": the value is too large for 32-bits: 0x" +
                   Twine::utohexstr(E));
     CBA.write<uintX_t>(E, ELFT::TargetEndianness);
if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
     SHeader.sh_link = Link;
 
   SHeader.sh_entsize = 4;
 
   if (Section.Signature)
     SHeader.sh_info =
         toSymbolIndex(*Section.Signature, Section.Name, /*IsDynamic=*/false);
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Members)
     return;
 
   for (const ELFYAML::SectionOrType &Member : *Section.Members) {
     unsigned int SectionIndex = 0;
     if (Member.sectionNameOrType == "GRP_COMDAT")
       SectionIndex = llvm::ELF::GRP_COMDAT;
     else
       SectionIndex = toSectionIndex(Member.sectionNameOrType, Section.Name);
     CBA.write<uint32_t>(SectionIndex, ELFT::TargetEndianness);
   }
   SHeader.sh_size = SHeader.sh_entsize * Section.Members->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::SymverSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   SHeader.sh_entsize = Section.EntSize ? (uint64_t)*Section.EntSize : 2;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   for (uint16_t Version : *Section.Entries)
     CBA.write<uint16_t>(Version, ELFT::TargetEndianness);
   SHeader.sh_size = Section.Entries->size() * SHeader.sh_entsize;
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::StackSizesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+  if (!Section.Entries)
     return;
-  }
 
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::StackSizeEntry &E : *Section.Entries) {
     CBA.write<uintX_t>(E.Address, ELFT::TargetEndianness);
     SHeader.sh_size += sizeof(uintX_t) + CBA.writeULEB128(E.Size);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::LinkerOptionsSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Options)
     return;
 
   for (const ELFYAML::LinkerOption &LO : *Section.Options) {
     CBA.write(LO.Key.data(), LO.Key.size());
     CBA.write('\0');
     CBA.write(LO.Value.data(), LO.Value.size());
     CBA.write('\0');
     SHeader.sh_size += (LO.Key.size() + LO.Value.size() + 2);
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::DependentLibrariesSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Libs)
     return;
 
   for (StringRef Lib : *Section.Libs) {
     CBA.write(Lib.data(), Lib.size());
     CBA.write('\0');
     SHeader.sh_size += Lib.size() + 1;
   }
void ELFState<ELFT>::writeSectionContent(
   else
     SHeader.sh_entsize = 16;
 
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::CallGraphEntry &E : *Section.Entries) {
     unsigned From = toSymbolIndex(E.From, Section.Name, /*IsDynamic=*/false);
     unsigned To = toSymbolIndex(E.To, Section.Name, /*IsDynamic=*/false);
 
     CBA.write<uint32_t>(From, ELFT::TargetEndianness);
if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = sizeof(typename ELFT::Word);
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+  if (!Section.Bucket)
     return;
-  }
 
   if (!Section.Bucket)
     return;
 
   CBA.write<uint32_t>(
       Section.NBucket.getValueOr(llvm::yaml::Hex64(Section.Bucket->size())),
       ELFT::TargetEndianness);
   CBA.write<uint32_t>(

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerdefSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verdef Elf_Verdef;
   typedef typename ELFT::Verdaux Elf_Verdaux;
 
   SHeader.sh_info = Section.Info;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.Entries->size(); ++I) {
     const ELFYAML::VerdefEntry &E = (*Section.Entries)[I];
 
     Elf_Verdef VerDef;

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::VerneedSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   typedef typename ELFT::Verneed Elf_Verneed;
   typedef typename ELFT::Vernaux Elf_Vernaux;
 
   SHeader.sh_info = Section.Info;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.VerneedV)
     return;
 
   uint64_t AuxCnt = 0;
   for (size_t I = 0; I < Section.VerneedV->size(); ++I) {
     const ELFYAML::VerneedEntry &VE = (*Section.VerneedV)[I];
 
     Elf_Verneed VerNeed;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   SHeader.sh_size = Section.VerneedV->size() * sizeof(Elf_Verneed) +
                     AuxCnt * sizeof(Elf_Vernaux);
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(
     Elf_Shdr &SHeader, const ELFYAML::ARMIndexTableSection &Section,
     ContiguousBlobAccumulator &CBA) {
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::ARMIndexTableEntry &E : *Section.Entries) {
     CBA.write<uint32_t>(E.Offset, ELFT::TargetEndianness);
     CBA.write<uint32_t>(E.Value, ELFT::TargetEndianness);
   }
   SHeader.sh_size = Section.Entries->size() * 8;
void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
   assert(Section.Type == llvm::ELF::SHT_DYNAMIC &&
          "Section type is not SHT_DYNAMIC");
 
   if (Section.EntSize)
     SHeader.sh_entsize = *Section.EntSize;
   else
     SHeader.sh_entsize = 2 * sizeof(uintX_t);
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Entries)
     return;
 
   for (const ELFYAML::DynamicEntry &DE : *Section.Entries) {
     CBA.write<uintX_t>(DE.Tag, ELFT::TargetEndianness);
     CBA.write<uintX_t>(DE.Val, ELFT::TargetEndianness);
   }
   SHeader.sh_size = 2 * sizeof(uintX_t) * Section.Entries->size();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::AddrsigSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".symtab") &&
       SN2I.lookup(".symtab", Link))
     SHeader.sh_link = Link;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+  if (!Section.Symbols)
     return;
-  }
 
   if (!Section.Symbols)
     return;
 
   for (StringRef Sym : *Section.Symbols)
     SHeader.sh_size +=
         CBA.writeULEB128(toSymbolIndex(Sym, Section.Name, /*IsDynamic=*/false));
 }
 
 template <class ELFT>
 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::NoteSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
-  uint64_t Offset = CBA.tell();
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
-    return;
-  }
-
   if (!Section.Notes)
     return;
 
+  uint64_t Offset = CBA.tell();
   for (const ELFYAML::NoteEntry &NE : *Section.Notes) {
     // Write name size.
     if (NE.Name.empty())
       CBA.write<uint32_t>(0, ELFT::TargetEndianness);
     else
       CBA.write<uint32_t>(NE.Name.size() + 1, ELFT::TargetEndianness);
 
     // Write description size.

 void ELFState<ELFT>::writeSectionContent(Elf_Shdr &SHeader,
                                          const ELFYAML::GnuHashSection &Section,
                                          ContiguousBlobAccumulator &CBA) {
   unsigned Link = 0;
   if (Section.Link.empty() && !ExcludedSectionHeaders.count(".dynsym") &&
       SN2I.lookup(".dynsym", Link))
     SHeader.sh_link = Link;
 
-  if (Section.Content || Section.Size) {
-    SHeader.sh_size = writeContent(CBA, Section.Content, Section.Size);
+  if (!Section.HashBuckets)
     return;
-  }
 
   if (!Section.Header)
     return;
 
   // We write the header first, starting with the hash buckets count. Normally
   // it is the number of entries in HashBuckets, but the "NBuckets" property can
   // be used to override this field, which is useful for producing broken
   // objects.