Deterministically allocate GOT/PLT slots

Slots are now created during relocation scanning deterministically in input
order, matching lld. The scan is now serial. Slot creation within it was
already serialized on a mutex, so parallelism only decided which input
reached the lock first.

.rela.dyn and .rela.plt are created once alongside .got/.plt rather than per
input file.

ifunc loops now iterate .plt instead of a DenseMap, which is not deterministic
even under a single-threaded link.

Signed-off-by: quic-areg <aregmi@qti.qualcomm.com>

Author: quic-areg

include/eld/Input/ELFObjectFile.h

@@ -48,8 +48,6 @@ class ELFObjectFile : public ELFFileBase {
   void setDynamicSections(ELFSection &GOT, ELFSection &GOTPLT, ELFSection &PLT,
                           ELFSection &RelDyn, ELFSection &RelPLT);
 
-  void setDynamicRelocSections(ELFSection &RelDyn, ELFSection &RelPLT);
-
   ELFSection *getRelaDyn() const { return RelaDyn; }
   ELFSection *getRelaPLT() const { return RelaPLT; }
 

include/eld/Target/GNULDBackend.h

@@ -1297,6 +1297,8 @@ class GNULDBackend {
   ELFSection *GOTSection = nullptr;
   ELFSection *GOTPLTSection = nullptr;
   ELFSection *PLTSection = nullptr;
+  ELFSection *RelDynSection = nullptr;
+  ELFSection *RelPLTSection = nullptr;
   LDSymbol *m_pGOTSymbol = nullptr;
   llvm::DenseMap<const Relocation *, Relocation *> m_RelativeRelocMap;
 

lib/Core/Linker.cpp

@@ -169,13 +169,6 @@ bool Linker::link() {
       return false;
   }
 
-  // Init per-file synthetic dynamic sections.
-  if (LinkerConfig::Object != ThisConfig->codeGenType()) {
-    for (auto &Input : ThisModule->getObjectList())
-      if (ELFObjectFile *ELFObj = llvm::dyn_cast<ELFObjectFile>(Input))
-        Backend->initDynamicSections(*ELFObj);
-  }
-
   if (ThisModule->getPrinter()->isVerbose())
     ThisConfig->raise(Diag::merging_input_sections);
   {

lib/Input/ELFObjectFile.cpp

@@ -44,14 +44,6 @@ void ELFObjectFile::setDynamicSections(ELFSection &PGOT, ELFSection &PGOTPLT,
   RelaPLT->setExcludedFromGC();
 }
 
-void ELFObjectFile::setDynamicRelocSections(ELFSection &PRelDyn,
-                                            ELFSection &PRelPLT) {
-  RelaDyn = &PRelDyn;
-  RelaPLT = &PRelPLT;
-  RelaDyn->setExcludedFromGC();
-  RelaPLT->setExcludedFromGC();
-}
-
 void ELFObjectFile::createDWARFContext(bool Is32) {
   if (DebugSections.empty())
     return;

lib/Object/ObjectLinker.cpp

@@ -2203,54 +2203,21 @@ bool ObjectLinker::scanRelocations(bool IsPartialLink) {
 
   getTargetBackend().provideSymbols();
 
+  // Slots are allocated as relocations are scanned in input order.
   std::vector<std::unique_ptr<Relocator::CopyRelocs>> AllCopyRelocs;
-  if (ThisConfig.options().numThreads() <= 1 ||
-      !ThisConfig.isScanRelocationsMultiThreaded()) {
-    if (ThisModule->getPrinter()->traceThreads())
-      ThisConfig.raise(Diag::threads_disabled) << "ScanRelocations";
-    for (auto &Input : ThisModule->getObjectList()) {
-      auto CopyRelocs = std::make_unique<Relocator::CopyRelocs>();
-      scanRelocationsHelper(Input, IsPartialLink, PluginVect, *CopyRelocs);
-      AllCopyRelocs.push_back(std::move(CopyRelocs));
-    }
-  } else {
-    if (ThisModule->getPrinter()->traceThreads())
-      ThisConfig.raise(Diag::threads_enabled)
-          << "ScanRelocations" << ThisConfig.options().numThreads();
-    llvm::ThreadPoolInterface *Pool = ThisModule->getThreadPool();
-    for (auto &Input : ThisModule->getObjectList()) {
-      auto CopyRelocs = std::make_unique<Relocator::CopyRelocs>();
-      auto &CopyRelocsRef = *CopyRelocs; // must dereference in the main thread
-      Pool->async([&] {
-        scanRelocationsHelper(Input, IsPartialLink, PluginVect, CopyRelocsRef);
-      });
-      AllCopyRelocs.push_back(std::move(CopyRelocs));
-    }
-    Pool->wait();
+  if (ThisModule->getPrinter()->traceThreads())
+    ThisConfig.raise(Diag::threads_disabled) << "ScanRelocations";
+  for (auto &Input : ThisModule->getObjectList()) {
+    auto CopyRelocs = std::make_unique<Relocator::CopyRelocs>();
+    scanRelocationsHelper(Input, IsPartialLink, PluginVect, *CopyRelocs);
+    AllCopyRelocs.push_back(std::move(CopyRelocs));
   }
   // assume there is only one copy relocation type per target
   Relocation::Type CopyRelocType = getTargetBackend().getCopyRelType();
   for (const auto &RelocVec : AllCopyRelocs)
     for (auto &Reloc : *RelocVec)
       createCopyRelocation(*Reloc, CopyRelocType);
 
-  // Merge per-file relocations
-  if (!IsPartialLink) {
-    ELFObjectFile *RelocInput =
-        getTargetBackend().getDynamicSectionHeadersInputFile();
-    auto MergeRelocs = [](ELFSection &To, ELFSection &From) {
-      To.appendRelocations(From.getRelocations());
-    };
-    for (auto &Input : ThisModule->getObjectList())
-      if (ELFObjectFile *Obj = llvm::dyn_cast<ELFObjectFile>(Input))
-        if (Obj != RelocInput) {
-          if (const auto &S = Obj->getRelaDyn())
-            MergeRelocs(*RelocInput->getRelaDyn(), *S);
-          if (const auto &S = Obj->getRelaPLT())
-            MergeRelocs(*RelocInput->getRelaPLT(), *S);
-        }
-  }
-
   // If there is a undefined symbol, fail the link. No point fixing the
   // relocations. This is overridden by --noinhibit-exec.
   if (!ThisConfig.getDiagEngine()->diagnose()) {

lib/Target/AArch64/AArch64LDBackend.cpp

@@ -523,8 +523,15 @@ bool AArch64LDBackend::finalizeScanRelocations() {
   if (!Obj)
     return true;
 
-  for (auto &[symInfo, plt] : m_PLTMap) {
-    if (!symInfo->isIFunc() || !symInfo->hasIFuncDirectRef() ||
+  if (!getPLT())
+    return true;
+
+  for (Fragment *F : getPLT()->getFragmentList()) {
+    auto *plt = llvm::dyn_cast<AArch64PLT>(F);
+    if (!plt)
+      continue;
+    ResolveInfo *symInfo = plt->symInfo();
+    if (!symInfo || !symInfo->isIFunc() || !symInfo->hasIFuncDirectRef() ||
         !symInfo->hasIFuncNeedsGOT())
       continue;
 
@@ -745,7 +752,7 @@ AArch64PLT *AArch64LDBackend::createPLT(ELFObjectFile *Obj, ResolveInfo *R,
       *m_Module.getIRBuilder(), createGOT(GOT::GOTPLTN, Obj, R, isIRelative),
       getPLT(), R);
   // init the corresponding rel entry in .rela.plt
-  Relocation &rela_entry = *Obj->getRelaPLT()->createOneReloc();
+  Relocation &rela_entry = *getRelaPLT()->createOneReloc();
   rela_entry.setType(isIRelative ? llvm::ELF::R_AARCH64_IRELATIVE
                                  : llvm::ELF::R_AARCH64_JUMP_SLOT);
   rela_entry.setTargetRef(make<FragmentRef>(*P->getGOT(), 0));

lib/Target/AArch64/AArch64Relocator.cpp

@@ -56,9 +56,9 @@ Relocation *helper_DynRel_init(ELFObjectFile *Obj, Relocation *R,
   Relocation *rela_entry = nullptr;
 
   if (pType == R_AARCH64_TLSDESC)
-    rela_entry = Obj->getRelaPLT()->createOneReloc();
+    rela_entry = B.getRelaPLT()->createOneReloc();
   else
-    rela_entry = Obj->getRelaDyn()->createOneReloc();
+    rela_entry = B.getRelaDyn()->createOneReloc();
 
   rela_entry->setType(pType);
   rela_entry->setTargetRef(make<FragmentRef>(*F, pOffset));

lib/Target/ARM/ARMLDBackend.cpp

@@ -637,8 +637,15 @@ bool ARMGNULDBackend::finalizeScanRelocations() {
   // holds the address of PLT[ifunc]. GOT references then resolve to this slot
   // rather than the GOTPLT slot, so that the GOT-loaded pointer equals the
   // direct-reference pointer (pointer equality).
-  for (auto &[symInfo, plt] : m_PLTMap) {
-    if (!symInfo->isIFunc() || !symInfo->hasIFuncDirectRef() ||
+  if (!getPLT())
+    return true;
+
+  for (Fragment *F : getPLT()->getFragmentList()) {
+    auto *plt = llvm::dyn_cast<ARMPLT>(F);
+    if (!plt)
+      continue;
+    ResolveInfo *symInfo = plt->symInfo();
+    if (!symInfo || !symInfo->isIFunc() || !symInfo->hasIFuncDirectRef() ||
         !symInfo->hasIFuncNeedsGOT())
       continue;
     ARMGOT *G = createGOT(GOT::Regular, nullptr, symInfo);
@@ -1121,7 +1128,7 @@ ARMPLT *ARMGNULDBackend::createPLT(ELFObjectFile *Obj, ResolveInfo *R,
       *m_Module.getIRBuilder(),
       createGOT(GOT::GOTPLTN, Obj, R, hasNow || isIRelative), getPLT(), R);
   // init the corresponding rel entry in .rel.plt
-  Relocation *rel_entry = Obj->getRelaPLT()->createOneReloc();
+  Relocation *rel_entry = getRelaPLT()->createOneReloc();
   rel_entry->setType(isIRelative ? llvm::ELF::R_ARM_IRELATIVE
                                  : llvm::ELF::R_ARM_JUMP_SLOT);
   rel_entry->setTargetRef(make<FragmentRef>(*P->getGOT(), 0));

lib/Target/ARM/ARMRelocator.cpp

@@ -68,7 +68,7 @@ static Relocation *helper_DynRel_init(ELFObjectFile *Obj, Relocation *R,
                                       ResolveInfo *pSym, Fragment *F,
                                       uint32_t pOffset, Relocator::Type pType,
                                       ARMGNULDBackend &B) {
-  Relocation *rel_entry = Obj->getRelaDyn()->createOneReloc();
+  Relocation *rel_entry = B.getRelaDyn()->createOneReloc();
   rel_entry->setType(pType);
   rel_entry->setTargetRef(make<FragmentRef>(*F, pOffset));
   rel_entry->setSymInfo(pSym);

lib/Target/GNULDBackend.cpp

@@ -1717,21 +1717,19 @@ ELFSection *GNULDBackend::getPLT() const { return PLTSection; }
 
 void GNULDBackend::initDynamicSections(ELFObjectFile &InputFile,
                                        const DynamicSectionLayout &Layout) {
+  if (GOTSection)
+    return;
+
   bool IsRela = Layout.RelType == llvm::ELF::SHT_RELA;
-  ELFSection &RelDyn = *m_Module.createInternalSection(
+  RelDynSection = m_Module.createInternalSection(
       InputFile, LDFileFormat::DynamicRelocation,
       IsRela ? ".rela.dyn" : ".rel.dyn", Layout.RelType, llvm::ELF::SHF_ALLOC,
       Layout.RelAlign);
-  ELFSection &RelPLT = *m_Module.createInternalSection(
+  RelPLTSection = m_Module.createInternalSection(
       InputFile, LDFileFormat::DynamicRelocation,
       IsRela ? ".rela.plt" : ".rel.plt", Layout.RelType, llvm::ELF::SHF_ALLOC,
       Layout.RelAlign);
 
-  if (GOTSection) {
-    InputFile.setDynamicRelocSections(RelDyn, RelPLT);
-    return;
-  }
-
   auto Create = [&](std::string Name, uint32_t Flags, uint32_t Align) {
     return m_Module.createInternalSection(InputFile, LDFileFormat::Internal,
                                           Name, llvm::ELF::SHT_PROGBITS, Flags,
@@ -1744,17 +1742,13 @@ void GNULDBackend::initDynamicSections(ELFObjectFile &InputFile,
              Layout.GOTPLTAlign);
   PLTSection = Create(".plt", llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR,
                       Layout.PLTAlign);
-  InputFile.setDynamicSections(*GOTSection, *GOTPLTSection, *PLTSection, RelDyn,
-                               RelPLT);
+  InputFile.setDynamicSections(*GOTSection, *GOTPLTSection, *PLTSection,
+                               *RelDynSection, *RelPLTSection);
 }
 
-ELFSection *GNULDBackend::getRelaDyn() const {
-  return m_DynamicSectionHeadersInputFile->getRelaDyn();
-}
+ELFSection *GNULDBackend::getRelaDyn() const { return RelDynSection; }
 
-ELFSection *GNULDBackend::getRelaPLT() const {
-  return m_DynamicSectionHeadersInputFile->getRelaPLT();
-}
+ELFSection *GNULDBackend::getRelaPLT() const { return RelPLTSection; }
 
 void GNULDBackend::reportErrorIfGOTIsDiscarded(ResolveInfo *R) const {
   ELFSection *GOT = getGOT();