[ELF2] - Initial lazy loading support (x86_x64 and x86)

[grimar]

Summary

Main aim of this patch is adding support of lazy loading.

This patch implements basic variant for x86_x64 and for X86 targets. What was done:

1. .got.plt section is created for functions that requires PLT. .got.plt has 3 predefined empty entries now that are required for dynamic linker.

Also other new items created are configured to have correct jump to PLT[N]

2. PLT section now has PLT[0] entry, also others ones are configured to support PLT->GOT(.got.plt) calls.
3. Implemented .rel[a].plt sections (based on patch http://reviews.llvm.org/D13569)
4. Fixed plt relocations types (based on patch http://reviews.llvm.org/D13589)

NOTES:
The .plt.got zero entry is empty now. According to ELF specification it should hold the address of the dynamic structure, referenced with the symbol
_DYNAMIC. The _DYNAMIC entry points to the .dynamic section which contains information used by the ELF interpreter to setup the binary.
This seems to be separate task and I think following patches should handle it, but not this one.

[ruiu]

ELF/OutputSections.cpp

39–41

Entries.resize(3);

65–70

if (B)
  Target->writeGotPltEntry(Buf, Out<ELFT>::Plt->getEntryAddr(*B);
Buf += sizeof(uintX_t);

115

Start with an uppercase character and end with a period.

116

Is PLT base is a common terminology? I prefer writePltZeroEntry as the name of the function.

174–208

This code needs explaining. I'm not actually sure that this code is correct overall.

762–766

Move this before template class GotSection<ELF32LE>;

ELF/OutputSections.h

305

Sort.

320

Sort.

ELF/Target.cpp

127–136

write32le(Buf + 2, GotEntryAddr - PltEntryAddr + 2);  // GOT+8
write32le(Buf + 8, GotEntryAddr - PltEntryAddr + 4);  // GOT+16

No assert() needed.

147–161

write32le(Buf + 2, GotEntryAdrr - PltEntryAddr - 6);
write32le(Buf + 7, Index);
write32le(Buf + 11, ...);

[grimar]

• Review comments addressed.
• Added x86 target implementation.
• Added isInGotPlt() method.
• Had to set PltZeroEntrySize = 0 for PPC64TargetInfo otherwise it fails the ppc64-toc-restore.s because of changed offsets. PPC64TargetInfo does not seem to implement PLT->GOT dispatchment.

ELF/OutputSections.cpp

39–41

Done.

65–70

Done.

115

Done.

116

Changed to writePltZeroEntry. Also changed PltBaseSize to PltZeroEntrySize.

174–208

I added some comments above, under each of 2 code sections of my changes.

192

Each symbol that needs plt relocation is placed to Plt and GotPlt, otherwise to Got.
Also symbol can be placed both to Got and Plt+GotPlt, for example when we take address of function from DSO and also make a call to it.
So here depending on what type of relocation is we switch from which table to take the offset from.

198

Relocations of symbols in ".rela.dyn" and ".rela.plt" are different.
Symbols that NeedsPlt placed to .rela.plt and requred to be R_X86_64_JUMP_SLOT.

762–766

Done.

ELF/OutputSections.h

305

Done.

320

Done.

ELF/Target.cpp

127–136

Done.

147–161

Done. Just note: Buf + 12, not + 11.

[ruiu]

ELF/OutputSections.cpp

192

Please add this as a comment to this function.

ELF/Target.cpp

55

It can read relocation minus index. Maybe I'd write <relocation index> instead of reloc-index.

143

Ditto

[grimar]

Review comments addressed.

[ruiu]

LGTM with a nit. This is a great feature. Thank you for doing this!

test/elf2/plt-i686.s

23–35

You want to use CHECK-NEXT instead of CHECK.

ELF/OutputSections.h

public:
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT>
+class GotPltSection final : public OutputSectionBase<ELFT::Is64Bits> {
+  typedef OutputSectionBase<ELFT::Is64Bits> Base;
+  typedef typename Base::uintX_t uintX_t;
+
+public:
+  GotPltSection();
+  void finalize() override;
+  void writeTo(uint8_t *Buf) override;
+  void addEntry(SymbolBody *Sym);
+  bool empty() const;
+  uintX_t getEntryAddr(const SymbolBody &B) const;
+
+private:
+  std::vector<const SymbolBody *> Entries;
+};
+
+template <class ELFT>
 class PltSection final : public OutputSectionBase<ELFT::Is64Bits> {
   typedef OutputSectionBase<ELFT::Is64Bits> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
   PltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;

 
 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;

 };
 
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   static DynamicSection<ELFT> *Dynamic;
   static GotSection<ELFT> *Got;
+  static GotPltSection<ELFT> *GotPlt;
   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;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
+template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT::Is64Bits> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
+template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT::Is64Bits> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT::Is64Bits> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
 }
 }
 #endif

ELF/OutputSections.cpp

OutputSectionBase<Is64Bits>::OutputSectionBase(StringRef Name, uint32_t sh_type,
                                                uintX_t sh_flags)
     : Name(Name) {
   memset(&Header, 0, sizeof(HeaderT));
   Header.sh_type = sh_type;
   Header.sh_flags = sh_flags;
 }
 
 template <class ELFT>
+GotPltSection<ELFT>::GotPltSection()
+    : OutputSectionBase<ELFT::Is64Bits>(".got.plt", llvm::ELF::SHT_PROGBITS,
+                                        llvm::ELF::SHF_ALLOC |
+                                            llvm::ELF::SHF_WRITE) {
+  this->Header.sh_addralign = this->getAddrSize();
+  // .got.plt has 3 reserved entry
+  Entries.push_back(nullptr);
+  Entries.push_back(nullptr);
+  Entries.push_back(nullptr);
+}
+
+template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
+  Sym->GotIndex = Entries.size();
+  Entries.push_back(Sym);
+}
+
+template <class ELFT> bool GotPltSection<ELFT>::empty() const {
+  return Entries.size() == 3;
+}
+
+template <class ELFT>
+typename GotPltSection<ELFT>::uintX_t
+GotPltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
+  return this->getVA() + B.GotIndex * this->getAddrSize();
+}
+
+template <class ELFT> void GotPltSection<ELFT>::finalize() {
+  this->Header.sh_size = Entries.size() * this->getAddrSize();
+}
+
+template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
+  for (const SymbolBody *B : Entries) {
+    uint8_t *Entry = Buf;
+    Buf += sizeof(uintX_t);
+    if (B) {
+      uint64_t Plt = Out<ELFT>::Plt->getEntryAddr(*B);
+      Target->writeGotPltEntry(Entry, Plt);
+    }
+  }
+}
+
+template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT::Is64Bits>(".got", llvm::ELF::SHT_PROGBITS,
                                         llvm::ELF::SHF_ALLOC |
                                             llvm::ELF::SHF_WRITE) {
   this->Header.sh_addralign = this->getAddrSize();
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
PltSection<ELFT>::PltSection()
     : OutputSectionBase<ELFT::Is64Bits>(".plt", llvm::ELF::SHT_PROGBITS,
                                         llvm::ELF::SHF_ALLOC |
                                             llvm::ELF::SHF_EXECINSTR) {
   this->Header.sh_addralign = 16;
 }
 
 template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
   uint8_t *Start = Buf;
+
+  // first write PLT[0] entry which is special
+  Target->writePltBaseEntry(Buf, Out<ELFT>::GotPlt->getVA(), this->getVA());
+  Buf += Target->getPltBaseSize();
+
   for (const SymbolBody *E : Entries) {
-    uint64_t Got = Out<ELFT>::Got->getEntryAddr(*E);
+    uint64_t Got = Out<ELFT>::GotPlt->getEntryAddr(*E);
     uint64_t Plt = Buf - Start + this->getVA();
-    Target->writePltEntry(Buf, Got, Plt);
+    Target->writePltEntry(Buf, Got, Plt, E->PltIndex);
     Buf += Target->getPltEntrySize();
   }
 }
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->PltIndex = Entries.size();
   Entries.push_back(Sym);
 }
 
 template <class ELFT>
 typename PltSection<ELFT>::uintX_t
 PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
-  return this->getVA() + B.PltIndex * Target->getPltEntrySize();
+  return this->getVA() + Target->getPltBaseSize() +
+         B.PltIndex * Target->getPltEntrySize();
 }
 
 template <class ELFT>
 void PltSection<ELFT>::finalize() {
-  this->Header.sh_size = Entries.size() * Target->getPltEntrySize();
+  this->Header.sh_size =
+      Target->getPltBaseSize() + Entries.size() * Target->getPltEntrySize();
 }
 
 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);
for (const DynamicReloc<ELFT> &Rel : Relocs) {
     const ObjectFile<ELFT> &File = *C.getFile();
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     const ELFFile<ELFT> &Obj = File.getObj();
     if (Body)
       Body = Body->repl();
 
     uint32_t Type = RI.getType(IsMips64EL);
 
     bool CanBePreempted = canBePreempted(Body);
     uintX_t Addend = 0;
     if (!CanBePreempted) {
       if (IsRela) {
         if (Body)
           Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
         else
           Addend += getLocalSymVA(
               Obj.getRelocationSymbol(&RI, File.getSymbolTable()), File);
       }
       P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
     }
 
     if (Body && Target->relocNeedsGot(Type, *Body)) {
+      bool NeedsPlt = Target->relocNeedsPlt(Type, *Body);
+      if (NeedsPlt)
+        P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
+      else
         P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(),
-                            Target->getGotReloc(), IsMips64EL);
+                            NeedsPlt ? Target->getPltReloc()
+                                     : Target->getGotReloc(),
+                            IsMips64EL);
     } else {
       if (IsRela)
         Addend += static_cast<const Elf_Rela &>(RI).r_addend;
       P->r_offset = RI.r_offset + C.getOutputSectionOff() + OutSec->getVA();
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
                             IsMips64EL);
     }
 
     if (IsRela)
       static_cast<Elf_Rela *>(P)->r_addend = Addend;
   }
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Out<ELFT>::DynSymTab->getSectionIndex();
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
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())
 

 template void OutputSectionBase<true>::writeHeaderTo<support::big>(
     ELFFile<ELFType<support::big, true>>::Elf_Shdr *SHdr);
 
 template class GotSection<ELF32LE>;
 template class GotSection<ELF32BE>;
 template class GotSection<ELF64LE>;
 template class GotSection<ELF64BE>;
 
+template class GotPltSection<ELF32LE>;
+template class GotPltSection<ELF32BE>;
+template class GotPltSection<ELF64LE>;
+template class GotPltSection<ELF64BE>;
+
 template class PltSection<ELF32LE>;
 template class PltSection<ELF32BE>;
 template class PltSection<ELF64LE>;
 template class PltSection<ELF64BE>;
 
 template class RelocationSection<ELF32LE>;
 template class RelocationSection<ELF32BE>;
 template class RelocationSection<ELF64LE>;

ELF/Target.h

 
 class TargetInfo {
 public:
   llvm::StringRef getDefaultEntry() const { return DefaultEntry; }
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const { return VAStart; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
+  unsigned getPltReloc() const { return PltReloc; }
   unsigned getGotRefReloc() const { return GotRefReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
+  unsigned getPltBaseSize() const { return PltBaseSize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
-  virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
+  virtual void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                               uint64_t PltEntryAddr) const = 0;
+  virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                             uint64_t PltEntryAddr, int32_t Index) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocPointsToGot(uint32_t Type) const;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                            uint64_t BaseAddr, uint64_t SymVA) const = 0;
 
   virtual ~TargetInfo();
 
 protected:
   unsigned PageSize = 4096;
   uint64_t VAStart;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
+  unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
+  unsigned PltBaseSize = 16;
   llvm::StringRef DefaultEntry = "_start";
 };
 
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocPointsToGot(uint32_t Type) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 class PPCTargetInfo final : public TargetInfo {
 public:
   PPCTargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 class ARMTargetInfo final : public TargetInfo {
 public:
   ARMTargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                       uint64_t PltEntryAddr) const override;
+  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                    uint64_t BaseAddr, uint64_t SymVA) const override;
 };
 
 extern std::unique_ptr<TargetInfo> Target;
 }
 }
 
 #endif

ELF/Target.cpp

 bool TargetInfo::relocPointsToGot(uint32_t Type) const { return false; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
 X86TargetInfo::X86TargetInfo() {
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   GotRefReloc = R_386_GOT32;
+  PltReloc = R_386_JUMP_SLOT;
   VAStart = 0x10000;
 }
 
+void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+
+void X86TargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                      uint64_t PltEntryAddr) const {};
+
 void X86TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                  uint64_t PltEntryAddr) const {
+                                  uint64_t PltEntryAddr, int32_t Index) const {
   // jmpl *val; nop; nop
   const uint8_t Inst[] = {0xff, 0x25, 0, 0, 0, 0, 0x90, 0x90};
   memcpy(Buf, Inst, sizeof(Inst));
   assert(isUInt<32>(GotEntryAddr));
   write32le(Buf + 2, GotEntryAddr);
 }
 
 bool X86TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return Type == R_386_GOT32 || relocNeedsPlt(Type, S);
 }
 
 bool X86TargetInfo::relocPointsToGot(uint32_t Type) const {
   return Type == R_386_GOTPC;
default:
     break;
   }
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   PCRelReloc = R_X86_64_PC32;
   GotReloc = R_X86_64_GLOB_DAT;
   GotRefReloc = R_X86_64_PC32;
+  PltReloc = R_X86_64_JUMP_SLOT;
   RelativeReloc = R_X86_64_RELATIVE;
+  PltEntrySize = 16;
 
   // On freebsd x86_64 the first page cannot be mmaped.
   // On linux that is controled by vm.mmap_min_addr. At least on some x86_64
   // installs that is 65536, so the first 15 pages cannot be used.
   // Given that, the smallest value that can be used in here is 0x10000.
   // If using 2MB pages, the smallest page aligned address that works is
   // 0x200000, but it looks like every OS uses 4k pages for executables.
   VAStart = 0x10000;
 }
 
-void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+void X86_64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
+  // Skip 6 bytes of "jmpq *got(%rip)"
+  write32le(Buf, Plt + 6);
+}
+
+void X86_64TargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                       uint64_t PltEntryAddr) const {
-  // jmpq *val(%rip); nop; nop
-  const uint8_t Inst[] = {0xff, 0x25, 0, 0, 0, 0, 0x90, 0x90};
+  const uint8_t PltData[] = {
+      0xff, 0x35, 0x00, 0x00, 0x00, 0x00, // pushq GOT+8(%rip)
+      0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp *GOT+16(%rip)
+      0x0f, 0x1f, 0x40, 0x00              // nopl 0x0(rax)
+  };
+  memcpy(Buf, PltData, sizeof(PltData));
+
+  uint64_t NextPC = PltEntryAddr + 6;
+  int64_t Delta = GotEntryAddr - NextPC + 8; //GOT + 8
+  assert(isInt<32>(Delta));
+  write32le(Buf + 2, Delta);
+  Buf += 6;
+
+  NextPC += 6;
+  Delta = GotEntryAddr - NextPC + 16; //GOT + 16
+  write32le(Buf + 2, Delta);
+  Buf += 6;
+}
+
+void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                     uint64_t PltEntryAddr, int32_t Index) const {
+  const uint8_t Inst[] = {
+      0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmpq *got(%rip)
+      0x68, 0x00, 0x00, 0x00, 0x00,       // pushq reloc-index
+      0xe9, 0x00, 0x00, 0x00, 0x00        // jmpq plt[0]
+  };
   memcpy(Buf, Inst, sizeof(Inst));
 
   uint64_t NextPC = PltEntryAddr + 6;
   int64_t Delta = GotEntryAddr - NextPC;
   assert(isInt<32>(Delta));
   write32le(Buf + 2, Delta);
+  Buf += 6;
+
+  NextPC += 5;
+  write32le(Buf + 1, Index);
+  Buf += 5;
+
+  NextPC += 5;
+  Delta = PltEntryAddr - Index * PltEntrySize - PltBaseSize - NextPC;
+  assert(isInt<32>(Delta));
+  write32le(Buf + 1, Delta);
 }
 
 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);
 }
 
 bool X86_64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
default:
     error(Twine("unrecognized reloc ") + Twine(Type));
     break;
   }
 }
 
 PPC64TargetInfo::PPC64TargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   PltEntrySize = 32;
   PageSize = 65536;
   VAStart = 0x10000000;
 }
+
+void PPC64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void PPC64TargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                       uint64_t PltEntryAddr) const {};
 void PPC64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                    uint64_t PltEntryAddr) const {}
+                                    uint64_t PltEntryAddr, int32_t Index) const {}
 bool PPC64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 bool PPC64TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 void PPC64TargetInfo::relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                                   uint64_t BaseAddr, uint64_t SymVA) const {
default:
     error(Twine("unrecognized reloc ") + Twine(Type));
     break;
   }
 }
 
 PPCTargetInfo::PPCTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   PageSize = 65536;
   VAStart = 0x10000000;
 }
+
+void PPCTargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void PPCTargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                      uint64_t PltEntryAddr) const {};
 void PPCTargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                  uint64_t PltEntryAddr) const {}
+                                  uint64_t PltEntryAddr, int32_t Index) const {}
 bool PPCTargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 bool PPCTargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 void PPCTargetInfo::relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                                 uint64_t BaseAddr, uint64_t SymVA) const {}
 
 ARMTargetInfo::ARMTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   VAStart = 0x8000;
 }
+
+void ARMTargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void ARMTargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                      uint64_t PltEntryAddr) const {};
 void ARMTargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                  uint64_t PltEntryAddr) const {}
+                                  uint64_t PltEntryAddr, int32_t Index) const {}
 bool ARMTargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 bool ARMTargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 void ARMTargetInfo::relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                                 uint64_t BaseAddr, uint64_t SymVA) const {}
 
 AArch64TargetInfo::AArch64TargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   VAStart = 0x400000;
 }
+
+void AArch64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void AArch64TargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                          uint64_t PltEntryAddr) const {};
 void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                      uint64_t PltEntryAddr) const {}
+                                      uint64_t PltEntryAddr,
+                                      int32_t Index) const {}
 bool AArch64TargetInfo::relocNeedsGot(uint32_t Type,
                                       const SymbolBody &S) const {
   return false;
 }
 bool AArch64TargetInfo::relocNeedsPlt(uint32_t Type,
                                       const SymbolBody &S) const {
   return false;
 }
default:
     error(Twine("unrecognized reloc ") + Twine(Type));
     break;
   }
 }
 
 MipsTargetInfo::MipsTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   DefaultEntry = "__start";
   PageSize = 65536;
   VAStart = 0x400000;
 }
 
-void MipsTargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+void MipsTargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+
+void MipsTargetInfo::writePltBaseEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                        uint64_t PltEntryAddr) const {}
 
+void MipsTargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                   uint64_t PltEntryAddr, int32_t Index) const {
+}
+
 bool MipsTargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
 bool MipsTargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
 void MipsTargetInfo::relocateOne(uint8_t *Buf, const void *RelP, uint32_t Type,
                                  uint64_t BaseAddr, uint64_t SymVA) const {}
 }
 }

ELF/Writer.cpp

template <class ELFT> void lld::elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   StringTableSection<ELFT::Is64Bits> StrTab(false);
   Out<ELFT>::StrTab = &StrTab;
   StringTableSection<ELFT::Is64Bits> DynStrTab(true);
   Out<ELFT>::DynStrTab = &DynStrTab;
   OutputSection<ELFT> Bss(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
   Out<ELFT>::Bss = &Bss;
   GotSection<ELFT> Got;
   Out<ELFT>::Got = &Got;
+  GotPltSection<ELFT> GotPlt;
+  Out<ELFT>::GotPlt = &GotPlt;
   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();
 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
for (const RelType &RI : Rels) {
 
     if (Body)
       Body = Body->repl();
     if (Body) {
       if (Target->relocNeedsPlt(Type, *Body)) {
         if (Body->isInPlt())
           continue;
         Out<ELFT>::Plt->addEntry(Body);
-      }
-      if (Target->relocNeedsGot(Type, *Body)) {
+        Out<ELFT>::GotPlt->addEntry(Body);
+      } else if (Target->relocNeedsGot(Type, *Body)) {
         if (Body->isInGot())
           continue;
         Out<ELFT>::Got->addEntry(Body);
       }
     }
 
     bool CBP = canBePreempted(Body);
     if (!CBP && (!Config->Shared || Target->isRelRelative(Type)))
       continue;
     if (CBP)
       Body->setUsedInDynamicReloc();
-    Out<ELFT>::RelaDyn->addReloc({C, RI});
+    if (Body && Target->relocNeedsPlt(Type, *Body))
+      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();
 
template <class ELFT> void Writer<ELFT>::createSections() {
   OutputSections.push_back(Out<ELFT>::SymTab);
   if (needsDynamicSections()) {
     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>::GotPlt->empty())
+    OutputSections.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareOutputSections<ELFT>);
 
   // Always put StrTabSec last so that no section names are added to it after
   // it's finalized.

test/elf2/plt-i686.s

 // RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld2 -shared %t2.o -o %t2.so
 // RUN: ld.lld2 %t.o %t2.so -o %t
 // RUN: llvm-readobj -s -r %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 // REQUIRES: x86
 
 // CHECK:      Name: .plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x11010
 // CHECK-NEXT: Offset:
-// CHECK-NEXT: Size: 16
+// CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rel.dyn {
-// CHECK-NEXT:     0x12050 R_386_GLOB_DAT bar 0x0
-// CHECK-NEXT:     0x12054 R_386_GLOB_DAT zed 0x0
+// CHECK-NEXT:   Section ({{.*}}) .rel.plt {
+// CHECK-NEXT:     0x12064 R_386_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x12068 R_386_JUMP_SLOT zed 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
-// 0x11010 - (0x11000 + 1) - 4 = 11
-// 0x11010 - (0x11005 + 1) - 4 = 2
-// 0x11018 - (0x1100a + 1) - 4 = 9
+// 16 is the size of PLT[0]
+// (0x11010 + 16) - (0x11000 + 1) - 4 = 11
+// (0x11010 + 16) - (0x11005 + 1) - 4 = 22
+// (0x11018 + 16) - (0x1100a + 1) - 4 = 25
 
 // DISASM:      _start:
-// DISASM-NEXT:   11000:  e9 0b 00 00 00  jmp  11
-// DISASM-NEXT:   11005:  e9 06 00 00 00  jmp  6
-// DISASM-NEXT:   1100a:  e9 09 00 00 00  jmp  9
+// DISASM-NEXT:   11000:  e9 1b 00 00 00  jmp  27
+// DISASM-NEXT:   11005:  e9 16 00 00 00  jmp  22
+// DISASM-NEXT:   1100a:  e9 19 00 00 00  jmp  25
 
-// 0x12050 = 73808
-// 0x12054 = 73812
+// 0x12064 = 73828
+// 0x12068 = 73832
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   11010:  ff 25 {{.*}}       jmpl *73808
-// DISASM-NEXT:   11016:  90                 nop
-// DISASM-NEXT:   11017:  90                 nop
-// DISASM-NEXT:   11018:  ff 25 {{.*}}       jmpl *73812
-// DISASM-NEXT:   1101e:  90                 nop
-// DISASM-NEXT:   1101f:  90                 nop
+// DISASM-NEXT:   11010:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11012:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11014:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11016:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11018:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   1101a:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   1101c:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   1101e:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11020:  ff 25 64 20 01 00 jmpl *73828
+// DISASM-NEXT:   11026:  90  nop
+// DISASM-NEXT:   11027:  90  nop
+// DISASM-NEXT:   11028:  ff 25 68 20 01 00 jmpl *73832
+// DISASM-NEXT:   1102e:  90  nop
+// DISASM-NEXT:   1102f:  90  nop
    
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT

test/elf2/plt.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
 // RUN: ld.lld2 -shared %t2.o -o %t2.so
 // RUN: ld.lld2 -shared %t.o %t2.so -o %t
 // RUN: llvm-readobj -s -r %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 // REQUIRES: x86
 
 // CHECK:      Name: .plt
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x1020
 // CHECK-NEXT: Offset:
-// CHECK-NEXT: Size: 24
+// CHECK-NEXT: Size: 64
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
 // CHECK:      Relocations [
-// CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x20A0 R_X86_64_GLOB_DAT bar 0x0
-// CHECK-NEXT:     0x20A8 R_X86_64_GLOB_DAT zed 0x0
-// CHECK-NEXT:     0x20B0 R_X86_64_GLOB_DAT _start 0x0
+// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:     0x20C8 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK-NEXT:     0x20D0 R_X86_64_JUMP_SLOT zed 0x0
+// CHECK-NEXT:     0x20D8 R_X86_64_JUMP_SLOT _start 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
-// 0x11020 - (0x11000 + 1) - 4 = 27
-// 0x11020 - (0x11005 + 1) - 4 = 22
-// 0x11028 - (0x1100a + 1) - 4 = 25
+// 0x1030 - (0x1000 + 5) = 43
+// 0x1030 - (0x1005 + 5) = 38
+// 0x1040 - (0x100a + 5) = 49
 
 // DISASM:      _start:
-// DISASM-NEXT:   1000:  e9 {{.*}}       jmp  27
-// DISASM-NEXT:   1005:  e9 {{.*}}       jmp  22
-// DISASM-NEXT:   100a:  e9 {{.*}}       jmp  25
+// DISASM-NEXT:   1000:  e9 {{.*}}       jmp  43
+// DISASM-NEXT:   1005:  e9 {{.*}}       jmp  38
+// DISASM-NEXT:   100a:  e9 {{.*}}       jmp  49
 
-// 0x120A0 - 0x11026  = 4218
-// 0x120A8 - 0x1102e  = 4218
+// 0x20C8 - 0x1036  = 4242
+// 0x20D0 - 0x1046  = 4234
 
 // DISASM:      Disassembly of section .plt:
 // DISASM-NEXT: .plt:
-// DISASM-NEXT:   1020:  ff 25 {{.*}}       jmpq *4218(%rip)
-// DISASM-NEXT:   1026:  90                 nop
-// DISASM-NEXT:   1027:  90                 nop
-// DISASM-NEXT:   1028:  ff 25 {{.*}}       jmpq *4218(%rip)
-// DISASM-NEXT:   102e:  90                 nop
-// DISASM-NEXT:   102f:  90                 nop
+// DISASM-NEXT:   1020:  ff 35 92 10 00 00  pushq 4242(%rip)
+// DISASM-NEXT:   1026:  ff 25 94 10 00 00  jmpq *4244(%rip)
+// DISASM-NEXT:   102c:  0f 1f 40 00        nopl (%rax)
+// DISASM-NEXT:   1030:  ff 25 92 10 00 00  jmpq *4242(%rip)
+// DISASM-NEXT:   1036:  68 00 00 00 00     pushq $0
+// DISASM-NEXT:   103b:  e9 e0 ff ff ff     jmp -32 <bar+1020>
+// DISASM-NEXT:   1040:  ff 25 8a 10 00 00  jmpq *4234(%rip)
+// DISASM-NEXT:   1046:  68 01 00 00 00     pushq $1
+// DISASM-NEXT:   104b:  e9 d0 ff ff ff     jmp -48 <bar+1020>
+// DISASM-NEXT:   1050:  ff 25 82 10 00 00  jmpq *4226(%rip)
+// DISASM-NEXT:   1056:  68 02 00 00 00     pushq $2
+// DISASM-NEXT:   105b:  e9 c0 ff ff ff     jmp -64 <bar+1020>
+  
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

test/elf2/relocation-i686.s

 // ADDR:      Name: .plt
 // ADDR-NEXT: Type: SHT_PROGBITS
 // ADDR-NEXT: Flags [
 // ADDR-NEXT:   SHF_ALLOC
 // ADDR-NEXT:   SHF_EXECINSTR
 // ADDR-NEXT: ]
 // ADDR-NEXT: Address: 0x11030
 // ADDR-NEXT: Offset: 0x1030
-// ADDR-NEXT: Size: 8
+// ADDR-NEXT: Size: 24
 
 // ADDR:      Name: .got
 // ADDR-NEXT: Type: SHT_PROGBITS
 // ADDR-NEXT: Flags [
 // ADDR-NEXT:   SHF_ALLOC
 // ADDR-NEXT:   SHF_WRITE
 // ADDR-NEXT: ]
-// ADDR-NEXT: Address: 0x12050
+// ADDR-NEXT: Address: 0x12070
 
 .section .R_386_GOTPC,"ax",@progbits
 R_386_GOTPC:
  movl $_GLOBAL_OFFSET_TABLE_, %eax
 
-// 0x12050 - 0x11014 = 4156
+// 0x12070 - 0x11014 = 4188
 
 // CHECK:      Disassembly of section .R_386_GOTPC:
 // CHECK-NEXT: R_386_GOTPC:
-// CHECK-NEXT:   11014:  {{.*}} movl  $4156, %eax
+// CHECK-NEXT:   11014:  {{.*}} movl  $4188, %eax
 
 .section .dynamic_reloc, "ax",@progbits
  call bar
-// 0x11030 - (0x11019 + 5) = 18
+// (0x11030 + 16) - (0x11019 + 5) = 34
 // CHECK:      Disassembly of section .dynamic_reloc:
 // CHECK-NEXT: .dynamic_reloc:
-// CHECK-NEXT:   11019:  e8 12 00 00 00 calll 18
+// CHECK-NEXT:   11019:  e8 22 00 00 00 calll 34
 
 .section .R_386_GOT32,"ax",@progbits
 .global R_386_GOT32
 R_386_GOT32:
         movl zed@GOT, %eax
 // This is the second symbol in the got, so the offset is 4.
 // CHECK:      Disassembly of section .R_386_GOT32:
 // CHECK-NEXT: R_386_GOT32:
 // CHECK-NEXT:   1101e:  {{.*}} movl 4, %eax

test/elf2/relocation.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/shared.s -o %t2
 // RUN: ld.lld2 %t2 -o %t2.so -shared
 // RUN: ld.lld2 %t %t2.so -o %t3
 // RUN: llvm-readobj -s  %t3 | FileCheck --check-prefix=SEC %s
 // RUN: llvm-objdump -s -d %t3 | FileCheck %s
 // REQUIRES: x86
 
 // SEC:      Name: .plt
 // SEC-NEXT: Type: SHT_PROGBITS
 // SEC-NEXT: Flags [
 // SEC-NEXT:   SHF_ALLOC
 // SEC-NEXT:   SHF_EXECINSTR
 // SEC-NEXT: ]
 // SEC-NEXT: Address: 0x11020
 // SEC-NEXT: Offset: 0x1020
-// SEC-NEXT: Size: 8
+// SEC-NEXT: Size: 32
 
-// SEC:         Name: .got
+// SEC:        Name: .got
 // SEC-NEXT:   Type: SHT_PROGBITS
 // SEC-NEXT:   Flags [
 // SEC-NEXT:     SHF_ALLOC
 // SEC-NEXT:     SHF_WRITE
 // SEC-NEXT:   ]
-// SEC-NEXT:   Address: 0x120A0
+// SEC-NEXT:   Address: 0x120E0
 // SEC-NEXT:   Offset:
-// SEC-NEXT:   Size: 16
+// SEC-NEXT:   Size: 8
+// SEC-NEXT:   Link: 0
+// SEC-NEXT:   Info: 0
+// SEC-NEXT:   AddressAlignment: 8
+// SEC-NEXT:   EntrySize: 0
+// SEC-NEXT: }
+
+// SEC:        Name: .got.plt 
+// SEC-NEXT:   Type: SHT_PROGBITS
+// SEC-NEXT:   Flags [
+// SEC-NEXT:     SHF_ALLOC
+// SEC-NEXT:     SHF_WRITE
+// SEC-NEXT:   ]
+// SEC-NEXT:   Address: 0x120E8
+// SEC-NEXT:   Offset: 0x20E8
+// SEC-NEXT:   Size: 32
 // SEC-NEXT:   Link: 0
 // SEC-NEXT:   Info: 0
 // SEC-NEXT:   AddressAlignment: 8
 // SEC-NEXT:   EntrySize: 0
-// SEC-NEXT: }
+// SEC-NEXT:   }
 
+
 .section       .text,"ax",@progbits,unique,1
 .global _start
 _start:
   call lulz
 
 .section       .text,"ax",@progbits,unique,2
 .zero 4
 .global lulz

 // CHECK: Disassembly of section .R_X86_64_32S:
 // CHECK-NEXT: R_X86_64_32S:
 // CHECK-NEXT:  {{.*}}: {{.*}} movq -978935, %rdx
 
 .section .R_X86_64_PC32,"ax",@progbits
 .global R_X86_64_PC32
 R_X86_64_PC32:
  call bar
-// 0x11020 - (0x11017 + 5) = 4
+// (0x11020 + 16) - (0x11017 + 5) = 20
+// 16 - is a size of PLT[0]
 // CHECK:      Disassembly of section .R_X86_64_PC32:
 // CHECK-NEXT: R_X86_64_PC32:
-// CHECK-NEXT:  11017:   e8 04 00 00 00  callq  4
+// CHECK-NEXT:  11017:   e8 14 00 00 00  callq  20
 
 .section .R_X86_64_64,"a",@progbits
 .global R_X86_64_64
 R_X86_64_64:
  .quad R_X86_64_64
 
 // CHECK:      Contents of section .R_X86_64_64:
 // CHECK-NEXT:   10158 58010100 00000000
 
 .section .R_X86_64_GOTPCREL,"a",@progbits
 .global R_X86_64_GOTPCREL
 R_X86_64_GOTPCREL:
  .long zed@gotpcrel
 
-// 0x120A8 - 0x10160 = 8008
-// 8008 = 0x481f0000   in little endian
+// 0x120E0 - 0x10160 = 8064
+// 8064 = 0x801f0000   in little endian
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   10160 481f0000
+// CHECK-NEXT:   10160 801f0000