[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 ↗

(On Diff #37107)

Entries.resize(3);

65–70 ↗

(On Diff #37107)

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

115 ↗

(On Diff #37107)

Start with an uppercase character and end with a period.

116 ↗

(On Diff #37107)

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

174–208 ↗

(On Diff #37107)

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

762–766 ↗

(On Diff #37107)

Move this before template class GotSection<ELF32LE>;

ELF/OutputSections.h

305 ↗

(On Diff #37107)

Sort.

320 ↗

(On Diff #37107)

Sort.

ELF/Target.cpp

127–136 ↗

(On Diff #37107)

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

No assert() needed.

147–161 ↗

(On Diff #37107)

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 ↗

(On Diff #37107)

Done.

65–70 ↗

(On Diff #37107)

Done.

115 ↗

(On Diff #37107)

Done.

116 ↗

(On Diff #37107)

Changed to writePltZeroEntry. Also changed PltBaseSize to PltZeroEntrySize.

174–208 ↗

(On Diff #37107)

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

192 ↗

(On Diff #37107)

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 ↗

(On Diff #37107)

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 ↗

(On Diff #37107)

Done.

ELF/OutputSections.h

305 ↗

(On Diff #37107)

Done.

320 ↗

(On Diff #37107)

Done.

ELF/Target.cpp

127–136 ↗

(On Diff #37107)

Done.

147–161 ↗

(On Diff #37107)

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

[ruiu]

ELF/OutputSections.cpp

183 ↗

(On Diff #37243)

Please add this as a comment to this function.

ELF/Target.cpp

66 ↗

(On Diff #37243)

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

152 ↗

(On Diff #37243)

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 ↗

(On Diff #37252)

You want to use CHECK-NEXT instead of CHECK.

lld/trunk/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;
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::Is64Bits> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSection<ELFT> *Opd;
   static uint8_t *OpdBuf;
   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> 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::Is64Bits> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSection<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::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

lld/trunk/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.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 * 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) {
+    if (B)
+      Target->writeGotPltEntry(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
+    Buf += sizeof(uintX_t);
+  }
+}
+
+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) {
   size_t Off = 0;
+  // 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 = Out<ELFT>::GotPlt->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();
+  this->Header.sh_size =
+      Target->getPltZeroEntrySize() + 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);
if (!CanBePreempted) {
           Addend += getSymVA<ELFT>(cast<ELFSymbolBody<ELFT>>(*Body));
         else
           Addend += getLocalRelTarget(File, RI);
       }
       P->setSymbolAndType(0, Target->getRelativeReloc(), IsMips64EL);
     }
 
     if (Body && Target->relocNeedsGot(Type, *Body)) {
+      // 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 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);
     }
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<false>::writeHeaderTo<support::little>(
     ELFFile<ELFType<support::little, false>>::Elf_Shdr *SHdr);
 template void OutputSectionBase<true>::writeHeaderTo<support::little>(
     ELFFile<ELFType<support::little, true>>::Elf_Shdr *SHdr);
 template void OutputSectionBase<false>::writeHeaderTo<support::big>(
     ELFFile<ELFType<support::big, false>>::Elf_Shdr *SHdr);
 template void OutputSectionBase<true>::writeHeaderTo<support::big>(
     ELFFile<ELFType<support::big, true>>::Elf_Shdr *SHdr);
 
+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>;

lld/trunk/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.

lld/trunk/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; }
-  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;
   uint64_t VAStart;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
+  unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
+  unsigned PltZeroEntrySize = 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 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 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 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 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 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 SymVA) const override;
   bool isRelRelative(uint32_t Type) 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 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 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 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 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 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 SymVA) const override;
 };
 
 extern std::unique_ptr<TargetInfo> Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

lld/trunk/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;
+  PltEntrySize = 16;
   VAStart = 0x10000;
 }
 
-void X86TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
+void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
+  // Skip 6 bytes of "jmpq *got(%rip)"
+  write32le(Buf, Plt + 6);
+}
+
+void X86TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                       uint64_t PltEntryAddr) const {
-  // jmpl *val; 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)
+      0x00, 0x00, 0x00, 0x00
+  };
+  memcpy(Buf, PltData, sizeof(PltData));
+  write32le(Buf + 2, GotEntryAddr - PltEntryAddr + 2); // GOT+8
+  write32le(Buf + 8, GotEntryAddr - PltEntryAddr + 4); // GOT+16
+};
+
+void X86TargetInfo::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 <relocation index>
+      0xe9, 0x00, 0x00, 0x00, 0x00        // jmpq plt[0]
+  };
   memcpy(Buf, Inst, sizeof(Inst));
-  assert(isUInt<32>(GotEntryAddr));
-  write32le(Buf + 2, GotEntryAddr);
+
+  write32le(Buf + 2, GotEntryAddr - PltEntryAddr - 6);
+  write32le(Buf + 7, Index);
+  write32le(Buf + 12, -Index * PltEntrySize - PltZeroEntrySize - 16);
 }
 
 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:
     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;
+  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::writePltZeroEntry(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));
+  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 {
+  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));
 
-  uint64_t NextPC = PltEntryAddr + 6;
-  int64_t Delta = GotEntryAddr - NextPC;
-  assert(isInt<32>(Delta));
-  write32le(Buf + 2, Delta);
+  write32le(Buf + 2, GotEntryAddr - PltEntryAddr - 6);
+  write32le(Buf + 7, Index);
+  write32le(Buf + 12, -Index * PltEntrySize - PltZeroEntrySize - 16);
 }
 
 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) {

 
 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;
+  PltZeroEntrySize = 0; //FIXME
 
   // We need 64K pages (at least under glibc/Linux, the loader won't
   // set different permissions on a finer granularity than that).
   PageSize = 65536;
 
   VAStart = 0x10000000;
 }
 
static 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));
   }
 }
 
 PPCTargetInfo::PPCTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   PageSize = 65536;
   VAStart = 0x10000000;
 }
+
+void PPCTargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
+void PPCTargetInfo::writePltZeroEntry(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, uint8_t *BufEnd,
                                 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::writePltZeroEntry(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;
 }
void AArch64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 MipsTargetInfo::MipsTargetInfo() {
   // PCRelReloc = FIXME
   // GotReloc = FIXME
+  // PltReloc = FIXME
   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::writePltZeroEntry(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;
 }
 

lld/trunk/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 (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->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.

lld/trunk/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: 48
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 16
 
+// CHECK:      Name: .got.plt
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address: 0x12058
+// CHECK-NEXT: Offset: 0x2058
+// CHECK-NEXT: Size: 20
+// CHECK-NEXT: Link: 0
+// CHECK-NEXT: Info: 0
+// CHECK-NEXT: AddressAlignment: 4
+// CHECK-NEXT: EntrySize: 0
+
 // 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 = 27
+// (0x11010 + 16) - (0x11005 + 1) - 4 = 22
+// (0x11020 + 16) - (0x1100a + 1) - 4 = 33
 
 // 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
-
-// 0x12050 = 73808
-// 0x12054 = 73812
-
+// DISASM-NEXT:   11000:  e9 1b 00 00 00  jmp  27
+// DISASM-NEXT:   11005:  e9 16 00 00 00  jmp  22
+// DISASM-NEXT:   1100a:  e9 21 00 00 00  jmp  33
+
+// 0x12064 - 0x11020 - 6 = 4158
+// 0x12068 - 0x11030 - 6 = 4146
+// 0x11010 - 0x1102b - 5 = -32
+// 0x11010 - 0x1103b - 5 = -48
 // 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:  ff 35 4a 10 00 00 pushl 4170
+// DISASM-NEXT:   11016:  ff 25 4c 10 00 00 jmpl *4172
+// DISASM-NEXT:   1101c:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   1101e:  00 00  addb %al, (%eax)
+// DISASM-NEXT:   11020:  ff 25 3e 10 00 00 jmpl *4158
+// DISASM-NEXT:   11026:  68 00 00 00 00 pushl $0
+// DISASM-NEXT:   1102b:  e9 e0 ff ff ff jmp -32
+// DISASM-NEXT:   11030:  ff 25 32 10 00 00 jmpl *4146
+// DISASM-NEXT:   11036:  68 01 00 00 00 pushl $1
+// DISASM-NEXT:   1103b:  e9 d0 ff ff ff jmp -48
+   
    
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT

lld/trunk/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

lld/trunk/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: 32
 
 // 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
+// 16 - is a size of PLT[0]
 // 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

lld/trunk/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