[ELF2] - Lazy relocation support for x86_64.

[grimar]

Summary

So thats final variant of lazy relocation support.
In compare with previous attemp there are 2 major changes:

1. This one does not break self-hosting.
2. DSO calls are working. Everything what was needed was implemented (I believe).
3. Target has supportsLazyRelocations() method which can switch lazy relocs on/off (currently all targets are OFF except x64 which is ON). So no any other targets are affected now, but x64 now has lazy relocs and ability to turn it off !

[ruiu]

ELF/OutputSections.cpp

312

Remove comment

386

Ditto

ELF/OutputSections.h

113–114

Use ELFFile<ELFT>::uintX_t instead of Base.

ELF/Target.cpp

219–226

Setting true and immediately use that value in if looks very odd.

LazyRelocations = true;
PltEntrySize = 16;
PltZeroEntrySize = 16;

230–231

Always assume it's true.

238–240

Same

254

Ditto.

620

Please do not add this kind of TODO. We should rather remove all useless "= FIXME", but that should be done in other patch.

704

Ditto.

ELF/Writer.cpp

105

Global variables are initialized to nullptr, so

if (Target->supportsLazyRelocations())
  Out<ELFT>::GotPlt = &GotPlt;

118

Ditto.

195

Move the assignment out of this if.

200

Ditto.

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

312

Done.

386

Done.

ELF/OutputSections.h

113–114

Done.

ELF/Target.cpp

219–226

Done.

230–231

Done.

238–240

Done.

254

Done.

620

Removed.

704

Removed.

ELF/Writer.cpp

105

Done.

118

Done.

195

Done.

200

Done.

[ruiu]

LGTM with a nit. Let's give it a shot. Please verify that you can still self-host with this patch on x86-64 before submitting.

ELF/OutputSections.h

113

Now I think you can remove this line.

ELF/Target.cpp

704

Did you?

[grimar]

I`ll commit tomorrow. There are some amount of conflicts after svn update.

[grimar]

r250807 + this patch did not break self-hosting for me.

ELF/OutputSections.h

public:
   void addEntry(SymbolBody *Sym);
   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> {
+  typedef OutputSectionBase<ELFT> 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> {
   typedef OutputSectionBase<ELFT> 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> {
   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;
private:
   const ELFSymbolBody<ELFT> *FiniSym = nullptr;
 };
 
 // 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 GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
+  static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
+template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 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> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
 }
 }
 #endif

ELF/OutputSections.cpp

OutputSectionBase<ELFT>::OutputSectionBase(StringRef Name, uint32_t sh_type,
                                            uintX_t sh_flags)
     : Name(Name) {
   memset(&Header, 0, sizeof(Elf_Shdr));
   Header.sh_type = sh_type;
   Header.sh_flags = sh_flags;
 }
 
 template <class ELFT>
+GotPltSection<ELFT>::GotPltSection()
+    : OutputSectionBase<ELFT>(".got.plt", llvm::ELF::SHT_PROGBITS,
+                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
+  this->Header.sh_addralign = sizeof(uintX_t);
+  // .got.plt has 3 reserved entry
+  Entries.resize(3);
+}
+
+template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
+  Sym->GotPltIndex = 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.GotPltIndex * sizeof(uintX_t);
+}
+
+template <class ELFT> void GotPltSection<ELFT>::finalize() {
+  this->Header.sh_size = Entries.size() * sizeof(uintX_t);
+}
+
+template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
+  write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Buf, Out<ELFT>::Dynamic->getVA());
+  for (const SymbolBody *B : Entries) {
+    if (B)
+      Target->writeGotPltEntry(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
+    Buf += sizeof(uintX_t);
+  }
+}
+
+template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT>(".got", llvm::ELF::SHT_PROGBITS,
                               llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotIndex = Entries.size();

 PltSection<ELFT>::PltSection()
     : OutputSectionBase<ELFT>(".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) {
   size_t Off = 0;
+  bool LazyReloc = Target->supportsLazyRelocations();
+  if (LazyReloc) {
+    // First write PLT[0] entry which is special.
+    Target->writePltZeroEntry(Buf, Out<ELFT>::GotPlt->getVA(), this->getVA());
+    Off += Target->getPltZeroEntrySize();
+  }
   for (const SymbolBody *E : Entries) {
-    uint64_t Got = Out<ELFT>::Got->getEntryAddr(*E);
+    uint64_t Got = LazyReloc ? Out<ELFT>::GotPlt->getEntryAddr(*E)
+                             : Out<ELFT>::Got->getEntryAddr(*E);
     uint64_t Plt = this->getVA() + Off;
-    Target->writePltEntry(Buf + Off, Got, Plt);
+    Target->writePltEntry(Buf + Off, Got, Plt, E->PltIndex);
     Off += 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->getPltZeroEntrySize() +
+         B.PltIndex * Target->getPltEntrySize();
 }
 
-template <class ELFT>
-void PltSection<ELFT>::finalize() {
-  this->Header.sh_size = Entries.size() * Target->getPltEntrySize();
+template <class ELFT> void PltSection<ELFT>::finalize() {
+  this->Header.sh_size = Target->getPltZeroEntrySize() +
+                         Entries.size() * Target->getPltEntrySize();
 }
 
 template <class ELFT>
-RelocationSection<ELFT>::RelocationSection(bool IsRela)
-    : OutputSectionBase<ELFT>(IsRela ? ".rela.dyn" : ".rel.dyn",
+RelocationSection<ELFT>::RelocationSection(StringRef Name, bool IsRela)
+    : OutputSectionBase<ELFT>(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) {
if (!CanBePreempted) {
           Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
         else
           Addend += getLocalRelTarget(File, RI);
       }
       P->setSymbolAndType(0, Target->getRelativeReloc(), Config->Mips64EL);
     }
 
     if (NeedsGot) {
+      // 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.
+      bool LazyReloc = Body && Target->supportsLazyRelocations() &&
+                       Target->relocNeedsPlt(Type, *Body);
+      if (LazyReloc)
+        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(), Config->Mips64EL);
+                            LazyReloc ? Target->getPltReloc()
+                                      : Target->getGotReloc(),
+                            Config->Mips64EL);
     } else {
       if (IsRela)
         Addend += static_cast<const Elf_Rela &>(RI).r_addend;
       P->r_offset = RI.r_offset + C.OutSec->getVA() + C.OutSecOff;
       if (CanBePreempted)
         P->setSymbolAndType(Body->getDynamicSymbolTableIndex(), Type,
                             Config->Mips64EL);
     }
template <class ELFT> void DynamicSection<ELFT>::finalize() {
   Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
 
   unsigned NumEntries = 0;
   if (Out<ELFT>::RelaDyn->hasRelocs()) {
     ++NumEntries; // DT_RELA / DT_REL
     ++NumEntries; // DT_RELASZ / DT_RELSZ
     ++NumEntries; // DT_RELAENT / DT_RELENT
   }
+  // RelaPlt can be missing if target does not supports lazy relocations.
+  if (Out<ELFT>::RelaPlt && 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));
   }
+  // RelaPlt can be missing if target does not supports lazy relocations.
+  if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
+    WritePtr(DT_JMPREL, Out<ELFT>::RelaPlt->getVA());
+    WriteVal(DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize());
+    WritePtr(DT_PLTGOT, Out<ELFT>::GotPlt->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())

 
 namespace lld {
 namespace elf2 {
 template class OutputSectionBase<ELF32LE>;
 template class OutputSectionBase<ELF32BE>;
 template class OutputSectionBase<ELF64LE>;
 template class OutputSectionBase<ELF64BE>;
 
+template class GotPltSection<ELF32LE>;
+template class GotPltSection<ELF32BE>;
+template class GotPltSection<ELF64LE>;
+template class GotPltSection<ELF64BE>;
+
 template class GotSection<ELF32LE>;
 template class GotSection<ELF32BE>;
 template class GotSection<ELF64LE>;
 template class GotSection<ELF64BE>;
 
 template class PltSection<ELF32LE>;
 template class PltSection<ELF32BE>;
 template class PltSection<ELF64LE>;

ELF/Symbols.h

public:
   }
 
   unsigned getDynamicSymbolTableIndex() const {
     return DynamicSymbolTableIndex;
   }
   void setDynamicSymbolTableIndex(unsigned V) { DynamicSymbolTableIndex = V; }
 
   uint32_t GotIndex = -1;
+  uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   bool isInGot() const { return GotIndex != -1U; }
+  bool isInGotPlt() const { return GotPltIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
 
   // A SymbolBody has a backreference to a Symbol. Originally they are
   // doubly-linked. A backreference will never change. But the pointer
   // in the Symbol may be mutated by the resolver. If you have a
   // pointer P to a SymbolBody and are not sure whether the resolver
   // has chosen the object among other objects having the same name,
   // you can access P->Backref->Body to get the resolver's result.

ELF/Target.h

 class SymbolBody;
 
 class TargetInfo {
 public:
   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 getPltZeroEntrySize() const { return PltZeroEntrySize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
+  bool supportsLazyRelocations() const { return LazyRelocations; }
   virtual unsigned getPLTRefReloc(unsigned Type) const;
-  virtual void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  virtual void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const = 0;
+  virtual void writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                            uint32_t Type, uint64_t BaseAddr,
                            uint64_t SymVA) const = 0;
 
   virtual ~TargetInfo();
 
 protected:
   unsigned PageSize = 4096;
 
   // 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.
   uint64_t VAStart = 0x10000;
 
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
+  unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
+  unsigned PltZeroEntrySize = 0;
+  bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();
 
 extern std::unique_ptr<TargetInfo> Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

ELF/Target.cpp

 template <bool IsLE> static void add32(uint8_t *L, int32_t V);
 template <> void add32<true>(uint8_t *L, int32_t V) { add32le(L, V); }
 template <> void add32<false>(uint8_t *L, int32_t V) { add32be(L, V); }
 
 namespace {
 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 writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                    uint32_t Type, uint64_t BaseAddr,
                    uint64_t SA) const override;
 };
 
 class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
   unsigned getPLTRefReloc(unsigned Type) const override;
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+  void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
+  void writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                    uint32_t Type, uint64_t BaseAddr,
                    uint64_t SA) 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 writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                    uint32_t Type, uint64_t BaseAddr,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) 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 writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                    uint32_t Type, uint64_t BaseAddr,
                    uint64_t SA) const override;
 };
 
 template <class ELFT> 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 writePltZeroEntry(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, uint8_t *BufEnd, const void *RelP,
                    uint32_t Type, uint64_t BaseAddr,
                    uint64_t SA) const override;
 };
 } // anonymous namespace
 

 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;
 }
 
+void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void X86TargetInfo::writePltZeroEntry(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 {
default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 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;
+  LazyRelocations = true;
+  if (LazyRelocations) {
+    PltEntrySize = 16;
+    PltZeroEntrySize = 16;
+  } else {
+    PltEntrySize = 8;
+    PltZeroEntrySize = 0;
+  }
 }
 
-void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+void X86_64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
+  if (!LazyRelocations)
+    return;
+  // Skip 6 bytes of "jmpq *got(%rip)"
+  write32le(Buf, Plt + 6);
+}
+
+void X86_64TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                          uint64_t PltEntryAddr) const {
+  if (!LazyRelocations)
+    return;
+
+  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));
+  write32le(Buf + 2, GotEntryAddr - PltEntryAddr + 2); // GOT+8
+  write32le(Buf + 8, GotEntryAddr - PltEntryAddr + 4); // GOT+16
+}
+
+void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                     uint64_t PltEntryAddr,
+                                     int32_t Index) const {
+  if (LazyRelocations) {
+    const uint8_t Inst[] = {
+        0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmpq *got(%rip)
+        0x68, 0x00, 0x00, 0x00, 0x00,       // pushq <relocation index>
+        0xe9, 0x00, 0x00, 0x00, 0x00        // jmpq plt[0]
+    };
+    memcpy(Buf, Inst, sizeof(Inst));
+
+    write32le(Buf + 2, GotEntryAddr - PltEntryAddr - 6);
+    write32le(Buf + 7, Index);
+    write32le(Buf + 12, -Index * PltEntrySize - PltZeroEntrySize - 16);
+  } else {
     // jmpq *val(%rip); nop; nop
     const uint8_t Inst[] = {0xff, 0x25, 0, 0, 0, 0, 0x90, 0x90};
     memcpy(Buf, Inst, sizeof(Inst));
 
     uint64_t NextPC = PltEntryAddr + 6;
     int64_t Delta = GotEntryAddr - NextPC;
     assert(isInt<32>(Delta));
     write32le(Buf + 2, Delta);
   }
+}
 
 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   return Type == R_X86_64_GOTPCREL || relocNeedsPlt(Type, S);
 }
 
 unsigned X86_64TargetInfo::getPLTRefReloc(unsigned Type) const {
   switch (Type) {
   case R_X86_64_32:

 
 static uint16_t applyPPCHighesta(uint64_t V) { return (V + 0x8000) >> 48; }
 
 PPC64TargetInfo::PPC64TargetInfo() {
   PCRelReloc = R_PPC64_REL24;
   GotReloc = R_PPC64_GLOB_DAT;
   GotRefReloc = R_PPC64_REL64;
   RelativeReloc = R_PPC64_RELATIVE;
+  // PltReloc = FIXME
   PltEntrySize = 32;
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   PageSize = 65536;
 
   // The PPC64 ELF ABI v1 spec, says:
   //
uint64_t getPPC64TocBase() {
 
   // Per the ppc64-elf-linux ABI, The TOC base is TOC value plus 0x8000
   // thus permitting a full 64 Kbytes segment. Note that the glibc startup
   // code (crt1.o) assumes that you can get from the TOC base to the
   // start of the .toc section with only a single (signed) 16-bit relocation.
   return TocVA + 0x8000;
 }
 
+void PPC64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void PPC64TargetInfo::writePltZeroEntry(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 {
   uint64_t Off = GotEntryAddr - getPPC64TocBase();
 
   // FIXME: What we should do, in theory, is get the offset of the function
   // descriptor in the .opd section, and use that as the offset from %r2 (the
   // TOC-base pointer). Instead, we have the GOT-entry offset, and that will
   // be a pointer to the function descriptor in the .opd section. Using
   // this scheme is simpler, but requires an extra indirection per PLT dispatch.
 
void PPC64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 AArch64TargetInfo::AArch64TargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
 }
-void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+
+void AArch64TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void AArch64TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                           uint64_t PltEntryAddr) const {}
+void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                      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;
 }
void AArch64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   PageSize = 65536;
 }
 
 template <class ELFT>
-void MipsTargetInfo<ELFT>::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                         uint64_t PltEntryAddr) const {}
+void MipsTargetInfo<ELFT>::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+template <class ELFT>
+void MipsTargetInfo<ELFT>::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+template <class ELFT>
+void MipsTargetInfo<ELFT>::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+                                         uint64_t PltEntryAddr, int32_t Index) const {}
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::relocNeedsGot(uint32_t Type,
                                          const SymbolBody &S) const {
   return false;
 }
 
 template <class ELFT>

ELF/Writer.cpp

template <class ELFT> void lld::elf2::writeResult(SymbolTable<ELFT> *Symtab) {
   StringTableSection<ELFT> StrTab(false);
   Out<ELFT>::StrTab = &StrTab;
   StringTableSection<ELFT> 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 = Target->supportsLazyRelocations() ? &GotPlt : nullptr;
   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 = Target->supportsLazyRelocations() ? &RelaPlt : nullptr;
   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) {
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
     bool NeedsGot = false;
+    bool NeedsPlt = false;
     if (Body) {
-      if (Target->relocNeedsPlt(Type, *Body)) {
+      if ((NeedsPlt = Target->relocNeedsPlt(Type, *Body))) {
         if (Body->isInPlt())
           continue;
         Out<ELFT>::Plt->addEntry(Body);
       }
-      NeedsGot = Target->relocNeedsGot(Type, *Body);
-      if (NeedsGot) {
+      if ((NeedsGot = Target->relocNeedsGot(Type, *Body))) {
+        if (NeedsPlt && Target->supportsLazyRelocations()) {
+          Out<ELFT>::GotPlt->addEntry(Body);
+        } else {
           if (Body->isInGot())
             continue;
           Out<ELFT>::Got->addEntry(Body);
         }
       }
+    }
 
     bool CBP = canBePreempted(Body, NeedsGot);
     if (!CBP && (!Config->Shared || Target->isRelRelative(Type)))
       continue;
     if (CBP)
       Body->setUsedInDynamicReloc();
+    if (NeedsPlt && Target->supportsLazyRelocations())
+      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>::StrTab);
   if (isOutputDynamic()) {
     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 && 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 && !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>);
 
   for (unsigned I = 0, N = OutputSections.size(); I < N; ++I)
     OutputSections[I]->SectionIndex = I + 1;

test/elf2/dynamic-reloc-weak.s

 
 // Both gold and bfd ld will produce a relocation for sym1 and sym2 only. That
 // That seems odd.  If the dynamic linker must get a chance to resolve sym1
 // and sym2, that should also be the case for sym3.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
 // CHECK-NEXT:     0x{{.*}} R_X86_64_GLOB_DAT sym1 0x0
-// CHECK-NEXT:     0x{{.*}} R_X86_64_GLOB_DAT sym2 0x0
 // CHECK-NEXT:   }
-// CHECK-NEXT: ]
+// CHECK-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK-NEXT:     0x{{.*}} R_X86_64_JUMP_SLOT sym2 0x0
+// CHECK-NEXT:   }
+// CHECK-NEXT: ]
 No newline at end of file

test/elf2/plt.s

 // 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: ]
 
 // CHECK2:      Name: .plt
 // CHECK2-NEXT: Type: SHT_PROGBITS
 // CHECK2-NEXT: Flags [
 // CHECK2-NEXT:   SHF_ALLOC
 // CHECK2-NEXT:   SHF_EXECINSTR
 // CHECK2-NEXT: ]
 // CHECK2-NEXT: Address: 0x11020
 // CHECK2-NEXT: Offset:
-// CHECK2-NEXT: Size: 16
+// CHECK2-NEXT: Size: 48
 // CHECK2-NEXT: Link: 0
 // CHECK2-NEXT: Info: 0
 // CHECK2-NEXT: AddressAlignment: 16
 
 // CHECK2:      Relocations [
-// CHECK2-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK2-NEXT:     0x120A0 R_X86_64_GLOB_DAT bar 0x0
-// CHECK2-NEXT:     0x120A8 R_X86_64_GLOB_DAT zed 0x0
+// CHECK2-NEXT:   Section ({{.*}}) .rela.plt {
+// CHECK2-NEXT:     0x120C8 R_X86_64_JUMP_SLOT bar 0x0
+// CHECK2-NEXT:     0x120D0 R_X86_64_JUMP_SLOT zed 0x0
 // CHECK2-NEXT:   }
 // CHECK2-NEXT: ]
 
 // Unfortunately FileCheck can't do math, so we have to check for explicit
 // values:
 
-// 0x1020 - (0x1000 + 1) - 4 = 27
-// 0x1020 - (0x1005 + 1) - 4 = 22
-// 0x1028 - (0x100a + 1) - 4 = 25
-// 0x1030 - (0x100f + 1) - 4 = 28
+// 0x1030 - (0x1000 + 5) = 43
+// 0x1030 - (0x1005 + 5) = 38
+// 0x1040 - (0x100a + 5) = 49
+// 0x1048 - (0x100a + 5) = 60
 
 // DISASM:      _start:
-// DISASM-NEXT:   1000:  e9 {{.*}}       jmp  27
-// DISASM-NEXT:   1005:  e9 {{.*}}       jmp  22
-// DISASM-NEXT:   100a:  e9 {{.*}}       jmp  25
-// DISASM-NEXT:   100f:  e9 {{.*}}       jmp  28
-
-// 0x20A0 - 0x1026  = 4218
-// 0x20A8 - 0x102e  = 4218
-// 0x20B0 - 0x1036  = 4218
+// DISASM-NEXT:   1000:  e9 {{.*}}       jmp  43
+// DISASM-NEXT:   1005:  e9 {{.*}}       jmp  38
+// DISASM-NEXT:   100a:  e9 {{.*}}       jmp  49
+// DISASM-NEXT:   100f:  e9 {{.*}}       jmp  60
+
+// 0x20C8 - 0x1036  = 4242
+// 0x20D0 - 0x1046  = 4234
+// 0x20D8 - 0x1056  = 4226
 
 // 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:   1030:  ff 25 {{.*}}       jmpq *4218(%rip)
-// DISASM-NEXT:   1036:  90                 nop
-// DISASM-NEXT:   1037:  90                 nop
-
-// 0x11020 - (0x11000 + 1) - 4 = 27
-// 0x11020 - (0x11005 + 1) - 4 = 22
-// 0x11028 - (0x1100a + 1) - 4 = 25
+// 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>
+
+// 0x11030 - (0x11000 + 1) - 4 = 43
+// 0x11030 - (0x11005 + 1) - 4 = 38
+// 0x11040 - (0x1100a + 1) - 4 = 49
 // 0x11000 - (0x1100f + 1) - 4 = -20
 
 // DISASM2:      _start:
-// DISASM2-NEXT:   11000:  e9 {{.*}}     jmp  27
-// DISASM2-NEXT:   11005:  e9 {{.*}}     jmp  22
-// DISASM2-NEXT:   1100a:  e9 {{.*}}     jmp  25
+// DISASM2-NEXT:   11000:  e9 {{.*}}     jmp  43
+// DISASM2-NEXT:   11005:  e9 {{.*}}     jmp  38
+// DISASM2-NEXT:   1100a:  e9 {{.*}}     jmp  49
 // DISASM2-NEXT:   1100f:  e9 {{.*}}     jmp  -20
 
+// 0x120C8 - 0x11036  = 4242
+// 0x120D0 - 0x11046  = 4234
+
 // DISASM2:      Disassembly of section .plt:
 // DISASM2-NEXT: .plt:
-// DISASM2-NEXT:     11020:  ff 25 7a 10 00 00 jmpq *4218(%rip)
-// DISASM2-NEXT:     11026:  90                nop
-// DISASM2-NEXT:     11027:  90                nop
-// DISASM2-NEXT:     11028:  ff 25 7a 10 00 00 jmpq *4218(%rip)
-// DISASM2-NEXT:     1102e:  90                nop
-// DISASM2-NEXT:     1102f:  90                nop
+// DISASM2-NEXT:  11020:  ff 35 92 10 00 00   pushq 4242(%rip)
+// DISASM2-NEXT:  11026:  ff 25 94 10 00 00   jmpq *4244(%rip)
+// DISASM2-NEXT:  1102c:  0f 1f 40 00         nopl  (%rax)
+// DISASM2-NEXT:  11030:  ff 25 92 10 00 00   jmpq *4242(%rip)
+// DISASM2-NEXT:  11036:  68 00 00 00 00      pushq $0
+// DISASM2-NEXT:  1103b:  e9 e0 ff ff ff      jmp -32 <bar+11020>
+// DISASM2-NEXT:  11040:  ff 25 8a 10 00 00   jmpq *4234(%rip)
+// DISASM2-NEXT:  11046:  68 01 00 00 00      pushq $1
+// DISASM2-NEXT:  1104b:  e9 d0 ff ff ff      jmp -48 <bar+11020>
 // DISASM2-NEXT-NOT: 110C0
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT
   jmp _start@plt

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: 0x11030
 // SEC-NEXT: Offset: 0x1030
-// SEC-NEXT: Size: 8
+// SEC-NEXT: Size: 32
 
 // 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

 // 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
  movl $bar, %eax
-// 0x11030 - (0x11017 + 5) = 20
-// 0x11030 = 69680
+//16 is a size of PLT[0]
+// 0x11030 + 16 - (0x11017 + 5) = 20
 // CHECK:      Disassembly of section .R_X86_64_PC32:
 // CHECK-NEXT: R_X86_64_PC32:
-// CHECK-NEXT:  11017:   {{.*}}  callq  20
-// CHECK-NEXT:  1101c:   {{.*}}  movl $69680, %eax
+// CHECK-NEXT:  11017:   {{.*}}  callq  36
+// CHECK-NEXT:  1101c:   {{.*}}  movl $69696, %eax
 
 .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
 // CHECK:      Contents of section .R_X86_64_GOTPCREL
-// CHECK-NEXT:   10160 481f0000
+// CHECK-NEXT:   10160 801f0000