[ELF2] - Implemented rel[a].plt sections

[grimar]

Summary

.rela.plt contains list of elements in the PLT, which are liable to the relocation during the dynamic linking.

[ruiu]

LGTM

ELF/OutputSections.h

 
 template <class ELFT>
 class RelocationSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
-  RelocationSection(bool IsRela);
+  RelocationSection(StringRef Name, bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc) { Relocs.push_back(Reloc); }
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
   bool isRela() const { return IsRela; }
 
 private:
   std::vector<DynamicReloc<ELFT>> Relocs;

 template <class ELFT> struct Out {
   static DynamicSection<ELFT> *Dynamic;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT::Is64Bits> *Interp;
   static OutputSection<ELFT> *Bss;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
+  static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT::Is64Bits> *DynStrTab;
   static StringTableSection<ELFT::Is64Bits> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
 };
 }
 }
 #endif

ELF/OutputSections.cpp

 template <> PltSection<ELF32BE> *Out<ELF32BE>::Plt = nullptr;
 template <> PltSection<ELF32LE> *Out<ELF32LE>::Plt = nullptr;
 template <> PltSection<ELF64BE> *Out<ELF64BE>::Plt = nullptr;
 template <> PltSection<ELF64LE> *Out<ELF64LE>::Plt = nullptr;
 template <> RelocationSection<ELF32BE> *Out<ELF32BE>::RelaDyn = nullptr;
 template <> RelocationSection<ELF32LE> *Out<ELF32LE>::RelaDyn = nullptr;
 template <> RelocationSection<ELF64BE> *Out<ELF64BE>::RelaDyn = nullptr;
 template <> RelocationSection<ELF64LE> *Out<ELF64LE>::RelaDyn = nullptr;
+template <> RelocationSection<ELF32BE> *Out<ELF32BE>::RelaPlt = nullptr;
+template <> RelocationSection<ELF32LE> *Out<ELF32LE>::RelaPlt = nullptr;
+template <> RelocationSection<ELF64BE> *Out<ELF64BE>::RelaPlt = nullptr;
+template <> RelocationSection<ELF64LE> *Out<ELF64LE>::RelaPlt = nullptr;
 template <> StringTableSection<false> *Out<ELF32BE>::DynStrTab = nullptr;
 template <> StringTableSection<false> *Out<ELF32LE>::DynStrTab = nullptr;
 template <> StringTableSection<true> *Out<ELF64BE>::DynStrTab = nullptr;
 template <> StringTableSection<true> *Out<ELF64LE>::DynStrTab = nullptr;
 template <> StringTableSection<false> *Out<ELF32BE>::StrTab = nullptr;
 template <> StringTableSection<false> *Out<ELF32LE>::StrTab = nullptr;
 template <> StringTableSection<true> *Out<ELF64BE>::StrTab = nullptr;
 template <> StringTableSection<true> *Out<ELF64LE>::StrTab = nullptr;

 
 template <class ELFT>
 typename PltSection<ELFT>::uintX_t
 PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.getPltIndex() * EntrySize;
 }
 
 template <class ELFT>
-RelocationSection<ELFT>::RelocationSection(bool IsRela)
-    : OutputSectionBase<ELFT::Is64Bits>(IsRela ? ".rela.dyn" : ".rel.dyn",
-                                        IsRela ? llvm::ELF::SHT_RELA
+RelocationSection<ELFT>::RelocationSection(StringRef Name, bool IsRela)
+    : OutputSectionBase<ELFT::Is64Bits>(Name, IsRela ? llvm::ELF::SHT_RELA
                                                      : llvm::ELF::SHT_REL,
                                         llvm::ELF::SHF_ALLOC),
       IsRela(IsRela) {
   this->Header.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
template <class ELFT> void DynamicSection<ELFT>::finalize() {
   Header.sh_link = Out<ELFT>::DynStrTab->getSectionIndex();
 
   unsigned NumEntries = 0;
   if (Out<ELFT>::RelaDyn->hasRelocs()) {
     ++NumEntries; // DT_RELA / DT_REL
     ++NumEntries; // DT_RELASZ / DT_RELSZ
     ++NumEntries; // DT_RELAENT / DT_RELENT
   }
+  if (Out<ELFT>::RelaPlt->hasRelocs()) {
+    ++NumEntries; // DT_JMPREL
+    ++NumEntries; // DT_PLTRELSZ
+    ++NumEntries; // DT_PLTGOT
+    ++NumEntries; // DT_PLTREL
+  }
+
   ++NumEntries; // DT_SYMTAB
   ++NumEntries; // DT_SYMENT
   ++NumEntries; // DT_STRTAB
   ++NumEntries; // DT_STRSZ
   ++NumEntries; // DT_HASH
 
   if (!Config->RPath.empty()) {
     ++NumEntries; // DT_RUNPATH / DT_RPATH
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
 
   if (Out<ELFT>::RelaDyn->hasRelocs()) {
     bool IsRela = Out<ELFT>::RelaDyn->isRela();
     WritePtr(IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn->getVA());
     WriteVal(IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->getSize());
     WriteVal(IsRela ? DT_RELAENT : DT_RELENT,
              IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
   }
+  if (Out<ELFT>::RelaPlt->hasRelocs()) {
+    WritePtr(DT_JMPREL, Out<ELFT>::RelaPlt->getVA());
+    WriteVal(DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize());
+    WritePtr(DT_PLTGOT, Out<ELFT>::Got->getVA());
+    WriteVal(DT_PLTREL, Out<ELFT>::RelaPlt->isRela() ? DT_RELA : DT_REL);
+  }
 
   WritePtr(DT_SYMTAB, Out<ELFT>::DynSymTab->getVA());
   WritePtr(DT_SYMENT, sizeof(Elf_Sym));
   WritePtr(DT_STRTAB, Out<ELFT>::DynStrTab->getVA());
   WriteVal(DT_STRSZ, Out<ELFT>::DynStrTab->data().size());
   WritePtr(DT_HASH, Out<ELFT>::HashTab->getVA());
 
   if (!Config->RPath.empty())

ELF/Writer.cpp

template <class ELFT> static void doWriteResult(SymbolTable *Symtab) {
   PltSection<ELFT> Plt;
   Out<ELFT>::Plt = &Plt;
   SymbolTableSection<ELFT> SymTab(*Symtab, *Out<ELFT>::StrTab);
   Out<ELFT>::SymTab = &SymTab;
   SymbolTableSection<ELFT> DynSymTab(*Symtab, *Out<ELFT>::DynStrTab);
   Out<ELFT>::DynSymTab = &DynSymTab;
   HashTableSection<ELFT> HashTab;
   Out<ELFT>::HashTab = &HashTab;
-  RelocationSection<ELFT> RelaDyn(Symtab->shouldUseRela());
+  bool IsRela = Symtab->shouldUseRela();
+  RelocationSection<ELFT> RelaDyn(IsRela ? ".rela.dyn" : ".rel.dyn", IsRela);
   Out<ELFT>::RelaDyn = &RelaDyn;
+  RelocationSection<ELFT> RelaPlt(IsRela ? ".rela.plt" : ".rel.plt", IsRela);
+  Out<ELFT>::RelaPlt = &RelaPlt;
   DynamicSection<ELFT> Dynamic(*Symtab);
   Out<ELFT>::Dynamic = &Dynamic;
 
   Writer<ELFT>(*Symtab).run();
 }
 
 void lld::elf2::writeResult(SymbolTable *Symtab) {
   switch (Symtab->getFirstELF()->getELFKind()) {
if (Body) {
         Out<ELFT>::Plt->addEntry(Body);
       }
       if (Target->relocNeedsGot(Type, *Body)) {
         if (Body->isInGot())
           continue;
         Out<ELFT>::Got->addEntry(Body);
       }
     }
-    if (canBePreempted(Body)) {
+
+    bool CanBePreempted = canBePreempted(Body);
+    if (CanBePreempted)
       Body->setUsedInDynamicReloc();
-      Out<ELFT>::RelaDyn->addReloc({C, RI});
-    } else if (Config->Shared && !Target->isRelRelative(Type)) {
+    if (CanBePreempted || (Config->Shared && !Target->isRelRelative(Type))) {
+      if (Body && Body->isInPlt())
+        Out<ELFT>::RelaPlt->addReloc({C, RI});
+      else
         Out<ELFT>::RelaDyn->addReloc({C, RI});
     }
   }
 }
 
 template <class ELFT>
 void Writer<ELFT>::scanRelocs(const InputSection<ELFT> &C) {
   ObjectFile<ELFT> *File = C.getFile();
   ELFFile<ELFT> &EObj = File->getObj();
if (needsDynamicSections()) {
     if (needsInterpSection())
       OutputSections.push_back(Out<ELFT>::Interp);
     OutputSections.push_back(Out<ELFT>::DynSymTab);
     OutputSections.push_back(Out<ELFT>::HashTab);
     OutputSections.push_back(Out<ELFT>::Dynamic);
     OutputSections.push_back(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
       OutputSections.push_back(Out<ELFT>::RelaDyn);
+    if (Out<ELFT>::RelaPlt->hasRelocs())
+      OutputSections.push_back(Out<ELFT>::RelaPlt);
   }
   if (!Out<ELFT>::Got->empty())
     OutputSections.push_back(Out<ELFT>::Got);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(
       OutputSections.begin(), OutputSections.end(),

test/elf2/plt-i686.s

 // CHECK-NEXT: Address: 0x12010
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 16
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rel.dyn {
-// CHECK-NEXT:     0x13050 R_386_GLOB_DAT bar 0x0
-// CHECK-NEXT:     0x13054 R_386_GLOB_DAT zed 0x0
+// CHECK-NEXT:   Section ({{.*}}) .rel.plt {
+// CHECK-NEXT:     0x13058 R_386_GLOB_DAT bar 0x0
+// CHECK-NEXT:     0x1305C R_386_GLOB_DAT zed 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
 // 0x12010 - (0x12000 + 1) - 4 = 11
 // 0x12010 - (0x12005 + 1) - 4 = 2
 // 0x12018 - (0x1200a + 1) - 4 = 9
 
 // DISASM:      _start:
 // DISASM-NEXT:   12000:  e9 0b 00 00 00  jmp  11
 // DISASM-NEXT:   12005:  e9 06 00 00 00  jmp  6
 // DISASM-NEXT:   1200a:  e9 09 00 00 00  jmp  9
 
-// 0x13050 = 77904
-// 0x13054 = 77908
+// 0x13058 = 77912
+// 0x1305C = 77916
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   12010:  ff 25 {{.*}}       jmpl *77904
+// DISASM-NEXT:   12010:  ff 25 {{.*}}       jmpl *77912
 // DISASM-NEXT:   12016:  90                 nop
 // DISASM-NEXT:   12017:  90                 nop
-// DISASM-NEXT:   12018:  ff 25 {{.*}}       jmpl *77908
+// DISASM-NEXT:   12018:  ff 25 {{.*}}       jmpl *77916
 // DISASM-NEXT:   1201e:  90                 nop
 // DISASM-NEXT:   1201f:  90                 nop
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT

test/elf2/plt.s

 // CHECK-NEXT: Address: 0x2020
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 24
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x30A0 R_X86_64_GLOB_DAT bar 0x0
-// CHECK-NEXT:     0x30A8 R_X86_64_GLOB_DAT zed 0x0
-// CHECK-NEXT:     0x30B0 R_X86_64_GLOB_DAT _start 0x0
+// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:     0x30B0 R_X86_64_GLOB_DAT bar 0x0
+// CHECK-NEXT:     0x30B8 R_X86_64_GLOB_DAT zed 0x0
+// CHECK-NEXT:     0x30C0 R_X86_64_GLOB_DAT _start 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
 // 0x12020 - (0x12000 + 1) - 4 = 27
 // 0x12020 - (0x12005 + 1) - 4 = 22
 // 0x12028 - (0x1200a + 1) - 4 = 25
 
 // DISASM:      _start:
 // DISASM-NEXT:   2000:  e9 {{.*}}       jmp  27
 // DISASM-NEXT:   2005:  e9 {{.*}}       jmp  22
 // DISASM-NEXT:   200a:  e9 {{.*}}       jmp  25
 
-// 0x130A0 - 0x12026  = 4218
-// 0x130A8 - 0x1202e  = 4218
+// 0x30B0 - 0x2026  = 4234
+// 0x30B8 - 0x202e  = 4234
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   2020:  ff 25 {{.*}}       jmpq *4218(%rip)
+// DISASM-NEXT:   2020:  ff 25 {{.*}}       jmpq *4234(%rip)
 // DISASM-NEXT:   2026:  90                 nop
 // DISASM-NEXT:   2027:  90                 nop
-// DISASM-NEXT:   2028:  ff 25 {{.*}}       jmpq *4218(%rip)
+// DISASM-NEXT:   2028:  ff 25 {{.*}}       jmpq *4234(%rip)
 // DISASM-NEXT:   202e:  90                 nop
 // DISASM-NEXT:   202f:  90                 nop
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

test/elf2/relocation.s

 // SEC-NEXT: Size: 8
 
 // SEC:         Name: .got
 // SEC-NEXT:   Type: SHT_PROGBITS
 // SEC-NEXT:   Flags [
 // SEC-NEXT:     SHF_ALLOC
 // SEC-NEXT:     SHF_WRITE
 // SEC-NEXT:   ]
-// SEC-NEXT:   Address: 0x130A0
+// SEC-NEXT:   Address: 0x130E0
 // SEC-NEXT:   Offset:
 // SEC-NEXT:   Size: 16
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
 // SEC-NEXT: }
 

 // CHECK:      Contents of section .R_X86_64_64:
 // CHECK-NEXT:   11000 00100100 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
-// 0x130A8 - 0x11008 = 8352
-// 8352 = 0x80200000   in little endian
+// 0x130E8 - 0x11008 = 8416
+// 8416 = 0xE0200000   in little endian
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   11008 a0200000
+// CHECK-NEXT:   11008 e0200000