[ELF2] Ensure the DynSymTab to be finalized before the others

[ikudrin]

Summary

It is required to fill up the GNU hash table section before its finalize() method is called.

[ruiu]

LGTM with a nit.

ELF/Writer.cpp

584–591

Can you merge these two?

// Finalizers fix each section's size.
// .dynamic section's finalizer may add strings to .dynstr, so finalize that early.
// Likewise, .dynsym is finalized early since that may fill up .gnu.hash.
Out<ELFT>::Dynamic->finalize();
if (isOutputDynamic())
  Out<ELFT>::DynSymTab->finalize();

ELF/OutputSections.cpp

 template <class ELFT>
 unsigned GnuHashTableSection<ELFT>::calcMaskWords(unsigned NumHashed) {
   if (!NumHashed)
     return 1;
   return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
 }
 
 template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
-  ArrayRef<SymbolBody *> A = Out<ELFT>::DynSymTab->getSymbols();
-  unsigned NumHashed = std::count_if(A.begin(), A.end(), includeInGnuHashTable);
+  unsigned NumHashed = HashedSymbols.size();
   NBuckets = calcNBuckets(NumHashed);
   MaskWords = calcMaskWords(NumHashed);
   // Second hash shift estimation: just predefined values.
   Shift2 = ELFT::Is64Bits ? 6 : 5;
 
   this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
   this->Header.sh_size = sizeof(Elf_Word) * 4            // Header
                          + sizeof(Elf_Off) * MaskWords   // Bloom Filter
SymbolTableSection<ELFT>::SymbolTableSection(
   typedef OutputSectionBase<ELFT> Base;
   typename Base::Elf_Shdr &Header = this->Header;
 
   Header.sh_entsize = sizeof(Elf_Sym);
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
+  if (this->Header.sh_size)
+    return; // Already finalized.
+
   this->Header.sh_size = getNumSymbols() * sizeof(Elf_Sym);
   this->Header.sh_link = StrTabSec.SectionIndex;
   this->Header.sh_info = NumLocals + 1;
 
   if (!StrTabSec.isDynamic()) {
     std::stable_sort(Symbols.begin(), Symbols.end(),
                      [](SymbolBody *L, SymbolBody *R) {
                        return getSymbolBinding(L) == STB_LOCAL &&

ELF/Writer.cpp

std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareOutputSections<ELFT>);
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
     OutputSections[I]->SectionIndex = I + 1;
 
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Out<ELFT>::ShStrTab->add(Sec->getName());
 
   // Fill the DynStrTab early because Dynamic adds strings to
   // DynStrTab but .dynstr may appear before .dynamic.
   Out<ELFT>::Dynamic->finalize();
 
+  // The dynamic symbols section should be finalized before the others
+  // because it can fill up the GNU hash section.
+  if (isOutputDynamic())
+    Out<ELFT>::DynSymTab->finalize();
+
   // Fill other section headers.
   for (OutputSectionBase<ELFT> *Sec : OutputSections)
     Sec->finalize();
 
   // If we have a .opd section (used under PPC64 for function descriptors),
   // store a pointer to it here so that we can use it later when processing
   // relocations.
   Out<ELFT>::Opd = Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC, 0});