[ELF][MIPS] Pass InputFile and SymbolBody to the Target::relocateOne method

[atanasyan]

Summary

The patch adds two new arguments to the Target::relocateOne routine and passes pointers to InputFile and SymbolBody. For all targets except MIPS at least for now it just increases amount of useless relocateOne's arguments. For MIPS it allows to cleanup InputSectionBase::relocate code and remove almost all if (EMachine == EM_MIPS) statements from it.

I have an idea how to remove the last if (EMachine == EM_MIPS) statement from the InputSectionBase::relocate, but it is for a separate patch.

[ruiu]

I'm not sure if this is a good change. Moving MIPS-specific code inside MipsTargetInfo is generally a good thing, but this adds unused parameters to all archs including non-MIPS ones. So MIPS-specific stuff is leaking to other archs here.

If MIPS is so different than the other archs, how about creating relocateOneMips? Do you think that will simplify the code?

[atanasyan]

In D16817#342067, @ruiu wrote:

If MIPS is so different than the other archs, how about creating relocateOneMips? Do you think that will simplify the code?

Now we call the relocateOne in four places in the InputSectionBase::relocate() code. If we introduce relocateOneMips we have to add if (EMachine == EM_MIPS) statement to all these places.

if (Config->EMachine == EM_MIPS)
  Target->relocateOneMips(File, Body, BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                          findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
else
  Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
                      findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));

Not sure that this will look better.

From the other side, the R_MIPS_26 relocation uses different formulas to calculate result for local / global symbols. To implement that I will need to know the type of symbols in the relocateOne or will have to add more MIPS specific code to the InputSectionBase::relocate().

[ruiu]

I was experimenting a few ideas to apply relocations in different ways, but
didn't get a better way yet. It is possible that we will end up just having
to add two more parameters to the function, but I'd like to experiment a
little bit more. Please give me a few more days.

[atanasyan]

In D16817#343645, @ruiu wrote:

I was experimenting a few ideas to apply relocations in different ways, but
didn't get a better way yet. It is possible that we will end up just having
to add two more parameters to the function, but I'd like to experiment a
little bit more. Please give me a few more days.

Ok. I'm going to experiment with this code too. Thanks for your help.

ELF/InputSection.cpp

for (size_t I = 0; I < Num; ++I) {
     uintX_t Offset = getOffset(RI.r_offset);
     if (Offset == (uintX_t)-1)
       continue;
 
     uint8_t *BufLoc = Buf + Offset;
     uintX_t AddrLoc = OutSec->getVA() + Offset;
     auto NextRelocs = llvm::make_range(&RI, Rels.end());
 
+    const Elf_Shdr *SymTab = File->getSymbolTable();
+    SymbolBody *Body = nullptr;
+    if (SymIndex >= SymTab->sh_info)
+      Body = File->getSymbolBody(SymIndex)->repl();
+
     if (Target->isTlsLocalDynamicRel(Type) &&
         !Target->canRelaxTls(Type, nullptr)) {
-      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
+      Target->relocateOne(File, Body, BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getLocalTlsIndexVA() +
                               getAddend<ELFT>(RI));
       continue;
     }
 
-    const Elf_Shdr *SymTab = File->getSymbolTable();
-    SymbolBody *Body = nullptr;
-    if (SymIndex >= SymTab->sh_info)
-      Body = File->getSymbolBody(SymIndex)->repl();
-
     if (Target->canRelaxTls(Type, Body)) {
       uintX_t SymVA;
       if (!Body)
         SymVA = getLocalRelTarget(*File, RI, 0);
       else if (Target->needsGot(Type, *Body))
         SymVA = Body->getGotVA<ELFT>();
       else
         SymVA = Body->getVA<ELFT>();
       // By optimizing TLS relocations, it is sometimes needed to skip
       // relocations that immediately follow TLS relocations. This function
       // knows how many slots we need to skip.
       I += Target->relaxTls(BufLoc, BufEnd, Type, AddrLoc, SymVA, Body);
       continue;
     }
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     uintX_t A = getAddend<ELFT>(RI);
     if (!Body) {
       uintX_t SymVA = getLocalRelTarget(*File, RI, A);
-      if (Config->EMachine == EM_MIPS) {
-        if (Type == R_MIPS_GPREL16 || Type == R_MIPS_GPREL32)
-          // We need to adjust SymVA value in case of R_MIPS_GPREL16/32
-          // relocations because they use the following expression to calculate
-          // the relocation's result for local symbol: S + A + GP0 - G.
-          SymVA += File->getMipsGp0();
-        else if (Type == R_MIPS_GOT16)
-          // R_MIPS_GOT16 relocation against local symbol requires index of
-          // a local GOT entry which contains page address corresponds
-          // to the symbol address.
-          SymVA = Out<ELFT>::Got->getMipsLocalPageAddr(SymVA);
-      }
-      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0,
+      Target->relocateOne(File, Body, BufLoc, BufEnd, Type, AddrLoc, SymVA, 0,
                           findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
       continue;
     }
 
     if (Target->isTlsGlobalDynamicRel(Type) &&
         !Target->canRelaxTls(Type, Body)) {
-      Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
+      Target->relocateOne(File, Body, BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getGlobalDynAddr(*Body) +
                               getAddend<ELFT>(RI));
       continue;
     }
 
     uintX_t SymVA = Body->getVA<ELFT>();
     if (Target->needsPlt(Type, *Body)) {
       SymVA = Body->getPltVA<ELFT>();
for (size_t I = 0; I < Num; ++I) {
     } else if (Target->isTlsDynRel(Type, *Body)) {
       continue;
     } else if (Target->isSizeRel(Type) && canBePreempted(Body, false)) {
       // A SIZE relocation is supposed to set a symbol size, but if a symbol
       // can be preempted, the size at runtime may be different than link time.
       // If that's the case, we leave the field alone rather than filling it
       // with a possibly incorrect value.
       continue;
-    } else if (Config->EMachine == EM_MIPS) {
-      if (Type == R_MIPS_HI16 && Body == Config->MipsGpDisp)
-        SymVA = getMipsGpAddr<ELFT>() - AddrLoc;
-      else if (Type == R_MIPS_LO16 && Body == Config->MipsGpDisp)
-        SymVA = getMipsGpAddr<ELFT>() - AddrLoc + 4;
     }
     uintX_t Size = getSymSize<ELFT>(*Body);
-    Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA + A, Size + A,
+    Target->relocateOne(File, Body, BufLoc, BufEnd, Type, AddrLoc, SymVA + A,
+                        Size + A,
                         findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     return;
   // Copy section contents from source object file to output file.

ELF/Target.h

 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ELF.h"
 
 #include <memory>
 
 namespace lld {
 namespace elf2 {
+class InputFile;
 class SymbolBody;
 
 class TargetInfo {
 public:
   uint64_t getVAStart() const;
   bool isTlsLocalDynamicRel(unsigned Type) const;
   bool isTlsGlobalDynamicRel(unsigned Type) const;
   virtual unsigned getDynRel(unsigned Type) const { return Type; }
public:
   // the link-time address. So we don't have to emit a relocation for the
   // dynamic linker if isRelRelative returns true.
   virtual bool isRelRelative(uint32_t Type) const;
 
   virtual bool isSizeRel(uint32_t Type) const;
   virtual bool needsDynRelative(unsigned Type) const { return false; }
   virtual bool needsGot(uint32_t Type, const SymbolBody &S) const;
   virtual bool needsPlt(uint32_t Type, const SymbolBody &S) const;
-  virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+  virtual void relocateOne(const InputFile *File, const SymbolBody *S,
+                           uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA, uint64_t ZA = 0,
                            uint8_t *PairedLoc = nullptr) const = 0;
   virtual bool isGotRelative(uint32_t Type) const;
   virtual bool canRelaxTls(unsigned Type, const SymbolBody *S) const;
   virtual bool needsCopyRel(uint32_t Type, const SymbolBody &S) const;
   virtual unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                             uint64_t P, uint64_t SA, const SymbolBody *S) const;
   virtual ~TargetInfo();

ELF/Target.cpp

 //
 // Refer the ELF spec for the single letter varaibles, S, A or P, used
 // in this file. SA is S+A.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 #include "Error.h"
+#include "InputFiles.h"
 #include "OutputSections.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ELF.h"
 
public:
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsDynRelative(unsigned Type) const override;
   bool needsGot(uint32_t Type, const SymbolBody &S) const override;
   bool needsPlt(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, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool canRelaxTls(unsigned Type, const SymbolBody *S) const override;
   unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                     uint64_t SA, const SymbolBody *S) const override;
   bool isGotRelative(uint32_t Type) const override;
 
 private:
   void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
public:
   void writeGotPltHeader(uint8_t *Buf) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, const SymbolBody &S) const override;
   bool needsPlt(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, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
   bool canRelaxTls(unsigned Type, const SymbolBody *S) const override;
   bool isSizeRel(uint32_t Type) const override;
   unsigned relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                     uint64_t SA, const SymbolBody *S) const override;
 
 private:
   void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsGdToIe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
   void relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                          uint64_t SA) const;
 };
 
 class PPCTargetInfo final : public TargetInfo {
 public:
   PPCTargetInfo();
-  void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   bool needsGot(uint32_t Type, const SymbolBody &S) const override;
   bool needsPlt(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, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 
 class AArch64TargetInfo final : public TargetInfo {
 public:
   AArch64TargetInfo();
   unsigned getDynRel(unsigned Type) const override;
   void writeGotPlt(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZero(uint8_t *Buf) const override;
   void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   unsigned getTlsGotRel(unsigned Type = -1) const override;
   bool isTlsDynRel(unsigned Type, const SymbolBody &S) const override;
   bool needsCopyRel(uint32_t Type, const SymbolBody &S) const override;
   bool needsGot(uint32_t Type, const SymbolBody &S) const override;
   bool needsPlt(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, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
 };
 
 class AMDGPUTargetInfo final : public TargetInfo {
 public:
   AMDGPUTargetInfo() {}
-  void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
-                   uint64_t SA, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
 };
 
 template <class ELFT> class MipsTargetInfo final : public TargetInfo {
 public:
   MipsTargetInfo();
   unsigned getDynRel(unsigned Type) const override;
   void writeGotHeader(uint8_t *Buf) const override;
   bool needsGot(uint32_t Type, const SymbolBody &S) const override;
   bool needsPlt(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, uint64_t ZA = 0,
+  void relocateOne(const InputFile *File, const SymbolBody *S, uint8_t *Loc,
+                   uint8_t *BufEnd, uint32_t Type, uint64_t P, uint64_t SA,
+                   uint64_t ZA = 0,
                    uint8_t *PairedLoc = nullptr) const override;
   bool isHintRel(uint32_t Type) const override;
   bool isRelRelative(uint32_t Type) const override;
 };
 } // anonymous namespace
 
 TargetInfo *createTarget() {
   switch (Config->EMachine) {

 
 bool X86TargetInfo::isGotRelative(uint32_t Type) const {
   // This relocation does not require got entry,
   // but it is relative to got and needs it to be created.
   // Here we request for that.
   return Type == R_386_GOTOFF;
 }
 
-void X86TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+void X86TargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                 uint64_t P, uint64_t SA, uint64_t ZA,
                                 uint8_t *PairedLoc) const {
   switch (Type) {
   case R_386_32:
     add32le(Loc, SA);
     break;
   case R_386_GOT32: {
     uint64_t V = SA - Out<ELF32LE>::Got->getVA() -
unsigned X86TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   case R_386_TLS_IE:
     relocateTlsIeToLe(Type, Loc, BufEnd, P, SA);
     return 0;
   case R_386_TLS_LDM:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   case R_386_TLS_LDO_32:
-    relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
+    relocateOne(nullptr, nullptr, Loc, BufEnd, R_386_TLS_LE, P, SA);
     return 0;
   }
   llvm_unreachable("Unknown TLS optimization");
 }
 
 // "Ulrich Drepper, ELF Handling For Thread-Local Storage" (5.1
 // IA-32 Linker Optimizations, http://www.akkadia.org/drepper/tls.pdf) shows
 // how GD can be optimized to IE:
 //   leal x@tlsgd(, %ebx, 1),
 //   call __tls_get_addr@plt
 // Is converted to:
 //   movl %gs:0, %eax
 //   addl x@gotntpoff(%ebx), %eax
 void X86TargetInfo::relocateTlsGdToIe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                                       uint64_t SA) const {
   const uint8_t Inst[] = {
       0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
       0x03, 0x83, 0x00, 0x00, 0x00, 0x00  // addl 0(%ebx), %eax
   };
   memcpy(Loc - 3, Inst, sizeof(Inst));
-  relocateOne(Loc + 5, BufEnd, R_386_32, P,
+  relocateOne(nullptr, nullptr, Loc + 5, BufEnd, R_386_32, P,
               SA - Out<ELF32LE>::Got->getVA() -
                   Out<ELF32LE>::Got->getNumEntries() * 4);
 }
 
 // GD can be optimized to LE:
 //   leal x@tlsgd(, %ebx, 1),
 //   call __tls_get_addr@plt
 // Can be converted to:
 //   movl %gs:0,%eax
 //   addl $x@ntpoff,%eax
 // But gold emits subl $foo@tpoff,%eax instead of addl.
 // These instructions are completely equal in behavior.
 // This method generates subl to be consistent with gold.
 void X86TargetInfo::relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
                                       uint64_t SA) const {
   const uint8_t Inst[] = {
       0x65, 0xa1, 0x00, 0x00, 0x00, 0x00, // movl %gs:0, %eax
       0x81, 0xe8, 0x00, 0x00, 0x00, 0x00  // subl 0(%ebx), %eax
   };
   memcpy(Loc - 3, Inst, sizeof(Inst));
-  relocateOne(Loc + 5, BufEnd, R_386_32, P,
+  relocateOne(nullptr, nullptr, Loc + 5, BufEnd, R_386_32, P,
               Out<ELF32LE>::TlsPhdr->p_memsz - SA);
 }
 
 // LD can be optimized to LE:
 //   leal foo(%reg),%eax
 //   call ___tls_get_addr
 // Is converted to:
 //   movl %gs:0,%eax
if (Type == R_386_TLS_IE) {
     // "ADDL foo@GOTNTPOFF(%RIP), %REG" is transformed to "LEAL foo(%REG), %REG"
     // Note: gold converts to ADDL instead of LEAL.
     *Inst = IsMov ? 0xc7 : 0x8d;
     if (IsMov)
       *Op = 0xc0 | ((*Op >> 3) & 7);
     else
       *Op = 0x80 | Reg | (Reg << 3);
   }
-  relocateOne(Loc, BufEnd, R_386_TLS_LE, P, SA);
+  relocateOne(nullptr, nullptr, Loc, BufEnd, R_386_TLS_LE, P, SA);
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyRel = R_X86_64_COPY;
   GotRel = R_X86_64_GLOB_DAT;
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;

 //  lea x@tpoff,%rax
 void X86_64TargetInfo::relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd,
                                          uint64_t P, uint64_t SA) const {
   const uint8_t Inst[] = {
       0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
       0x48, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00              // lea x@tpoff,%rax
   };
   memcpy(Loc - 4, Inst, sizeof(Inst));
-  relocateOne(Loc + 8, BufEnd, R_X86_64_TPOFF32, P, SA);
+  relocateOne(nullptr, nullptr, Loc + 8, BufEnd, R_X86_64_TPOFF32, P, SA);
 }
 
 // "Ulrich Drepper, ELF Handling For Thread-Local Storage" (5.5
 // x86-x64 linker optimizations, http://www.akkadia.org/drepper/tls.pdf) shows
 // how GD can be optimized to IE:
 //  .byte 0x66
 //  leaq x@tlsgd(%rip), %rdi
 //  .word 0x6666
 //  rex64
 //  call __tls_get_addr@plt
 // Is converted to:
 //  mov %fs:0x0,%rax
 //  addq x@tpoff,%rax
 void X86_64TargetInfo::relocateTlsGdToIe(uint8_t *Loc, uint8_t *BufEnd,
                                          uint64_t P, uint64_t SA) const {
   const uint8_t Inst[] = {
       0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
       0x48, 0x03, 0x05, 0x00, 0x00, 0x00, 0x00              // addq x@tpoff,%rax
   };
   memcpy(Loc - 4, Inst, sizeof(Inst));
-  relocateOne(Loc + 8, BufEnd, R_X86_64_TPOFF64, P + 12, SA);
+  relocateOne(nullptr, nullptr, Loc + 8, BufEnd, R_X86_64_TPOFF64, P + 12, SA);
 }
 
 // In some conditions, R_X86_64_GOTTPOFF relocation can be optimized to
 // R_X86_64_TPOFF32 so that it does not use GOT.
 // This function does that. Read "ELF Handling For Thread-Local Storage,
 // 5.5 x86-x64 linker optimizations" (http://www.akkadia.org/drepper/tls.pdf)
 // by Ulrich Drepper for details.
 void X86_64TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd,
void X86_64TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd,
   // we dont have.
   if (RspAdd)
     *Inst = 0x81;
   else
     *Inst = IsMov ? 0xc7 : 0x8d;
   if (*Prefix == 0x4c)
     *Prefix = (IsMov || RspAdd) ? 0x49 : 0x4d;
   *RegSlot = (IsMov || RspAdd) ? (0xc0 | Reg) : (0x80 | Reg | (Reg << 3));
-  relocateOne(Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
+  relocateOne(nullptr, nullptr, Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
 }
 
 // This function applies a TLS relocation with an optimization as described
 // in the Ulrich's document. As a result of rewriting instructions at the
 // relocation target, relocations immediately follow the TLS relocation (which
 // would be applied to rewritten instructions) may have to be skipped.
 // This function returns a number of relocations that need to be skipped.
 unsigned X86_64TargetInfo::relaxTls(uint8_t *Loc, uint8_t *BufEnd,
                                     uint32_t Type, uint64_t P, uint64_t SA,
                                     const SymbolBody *S) const {
   switch (Type) {
   case R_X86_64_DTPOFF32:
-    relocateOne(Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
+    relocateOne(nullptr, nullptr, Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
     return 0;
   case R_X86_64_GOTTPOFF:
     relocateTlsIeToLe(Loc, BufEnd, P, SA);
     return 0;
   case R_X86_64_TLSGD: {
     if (canBePreempted(S, true))
       relocateTlsGdToIe(Loc, BufEnd, P, SA);
     else
       relocateTlsGdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   }
   case R_X86_64_TLSLD:
     relocateTlsLdToLe(Loc, BufEnd, P, SA);
     // The next relocation should be against __tls_get_addr, so skip it
     return 1;
   }
   llvm_unreachable("Unknown TLS optimization");
 }
 
-void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+void X86_64TargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                   uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
   switch (Type) {
   case R_X86_64_32:
     checkUInt<32>(SA, Type);
     write32le(Loc, SA);
     break;
   case R_X86_64_32S:

 static uint16_t applyPPCHigher(uint64_t V) { return V >> 32; }
 static uint16_t applyPPCHighera(uint64_t V) { return (V + 0x8000) >> 32; }
 static uint16_t applyPPCHighest(uint64_t V) { return V >> 48; }
 static uint16_t applyPPCHighesta(uint64_t V) { return (V + 0x8000) >> 48; }
 
 PPCTargetInfo::PPCTargetInfo() {}
 bool PPCTargetInfo::isRelRelative(uint32_t Type) const { return false; }
 
-void PPCTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+void PPCTargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                 uint64_t P, uint64_t SA, uint64_t ZA,
                                 uint8_t *PairedLoc) const {
   switch (Type) {
   case R_PPC_ADDR16_HA:
     write16be(Loc, applyPPCHa(SA));
     break;
   case R_PPC_ADDR16_LO:
     write16be(Loc, applyPPCLo(SA));
bool PPC64TargetInfo::isRelRelative(uint32_t Type) const {
   default:
     return true;
   case R_PPC64_ADDR64:
   case R_PPC64_TOC:
     return false;
   }
 }
 
-void PPC64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+void PPC64TargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                  uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                   uint64_t P, uint64_t SA, uint64_t ZA,
                                   uint8_t *PairedLoc) const {
   uint64_t TB = getPPC64TocBase();
 
   // For a TOC-relative relocation, adjust the addend and proceed in terms of
   // the corresponding ADDR16 relocation type.
   switch (Type) {
   case R_PPC64_TOC16:       Type = R_PPC64_ADDR16;       SA -= TB; break;
const uint8_t PltData[] = {
       0x1f, 0x20, 0x03, 0xd5, // nop
       0x1f, 0x20, 0x03, 0xd5, // nop
       0x1f, 0x20, 0x03, 0xd5  // nop
   };
   memcpy(Buf, PltData, sizeof(PltData));
 
   uint64_t Got = Out<ELF64LE>::GotPlt->getVA();
   uint64_t Plt = Out<ELF64LE>::Plt->getVA();
-  relocateOne(Buf + 4, Buf + 8, R_AARCH64_ADR_PREL_PG_HI21, Plt + 4, Got + 16);
-  relocateOne(Buf + 8, Buf + 12, R_AARCH64_LDST64_ABS_LO12_NC, Plt + 8,
-              Got + 16);
-  relocateOne(Buf + 12, Buf + 16, R_AARCH64_ADD_ABS_LO12_NC, Plt + 12,
-              Got + 16);
+  relocateOne(nullptr, nullptr, Buf + 4, Buf + 8, R_AARCH64_ADR_PREL_PG_HI21,
+              Plt + 4, Got + 16);
+  relocateOne(nullptr, nullptr, Buf + 8, Buf + 12, R_AARCH64_LDST64_ABS_LO12_NC,
+              Plt + 8, Got + 16);
+  relocateOne(nullptr, nullptr, Buf + 12, Buf + 16, R_AARCH64_ADD_ABS_LO12_NC,
+              Plt + 12, Got + 16);
 }
 
 void AArch64TargetInfo::writePlt(uint8_t *Buf, 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));
 
-  relocateOne(Buf, Buf + 4, R_AARCH64_ADR_PREL_PG_HI21, PltEntryAddr,
-              GotEntryAddr);
-  relocateOne(Buf + 4, Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC, PltEntryAddr + 4,
-              GotEntryAddr);
-  relocateOne(Buf + 8, Buf + 12, R_AARCH64_ADD_ABS_LO12_NC, PltEntryAddr + 8,
-              GotEntryAddr);
+  relocateOne(nullptr, nullptr, Buf, Buf + 4, R_AARCH64_ADR_PREL_PG_HI21,
+              PltEntryAddr, GotEntryAddr);
+  relocateOne(nullptr, nullptr, Buf + 4, Buf + 8, R_AARCH64_LDST64_ABS_LO12_NC,
+              PltEntryAddr + 4, GotEntryAddr);
+  relocateOne(nullptr, nullptr, Buf + 8, Buf + 12, R_AARCH64_ADD_ABS_LO12_NC,
+              PltEntryAddr + 8, GotEntryAddr);
 }
 
 unsigned AArch64TargetInfo::getTlsGotRel(unsigned Type) const {
   if (Type == R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 ||
       Type == R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC)
     return Type;
   return TlsGotRel;
 }

 
 // Page(Expr) is the page address of the expression Expr, defined
 // as (Expr & ~0xFFF). (This applies even if the machine page size
 // supported by the platform has a different value.)
 static uint64_t getAArch64Page(uint64_t Expr) {
   return Expr & (~static_cast<uint64_t>(0xFFF));
 }
 
-void AArch64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
+void AArch64TargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                    uint8_t *Loc, uint8_t *BufEnd,
                                     uint32_t Type, uint64_t P, uint64_t SA,
                                     uint64_t ZA, uint8_t *PairedLoc) const {
   switch (Type) {
   case R_AARCH64_ABS16:
     checkIntUInt<16>(SA, Type);
     write16le(Loc, SA);
     break;
   case R_AARCH64_ABS32:
default:
     fatal("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Implementing relocations for AMDGPU is low priority since most
 // programs don't use relocations now. Thus, this function is not
 // actually called (relocateOne is called for each relocation).
 // That's why the AMDGPU port works without implementing this function.
-void AMDGPUTargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+void AMDGPUTargetInfo::relocateOne(const InputFile *File, const SymbolBody *S,
+                                   uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA, uint64_t ZA,
                                    uint8_t *PairedLoc) const {
   llvm_unreachable("not implemented");
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   PageSize = 65536;
   GotHeaderEntriesNum = 2;
static void applyMipsPcReloc(uint8_t *Loc, uint32_t Type, uint64_t P,
   int64_t A = SignExtend64<BSIZE + 2>((Instr & Mask) << 2);
   checkAlignment<4>(SA + A, Type);
   int64_t V = SA + A - P;
   checkInt<BSIZE + 2>(V, Type);
   write32<E>(Loc, (Instr & ~Mask) | ((V >> 2) & Mask));
 }
 
 template <class ELFT>
-void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
-                                       uint32_t Type, uint64_t P, uint64_t SA,
-                                       uint64_t ZA, uint8_t *PairedLoc) const {
+void MipsTargetInfo<ELFT>::relocateOne(const InputFile *File,
+                                       const SymbolBody *S, uint8_t *Loc,
+                                       uint8_t *BufEnd, uint32_t Type,
+                                       uint64_t P, uint64_t SA, uint64_t ZA,
+                                       uint8_t *PairedLoc) const {
   const endianness E = ELFT::TargetEndianness;
   switch (Type) {
   case R_MIPS_32:
     add32<E>(Loc, SA);
     break;
   case R_MIPS_CALL16:
   case R_MIPS_GOT16: {
+    // R_MIPS_GOT16 relocation against local symbol requires index of a local
+    // GOT entry which contains page address corresponds to the symbol address.
+    if (!S)
+      SA = Out<ELFT>::Got->getMipsLocalPageAddr(SA);
     int64_t V = SA - getMipsGpAddr<ELFT>();
     if (Type == R_MIPS_GOT16)
       checkInt<16>(V, Type);
     write32<E>(Loc, (read32<E>(Loc) & 0xffff0000) | (V & 0xffff));
     break;
   }
   case R_MIPS_GPREL16: {
     uint32_t Instr = read32<E>(Loc);
     int64_t V = SA + SignExtend64<16>(Instr & 0xffff) - getMipsGpAddr<ELFT>();
+    if (!S)
+      V += cast<ObjectFile<ELFT>>(File)->getMipsGp0();
     checkInt<16>(V, Type);
     write32<E>(Loc, (Instr & 0xffff0000) | (V & 0xffff));
     break;
   }
-  case R_MIPS_GPREL32:
-    write32<E>(Loc, SA + int32_t(read32<E>(Loc)) - getMipsGpAddr<ELFT>());
+  case R_MIPS_GPREL32: {
+    int64_t V = SA + int32_t(read32<E>(Loc)) - getMipsGpAddr<ELFT>();
+    if (!S)
+      V += cast<ObjectFile<ELFT>>(File)->getMipsGp0();
+    write32<E>(Loc, V);
     break;
+  }
   case R_MIPS_HI16: {
     uint32_t Instr = read32<E>(Loc);
+    if (S == Config->MipsGpDisp)
+      SA = getMipsGpAddr<ELFT>() - P;
     if (PairedLoc) {
       uint64_t AHL = ((Instr & 0xffff) << 16) +
                      SignExtend64<16>(read32<E>(PairedLoc) & 0xffff);
       write32<E>(Loc, (Instr & 0xffff0000) | mipsHigh(SA + AHL));
     } else {
       warning("Can't find matching R_MIPS_LO16 relocation for R_MIPS_HI16");
       write32<E>(Loc, (Instr & 0xffff0000) | mipsHigh(SA));
     }
     break;
   }
   case R_MIPS_JALR:
     // Ignore this optimization relocation for now
     break;
   case R_MIPS_LO16: {
     uint32_t Instr = read32<E>(Loc);
+    if (S == Config->MipsGpDisp)
+      SA = getMipsGpAddr<ELFT>() - P + 4;
     int64_t AHL = SignExtend64<16>(Instr & 0xffff);
     write32<E>(Loc, (Instr & 0xffff0000) | ((SA + AHL) & 0xffff));
     break;
   }
   case R_MIPS_PC16:
     applyMipsPcReloc<E, 16>(Loc, Type, P, SA);
     break;
   case R_MIPS_PC19_S2: