[LLD][ELF] Alloc local symbols to be added to the SymTab after global symbols

[peter.smith]

Summary

This change moves the SymbolBodies with isLocal() == true before the global symbols then calculating NumLocals rather than assuming all locals are added before globals and the first NumLocals have isLocal() == true.

This permits the thunk creation code, that generates local symbols, to be moved after the pass that adds global symbols from synthetics to the symbol table.

[ruiu]

LGTM

ELF/SyntheticSections.cpp

1091

Please mention that that's required by the ELF standard.

ELF/SyntheticSections.cpp

static bool sortMipsSymbols(const SymbolBody *L, const SymbolBody *R) {
   bool RIsInLocalGot = !R->IsInGlobalMipsGot;
   if (LIsInLocalGot || RIsInLocalGot)
     return !RIsInLocalGot;
   return L->GotIndex < R->GotIndex;
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
   this->OutSec->Link = this->Link = StrTabSec.OutSec->SectionIndex;
-  this->OutSec->Info = this->Info = NumLocals + 1;
   this->OutSec->Entsize = this->Entsize;
 
+  if (!StrTabSec.isDynamic()) {
+    // All explictly added STB_LOCAL symbols without a Symbol are first
+    auto It = std::stable_partition(
+        Symbols.begin(), Symbols.end(),
+        [](const SymbolTableEntry &S) { return S.Symbol->isLocal(); });
+    NumLocals = It - Symbols.begin();
+  }
+  this->OutSec->Info = this->Info = 1 + NumLocals;
+
   if (Config->Relocatable)
     return;
 
   if (!StrTabSec.isDynamic()) {
     auto GlobBegin = Symbols.begin() + NumLocals;
     auto It = std::stable_partition(
         GlobBegin, Symbols.end(), [](const SymbolTableEntry &S) {
           return S.Symbol->symbol()->computeBinding() == STB_LOCAL;

 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::addGlobal(SymbolBody *B) {
   Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
 }
 
 template <class ELFT> void SymbolTableSection<ELFT>::addLocal(SymbolBody *B) {
   assert(!StrTabSec.isDynamic());
-  ++NumLocals;
   Symbols.push_back({B, StrTabSec.addString(B->getName())});
 }
 
 template <class ELFT>
 size_t SymbolTableSection<ELFT>::getSymbolIndex(SymbolBody *Body) {
   auto I = llvm::find_if(Symbols, [&](const SymbolTableEntry &E) {
     if (E.Symbol == Body)
       return true;

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // we can correctly decide if a dynamic relocation is needed.
   forEachRelSec(scanRelocations<ELFT>);
 
   if (In<ELFT>::Plt && !In<ELFT>::Plt->empty())
     In<ELFT>::Plt->addSymbols();
   if (In<ELFT>::Iplt && !In<ELFT>::Iplt->empty())
     In<ELFT>::Iplt->addSymbols();
 
-  // Some architectures use small displacements for jump instructions.
-  // It is linker's responsibility to create thunks containing long
-  // jump instructions if jump targets are too far. Create thunks.
-  if (Target->NeedsThunks)
-    createThunks<ELFT>(OutputSections);
-
-  // Now that we have defined all possible symbols including linker-
+  // Now that we have defined all possible global symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
   for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     SymbolBody *Body = S->body();
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (In<ELFT>::SymTab)
       In<ELFT>::SymTab->addGlobal(Body);
template <class ELFT> void Writer<ELFT>::finalizeSections() {
   // image base and the dynamic section on mips includes the image base.
   if (!Config->Relocatable && !Config->OFormatBinary) {
     Phdrs = Script<ELFT>::X->hasPhdrsCommands() ? Script<ELFT>::X->createPhdrs()
                                                 : createPhdrs();
     addPtArmExid(Phdrs);
     fixHeaders();
   }
 
+  // Some architectures use small displacements for jump instructions.
+  // It is linker's responsibility to create thunks containing long
+  // jump instructions if jump targets are too far. Create thunks.
+  if (Target->NeedsThunks)
+    createThunks<ELFT>(OutputSections);
+
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
   for (OutputSectionBase *Sec : OutputSections)
     Sec->finalize();
 
   // Dynamic section must be the last one in this list and dynamic
   // symbol table section (DynSymTab) must be the first one.