[ELF2] Implement R_MIPS_GOT16 relocation.

[ikudrin]

Summary

The main purpose of this patch is to add support for GOT section for MIPS target. Only reserved and global entries are supported for now.
In addition, the platform specific symbol "_gp" is added, which point to the start of .got section + 0x7ff0.

[atanasyan]

By the way, what is your plan on MIPS support in ELF2? Is this patch just an experiment or you are going to port all MIPS related functionality from ELF to ELF2? As to me I plan to do that. But if you like and have a time to do that by yourself I will reschedule my work for Imagination accordingly.

ELF/Target.h

35

I do not think the term FirstElement is a good choice. First - MIPS GOT contains two first elements so singular is not applicable. In fact "Module pointer" might be missed and all MIPS ABI consider these items as almost regular entries not as some sort of solid header. Second - both elements always have the same size as other GOT entries so it is enough to have a number of "first" elements. In that case we will not have to override this value for MIPS64.

I would add GotHeaderEntriesNumber class field and rewrite the GotSection<ELFT>::addEntry:

template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
  Sym->GotIndex = Entries.size() + GotHeaderEntriesNumber;
  Entries.push_back(Sym);
}

[ikudrin]

In D14211#278476, @atanasyan wrote:

By the way, what is your plan on MIPS support in ELF2? Is this patch just an experiment or you are going to port all MIPS related functionality from ELF to ELF2? As to me I plan to do that. But if you like and have a time to do that by yourself I will reschedule my work for Imagination accordingly.

My first goal was to finish with the GNU hash section and sorting requirements for dynamic symbol table. Because MIPS has its own requirements for the order of dynamic symbols, it looks as a good place to put my effort. At least, I plan to add sorting function and mandatory dynamic table entries.

Right now I have some time which I can spend to port MIPS functionality from ELF to ELF2. If you don't mind, we can synchronize our plans.

[ruiu]

Hi Igor,

What's your plan on this patch now? Do you still need code review?

[ikudrin]

In D14211#278495, @ruiu wrote:

What's your plan on this patch now? Do you still need code review?

I'm going to post an updated version on Monday. I'll really appreciate any comments.

I have two more (almost done) patches, based on this one. I'm planning to post them on Monday, so the more nits I correct here, the less mess will be there.

[ikudrin]

• SymbolBody::GotIndex -> GlobalGotIndex
• TargetInfo::GotFirstElement -> GotHeaderEntries

[ikudrin]

ELF/Target.h

35

Since we treat global symbols in a different way than local ones, I think we won't be able to set the GotIndex properly when we add support for local entries of GOT. My suggestion is to just rename the field GotIndex to GlobalGotIndex and use it accordingly, see the updated patch.

[atanasyan]

ELF/Symbols.h

94

This change does not look mandatory right now while you do not introduce local entries. Will you maintain local entries counter or first global entry index? Moreover how will it work for targets where GOT is solid and is not split into local/global parts? I suggest to keep this part of code unchanged and review it later with next patches.

ELF/Target.cpp

684

Do we really need both these separate constant? I think it is enough to keep them in the writeGotHeaderEntries.

691

Are we sure that P[0] is initialized by zero?

[ikudrin]

ELF/Target.cpp

684

In this case we have to write it like (uintX_t(1) << (sizeof(uintX_t) * 8 - 1)) to be ready for 64bit targets. Is it correct?

691

As far as I can understand, it's common practice here. See, for example, SymbolTableSection<ELFT>::writeTo(), which just skips the first entry rather than zero it.

[atanasyan]

ELF/Target.cpp

684

Will that work too?

uintX_t MP = ELFT::Is64Bits ? 0x8000000000000000ull : 0x80000000;
P[1] = MP;

691

ok

[ikudrin]

ELF/Target.cpp

684

Well, I've thought about that variant. It seems a bit untidy for me because its rvalue is of type uint64_t and has to be truncated on 32bit platform. Sometimes it can produce warnings, so I prefer to avoid it.

[ikudrin]

• Removed MipsTargetInfo<ELF32LE>::ModulePointer.
• Changed the calculation of SymbolBody::GotIndex.
• The test was broken.

Please note, this version has a little shortcoming. When creates DSO, it produces .rel.dyn section filled with R_MIPS_NONE records. I'm going to fix that in the following update(s).

[ruiu]

ELF/SymbolTable.cpp

76–77

resolve(new (Alloc) DefinedAbsolute..

ELF/SymbolTable.h

53–55

This is inconsistent with other functions that add extra symbols. Other functions takes names and values. Can you change the signature of this function to

void addAbsoluteSym(StringRef Name, uintX_t Value);

ELF/Target.cpp

133

In general please do not use mutable fields unless for cache or something.

691

All writeTo() assumes that the buffer Buf points to is initialized with zero since that's a mmap'ed file that is newly created.

693

Drop ull suffix.

730

Since this function is used only once, remove that and inline here.

write32<IsLE>(Loc, (read32<IsLE>(Loc) & 0xffff0000) | V);

749

This line needs a comment for the magic number.

ELF/Writer.cpp

137

We do not try to push everything that is specific to each target to Target. For example, we have PPC64-specific code in the writer, and that made the entire code more readable.

addSpecificSymbols and updateSpecificSymbols abstracted a concept of "target specific symbols", but currently it's used only for MIPS. I don't like that abstraction. I'd replace Target->updateSpecificSymbols() with to make it less abstract.

if (Config->EMachine == EM_MIPS)
  updateGpSymbol();

[ikudrin]

ELF/SymbolTable.cpp

76–77

This will be inconsistent with other functions that add extra symbols.Should I rewrite them too?

ELF/Target.cpp

730

The function seems to be used in many other MIPS relocations.

[ikudrin]

• Move the functionality of adding and updating target specific symbols from TargetInfo to Driver and Writer.
• The DefinedAbsoluteSynthetic class is added to represent the synthetic absolute symbol which address can be updated.
• Address other review comments.

[ruiu]

ELF/Driver.cpp

254

Please describe what _gp symbols is in MIPS briefly instead of this generic comment.

ELF/OutputSections.cpp

655

I don't think we need a new type. I expected that we could create an Elf_Sym in the writer, sets Value to its st_value, and pass that object to DefinedAbsolute.

ELF/SymbolTable.cpp

76

Like this?

typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
auto *S= new (Alloc) Elf_Sym;
memset(S, 0, sizeof(Elf_Sym));
S->st_value = Value;
resolve(new (Alloc) DefinedAbsolute<ELFT>(Name, *S));

ELF/Writer.cpp

772

It's better to mention that this is to backfill _gp symbol value for MIPS.

[ikudrin]

ELF/OutputSections.cpp

655

We have to reserve the place for the _gp symbol in the symbols and dynamic symbols sections. It requires the symbol to have all properties (like type, binding, etc.) to be set to the correct values because they can affect the sorting order. Therefore we can't use weak or undefined symbols for reserving the place.

We have to update the value of the _gp symbol after assigning addresses for all the sections. We can't do it through adding a new Absolute symbol to the symbol table because it will produce the "duplicate symbol" error. Thus, we have to update the st_value field of the existent symbol.

The DefinedAbsolute class has only the constant reference to the contained symbol, so it is required to use const_cast to update the st_value field. I'm not sure that it is a straightforward way to do the things, because it involves much indirect information that this particular symbol was intentionaly added (in Driver), it has reserved memory and not referenced to memmaped file (in SymTab), it was not replaced by another symbol (because of SymTab rules) and so on.

The DefinedAbsoluteSynthetic class makes things more strict because it stores Elf_Sym within the class and gives explicit access to update the st_value field.

[ruiu]

I applied your patch locally to see what's the simplest way to do for _gp symbol. Can you please take a look at this? http://reviews.llvm.org/D14347 This is pretty similar to your second patch minus Target abstraction. This seems to be easiest. What do you think?

[ikudrin]

In D14211#281496, @ruiu wrote:

I applied your patch locally to see what's the simplest way to do for _gp symbol. Can you please take a look at this? http://reviews.llvm.org/D14347 This is pretty similar to your second patch minus Target abstraction. This seems to be easiest. What do you think?

So, addAbosluteSym() eventually receives a reference to Elf_Sym. The question is, where to store Elf_Sym itself. I'd prefere to put it as a static member of the DefinedAbsolute class rather than the Out class, like we do for DefinedAbsolute::IgnoreUndef, Undefined::Required, etc.

[ikudrin]

• Remove DefinedAbsoluteSynthetic class, apply other changes from Rui's patch (the main difference is the place to store MipsGp variable).
• Fix the problem with filling GOT and relocations for DSO.
• Add the SHF_MIPS_GPREL flag for GOT section.
• The getMipsGpAddr() function now checks if the GOT section has VA set.
• Update the test.

[ruiu]

LGTM with a few nits.

ELF/Driver.cpp

255

Please add a reference to the MIPS ABI spec about _gp symbol.

ELF/Symbols.h

179

Add a blank line before this line.

[ikudrin]

• Add a link to the documentation

I'll commit it tomorrow if no more comments are added.

ELF/Driver.cpp

if (!Config->Shared) {
     // The situation is even stranger on x86_64 where the assembly doesn't
     // need the magical symbol, but gas still puts _GLOBAL_OFFSET_TABLE_ as
     // an undefined symbol in the .o files.
     // Given that the symbol is effectively unused, we just create a dummy
     // hidden one to avoid the undefined symbol error.
     Symtab.addIgnoredSym("_GLOBAL_OFFSET_TABLE_");
   }
 
+  // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
+  // so that it points to an absolute address which is relative to GOT.
+  // See "Global Data Symbols" in Chapter 6 in the following document:
+  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+  if (Config->EMachine == EM_MIPS)
+    Symtab.addAbsoluteSym("_gp", DefinedAbsolute<ELFT>::MipsGp);
+
   for (std::unique_ptr<InputFile> &F : Files)
     Symtab.addFile(std::move(F));
 
   for (StringRef S : Config->Undefined)
     Symtab.addUndefinedOpt(S);
 
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
   // Write the result to the file.
   Symtab.scanShlibUndefined();
   if (Config->GcSections)
     markLive<ELFT>(&Symtab);
   writeResult<ELFT>(&Symtab);
 }

ELF/OutputSections.h

 };
 
 template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
   GotSection();
-  void finalize() override {
-    this->Header.sh_size = Entries.size() * sizeof(uintX_t);
-  }
+  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;
 };

ELF/OutputSections.cpp

for (const SymbolBody *B : Entries) {
     Buf += sizeof(uintX_t);
   }
 }
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT>(".got", llvm::ELF::SHT_PROGBITS,
                               llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
+  if (Config->EMachine == EM_MIPS)
+    this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
-  Sym->GotIndex = Entries.size();
+  Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
   Entries.push_back(Sym);
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.GotIndex * sizeof(uintX_t);
 }
 
+template <class ELFT> void GotSection<ELFT>::finalize() {
+  this->Header.sh_size =
+      (Target->getGotHeaderEntriesNum() + Entries.size()) * sizeof(uintX_t);
+}
+
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
+  Target->writeGotHeaderEntries(Buf);
+  Buf += Target->getGotHeaderEntriesNum() * sizeof(uintX_t);
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
-    if (canBePreempted(B, false))
+    // MIPS has special rules to fill up GOT entries.
+    // As the first approach, we can store addresses for symbols
+    // which have them.
+    if (Config->EMachine != EM_MIPS && canBePreempted(B, false))
       continue; // The dynamic linker will take care of it.
     uintX_t VA = getSymVA<ELFT>(*B);
     write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
   }
 }
 
 template <class ELFT>
 PltSection<ELFT>::PltSection()

 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Sym.st_value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> &SC = DR.Section;
     if (DR.Sym.getType() == STT_TLS)
       return SC.OutSec->getVA() + SC.getOffset(DR.Sym) -
              Out<ELFT>::TlsInitImageVA;
     return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
   }

ELF/SymbolTable.h

public:
   }
 
   const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
     return SharedFiles;
   }
 
   SymbolBody *addUndefined(StringRef Name);
   SymbolBody *addUndefinedOpt(StringRef Name);
+  void addAbsoluteSym(StringRef Name,
+                      typename llvm::object::ELFFile<ELFT>::Elf_Sym &ESym);
   void addSyntheticSym(StringRef Name, OutputSectionBase<ELFT> &Section,
                        typename llvm::object::ELFFile<ELFT>::uintX_t Value);
   void addIgnoredSym(StringRef Name);
   bool isUndefined(StringRef Name);
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
 
 private:
   Symbol *insert(SymbolBody *New);

ELF/SymbolTable.cpp

 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addUndefinedOpt(StringRef Name) {
   auto *Sym = new (Alloc) Undefined<ELFT>(Name, Undefined<ELFT>::Optional);
   resolve(Sym);
   return Sym;
 }
 
 template <class ELFT>
+void SymbolTable<ELFT>::addAbsoluteSym(StringRef Name,
+                                       typename ELFFile<ELFT>::Elf_Sym &ESym) {
+  resolve(new (Alloc) DefinedAbsolute<ELFT>(Name, ESym));
+}
+
+template <class ELFT>
 void SymbolTable<ELFT>::addSyntheticSym(StringRef Name,
                                         OutputSectionBase<ELFT> &Section,
                                         typename ELFFile<ELFT>::uintX_t Value) {
   typedef typename DefinedSynthetic<ELFT>::Elf_Sym Elf_Sym;
   auto ESym = new (Alloc) Elf_Sym;
   memset(ESym, 0, sizeof(Elf_Sym));
   ESym->st_value = Value;
   auto Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, *ESym, Section);

ELF/Symbols.h

public:
   uint8_t getVisibility() const { return Visibility; }
 
   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

 };
 
 template <class ELFT> class DefinedAbsolute : public Defined<ELFT> {
   typedef ELFSymbolBody<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   static Elf_Sym IgnoreUndef;
 
+  // The content for _gp symbol for MIPS target.
+  // The symbol has to be added early to reserve a place in symbol tables.
+  // The value of the symbol is computed later by Writer.
+  static Elf_Sym MipsGp;
+
   DefinedAbsolute(StringRef N, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::DefinedAbsoluteKind, N, Sym) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::DefinedAbsoluteKind;
   }
 };
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::IgnoreUndef;
 
+template <class ELFT>
+typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::MipsGp;
+
 template <class ELFT> class DefinedCommon : public Defined<ELFT> {
   typedef ELFSymbolBody<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   DefinedCommon(StringRef N, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::DefinedCommonKind, N, Sym) {

ELF/Target.h

 //===- Target.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_TARGET_H
 #define LLD_ELF_TARGET_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Object/ELF.h"
 
 #include <memory>
 
 namespace lld {
 namespace elf2 {
 class SymbolBody;
 
 class TargetInfo {
 public:
   unsigned getPageSize() const { return PageSize; }
   uint64_t getVAStart() const { return VAStart; }
   unsigned getCopyReloc() const { return CopyReloc; }
   unsigned getPCRelReloc() const { return PCRelReloc; }
   unsigned getGotReloc() const { return GotReloc; }
   unsigned getPltReloc() const { return PltReloc; }
   unsigned getGotRefReloc() const { return GotRefReloc; }
   unsigned getRelativeReloc() const { return RelativeReloc; }
   unsigned getPltZeroEntrySize() const { return PltZeroEntrySize; }
   unsigned getPltEntrySize() const { return PltEntrySize; }
   bool supportsLazyRelocations() const { return LazyRelocations; }
+  unsigned getGotHeaderEntriesNum() const { return GotHeaderEntriesNum; }
   virtual unsigned getPLTRefReloc(unsigned Type) const;
+  virtual void writeGotHeaderEntries(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 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;
protected:
   unsigned CopyReloc;
   unsigned PCRelReloc;
   unsigned GotRefReloc;
   unsigned GotReloc;
   unsigned PltReloc;
   unsigned RelativeReloc;
   unsigned PltEntrySize = 8;
   unsigned PltZeroEntrySize = 0;
+  unsigned GotHeaderEntriesNum = 0;
   bool LazyRelocations = false;
 };
 
 uint64_t getPPC64TocBase();
 
+template <class ELFT>
+typename llvm::object::ELFFile<ELFT>::uintX_t getMipsGpAddr();
+
 extern std::unique_ptr<TargetInfo> Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

ELF/Target.cpp

 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 namespace lld {
 namespace elf2 {
 
 std::unique_ptr<TargetInfo> Target;
 
+template <bool IsLE> static uint32_t read32(const uint8_t *L);
+template <> uint32_t read32<true>(const uint8_t *L) { return read32le(L); }
+template <> uint32_t read32<false>(const uint8_t *L) { return read32be(L); }
+
+template <bool IsLE> static void write32(uint8_t *L, uint32_t V);
+template <> void write32<true>(uint8_t *L, uint32_t V) { write32le(L, V); }
+template <> void write32<false>(uint8_t *L, uint32_t V) { write32be(L, V); }
+
 static void add32le(uint8_t *L, int32_t V) { write32le(L, read32le(L) + V); }
 static void add32be(uint8_t *L, int32_t V) { write32be(L, read32be(L) + V); }
 static void or32le(uint8_t *L, int32_t V) { write32le(L, read32le(L) | V); }
 
 template <bool IsLE> static void add32(uint8_t *L, int32_t V);
 template <> void add32<true>(uint8_t *L, int32_t V) { add32le(L, V); }
 template <> void add32<false>(uint8_t *L, int32_t V) { add32be(L, V); }
 
public:
   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();
+  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;
   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() {
   switch (Config->EMachine) {
   case EM_386:
     return new X86TargetInfo();
   case EM_AARCH64:
     return new AArch64TargetInfo();
   case EM_MIPS:
     switch (Config->EKind) {
     case ELF32LEKind:
       return new MipsTargetInfo<ELF32LE>();

 }
 
 unsigned TargetInfo::getPLTRefReloc(unsigned Type) const { return PCRelReloc; }
 
 bool TargetInfo::relocPointsToGot(uint32_t Type) const { return false; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
+void TargetInfo::writeGotHeaderEntries(uint8_t *Buf) const {}
+
 X86TargetInfo::X86TargetInfo() {
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   GotRefReloc = R_386_GOT32;
   PltReloc = R_386_JUMP_SLOT;
 }
 
 void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {}
case R_AARCH64_PREL64:
     break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 template <class ELFT> MipsTargetInfo<ELFT>::MipsTargetInfo() {
   PageSize = 65536;
+  GotRefReloc = R_MIPS_GOT16;
+  GotHeaderEntriesNum = 2;
+}
+
+template <class ELFT>
+void MipsTargetInfo<ELFT>::writeGotHeaderEntries(uint8_t *Buf) const {
+  typedef typename llvm::object::ELFFile<ELFT>::Elf_Off Elf_Off;
+  auto *P = reinterpret_cast<Elf_Off *>(Buf);
+  // Module pointer
+  P[1] = ELFT::Is64Bits ? 0x8000000000000000 : 0x80000000;
 }
 
 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 {}
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::relocNeedsGot(uint32_t Type,
                                          const SymbolBody &S) const {
-  return false;
+  return Type == R_MIPS_GOT16;
 }
 
 template <class ELFT>
 bool MipsTargetInfo<ELFT>::relocNeedsPlt(uint32_t Type,
                                          const SymbolBody &S) const {
   return false;
 }
 
 template <class ELFT>
 void MipsTargetInfo<ELFT>::relocateOne(uint8_t *Loc, uint8_t *BufEnd,
                                        uint32_t Type, uint64_t P,
                                        uint64_t SA) const {
   const bool IsLE = ELFT::TargetEndianness == support::little;
   switch (Type) {
   case R_MIPS_32:
     add32<IsLE>(Loc, SA);
     break;
+  case R_MIPS_GOT16: {
+    int64_t V = SA - getMipsGpAddr<ELFT>();
+    if (!isInt<16>(V))
+      error("Relocation R_MIPS_GOT16 out of range");
+    write32<IsLE>(Loc, (read32<IsLE>(Loc) & 0xffff0000) | (V & 0xffff));
+    break;
+  }
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
+
+template <class ELFT>
+typename llvm::object::ELFFile<ELFT>::uintX_t getMipsGpAddr() {
+  const unsigned GPOffset = 0x7ff0;
+  return Out<ELFT>::Got->getVA() ? (Out<ELFT>::Got->getVA() + GPOffset) : 0;
+}
+
+template uint32_t getMipsGpAddr<ELF32LE>();
+template uint32_t getMipsGpAddr<ELF32BE>();
+template uint64_t getMipsGpAddr<ELF64LE>();
+template uint64_t getMipsGpAddr<ELF64BE>();
 }
 }

ELF/Writer.cpp

 }
 
 // The main function of the writer.
 template <class ELFT> void Writer<ELFT>::run() {
   if (!Config->DiscardAll)
     copyLocalSymbols();
   createSections();
   assignAddresses();
   openFile(Config->OutputFile);
   writeHeader();
   writeSections();
   error(Buffer->commit());
 }
 
 namespace {
 template <bool Is64Bits> struct SectionKey {
   typedef typename std::conditional<Is64Bits, uint64_t, uint32_t>::type uintX_t;
if (Body) {
         } else {
           if (Body->isInGot())
             continue;
           Out<ELFT>::Got->addEntry(Body);
         }
       }
     }
 
+    if (Config->EMachine == EM_MIPS && NeedsGot) {
+      // MIPS ABI has special rules to process GOT entries
+      // and doesn't require relocation entries for them.
+      Body->setUsedInDynamicReloc();
+      continue;
+    }
     bool CBP = canBePreempted(Body, NeedsGot);
     if (!CBP && (!Config->Shared || Target->isRelRelative(Type)))
       continue;
     if (CBP)
       Body->setUsedInDynamicReloc();
     if (NeedsPlt && Target->supportsLazyRelocations())
       Out<ELFT>::RelaPlt->addReloc({C, RI});
     else
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+
+  // Update MIPS _gp absolute symbol so that it points to the static data.
+  if (Config->EMachine == EM_MIPS)
+    DefinedAbsolute<ELFT>::MipsGp.st_value = getMipsGpAddr<ELFT>();
 }
 
 // Returns the number of PHDR entries.
 template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
   bool Tls = false;
   int I = 2; // 2 for PT_PHDR and the first PT_LOAD
   if (needsInterpSection())
     ++I;

test/elf2/basic-mips.s

 # CHECK-NEXT:     ABIVersion: 0
 # CHECK-NEXT:     Unused: (00 00 00 00 00 00 00)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Type: Executable (0x2)
 # CHECK-NEXT:   Machine: EM_MIPS (0x8)
 # CHECK-NEXT:   Version: 1
 # CHECK-NEXT:   Entry: 0x20000
 # CHECK-NEXT:   ProgramHeaderOffset: 0x34
-# CHECK-NEXT:   SectionHeaderOffset: 0x20070
+# CHECK-NEXT:   SectionHeaderOffset: 0x20084
 # CHECK-NEXT:   Flags [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   HeaderSize: 52
 # CHECK-NEXT:   ProgramHeaderEntrySize: 32
 # CHECK-NEXT:   ProgramHeaderCount: 4
 # CHECK-NEXT:   SectionHeaderEntrySize: 40
 # CHECK-NEXT:   SectionHeaderCount: 9
 # CHECK-NEXT:   StringTableSectionIndex: 7

 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 6
 # CHECK-NEXT:     Name: .symtab
 # CHECK-NEXT:     Type: SHT_SYMTAB (0x2)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
 # CHECK-NEXT:     Offset: 0x20000
-# CHECK-NEXT:     Size: 32
+# CHECK-NEXT:     Size: 48
 # CHECK-NEXT:     Link: 8
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     AddressAlignment: 4
 # CHECK-NEXT:     EntrySize: 16
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 7
 # CHECK-NEXT:     Name: .shstrtab
 # CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x20020
+# CHECK-NEXT:     Offset: 0x20030
 # CHECK-NEXT:     Size: 68
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section {
 # CHECK-NEXT:     Index: 8
 # CHECK-NEXT:     Name: .strtab (46)
 # CHECK-NEXT:     Type: SHT_STRTAB (0x3)
 # CHECK-NEXT:     Flags [ (0x0)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:     Address: 0x0
-# CHECK-NEXT:     Offset: 0x20064
-# CHECK-NEXT:     Size: 9
+# CHECK-NEXT:     Offset: 0x20074
+# CHECK-NEXT:     Size: 13
 # CHECK-NEXT:     Link: 0
 # CHECK-NEXT:     Info: 0
 # CHECK-NEXT:     AddressAlignment: 1
 # CHECK-NEXT:     EntrySize: 0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Symbols [
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name:  (0)
 # CHECK-NEXT:     Value: 0x0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local (0x0)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: Undefined (0x0)
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: _gp
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local (0x0)
+# CHECK-NEXT:     Type: None (0x0)
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Absolute (0xFFF1)
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: __start
 # CHECK-NEXT:     Value: 0x20000
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Global (0x1)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0
 # CHECK-NEXT:     Section: .text
 # CHECK-NEXT:   }

test/elf2/mips-got-relocs.s

+# Check R_MIPS_GOT16 relocation calculation.
+
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-be.o
+# RUN: ld.lld2 %t-be.o -o %t-be.exe
+# RUN: llvm-objdump -section-headers -t %t-be.exe | FileCheck -check-prefix=EXE_SYM %s
+# RUN: llvm-objdump -s -section=.got %t-be.exe | FileCheck -check-prefix=EXE_GOT_BE %s
+# RUN: llvm-objdump -d %t-be.exe | FileCheck -check-prefix=EXE_DIS_BE %s
+# RUN: llvm-readobj -relocations %t-be.exe | FileCheck -check-prefix=NORELOC %s
+# RUN: llvm-readobj -sections %t-be.exe | FileCheck -check-prefix=SHFLAGS %s
+
+# RUN: llvm-mc -filetype=obj -triple=mipsel-unknown-linux %s -o %t-el.o
+# RUN: ld.lld2 %t-el.o -o %t-el.exe
+# RUN: llvm-objdump -section-headers -t %t-el.exe | FileCheck -check-prefix=EXE_SYM %s
+# RUN: llvm-objdump -s -section=.got %t-el.exe | FileCheck -check-prefix=EXE_GOT_EL %s
+# RUN: llvm-objdump -d %t-el.exe | FileCheck -check-prefix=EXE_DIS_EL %s
+# RUN: llvm-readobj -relocations %t-el.exe | FileCheck -check-prefix=NORELOC %s
+# RUN: llvm-readobj -sections %t-el.exe | FileCheck -check-prefix=SHFLAGS %s
+
+# RUN: ld.lld2 -shared %t-be.o -o %t-be.so
+# RUN: llvm-objdump -section-headers -t %t-be.so | FileCheck -check-prefix=DSO_SYM %s
+# RUN: llvm-objdump -s -section=.got %t-be.so | FileCheck -check-prefix=DSO_GOT_BE %s
+# RUN: llvm-objdump -d %t-be.so | FileCheck -check-prefix=DSO_DIS_BE %s
+# RUN: llvm-readobj -relocations %t-be.so | FileCheck -check-prefix=NORELOC %s
+# RUN: llvm-readobj -sections %t-be.so | FileCheck -check-prefix=SHFLAGS %s
+
+# RUN: ld.lld2 -shared %t-el.o -o %t-el.so
+# RUN: llvm-objdump -section-headers -t %t-el.so | FileCheck -check-prefix=DSO_SYM %s
+# RUN: llvm-objdump -s -section=.got %t-el.so | FileCheck -check-prefix=DSO_GOT_EL %s
+# RUN: llvm-objdump -d %t-el.so | FileCheck -check-prefix=DSO_DIS_EL %s
+# RUN: llvm-readobj -relocations %t-el.so | FileCheck -check-prefix=NORELOC %s
+# RUN: llvm-readobj -sections %t-el.so | FileCheck -check-prefix=SHFLAGS %s
+
+# REQUIRES: mips
+
+  .text
+  .globl  __start
+__start:
+  lui $2, %got(v1)
+
+  .data
+  .globl v1
+  .type  v1,@object
+  .size  v1,4
+v1:
+  .word 0
+
+# EXE_SYM: Sections:
+# EXE_SYM: .got 0000000c 0000000000030004 DATA
+# EXE_SYM: SYMBOL TABLE:
+# EXE_SYM: 00037ff4         *ABS*    00000000 _gp
+#          ^-- .got + GP offset (0x7ff0)
+# EXE_SYM: 00030000 g       .data    00000004 v1
+
+# EXE_GOT_BE: Contents of section .got:
+# EXE_GOT_BE:  30004 00000000 80000000 00030000
+#                    ^        ^        ^-- v1 (0x30000)
+#                    |        +-- Module pointer (0x80000000)
+#                    +-- Lazy resolver (0x0)
+
+# EXE_GOT_EL: Contents of section .got:
+# EXE_GOT_EL:  30004 00000000 00000080 00000300
+#                    ^        ^        ^-- v1 (0x30000)
+#                    |        +-- Module pointer (0x80000000)
+#                    +-- Lazy resolver (0x0)
+
+# v1GotAddr (0x3000c) - _gp (0x37ff4) = -0x7fe8 => 0x8018 = 32792
+# EXE_DIS_BE:  20000:  3c 02 80 18  lui $2, 32792
+# EXE_DIS_EL:  20000:  18 80 02 3c  lui $2, 32792
+
+# DSO_SYM: Sections:
+# DSO_SYM: .got 0000000c 0000000000020034 DATA
+# DSO_SYM: SYMBOL TABLE:
+# DSO_SYM: 00028024         *ABS*    00000000 _gp
+#          ^-- .got + GP offset (0x7ff0)
+# DSO_SYM: 00020000 g       .data    00000004 v1
+
+# DSO_GOT_BE: Contents of section .got:
+# DSO_GOT_BE:  20034 00000000 80000000 00020000
+#                    ^        ^        ^-- v1 (0x20000)
+#                    |        +-- Module pointer (0x80000000)
+#                    +-- Lazy resolver (0x0)
+
+# DSO_GOT_EL: Contents of section .got:
+# DSO_GOT_EL:  20034 00000000 00000080 00000200
+#                    ^        ^        ^-- v1 (0x20000)
+#                    |        +-- Module pointer (0x80000000)
+#                    +-- Lazy resolver (0x0)
+
+# v1GotAddr (0x2003c) - _gp (0x28024) = -0x7fe8 => 0x8018 = 32792
+# DSO_DIS_BE:  10000:  3c 02 80 18  lui $2, 32792
+# DSO_DIS_EL:  10000:  18 80 02 3c  lui $2, 32792
+
+# NORELOC:      Relocations [
+# NORELOC-NEXT: ]
+
+# SHFLAGS:      Name: .got
+# SHFLAGS-NEXT: Type: SHT_PROGBITS
+# SHFLAGS-NEXT: Flags [ (0x10000003)
+#                        ^-- SHF_MIPS_GPREL | SHF_ALLOC | SHF_WRITE