[ELF][MIPS] Implement R_MIPS_GPREL16/R_MIPS_GPREL32 relocation

[atanasyan]

Summary

The R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations use the following expressions for calculations:

local symbol:  S + A + GP0 - GP
global symbol: S + A - GP

GP  - Represents the final gp value, i.e. _gp symbol
GP0 - Represents the gp value used to create the relocatable object

The GP0 value is taken from the .reginfo data section defined by an object file. To implement that I keep a reference to MipsReginfoInputSection
in the ObjectFile class. This reference is used by the ObjectFile::getMipsGp0 method to return the GP0 value.

[ruiu]

LGTM with a few nits.

ELF/InputFiles.h

126 ↗

(On Diff #43558)

It is even better if you mention that the function is needed to support R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.

ELF/InputSection.cpp

190 ↗

(On Diff #43558)

Please add a comment here why we need this.

ELF/Target.cpp

1392–1396 ↗

(On Diff #43558)

case R_MIPS_GPREL32:
  write32<E>(Loc, SA + int32_t(read32<E>(Loc)) - getMipsGpAddr<ELFT>());
  break;

lld/trunk/ELF/InputFiles.h

SymbolBody *getSymbolBody(uint32_t SymbolIndex) const {
     return this->SymbolBodies[SymbolIndex - FirstNonLocal];
   }
 
   Elf_Sym_Range getLocalSymbols();
   const Elf_Sym *getLocalSymbol(uintX_t SymIndex);
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
+  // Get MIPS GP0 value defined by this file. This value represents the gp value
+  // used to create the relocatable object and required to support
+  // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
+  uint32_t getMipsGp0() const;
+
 private:
   void initializeSections(llvm::DenseSet<StringRef> &Comdats);
   void initializeSymbols();
   InputSectionBase<ELFT> *createInputSection(const Elf_Shdr &Sec);
 
   SymbolBody *createSymbolBody(StringRef StringTable, const Elf_Sym *Sym);
 
   // List of all sections defined by this file.
   std::vector<InputSectionBase<ELFT> *> Sections;
 
   // List of all symbols referenced or defined by this file.
   std::vector<SymbolBody *> SymbolBodies;
 
+  // MIPS .reginfo section defined by this file.
+  MipsReginfoInputSection<ELFT> *MipsReginfo = nullptr;
+
   llvm::BumpPtrAllocator Alloc;
   llvm::SpecificBumpPtrAllocator<MergeInputSection<ELFT>> MAlloc;
   llvm::SpecificBumpPtrAllocator<EHInputSection<ELFT>> EHAlloc;
 };
 
 class ArchiveFile : public InputFile {
 public:
   explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}

lld/trunk/ELF/InputFiles.cpp

 ObjectFile<ELFT>::ObjectFile(MemoryBufferRef M)
     : ELFFileBase<ELFT>(Base::ObjectKind, M) {}
 
 template <class ELFT>
 typename ObjectFile<ELFT>::Elf_Sym_Range ObjectFile<ELFT>::getLocalSymbols() {
   return this->getSymbolsHelper(true);
 }
 
+template <class ELFT> uint32_t ObjectFile<ELFT>::getMipsGp0() const {
+  return MipsReginfo ? MipsReginfo->getGp0() : 0;
+}
+
 template <class ELFT>
 const typename ObjectFile<ELFT>::Elf_Sym *
 ObjectFile<ELFT>::getLocalSymbol(uintX_t SymIndex) {
   uint32_t FirstNonLocal = this->Symtab->sh_info;
   if (SymIndex >= FirstNonLocal)
     return nullptr;
   Elf_Sym_Range Syms = this->ELFObj.symbols(this->Symtab);
   return Syms.begin() + SymIndex;
elf2::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   // PT_GNU_STACK segment in outputs. Since the presence of the segment
   // is controlled only by the command line option (-z execstack) in LLD,
   // .note.GNU-stack is ignored.
   if (Name == ".note.GNU-stack")
     return &InputSection<ELFT>::Discarded;
 
   // A MIPS object file has a special section that contains register
   // usage info, which needs to be handled by the linker specially.
-  if (Config->EMachine == EM_MIPS && Name == ".reginfo")
-    return new (this->Alloc) MipsReginfoInputSection<ELFT>(this, &Sec);
+  if (Config->EMachine == EM_MIPS && Name == ".reginfo") {
+    MipsReginfo = new (this->Alloc) MipsReginfoInputSection<ELFT>(this, &Sec);
+    return MipsReginfo;
+  }
 
   if (Name == ".eh_frame")
     return new (this->EHAlloc.Allocate()) EHInputSection<ELFT>(this, &Sec);
   if (shouldMerge<ELFT>(Sec))
     return new (this->MAlloc.Allocate()) MergeInputSection<ELFT>(this, &Sec);
   return new (this->Alloc) InputSection<ELFT>(this, &Sec);
 }
 

lld/trunk/ELF/InputSection.h

 class MipsReginfoInputSection : public InputSectionBase<ELFT> {
   typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 
 public:
   MipsReginfoInputSection(ObjectFile<ELFT> *F, const Elf_Shdr *Header);
 
   uint32_t getGeneralMask() const;
+  uint32_t getGp0() const;
 
   static bool classof(const InputSectionBase<ELFT> *S);
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

lld/trunk/ELF/InputSection.cpp

if (Target->isTlsOptimized(Type, 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);
+      // 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.
+      if (Config->EMachine == EM_MIPS &&
+          (Type == R_MIPS_GPREL16 || Type == R_MIPS_GPREL32))
+        SymVA += File->getMipsGp0();
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA, 0,
                           findMipsPairedReloc(Buf, SymIndex, Type, NextRelocs));
       continue;
     }
 
     if (Target->isTlsGlobalDynamicReloc(Type) &&
         !Target->isTlsOptimized(Type, Body)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,

 template <class ELFT>
 uint32_t MipsReginfoInputSection<ELFT>::getGeneralMask() const {
   ArrayRef<uint8_t> D = this->getSectionData();
   if (D.size() != sizeof(Elf_Mips_RegInfo))
     error("Invalid size of .reginfo section");
   return reinterpret_cast<const Elf_Mips_RegInfo *>(D.data())->ri_gprmask;
 }
 
+template <class ELFT> uint32_t MipsReginfoInputSection<ELFT>::getGp0() const {
+  ArrayRef<uint8_t> D = this->getSectionData();
+  if (D.size() != sizeof(Elf_Mips_RegInfo))
+    error("Invalid size of .reginfo section");
+  return reinterpret_cast<const Elf_Mips_RegInfo *>(D.data())->ri_gp_value;
+}
+
 template <class ELFT>
 bool MipsReginfoInputSection<ELFT>::classof(const InputSectionBase<ELFT> *S) {
   return S->SectionKind == InputSectionBase<ELFT>::MipsReginfo;
 }
 
 namespace lld {
 namespace elf2 {
 template class InputSectionBase<object::ELF32LE>;

lld/trunk/ELF/Target.cpp

void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
   case R_MIPS_CALL16:
   case R_MIPS_GOT16: {
     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>();
+    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>());
+    break;
   case R_MIPS_HI16: {
     uint32_t Instr = read32<E>(Loc);
     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");

lld/trunk/test/ELF/mips-gprel32-relocs.test

+# Check R_MIPS_GPREL32 relocation calculation.
+
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
+# RUN: ld.lld -shared -o %t.so %t.o
+# RUN: llvm-objdump -s -section=.rodata -t %t.so | FileCheck %s
+
+# REQUIRES: mips
+
+  .text
+  .globl  __start
+__start:
+  lw      $t0,%call16(__start)($gp)
+foo:
+  nop
+bar:
+  nop
+
+  .section .rodata, "a"
+v1:
+  .gpword foo
+  .gpword bar
+
+# CHECK: Contents of section .rodata:
+# CHECK:  0114 fffe8014 fffe8018
+#              ^ 0x10004 - 0x27ff0
+#                       ^ 0x10008 - 0x27ff0
+
+# CHECK: SYMBOL TABLE:
+# CHECK: 00010008         .text           00000000 bar
+# CHECK: 00010004         .text           00000000 foo
+# CHECK: 00027ff0         *ABS*           00000000 _gp