Use relocations to fill statically known got entries

[• rafael]

Summary

Right now we just remember a SymbolBody for each got entry and duplicate a bit of logic to decide what value, if any, should be written for that SymbolBody.

With ARM there will be more complicated values, and it seems better to just use the relocation code to fill the got entries. This makes it clear that each entry is filled by the dynamic linker or by the static linker.

[peter.smith]

I think the approach looks good.

One possible problem is that we have missed out on the possibilities that other architectures will need these relocations. For example in aarch64 it is possible to generate got slot generating relocations that would be resolved statically in some cases:

extern int foo __attribute__((weak));

int _start(void)
{
    return foo;
}

clang --target=aarch64-linux-gnu -c foo.c
ld.lld foo.o -o foo.axf
bin/ld.lld: error: unrecognized reloc 1025

I think it could be prudent to add the R*_GLOB_DAT to the other targets as well.

I'll merge in my downstream changes for static TLS in ARM and run it past some additional tests, will let you know if I find anything.

[emaste]

lld/ELF/Target.cpp

1700–1701

these were previously in alpha(ish) order

[peter.smith]

lld/ELF/Target.cpp

1699

For ARM (and Mips if it were to use this mechanism) I think we are missing the Target::moduleIndexRel R_ARM_TLS_DTPMOD32 (Always resolves to 1 for an executable). This is currently not showing up in the tests as for ARM as the current implementation forces TLS to use dynamic relocations, but will need to be fixed for static linking. The handleNoRelaxTlsRelocation will most likely need to generate this. I think this could be added in a later patch though.

[ruiu]

LGTM with all comments addressed.

lld/ELF/SyntheticSections.cpp

405

Thank you for doing this. push_back'ing two nullptrs looked odd.

432

nit: you can just inline this.

lld/ELF/Target.cpp

805

sort

[• espindola]

288107

lld/ELF/Relocations.cpp

if (Expr == R_TLSDESC_PAGE || Expr == R_TLSDESC || Expr == R_TLSDESC_CALL ||
     if (Config->Shared) {
       if (In<ELFT>::Got->addDynTlsEntry(Body)) {
         uintX_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
         In<ELFT>::RelaDyn->addReloc(
             {Target->TlsModuleIndexRel, In<ELFT>::Got, Off, false, &Body, 0});
 
         // If the symbol is preemptible we need the dynamic linker to write
         // the offset too.
+        uintX_t OffsetOff = Off + (uintX_t)sizeof(uintX_t);
         if (isPreemptible(Body, Type))
           In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, In<ELFT>::Got,
-                                       Off + (uintX_t)sizeof(uintX_t), false,
-                                       &Body, 0});
+                                       OffsetOff, false, &Body, 0});
+        else
+          In<ELFT>::Got->Relocations.push_back(
+              {R_ABS, Target->TlsOffsetRel, OffsetOff, 0, &Body});
       }
       C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
       return 1;
     }
 
     // Global-Dynamic relocs can be relaxed to Initial-Exec or Local-Exec
     // depending on the symbol being locally defined or not.
     if (isPreemptible(Body, Type)) {
if (refersToGotEntry(Expr)) {
                   Body.getGotOffset<ELFT>(), false, &Body, 0});
         continue;
       }
 
       if (Body.isInGot())
         continue;
 
       In<ELFT>::Got->addEntry(Body);
-      if (Preemptible || (Config->Pic && !isAbsolute<ELFT>(Body))) {
-        uint32_t DynType;
-        if (Body.isTls())
-          DynType = Target->TlsGotRel;
-        else if (Preemptible)
-          DynType = Target->GotRel;
-        else
-          DynType = Target->RelativeRel;
-        AddDyn({DynType, In<ELFT>::Got, Body.getGotOffset<ELFT>(), !Preemptible,
-                &Body, 0});
-      }
+      uintX_t Off = Body.getGotOffset<ELFT>();
+      else if (!Preemptible && Config->Pic && !isAbsolute<ELFT>(Body))
+        DynType = Target->RelativeRel;
+      else
+
+      if (Preemptible || (Config->Pic && !isAbsolute<ELFT>(Body)))
+        AddDyn({DynType, In<ELFT>::Got, Off, !Preemptible, &Body, 0});
+        In<ELFT>::Got->Relocations.push_back({R_ABS, DynType, Off, 0, &Body});
       continue;
     }
   }
 }
 
 template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &S) {
   if (S.AreRelocsRela)
     scanRelocs(S, S.relas());

lld/ELF/SyntheticSections.h

public:
   uintX_t getTlsIndexVA() { return this->getVA() + TlsIndexOff; }
   uint32_t getTlsIndexOff() const { return TlsIndexOff; }
 
   // Flag to force GOT to be in output if we have relocations
   // that relies on its address.
   bool HasGotOffRel = false;
 
 private:
-  std::vector<const SymbolBody *> Entries;
+  size_t NumEntries = 0;
   uint32_t TlsIndexOff = -1;
   uintX_t Size = 0;
 };
 
 // .note.gnu.build-id section.
 template <class ELFT> class BuildIdSection : public SyntheticSection<ELFT> {
   // First 16 bytes are a header.
   static const unsigned HeaderSize = 16;

lld/ELF/SyntheticSections.cpp

 }
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                              Target->GotEntrySize, ".got") {}
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
-  Sym.GotIndex = Entries.size();
-  Entries.push_back(&Sym);
+  Sym.GotIndex = NumEntries;
+  ++NumEntries;
 }
 
 template <class ELFT> bool GotSection<ELFT>::addDynTlsEntry(SymbolBody &Sym) {
   if (Sym.GlobalDynIndex != -1U)
     return false;
-  Sym.GlobalDynIndex = Entries.size();
+  Sym.GlobalDynIndex = NumEntries;
   // Global Dynamic TLS entries take two GOT slots.
-  Entries.push_back(nullptr);
-  Entries.push_back(&Sym);
+  NumEntries += 2;
   return true;
 }
 
 // Reserves TLS entries for a TLS module ID and a TLS block offset.
 // In total it takes two GOT slots.
 template <class ELFT> bool GotSection<ELFT>::addTlsIndex() {
   if (TlsIndexOff != uint32_t(-1))
     return false;
-  TlsIndexOff = Entries.size() * sizeof(uintX_t);
-  Entries.push_back(nullptr);
-  Entries.push_back(nullptr);
+  TlsIndexOff = NumEntries * sizeof(uintX_t);
+  NumEntries += 2;
   return true;
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
   return this->getVA() + B.GlobalDynIndex * sizeof(uintX_t);
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getGlobalDynOffset(const SymbolBody &B) const {
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::finalize() {
-  Size = Entries.size() * sizeof(uintX_t);
+  Size = NumEntries * sizeof(uintX_t);
 }
 
 template <class ELFT> bool GotSection<ELFT>::empty() const {
   // If we have a relocation that is relative to GOT (such as GOTOFFREL),
   // we need to emit a GOT even if it's empty.
-  return Entries.empty() && !HasGotOffRel;
+  return NumEntries == 0 && !HasGotOffRel;
 }
 
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
-  for (const SymbolBody *B : Entries) {
-    uint8_t *Entry = Buf;
-    Buf += sizeof(uintX_t);
-    if (!B)
-      continue;
-    if (B->isPreemptible())
-      continue; // The dynamic linker will take care of it.
-    uintX_t VA = B->getVA<ELFT>();
-    write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
-  }
+  uint8_t *BufEnd = Buf + Size;
+  this->relocate(Buf, BufEnd);
 }
 
 template <class ELFT>
 MipsGotSection<ELFT>::MipsGotSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL,
                              SHT_PROGBITS, Target->GotEntrySize, ".got") {}
 
 template <class ELFT>

lld/ELF/Target.cpp

void X86_64TargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_X86_64_SIZE32:
     checkInt<32>(Val, Type);
     write32le(Loc, Val);
     break;
   case R_X86_64_64:
   case R_X86_64_DTPOFF64:
   case R_X86_64_SIZE64:
   case R_X86_64_PC64:
+  case R_X86_64_GLOB_DAT:
     write64le(Loc, Val);
     break;
   default:
     fatal("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT>
void ARMTargetInfo::relocateOne(uint8_t *Loc, uint32_t Type,
   case R_ARM_GOT_PREL:
   case R_ARM_REL32:
   case R_ARM_TARGET1:
   case R_ARM_TARGET2:
   case R_ARM_TLS_GD32:
   case R_ARM_TLS_IE32:
   case R_ARM_TLS_LDM32:
   case R_ARM_TLS_LDO32:
   case R_ARM_TLS_LE32:
+  case R_ARM_GLOB_DAT:
+  case R_ARM_TLS_TPOFF32:
     write32le(Loc, Val);
     break;
   case R_ARM_PREL31:
     checkInt<31>(Val, Type);
     write32le(Loc, (read32le(Loc) & 0x80000000) | (Val & ~0x80000000));
     break;
   case R_ARM_CALL:
     // R_ARM_CALL is used for BL and BLX instructions, depending on the