[yaml2obj] - Change how we handle implicit sections.

[grimar]

Summary

We have a few sections that can be added implicitly to the output:
".dynsym", ".dynstr", ".symtab", ".strtab" and ".shstrtab".

Problem appears when such section is listed explicitly in YAML.
In that case it's content is written twice:
first time during writing of regular sections listed in the document
and second time during special handling.

Because of that their file offsets can become unexpectedly broken:
(yaml file for sample below lists .dynsym explicitly before .text.foo)

Before patch:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .dynsym           DYNSYM           0000000000000100  00000250
       0000000000000030  0000000000000018   A       6     0     8
  [ 2] .text.foo         PROGBITS         0000000000000200  00000200
       0000000000000000  0000000000000000  AX       0     0     0

After patch:
Section Headers:
  [Nr] Name         Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .dynsym           DYNSYM           0000000000000100  00000200
       0000000000000030  0000000000000018   A       6     0     8
  [ 2] .text.foo         PROGBITS         0000000000000200  00000230
       0000000000000000  0000000000000000  AX       0     0     0

This patch reorganizes our code and fixes the issue described.

[grimar]

• Removed unused properties from yaml.

[grimar]

• Removed even more unused properties from YAML.

[grimar]

Planning changes (found an assertion failture because of this in one of llvm-readelf test cases).

[grimar]

• Updated implementation.

[jhenderson]

test/tools/yaml2obj/implicit-sections.test

4

Your comment says that you are checking the file offset of these sections, but the CHECK tests the other properties too. Should the comment be expanded to say something like "Check the section header properties of ..." or should the text being checked for be relaxed (e.g. by regexing out the Type and Address columns, and removing the Size and Nr columns?

FWIW, I think there is probably value in checking the Address, Size and Type output, if they aren't explicitly tested elsewhere, so I think the comment is the thing that needs changing.

Also, does the offset really need to be ascending? I don't think that's strictly required.

40

Maybe worth putting a comment to say that the DynamicSymbols block is required for the .dynsym to be generated?

It might also be good to have a test case for no dynamic symbol.

tools/yaml2obj/yaml2elf.cpp

260

Here and elsewhere, I'd probably rename DocSec to YAMLSec or similar. I think that's a little clearer.

261

My immediate thought was "What was already initialized?" so this probably should be a bit more verbose and say "Check if the header was already initialized".

310

"later. But" -> Either "later, but" or "later. However," (I think either is more natural English).

311

That allows keeping the correct file offset -> This ensures the file offset remains correct.

353

Missing trailing full stop.

358

Missing trailing full stop.

403

What if the raw section has no info specified? I'd expect it to auto-derive the property in this case.

405

Casting to unsigned here seems wrong, since entsize is a 64 bit number...

407

Ditto on both points. AddressAlign is a 64-bit field, so casting to unsigned seems wrong. Additionally, a user might expect yaml2obj to derive the AddressAlign field automatically if they don't explicitly specify it.

410

Not sure exactly where it belongs, but I think we need some sort of error in case somebody explicitly specifies content for a symbol table, but also specifies static symbols.

428

What about a user who explicitly specifies sh_size, but not Content? Is that possible currently for symbol table sections?

440

See above comments re. AddressAlign casting/auto-deriving.

444

Similar to above, do we need an error if a user has specified a Symbol and a custom string table?

[grimar]

• Addressed review comments.

Note:
Many of my answers suggest changing things in the follow-ups.
(because other independent changes need to be done to achieve the ideal behavior).
If you think it will be better I can first prepare patches for those things and rebase this one after.
I fine with either way.

test/tools/yaml2obj/implicit-sections.test

4

I rewrote the comment.

FWIW, I think there is probably value in checking the Address, Size and Type output, if they aren't explicitly tested elsewhere, so I think the comment is the thing that needs changing.

I think testing the Size is usefull, because allows to check how the Off was calculated.
Testing Address is valueable for demonstration of the correlation between Off and Address.
It is not harmfull to check the 'Type` since how section header is written only once (i.e. bug was fixed and
logic changed significantly. Previously they were written as RawContentSection at first)
and this test case is probably only one when we show the behavior of all implicit sections in the
situation when them were all of them are explicitly described in YAML.

Also, does the offset really need to be ascending? I don't think that's strictly required.

I think the order of sections should match the YAML.
Without this patch offsets would be unordered, what looks obviously wrong to me:

Section Headers:
  [Nr] Name              Type             Address           Offset
       Size              EntSize          Flags  Link  Info  Align
  [ 0]                   NULL             0000000000000000  00000000
       0000000000000000  0000000000000000           0     0     0
  [ 1] .dynstr           STRTAB           0000000000000100  00000280
       0000000000000009  0000000000000000   A       0     0     1
  [ 2] .dynsym           DYNSYM           0000000000000150  00000250
       0000000000000030  0000000000000018   A       1     0     8
  [ 3] .symtab           SYMTAB           0000000000000000  00000200
       0000000000000018  0000000000000018           4     0     8
  [ 4] .strtab           STRTAB           0000000000000000  00000218
       0000000000000001  0000000000000000           0     0     1
  [ 5] .shstrtab         STRTAB           0000000000000000  00000219
       0000000000000035  0000000000000000           0     0     1
  [ 6] .text.foo         PROGBITS         0000000000000200  00000200
       0000000000000000  0000000000000000           0     0     0

And that it what my comment tried to say - if there was not described something very special in YAML (i.e. offsets were not explicitly set somehow),
then I think it is very natural to place sections in the order they described and make them have ascending file offset by default.
(that is what all linkers do I believe, for example).

The requirement I know is:
"To obtain this efficiency in practice, executable and shared object files must have segment images whose file offsets and virtual addresses are congruent, modulo the page size."
(https://docs.oracle.com/cd/E19683-01/816-1386/chapter6-34713/index.html)

yaml2obj does not follow it it seems. At least for sample above. But still having offset(.dynstr) > offset(.dynsym) and
VA(.dynstr) < VA(.dynsym) at the same time it something very strange/unnatural IMO.

40

Done.

tools/yaml2obj/yaml2elf.cpp

403

Yes, but we probably need to make RawSec->Info be Optional for doing that. It is not true atm.
(I am planning to improve this and other situations in a followups).

405

Hmm, right.

407

Casting was fixed.

Additionally, a user might expect yaml2obj to derive the AddressAlign field automatically if they don't explicitly specify it.

Again, it seems AddressAlign needs to be optional. I'd leave it for a follow up(s).

410

Yes, sure I though about this too. I would like to do it in a follow up because I guess we
need to make Content be Optional to do that correctly.

428

It was possible before this patch to do:

!ELF
FileHeader:
  Class:   ELFCLASS64
  Data:    ELFDATA2LSB
  Type:    ET_DYN
  Machine: EM_X86_64
Sections:
  - Name:    .dynsym
    Type:    SHT_DYNSYM
    Address: 0x150
    Size:    0x200

And get the .dynsym' of size 0x200. With this patch the default symbol table will be created
(because there is no Content) in this case and Size will be ignored.

Again, it seems to me that for correct implementation Size need to be Optional.
Otherwise we can't distinguish "No Size was set" and "Size was set to zero" cases.

444

Similar answer :]

[jhenderson]

test/tools/yaml2obj/implicit-sections.test

4

sections usually -> sections are usually

50

in case -> for the case

51

but sections -> but the sections

tools/yaml2obj/yaml2elf.cpp

310–311

clang-format?

403

Okay, sounds good.

405

Actually, I lied slightly, in that sh_entsize's size is dependent on the ELF format (32 versus 64 bits). Not sure what the right approach here is though. We could truncate (as I think this will do) or emit an error (but the latter might be a little annoying to implement. Truncation is probably fine for now.

407

Okay.

410

Sounds good.

428

Hmmm... I'm not comfortable about this behaviour change, since this could test failures/spurious passes. If there are no uses of this approach currently, I guess it's okay though.

[grimar]

tools/yaml2obj/yaml2elf.cpp

405

Actually, I lied slightly, in that sh_entsize's size is dependent on the ELF format (32 versus 64 bits).

Yes, I know, but I think we always truncate values everywhere.
We have a comment saying "Just use 64, since it can hold 32-bit values too." in ELFYAML.h where we declare types for ELF things. And I do not think I saw any code checking we do not truncate, so I also guess it is fine for now.

(Anyways., if we want to fix it, it is probably should be checked much earlier. I.e. we might want to report an overflow error during parsing YAML on 32 bits platforms probably).

[jhenderson]

tools/yaml2obj/yaml2elf.cpp

405

Yes, you're probably right.

[grimar]

• Addressed review comments.

tools/yaml2obj/yaml2elf.cpp

428

I'll work on a follow up for this in the first place after landing this patch.

[jhenderson]

Okay, LGTM.

test/tools/yaml2obj/implicit-sections.test

+# RUN: yaml2obj %s -o %t
+# RUN: llvm-readelf -S %t | FileCheck %s
+
+## Check that file offset of usually implicit sections ".dynsym",
+## ".dynstr", ".symtab", ".strtab", ".shstrtab" is ascending.
+
+# CHECK:      Section Headers:
+# CHECK-NEXT:  [Nr] Name      Type     Address          Off    Size
+# CHECK-NEXT:  [ 0]           NULL     0000000000000000 000000 000000
+# CHECK-NEXT:  [ 1] .dynsym   DYNSYM   0000000000000100 000200 000030
+# CHECK-NEXT:  [ 2] .dynstr   STRTAB   0000000000000150 000230 000009
+# CHECK-NEXT:  [ 3] .symtab   SYMTAB   0000000000000000 000239 000018
+# CHECK-NEXT:  [ 4] .strtab   STRTAB   0000000000000000 000251 000001
+# CHECK-NEXT:  [ 5] .shstrtab STRTAB   0000000000000000 000252 000035
+# CHECK-NEXT:  [ 6] .text.foo PROGBITS 0000000000000200 000287 000000
+
+!ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_DYN
+  Machine: EM_X86_64
+Sections:
+  - Name:    .dynsym
+    Type:    SHT_DYNSYM
+    Address: 0x100
+  - Name:    .dynstr
+    Type:    SHT_STRTAB
+    Address: 0x150
+  - Name:    .symtab
+    Type:    SHT_SYMTAB
+  - Name:    .strtab
+    Type:    SHT_STRTAB
+  - Name:    .shstrtab
+    Type:    SHT_STRTAB
+  - Name:    .text.foo
+    Type:    SHT_PROGBITS
+    Address: 0x200
+DynamicSymbols:
+  - Name:    _Z3fooi
+    Binding: STB_GLOBAL

tools/yaml2obj/yaml2elf.cpp

class ELFState {
   NameToIdxMap SN2I;
   NameToIdxMap SymN2I;
   const ELFYAML::Object &Doc;
 
   bool buildSectionIndex();
   bool buildSymbolIndex(ArrayRef<ELFYAML::Symbol> Symbols);
   void initELFHeader(Elf_Ehdr &Header);
   void initProgramHeaders(std::vector<Elf_Phdr> &PHeaders);
-  bool initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
+  bool initImplicitHeader(ELFState<ELFT> &State, ContiguousBlobAccumulator &CBA,
+                          Elf_Shdr &Header, StringRef SecName,
+                          ELFYAML::Section *DocSec);
+  bool initSectionHeaders(ELFState<ELFT> &State,
+                          std::vector<Elf_Shdr> &SHeaders,
                           ContiguousBlobAccumulator &CBA);
   void initSymtabSectionHeader(Elf_Shdr &SHeader, SymtabType STType,
-                               ContiguousBlobAccumulator &CBA);
+                               ContiguousBlobAccumulator &CBA,
+                               ELFYAML::Section *DocSec);
   void initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                StringTableBuilder &STB,
-                               ContiguousBlobAccumulator &CBA);
+                               ContiguousBlobAccumulator &CBA,
+                               ELFYAML::Section *DocSec);
   void setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                               std::vector<Elf_Shdr> &SHeaders);
   void addSymbols(ArrayRef<ELFYAML::Symbol> Symbols, std::vector<Elf_Sym> &Syms,
                   const StringTableBuilder &Strtab);
   bool writeSectionContent(Elf_Shdr &SHeader,
                            const ELFYAML::RawContentSection &Section,
                            ContiguousBlobAccumulator &CBA);
   bool writeSectionContent(Elf_Shdr &SHeader,
if (!SN2I.lookup(IndexSrc, IndexDest) && !to_integer(IndexSrc, IndexDest)) {
     WithColor::error() << "Unknown section referenced: '" << IndexSrc
                        << "' at YAML section '" << SecName << "'.\n";
     return false;
   }
   return true;
 }
 
 template <class ELFT>
-bool ELFState<ELFT>::initSectionHeaders(std::vector<Elf_Shdr> &SHeaders,
+bool ELFState<ELFT>::initImplicitHeader(ELFState<ELFT> &State,
+                                        ContiguousBlobAccumulator &CBA,
+                                        Elf_Shdr &Header, StringRef SecName,
+                                        ELFYAML::Section *DocSec) {
+  // Was already initialized.
+  if (Header.sh_offset)
+    return false;
+
+  if (SecName == ".symtab")
+    State.initSymtabSectionHeader(Header, SymtabType::Static, CBA, DocSec);
+  else if (SecName == ".strtab")
+    State.initStrtabSectionHeader(Header, SecName, State.DotStrtab, CBA,
+                                  DocSec);
+  else if (SecName == ".shstrtab")
+    State.initStrtabSectionHeader(Header, SecName, State.DotShStrtab, CBA,
+                                  DocSec);
+
+  else if (SecName == ".dynsym")
+    State.initSymtabSectionHeader(Header, SymtabType::Dynamic, CBA, DocSec);
+  else if (SecName == ".dynstr")
+    State.initStrtabSectionHeader(Header, SecName, State.DotDynstr, CBA,
+                                  DocSec);
+  else
+    return false;
+  return true;
+}
+
+template <class ELFT>
+bool ELFState<ELFT>::initSectionHeaders(ELFState<ELFT> &State,
+                                        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.
   Elf_Shdr SHeader;
   zero(SHeader);
   SHeaders.push_back(SHeader);
 
   for (const auto &Sec : Doc.Sections) {
     zero(SHeader);
     SHeader.sh_name = DotShStrtab.getOffset(Sec->Name);
     SHeader.sh_type = Sec->Type;
     SHeader.sh_flags = Sec->Flags;
     SHeader.sh_addr = Sec->Address;
     SHeader.sh_addralign = Sec->AddressAlign;
 
     if (!Sec->Link.empty()) {
       unsigned Index;
       if (!convertSectionIndex(SN2I, Sec->Name, Sec->Link, Index))
         return false;
       SHeader.sh_link = Index;
     }
 
+    // We have a few sections like string or symbol tables that are added
+    // implicitly later. But if they are explicitly specified in the YAML, we
+    // want to write them right now. That allows keeping the correct file offset.
+    if (initImplicitHeader(State, CBA, SHeader, Sec->Name, Sec.get())) {
+      SHeaders.push_back(SHeader);
+      continue;
+    }
+
     if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec.get())) {
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else if (auto S = dyn_cast<ELFYAML::RelocationSection>(Sec.get())) {
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else if (auto S = dyn_cast<ELFYAML::Group>(Sec.get())) {
       if (!writeSectionContent(SHeader, *S, CBA))
for (const auto &Sec : Doc.Sections) {
     } else if (auto S = dyn_cast<ELFYAML::VerdefSection>(Sec.get())) {
       if (!writeSectionContent(SHeader, *S, CBA))
         return false;
     } else
       llvm_unreachable("Unknown section type");
 
     SHeaders.push_back(SHeader);
   }
+
+  // Populate SHeaders with implicit sections not present in the Doc
+  for (StringRef Name : State.implicitSectionNames())
+    if (State.SN2I.get(Name) >= SHeaders.size())
+      SHeaders.push_back({});
+
+  // Initialize the implicit sections
+  initImplicitHeader(State, CBA, SHeaders[State.SN2I.get(".symtab")], ".symtab",
+                     nullptr /*DocSec*/);
+  initImplicitHeader(State, CBA, SHeaders[State.SN2I.get(".strtab")], ".strtab",
+                     nullptr /*DocSec*/);
+  initImplicitHeader(State, CBA, SHeaders[State.SN2I.get(".shstrtab")],
+                     ".shstrtab", nullptr /*DocSec*/);
+  if (!Doc.DynamicSymbols.empty()) {
+    initImplicitHeader(State, CBA, SHeaders[State.SN2I.get(".dynsym")],
+                       ".dynsym", nullptr /*DocSec*/);
+    initImplicitHeader(State, CBA, SHeaders[State.SN2I.get(".dynstr")],
+                       ".dynstr", nullptr /*DocSec*/);
+  }
+
   return true;
 }
 
 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();
 }
 
 template <class ELFT>
 void ELFState<ELFT>::initSymtabSectionHeader(Elf_Shdr &SHeader,
                                              SymtabType STType,
-                                             ContiguousBlobAccumulator &CBA) {
+                                             ContiguousBlobAccumulator &CBA,
+                                             ELFYAML::Section *DocSec) {
   zero(SHeader);
   bool IsStatic = STType == SymtabType::Static;
   SHeader.sh_name = DotShStrtab.getOffset(IsStatic ? ".symtab" : ".dynsym");
   SHeader.sh_type = IsStatic ? ELF::SHT_SYMTAB : ELF::SHT_DYNSYM;
   SHeader.sh_link = IsStatic ? getDotStrTabSecNo() : getDotDynStrSecNo();
   if (!IsStatic)
     SHeader.sh_flags |= ELF::SHF_ALLOC;
 
   // One greater than symbol table index of the last local symbol.
   const auto &Symbols = IsStatic ? Doc.Symbols : Doc.DynamicSymbols;
-  SHeader.sh_info = findFirstNonGlobal(Symbols) + 1;
-  SHeader.sh_entsize = sizeof(Elf_Sym);
-  SHeader.sh_addralign = 8;
-
-  // Get the section index ignoring the SHT_NULL section.
-  unsigned SecNdx =
-      IsStatic ? getDotSymTabSecNo() - 1 : getDotDynSymSecNo() - 1;
+
   // If the symbol table section is explicitly described in the YAML
   // then we should set the fields requested.
-  if (SecNdx < Doc.Sections.size()) {
-    ELFYAML::Section *Sec = Doc.Sections[SecNdx].get();
-    SHeader.sh_addr = Sec->Address;
-    if (auto S = dyn_cast<ELFYAML::RawContentSection>(Sec))
-      SHeader.sh_info = S->Info;
-  }
-
+  ELFYAML::RawContentSection *RawSec =
+      dyn_cast_or_null<ELFYAML::RawContentSection>(DocSec);
+  SHeader.sh_info =
+      RawSec ? (unsigned)RawSec->Info : findFirstNonGlobal(Symbols) + 1;
+  SHeader.sh_entsize = (DocSec && DocSec->EntSize)
+                           ? (unsigned)(*DocSec->EntSize)
+                           : sizeof(Elf_Sym);
+  SHeader.sh_addralign = DocSec ? (unsigned)DocSec->AddressAlign : 8;
+  SHeader.sh_addr = DocSec ? (unsigned)DocSec->Address : 0;
+
+  if (RawSec && RawSec->Content.binary_size()) {
+    RawSec->Content.writeAsBinary(
+        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
+    SHeader.sh_size = RawSec->Size;
+  } else {
     std::vector<Elf_Sym> Syms;
     {
       // Ensure STN_UNDEF is present
       Elf_Sym Sym;
       zero(Sym);
       Syms.push_back(Sym);
     }
 
     addSymbols(Symbols, Syms, IsStatic ? DotStrtab : DotDynstr);
 
     writeArrayData(
         CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign),
         makeArrayRef(Syms));
     SHeader.sh_size = arrayDataSize(makeArrayRef(Syms));
   }
+}
 
 template <class ELFT>
 void ELFState<ELFT>::initStrtabSectionHeader(Elf_Shdr &SHeader, StringRef Name,
                                              StringTableBuilder &STB,
-                                             ContiguousBlobAccumulator &CBA) {
+                                             ContiguousBlobAccumulator &CBA,
+                                             ELFYAML::Section *DocSec) {
   zero(SHeader);
   SHeader.sh_name = DotShStrtab.getOffset(Name);
   SHeader.sh_type = ELF::SHT_STRTAB;
-  STB.write(CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
+  SHeader.sh_addralign = DocSec ? (unsigned)DocSec->AddressAlign : 1;
+
+  ELFYAML::RawContentSection *RawSec =
+      dyn_cast_or_null<ELFYAML::RawContentSection>(DocSec);
+  if (RawSec && RawSec->Content.binary_size()) {
+    RawSec->Content.writeAsBinary(
+        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
+    SHeader.sh_size = RawSec->Size;
+  } else {
+    STB.write(
+        CBA.getOSAndAlignedOffset(SHeader.sh_offset, SHeader.sh_addralign));
     SHeader.sh_size = STB.getSize();
-  SHeader.sh_addralign = 1;
+  }
+
+  if (DocSec && DocSec->EntSize)
+    SHeader.sh_entsize = *DocSec->EntSize;
 
   // If .dynstr section is explicitly described in the YAML
   // then we want to use its section address.
   if (Name == ".dynstr") {
-    // Take section index and ignore the SHT_NULL section.
-    unsigned SecNdx = getDotDynStrSecNo() - 1;
-    if (SecNdx < Doc.Sections.size())
-      SHeader.sh_addr = Doc.Sections[SecNdx]->Address;
-
+    if (DocSec)
+      SHeader.sh_addr = DocSec->Address;
     // We assume that .dynstr is always allocatable.
     SHeader.sh_flags |= ELF::SHF_ALLOC;
   }
 }
 
 template <class ELFT>
 void ELFState<ELFT>::setProgramHeaderLayout(std::vector<Elf_Phdr> &PHeaders,
                                             std::vector<Elf_Shdr> &SHeaders) {

 }
 
 template <class ELFT> void ELFState<ELFT>::finalizeStrings() {
   // Add the regular symbol names to .strtab section.
   for (const ELFYAML::Symbol &Sym : Doc.Symbols)
     DotStrtab.add(Sym.Name);
   DotStrtab.finalize();
 
-  if (Doc.DynamicSymbols.empty())
-    return;
-
   // Add the dynamic symbol names to .dynstr section.
   for (const ELFYAML::Symbol &Sym : Doc.DynamicSymbols)
     DotDynstr.add(Sym.Name);
 
   // SHT_GNU_verdef and SHT_GNU_verneed sections might also
   // add strings to .dynstr section.
   for (const std::unique_ptr<ELFYAML::Section> &Sec : Doc.Sections) {
     if (auto VerNeed = dyn_cast<ELFYAML::VerneedSection>(Sec.get())) {
int ELFState<ELFT>::writeELF(raw_ostream &OS, const ELFYAML::Object &Doc) {
   // XXX: This offset is tightly coupled with the order that we write
   // things to `OS`.
   const size_t SectionContentBeginOffset = Header.e_ehsize +
                                            Header.e_phentsize * Header.e_phnum +
                                            Header.e_shentsize * Header.e_shnum;
   ContiguousBlobAccumulator CBA(SectionContentBeginOffset);
 
   std::vector<Elf_Shdr> SHeaders;
-  if (!State.initSectionHeaders(SHeaders, CBA))
+  if (!State.initSectionHeaders(State, SHeaders, CBA))
     return 1;
 
-  // Populate SHeaders with implicit sections not present in the Doc
-  for (StringRef Name : State.implicitSectionNames())
-    if (State.SN2I.get(Name) >= SHeaders.size())
-      SHeaders.push_back({});
-
-  // Initialize the implicit sections
-  State.initSymtabSectionHeader(SHeaders[State.SN2I.get(".symtab")],
-                                SymtabType::Static, CBA);
-  State.initStrtabSectionHeader(SHeaders[State.SN2I.get(".strtab")], ".strtab",
-                                State.DotStrtab, CBA);
-  State.initStrtabSectionHeader(SHeaders[State.SN2I.get(".shstrtab")],
-                                ".shstrtab", State.DotShStrtab, CBA);
-  if (!Doc.DynamicSymbols.empty()) {
-    State.initSymtabSectionHeader(SHeaders[State.SN2I.get(".dynsym")],
-                                  SymtabType::Dynamic, CBA);
-    State.initStrtabSectionHeader(SHeaders[State.SN2I.get(".dynstr")],
-                                  ".dynstr", State.DotDynstr, CBA);
-  }
-
   // Now we can decide segment offsets
   State.setProgramHeaderLayout(PHeaders, SHeaders);
 
   OS.write((const char *)&Header, sizeof(Header));
   writeArrayData(OS, makeArrayRef(PHeaders));
   writeArrayData(OS, makeArrayRef(SHeaders));
   CBA.writeBlobToStream(OS);
   return 0;