[ELF] - Lazy relocations support for x86 target.

[grimar]

Summary

Patch implements lazy relocations for x86.
One of features of x86 is that executable files and shared object files have separate procedure linkage tables. So patch implements both cases.
As a noticable difference with other targets can mention that relocation offset is required for writePltEntry. I added it as parameter. Also it needs offset in Got, so added addr of Got either.

Detailed information about instructions used can be found in http://docs.oracle.com/cd/E19620-01/805-3050/chapter6-1235/index.html (search: x86: Procedure Linkage Table).

[ikudrin]

ELF/Target.cpp

196 ↗

(On Diff #41050)

The address of the .dynamic section has to be stored at the location which is pointed to by the _GLOBAL_OFFSET_TABLE_ symbol. Although we don't use this symbol explicitly, the same effect is achieved in the method InputSectionBase<ELFT>::relocate() in the branch "if (Target->relocPointsToGot(Type))". But in that branch, the address of .got section is used, not .got.plt's.

[ruiu]

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

This piece of code does not depends on any local context of Writer.cpp, so I think you can move this into a function that handles i386 PLT entries instead of propagating this unsigned value all the way to the consumer.

[grimar]

ELF/Target.cpp

196 ↗

(On Diff #41050)

According to gold source code _GLOBAL_OFFSET_TABLE_ points to got.plt for x86. So if address of .dynamic section should be placed there then .. its already there :)

Just note about relocPointsToGot() - I will review this one. It is not clear for me why we need it as separate method if we have relocNeedsGot(). relocPointsToGot() is used only for x86 now and I think we can combine it with relocNeedsGot().

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

What I need is a accordance of PLT entry and the offset in relocation table for its relocation. It can be calculated only here I think.

That its only needed for x86 now, thats true. But what is the way to move it from here ? Function that handles i386 PLT entries is

writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr, uint64_t PltEntryAddr, int32_t Index, unsigned RelOff).

It does not know anything about conformity of relocations and PLT entries.
I added RelOff for it since I dont know the easier/shorter way to do what is needed.

[ruiu]

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

I think I don't understand what you mean. What I wanted to say is since no local variables are used in the following expression, you can move this code to somewhere else.

unsigned RelOff = Target->supportsLazyRelocations()
                      ? Out<ELFT>::RelaPlt->getRelocOffset()
                      : Out<ELFT>::RelaDyn->getRelocOffset();

[grimar]

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

I understood what you want.
But I think it is only can be moved to

template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym)

from here. It is anyways common code and not just i386 specific.

Point is that getRelocOffset() returns current offset in relocation table, so it needs to be remembered for each added Plt entry. Because
each Out<ELFT>::RelaPlt->addReloc({&C, &RI}); call below changes it.

[ruiu]

ELF/OutputSections.cpp

154 ↗

(On Diff #41050)

I'd give names to both pair elements.

SymbolBody *E = I.first;
unsigned RelOff = I.second;

288 ↗

(On Diff #41050)

remove const as it is obvious.

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

Yeah, so why don't you move this into addEntry?

[grimar]

Review comments addressed.

ELF/OutputSections.cpp

154 ↗

(On Diff #41050)

Done.

288 ↗

(On Diff #41050)

Well, I removed. But I just saw the same in

template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
  const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);

ELF/Writer.cpp

248–250 ↗

(On Diff #41050)

Done.

[ruiu]

LGTM

ELF/OutputSections.cpp

292 ↗

(On Diff #41174)

Oh OK then you can keep it. Consistency matters.

ELF/Target.cpp

225 ↗

(On Diff #41174)

Let's use shorter name as the scope is very narrow.

DsoPltData -> V

[grimar]

ELF/OutputSections.cpp

292 ↗

(On Diff #41174)

Done.

ELF/Target.cpp

225 ↗

(On Diff #41174)

Done.

lld/trunk/ELF/OutputSections.h

public:
   PltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
-  std::vector<const SymbolBody *> Entries;
+  std::vector<std::pair<const SymbolBody *, unsigned>> Entries;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   InputSectionBase<ELFT> *C;
   const Elf_Rel *RI;
 };
 

 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(StringRef Name, bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc) { Relocs.push_back(Reloc); }
+  unsigned getRelocOffset();
   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;
   const bool IsRela;

lld/trunk/ELF/OutputSections.cpp

 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 = LazyReloc ? Out<ELFT>::GotPlt->getEntryAddr(*E)
+  for (std::pair<const SymbolBody *, size_t> &I : Entries) {
+    const SymbolBody *E = I.first;
+    unsigned RelOff = I.second;
+    uint64_t GotVA =
+        LazyReloc ? Out<ELFT>::GotPlt->getVA() : Out<ELFT>::Got->getVA();
+    uint64_t GotE = LazyReloc ? Out<ELFT>::GotPlt->getEntryAddr(*E)
                               : Out<ELFT>::Got->getEntryAddr(*E);
     uint64_t Plt = this->getVA() + Off;
-    Target->writePltEntry(Buf + Off, Got, Plt, E->PltIndex);
+    Target->writePltEntry(Buf + Off, GotVA, GotE, Plt, E->PltIndex, RelOff);
     Off += Target->getPltEntrySize();
   }
 }
 
 template <class ELFT> void PltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->PltIndex = Entries.size();
-  Entries.push_back(Sym);
+  unsigned RelOff = Target->supportsLazyRelocations()
+                        ? Out<ELFT>::RelaPlt->getRelocOffset()
+                        : Out<ELFT>::RelaDyn->getRelocOffset();
+  Entries.push_back(std::make_pair(Sym, RelOff));
 }
 
 template <class ELFT>
 typename PltSection<ELFT>::uintX_t
 PltSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + Target->getPltZeroEntrySize() +
          B.PltIndex * Target->getPltEntrySize();
 }
for (const DynamicReloc<ELFT> &Rel : Relocs) {
     else
       Addend = getLocalRelTarget(File, RI);
 
     if (IsRela)
       static_cast<Elf_Rela *>(P)->r_addend = Addend;
   }
 }
 
+template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
+  const unsigned EntrySize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
+  return EntrySize * Relocs.size();
+}
+
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
 template <class ELFT>
 InterpSection<ELFT>::InterpSection()
     : OutputSectionBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,

lld/trunk/ELF/Target.h

public:
   virtual bool isTlsDynReloc(unsigned Type) const { return false; }
   virtual unsigned getGotRefReloc(unsigned Type) const;
   virtual unsigned getPltRefReloc(unsigned Type) const;
   virtual void writeGotHeaderEntries(uint8_t *Buf) const;
   virtual void writeGotPltHeaderEntries(uint8_t *Buf) const;
   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 void writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                             uint64_t GotEntryAddr, uint64_t PltEntryAddr,
+                             int32_t Index, unsigned RelOff) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
   virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA) const = 0;
   virtual bool isTlsOptimized(unsigned Type, const SymbolBody &S) const;
   virtual void relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,

lld/trunk/ELF/Target.cpp

 
 static void add32le(uint8_t *P, int32_t V) { add32<support::little>(P, V); }
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
+  void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   unsigned getDynReloc(unsigned Type) const override;
   bool isTlsDynReloc(unsigned Type) const override;
   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;
+  void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index,
+                     unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) 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 *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
 };
 
 class X86_64TargetInfo final : public TargetInfo {
 public:
   X86_64TargetInfo();
   unsigned getPltRefReloc(unsigned Type) const override;
   bool isTlsDynReloc(unsigned Type) const override;
   void writeGotPltHeaderEntries(uint8_t *Buf) const override;
   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;
+  void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index,
+                     unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) 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 *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) const override;
   bool isTlsOptimized(unsigned Type, const SymbolBody &S) const override;
   void relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                            uint64_t SA) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
   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;
+  void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index,
+                     unsigned RelOff) 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 *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   unsigned getGotRefReloc(unsigned Type) const override;
   unsigned getPltRefReloc(unsigned Type) const override;
   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;
+  void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index,
+                     unsigned RelOff) 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 *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   unsigned getGotRefReloc(unsigned Type) const override;
   void writeGotHeaderEntries(uint8_t *Buf) const override;
   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;
+  void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
+                     uint64_t PltEntryAddr, int32_t Index,
+                     unsigned RelOff) 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 *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
 };
 } // anonymous namespace
 
 TargetInfo *createTarget() {

 void TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {}
 
 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   GotRefReloc = R_386_GOT32;
   PltReloc = R_386_JUMP_SLOT;
+  LazyRelocations = true;
+  PltEntrySize = 16;
+  PltZeroEntrySize = 16;
+}
+
+void X86TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {
+  write32le(Buf, Out<ELF32LE>::Dynamic->getVA());
+}
+
+void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
+  // Skip 6 bytes of "pushl (GOT+4)"
+  write32le(Buf, Plt + 6);
 }
 
 unsigned X86TargetInfo::getDynReloc(unsigned Type) const {
   if (Type == R_386_TLS_LE)
     return R_386_TLS_TPOFF;
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
 bool X86TargetInfo::isTlsDynReloc(unsigned Type) const {
   if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32)
     return Config->Shared;
   return false;
 }
 
-void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
 void X86TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                      uint64_t PltEntryAddr) const {}
+                                      uint64_t PltEntryAddr) const {
+  // Executable files and shared object files have
+  // separate procedure linkage tables.
+  if (Config->Shared) {
+    const uint8_t V[] = {
+        0xff, 0xb3, 0x04, 0x00, 0x00, 0x00, // pushl 4(%ebx
+        0xff, 0xa3, 0x08, 0x00, 0x00, 0x00, // jmp *8(%ebx)
+        0x90, 0x90, 0x90, 0x90              // nop;nop;nop;nop
+    };
+    memcpy(Buf, V, sizeof(V));
+    return;
+  }
+
+  const uint8_t PltData[] = {
+      0xff, 0x35, 0x00, 0x00, 0x00, 0x00, // pushl (GOT+4)
+      0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // jmp *(GOT+8)
+      0x90, 0x90, 0x90, 0x90              // nop;nop;nop;nop
+  };
+  memcpy(Buf, PltData, sizeof(PltData));
+  write32le(Buf + 2, GotEntryAddr + 4); // GOT+4
+  write32le(Buf + 8, GotEntryAddr + 8); // GOT+8
+}
 
-void X86TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                  uint64_t PltEntryAddr, int32_t Index) const {
-  // jmpl *val; nop; nop
-  const uint8_t Inst[] = {0xff, 0x25, 0, 0, 0, 0, 0x90, 0x90};
+void X86TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                                  uint64_t GotEntryAddr, uint64_t PltEntryAddr,
+                                  int32_t Index, unsigned RelOff) const {
+  const uint8_t Inst[] = {
+      0xff, 0x00, 0x00, 0x00, 0x00, 0x00, // jmp *foo_in_GOT|*foo@GOT(%ebx)
+      0x68, 0x00, 0x00, 0x00, 0x00,       // pushl $reloc_offset
+      0xe9, 0x00, 0x00, 0x00, 0x00        // jmp .PLT0@PC
+  };
   memcpy(Buf, Inst, sizeof(Inst));
-  assert(isUInt<32>(GotEntryAddr));
-  write32le(Buf + 2, GotEntryAddr);
+  // jmp *foo@GOT(%ebx) or jmp *foo_in_GOT
+  Buf[1] = Config->Shared ? 0xa3 : 0x25;
+  write32le(Buf + 2, Config->Shared ? (GotEntryAddr - GotAddr) : GotEntryAddr);
+  write32le(Buf + 7, RelOff);
+  write32le(Buf + 12, -Index * PltEntrySize - PltZeroEntrySize - 16);
 }
 
 bool X86TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
   if (Type == R_386_32 || Type == R_386_16 || Type == R_386_8)
     if (auto *SS = dyn_cast<SharedSymbol<ELF32LE>>(&S))
       return SS->Sym.getType() == STT_OBJECT;
   return false;
 }
const uint8_t PltData[] = {
       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 {
+void X86_64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                                     uint64_t GotEntryAddr,
+                                     uint64_t PltEntryAddr, int32_t Index,
+                                     unsigned RelOff) 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));
 
   write32le(Buf + 2, GotEntryAddr - PltEntryAddr - 6);
uint64_t getPPC64TocBase() {
   // 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, int32_t Index) const {
+void PPC64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                                    uint64_t GotEntryAddr,
+                                    uint64_t PltEntryAddr, int32_t Index,
+                                    unsigned RelOff) 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 AArch64TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
   relocateOne(Buf + 4, Buf + 8, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr + 4,
               GotEntryAddr + 16);
   relocateOne(Buf + 8, Buf + 12, R_AARCH64_LDST64_ABS_LO12_NC, PltEntryAddr + 8,
               GotEntryAddr + 16);
   relocateOne(Buf + 12, Buf + 16, R_AARCH64_ADD_ABS_LO12_NC, PltEntryAddr + 12,
               GotEntryAddr + 16);
 }
 
-void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                      uint64_t PltEntryAddr,
-                                      int32_t Index) const {
+void AArch64TargetInfo::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                                      uint64_t GotEntryAddr,
+                                      uint64_t PltEntryAddr, int32_t Index,
+                                      unsigned RelOff) const {
   const uint8_t Inst[] = {
       0x10, 0x00, 0x00, 0x90, // adrp x16, Page(&(.plt.got[n]))
       0x11, 0x02, 0x40, 0xf9, // ldr  x17, [x16, Offset(&(.plt.got[n]))]
       0x10, 0x02, 0x00, 0x91, // add  x16, x16, Offset(&(.plt.got[n]))
       0x20, 0x02, 0x1f, 0xd6  // br   x17
   };
   memcpy(Buf, Inst, sizeof(Inst));
 

 }
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
 template <class ELFT>
 void MipsTargetInfo<ELFT>::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                        uint64_t PltEntryAddr) const {}
 template <class ELFT>
-void MipsTargetInfo<ELFT>::writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                                         uint64_t PltEntryAddr, int32_t Index) const {}
+void MipsTargetInfo<ELFT>::writePltEntry(uint8_t *Buf, uint64_t GotAddr,
+                                         uint64_t GotEntryAddr,
+                                         uint64_t PltEntryAddr, int32_t Index,
+                                         unsigned RelOff) const {}
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::relocNeedsGot(uint32_t Type,
                                          const SymbolBody &S) const {
   return Type == R_MIPS_GOT16 || Type == R_MIPS_CALL16;
 }
 
 template <class ELFT>

lld/trunk/test/ELF/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.lld -shared %t2.o -o %t2.so
 // RUN: ld.lld %t.o %t2.so -o %t
-// RUN: llvm-readobj -s -r %t | FileCheck %s
+// RUN: llvm-readobj -s -r %t | FileCheck --check-prefix=CHECK %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
+// RUN: ld.lld -shared %t.o %t2.so -o %t
+// RUN: llvm-readobj -s -r %t | FileCheck --check-prefix=CHECKSHARED %s
+// RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASMSHARED %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
+
+// 0x12058 + got.plt.reserved(12) = 0x12064
+// 0x12058 + got.plt.reserved(12) + 4 = 0x12068
 // 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
+
+// 0x11010 - 0x1102b - 5 = -32
+// 0x11010 - 0x1103b - 5 = -48
+// 73820 = 0x1205C = .got.plt (0x12058) + 4
+// 73824 = 0x12060 = .got.plt (0x12058) + 8
+// 73828 = 0x12064 = .got.plt (0x12058) + got.plt.reserved(12)
+// 73832 = 0x12068 = .got.plt (0x12058) + got.plt.reserved(12) + 4
 // 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 5c 20 01 00 pushl 73820
+// DISASM-NEXT:    11016: ff 25 60 20 01 00 jmpl *73824
+// DISASM-NEXT:    1101c: 90 nop
+// DISASM-NEXT:    1101d: 90 nop
+// DISASM-NEXT:    1101e: 90 nop
+// DISASM-NEXT:    1101f: 90 nop
+// DISASM-NEXT:    11020: ff 25 64 20 01 00 jmpl *73828
+// DISASM-NEXT:    11026: 68 00 00 00 00 pushl $0
+// DISASM-NEXT:    1102b: e9 e0 ff ff ff jmp -32 <.plt>
+// DISASM-NEXT:    11030: ff 25 68 20 01 00 jmpl *73832
+// DISASM-NEXT:    11036: 68 08 00 00 00 pushl $8
+// DISASM-NEXT:    1103b: e9 d0 ff ff ff jmp -48 <.plt>
+
+// CHECKSHARED:        Name: .plt
+// CHECKSHARED-NEXT:   Type: SHT_PROGBITS
+// CHECKSHARED-NEXT:   Flags [
+// CHECKSHARED-NEXT:     SHF_ALLOC
+// CHECKSHARED-NEXT:     SHF_EXECINSTR
+// CHECKSHARED-NEXT:   ]
+// CHECKSHARED-NEXT:   Address: 0x1010
+// CHECKSHARED-NEXT:   Offset: 0x1010
+// CHECKSHARED-NEXT:   Size: 48
+// CHECKSHARED-NEXT:   Link: 0
+// CHECKSHARED-NEXT:   Info: 0
+// CHECKSHARED-NEXT:   AddressAlignment: 16
+// CHECKSHARED-NEXT:   EntrySize: 0
+// CHECKSHARED-NEXT:   }
+// CHECKSHARED:        Name: .got.plt
+// CHECKSHARED-NEXT:   Type: SHT_PROGBITS
+// CHECKSHARED-NEXT:   Flags [
+// CHECKSHARED-NEXT:     SHF_ALLOC
+// CHECKSHARED-NEXT:     SHF_WRITE
+// CHECKSHARED-NEXT:   ]
+// CHECKSHARED-NEXT:   Address: 0x2058
+// CHECKSHARED-NEXT:   Offset: 0x2058
+// CHECKSHARED-NEXT:   Size: 20
+// CHECKSHARED-NEXT:   Link: 0
+// CHECKSHARED-NEXT:   Info: 0
+// CHECKSHARED-NEXT:   AddressAlignment: 4
+// CHECKSHARED-NEXT:   EntrySize: 0
+// CHECKSHARED-NEXT:   }
+
+// 0x2058 + got.plt.reserved(12) = 0x2064
+// 0x2058 + got.plt.reserved(12) + 4 = 0x2068
+// CHECKSHARED:        Relocations [
+// CHECKSHARED-NEXT:     Section ({{.*}}) .rel.plt {
+// CHECKSHARED-NEXT:       0x2064 R_386_JUMP_SLOT bar 0x0
+// CHECKSHARED-NEXT:       0x2068 R_386_JUMP_SLOT zed 0x0
+// CHECKSHARED-NEXT:     }
+// CHECKSHARED-NEXT:   ]
+
+// DISASMSHARED:       _start:
+// DISASMSHARED-NEXT:  1000: e9 1b 00 00 00 jmp 27
+// DISASMSHARED-NEXT:  1005: e9 16 00 00 00 jmp 22
+// DISASMSHARED-NEXT:  100a: e9 21 00 00 00 jmp 33
+// DISASMSHARED-NEXT:  Disassembly of section .plt:
+// DISASMSHARED-NEXT:  .plt:
+// DISASMSHARED-NEXT:  1010: ff b3 04 00 00 00  pushl 4(%ebx)
+// DISASMSHARED-NEXT:  1016: ff a3 08 00 00 00  jmpl *8(%ebx)
+// DISASMSHARED-NEXT:  101c: 90 nop
+// DISASMSHARED-NEXT:  101d: 90 nop
+// DISASMSHARED-NEXT:  101e: 90 nop
+// DISASMSHARED-NEXT:  101f: 90 nop
+// DISASMSHARED-NEXT:  1020: ff a3 0c 00 00 00  jmpl *12(%ebx)
+// DISASMSHARED-NEXT:  1026: 68 00 00 00 00     pushl $0
+// DISASMSHARED-NEXT:  102b: e9 e0 ff ff ff     jmp -32 <.plt>
+// DISASMSHARED-NEXT:  1030: ff a3 10 00 00 00  jmpl *16(%ebx)
+// DISASMSHARED: 1036: 68 08 00 00 00     pushl $8
+// DISASMSHARED: 103b: e9 d0 ff ff ff     jmp -48 <.plt>
 
 .global _start
 _start:
   jmp bar@PLT
   jmp bar@PLT
   jmp zed@PLT

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