[ELF][MIPS] Support GOT entries for non-preemptible symbols with different addends

[atanasyan]

Summary

There are two motivations for this patch. The first one is a preparation for support MIPS TLS relocations. It might sound like a joke but for GOT entries related to TLS relocations MIPS ABI uses almost regular approach with creation of dynamic relocations for each GOT enty etc. But we need to separate these 'regular' TLS related entries from MIPS specific local/global parts of GOT. ABI declare simple solution - all TLS related entries allocated at the end of GOT after local/global parts. The second motivation it to support GOT relocations for non-preemptible symbols with addends. If we have more than one GOT relocations against symbol S with different addends we need to create GOT entries for each unique Symbol/Addend pairs.

So we store all MIPS GOT entries in separate containers. For non-preemptible symbols we have to maintain two data structures. The first one is MipsLocal vector. Each entry corresponds to the GOT entry from the 'local' part of the GOT contains the symbol's address plus addend. The second one is MipsLocalMap. It is a map from Symbol/Addend pair to the GOT index.

[ruiu]

I think I don't fully digest the MIPS ABI yet, so I guess this review is superficial. I'll take time to read it again. Overall it looks good though.

ELF/OutputSections.cpp

95

Define GotSection::addMipsEntry and move MIPS-related code there, so that this function is as short as

if (Config->EMachine == EM_MIPS) {
  addMipsEntry(Sym, Addend, Expr);
  return;
Sym.GotIndex = Entries.size();
Entries.push_back(&Sym);

95–96

Can this be

MipsLocalMap.insert({{&Sym, Addend}, MipsLocalMap.size()})

?

197

If the control cannot reach here only because of a bug, use llvm_unreachable.

ELF/OutputSections.h

136

Add a newline before the comment.

151

Add newlines before comments.

ELF/Symbols.h

100

Move this after IsLocal so that SymbolKind is aligned on 8 byte boundary.

[atanasyan]

• Moved MIPS specific code to the GotSection::addMipsEntry
• Simplified insertion into the MipsLocalMap
• Fixed comments formatting
• Fixed SymbolKind alignment

[• rafael]

So, there something I don't understand about the mips abi. In other
ABIs, a got relocation of symbol foo with addend X means
"got_entry(foo) + X". For example, R_X86_64_GOTPCREL normally has and
addend of -4 since it is commonly used with pc relative addressing
that uses the address of the next instruction.

What exactly is the rule for mips? Is a R_MIPS_SOMETHING_GOT with an
addend of X supposed to mean "got_entry(foo + X)"? Is that always the
case? Only for some relocations? Only when foo is local?

Cheers,
Rafael

[atanasyan]

In D21297#457462, @rafael wrote:

What exactly is the rule for mips? Is a R_MIPS_SOMETHING_GOT with an
addend of X supposed to mean "got_entry(foo + X)"? Is that always the
case? Only for some relocations? Only when foo is local?

In general all MIPS GOT related relocations against (S+A) expect that corresponding GOT entry contain a real address of S + A. For example, here is a quote from R_MIPS_GOT_DISP relocation result description:

The offset into the global offset table at which the address of the relocation entry symbol, adjusted by the addend, resides during execution.

In fact compilers/assemblers generate GOT related relocations for non-preemptible symbols because in that case they know what happens at the S+A address. I do not know why does compiler require allocation of additional GOT entry instead of adding addend to the result of GOT entry reading. Maybe the idea is to escape additional instructions.

On my test base I have never seen a GOT relocation against preemptible symbol with addend, but I am going to add fatal call to catch such case.

[• rafael]

In general all MIPS GOT related relocations against (S+A) expect that corresponding GOT entry contain a real address of S + A. For example, here is a quote from R_MIPS_GOT_DISP relocation result description:

The offset into the global offset table at which the address of the relocation entry symbol, adjusted by the addend, resides during execution.

In fact compilers/assemblers generate GOT related relocations for non-preemptible symbols because in that case they know what happens at the S+A address. I do not know why does compiler require allocation of additional GOT entry instead of adding addend to the result of GOT entry reading. Maybe the idea is to escape additional instructions.

It sounds like we should have another expression. Say
R_GOT_ADDEND_OFF. With that it would be easier to write code that

• Creates a got entry for S+A instead of just S. If the addend is 0,

it uses the existing GotIndex/GotPltIndex. Otherwise we need a map. I
would suggest starting with just a (sym, addend). We can try
optimizing it afterwards.

• When handling the expression, we would have

case R_GOT_ADDEND_OFFSET:

return Body.getGotOffset<ELFT>(A);

And the implementation of getGotOffset uses the hash table in the Got
section if the addend is not 0.

This should allow handling both preemptable and non preemptable
symbols uniformly, no?

It also looks like this code would be cleaner if we used
section+offsets instead of symbols is the Relocation vector. I will
give that a try.

On my test base I have never seen a GOT relocation against preemptible symbol with addend, but I am going to add fatal call to catch such case.

What does gold/bfd do in that case?

Cheers,
Rafael

[atanasyan]

In D21297#457595, @rafael wrote:

It sounds like we should have another expression. Say
R_GOT_ADDEND_OFF. With that it would be easier to write code that

• Creates a got entry for S+A instead of just S. If the addend is 0,

it uses the existing GotIndex/GotPltIndex. Otherwise we need a map. I
would suggest starting with just a (sym, addend). We can try
optimizing it afterwards.

• When handling the expression, we would have

case R_GOT_ADDEND_OFFSET:

return Body.getGotOffset<ELFT>(A);

And the implementation of getGotOffset uses the hash table in the Got
section if the addend is not 0.

So you suggest to hide the fact that it is MIPS specific stuff. Ok, I will rename related functions and expressions. Now I use a similar approach for the R_MIPS_GOT_LOCAL expression so it will be rather easy.

This should allow handling both preemptable and non preemptable
symbols uniformly, no?

I'm not sure. We still need to write GOT entries for preemptable and non preemptable symbols to the different parts of the GOT. Probably we can use a single expression type in both cases but check symbol type in more than one place.

It also looks like this code would be cleaner if we used
section+offsets instead of symbols is the Relocation vector. I will
give that a try.

What will be a section for preemptable symbol comes from DSO?

On my test base I have never seen a GOT relocation against preemptible symbol with addend, but I am going to add fatal call to catch such case.

What does gold/bfd do in that case?

BFD and Gold handle (Symbol,Addend) pairs for any type of symbols. So they are ready to handle GOT relocations against preemptable symbols and non-zero addends. So your approach covers this case too.

I will try to re-write the patch and send update for review.

[atanasyan]

I was not quite right when said that BFD/Gold linkers are able to handle GOT relocations against preemptable symbols and non-zero addends. The accept such relocations because sometimes we need to create a GOT entry just because we need to create a dynamic relocation and the dynamic relocation handles addend (see rL266921). But anyway each preemptable symbol referenced by GOT relocations got single GOT entry.

In this patch I try to handle GOT relocation for preemptable and non-preemptable symbols uniformly.

• There are only two MIPS GOT specific relocation expressions R_MIPS_GOT_LOCAL_PAGE and R_MIPS_GOT_OFF.
• All GOT entries created for R_MIPS_GOT_OFF expressions stored in MipsLocal and MipsGlobal vectors.
• We do not need to save addends for preemptable symbol but using the same type for MipsLocal and MipsGlobal elements simplify the code.
• All GOT offsets calculated by GotSection<ELFT>::getMipsGotOffset method. I did not put this code to the SymbolBody::getGotOffset to escape exposing GotSection implementation details.

[ruiu]

ELF/OutputSections.cpp

200–201

assert(It != MipsGotMap.end());

ELF/OutputSections.h

159

Instead of std::pair, can you define a struct, so that instead of first/second, we can use meaningful names?

163

Add newlines before comments.

[atanasyan]

ELF/OutputSections.h

159

Instead of std::pair, can you define a struct

In that case I have to define some additional stuff like getEmptyKey, isEqual, ... to be able to use this struct in the DenseMap. For my taste it makes the code overcomplicated.

[ruiu]

Fair point.

[atanasyan]

• Replace llvm_unreachable by assert.
• Fix comment formatting.
• Use lambda for adding entries to the MipsLocal and MipsGlobal containers. For my taste now GotSection<ELFT>::addMipsEntry looks a bit more clear.

[ruiu]

LGTM

[atanasyan]

Thanks for review.

ELF/InputSection.cpp

case R_RELAX_GOT_PC_NOPIC:
     return Body.getVA<ELFT>(A);
   case R_GOT_OFF:
     return Body.getGotOffset<ELFT>() + A;
   case R_MIPS_GOT_LOCAL_PAGE:
     // If relocation against MIPS local symbol requires GOT entry, this entry
     // should be initialized by 'page address'. This address is high 16-bits
     // of sum the symbol's value and the addend.
     return Out<ELFT>::Got->getMipsLocalPageOffset(Body.getVA<ELFT>(A));
-  case R_MIPS_GOT_LOCAL:
-    // For non-local symbols GOT entries should contain their full
-    // addresses. But if such symbol cannot be preempted, we do not
-    // have to put them into the "global" part of GOT and use dynamic
-    // linker to determine their actual addresses. That is why we
-    // create GOT entries for them in the "local" part of GOT.
-    return Out<ELFT>::Got->getMipsLocalEntryOffset(Body.getVA<ELFT>(A));
+  case R_MIPS_GOT_OFF:
+    // In case of MIPS if a GOT relocation has non-zero addend this addend
+    // should be applied to the GOT entry content not to the GOT entry offset.
+    // That is why we use separate expression type.
+    return Out<ELFT>::Got->getMipsGotOffset(Body, A);
   case R_PPC_OPD: {
     uint64_t SymVA = Body.getVA<ELFT>(A);
     // If we have an undefined weak symbol, we might get here with a symbol
     // address of zero. That could overflow, but the code must be unreachable,
     // so don't bother doing anything at all.
     if (!SymVA)
       return 0;
     if (Out<ELF64BE>::Opd) {

ELF/OutputSections.h

 //===- OutputSections.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_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "Config.h"
+#include "Relocations.h"
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/SHA1.h"
 
template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
   typedef OutputSectionBase<ELFT> Base;
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody &Sym);
+  void addMipsEntry(SymbolBody &Sym, uintX_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
   bool addTlsIndex();
-  bool empty() const { return MipsLocalEntries == 0 && Entries.empty(); }
-  uintX_t getMipsLocalEntryOffset(uintX_t EntryValue);
+  bool empty() const { return MipsPageEntries == 0 && Entries.empty(); }
   uintX_t getMipsLocalPageOffset(uintX_t Addr);
+  uintX_t getMipsGotOffset(const SymbolBody &B, uintX_t Addend) const;
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
   uintX_t getNumEntries() const { return Entries.size(); }
 
   // Returns the symbol which corresponds to the first entry of the global part
   // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
   // table properties.
   // Returns nullptr if the global part is empty.
   const SymbolBody *getMipsFirstGlobalEntry() const;
 
   // Returns the number of entries in the local part of GOT including
   // the number of reserved entries. This method is MIPS-specific.
   unsigned getMipsLocalEntriesNum() const;
 
   uintX_t getTlsIndexVA() { return Base::getVA() + TlsIndexOff; }
   uint32_t getTlsIndexOff() { return TlsIndexOff; }
 
   // Flag to force GOT to be in output if we have relocations
   // that relies on its address.
   bool HasGotOffRel = false;
 
 private:
   std::vector<const SymbolBody *> Entries;
   uint32_t TlsIndexOff = -1;
-  uint32_t MipsLocalEntries = 0;
+  uint32_t MipsPageEntries = 0;
   // Output sections referenced by MIPS GOT relocations.
   llvm::SmallPtrSet<const OutputSectionBase<ELFT> *, 10> MipsOutSections;
   llvm::DenseMap<uintX_t, size_t> MipsLocalGotPos;
+
+  // MIPS ABI requires to create unique GOT entry for each Symbol/Addend
+  // pairs. The `MipsGotMap` maps (S,A) pair to the GOT index in the `MipsLocal`
+  // or `MipsGlobal` vectors. In general it does not have a sence to take in
+  // account addend for preemptible symbols because the corresponding
+  // GOT entries should have one-to-one mapping with dynamic symbols table.
+  // But we use the same container's types for both kind of GOT entries
+  // to handle them uniformly.
+  typedef std::pair<const SymbolBody*, uintX_t> MipsGotSAPair;
+  llvm::DenseMap<MipsGotSAPair, size_t> MipsGotMap;
+  std::vector<MipsGotSAPair> MipsLocal;
+  std::vector<MipsGotSAPair> MipsGlobal;
+  // Write MIPS-specific parts of the GOT.
+  void writeMipsGot(uint8_t *&Buf);
 };
 
 template <class ELFT>
 class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotPltSection();

ELF/OutputSections.cpp

 template <class ELFT>
 GotSection<ELFT>::GotSection()
     : OutputSectionBase<ELFT>(".got", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE) {
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= SHF_MIPS_GPREL;
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
-template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
-  if (Config->EMachine == EM_MIPS) {
-    // For "true" local symbols which can be referenced from the same module
-    // only compiler creates two instructions for address loading:
-    //
-    // lw   $8, 0($gp) # R_MIPS_GOT16
-    // addi $8, $8, 0  # R_MIPS_LO16
-    //
-    // The first instruction loads high 16 bits of the symbol address while
-    // the second adds an offset. That allows to reduce number of required
-    // GOT entries because only one global offset table entry is necessary
-    // for every 64 KBytes of local data. So for local symbols we need to
-    // allocate number of GOT entries to hold all required "page" addresses.
-    //
-    // All global symbols (hidden and regular) considered by compiler uniformly.
-    // It always generates a single `lw` instruction and R_MIPS_GOT16 relocation
-    // to load address of the symbol. So for each such symbol we need to
-    // allocate dedicated GOT entry to store its address.
-    //
-    // If a symbol is preemptible we need help of dynamic linker to get its
-    // final address. The corresponding GOT entries are allocated in the
-    // "global" part of GOT. Entries for non preemptible global symbol allocated
-    // in the "local" part of GOT.
-    //
-    // See "Global Offset Table" in Chapter 5:
-    // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    if (Sym.isLocal()) {
-      // At this point we do not know final symbol value so to reduce number
-      // of allocated GOT entries do the following trick. Save all output
-      // sections referenced by GOT relocations. Then later in the `finalize`
-      // method calculate number of "pages" required to cover all saved output
-      // section and allocate appropriate number of GOT entries.
-      auto *OutSec = cast<DefinedRegular<ELFT>>(&Sym)->Section->OutSec;
-      MipsOutSections.insert(OutSec);
-      return;
-    }
-    if (!Sym.isPreemptible()) {
-      // In case of non-local symbols require an entry in the local part
-      // of MIPS GOT, we set GotIndex to 1 just to accent that this symbol
-      // has the GOT entry and escape creation more redundant GOT entries.
-      // FIXME (simon): We can try to store such symbols in the `Entries`
-      // container. But in that case we have to sort out that container
-      // and update GotIndex assigned to symbols.
-      Sym.GotIndex = 1;
-      ++MipsLocalEntries;
-      return;
-    }
-  }
-  Sym.GotIndex = Entries.size();
-  Entries.push_back(&Sym);
+template <class ELFT>
+void GotSection<ELFT>::addEntry(SymbolBody &Sym) {
+  Sym.GotIndex = Entries.size();
+  Entries.push_back(&Sym);
+}
+
+template <class ELFT>
+void GotSection<ELFT>::addMipsEntry(SymbolBody &Sym, uintX_t Addend,
+                                    RelExpr Expr) {
+  if (Expr == R_MIPS_GOT_LOCAL_PAGE) {
+  if (Sym.isPreemptible())
+    // Ignore addends for preemptible symbols.
+    // They got single GOT entry anyway.
+    Addend = 0;
+  if (Sym.isInGot() && !Addend)
+  auto &MipsEntries = Sym.isPreemptible() ? MipsGlobal : MipsLocal;
+  size_t NewIndex = MipsEntries.size();
+  if (!MipsGotMap.insert({{&Sym, Addend}, NewIndex}).second)
+    return;
+  MipsEntries.emplace_back(&Sym, Addend);
+  if (!Addend)
+    Sym.GotIndex = NewIndex;
+  if (Sym.isPreemptible())
+    Sym.IsInGlobalMipsGot = true;
 }
 
 template <class ELFT> bool GotSection<ELFT>::addDynTlsEntry(SymbolBody &Sym) {
   if (Sym.GlobalDynIndex != -1U)
     return false;
   Sym.GlobalDynIndex = Entries.size();
   // Global Dynamic TLS entries take two GOT slots.
   Entries.push_back(nullptr);
template <class ELFT> bool GotSection<ELFT>::addTlsIndex() {
   return true;
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getMipsLocalPageOffset(uintX_t EntryValue) {
   // Initialize the entry by the %hi(EntryValue) expression
   // but without right-shifting.
-  return getMipsLocalEntryOffset((EntryValue + 0x8000) & ~0xffff);
-}
-
-template <class ELFT>
-typename GotSection<ELFT>::uintX_t
-GotSection<ELFT>::getMipsLocalEntryOffset(uintX_t EntryValue) {
+  EntryValue = (EntryValue + 0x8000) & ~0xffff;
   // Take into account MIPS GOT header.
   // See comment in the GotSection::writeTo.
   size_t NewIndex = MipsLocalGotPos.size() + 2;
   auto P = MipsLocalGotPos.insert(std::make_pair(EntryValue, NewIndex));
-  assert(!P.second || MipsLocalGotPos.size() <= MipsLocalEntries);
+  assert(!P.second || MipsLocalGotPos.size() <= MipsPageEntries);
   return (uintX_t)P.first->second * sizeof(uintX_t) - MipsGPOffset;
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
+GotSection<ELFT>::getMipsGotOffset(const SymbolBody &B, uintX_t Addend) const {
+  uintX_t Off = MipsPageEntries;
+  if (B.IsInGlobalMipsGot)
+    Off += MipsLocal.size() + B.GotIndex;
+  else if (B.isInGot())
+    Off += B.GotIndex;
+  else {
+    auto It = MipsGotMap.find({&B, Addend});
+    if (It == MipsGotMap.end())
+      llvm_unreachable("Cannot find GOT entry for the symbol");
+    Off += It->second;
+  }
+  return Off * sizeof(uintX_t) - MipsGPOffset;
+}
+
+template <class ELFT>
+typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getGlobalDynAddr(const SymbolBody &B) const {
   return this->getVA() + B.GlobalDynIndex * sizeof(uintX_t);
 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getGlobalDynOffset(const SymbolBody &B) const {
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
 template <class ELFT>
 const SymbolBody *GotSection<ELFT>::getMipsFirstGlobalEntry() const {
-  return Entries.empty() ? nullptr : Entries.front();
+  return MipsGlobal.empty() ? nullptr : MipsGlobal.front().first;
 }
 
 template <class ELFT>
 unsigned GotSection<ELFT>::getMipsLocalEntriesNum() const {
-  return MipsLocalEntries;
+  return MipsPageEntries + MipsLocal.size();
 }
 
 template <class ELFT> void GotSection<ELFT>::finalize() {
   size_t EntriesNum = Entries.size();
   if (Config->EMachine == EM_MIPS) {
     // Take into account MIPS GOT header.
     // See comment in the GotSection::writeTo.
-    MipsLocalEntries += 2;
+    MipsPageEntries += 2;
     for (const OutputSectionBase<ELFT> *OutSec : MipsOutSections) {
       // Calculate an upper bound of MIPS GOT entries required to store page
       // addresses of local symbols. We assume the worst case - each 64kb
       // page of the output section has at least one GOT relocation against it.
       // Add 0x8000 to the section's size because the page address stored
       // in the GOT entry is calculated as (value + 0x8000) & ~0xffff.
-      MipsLocalEntries += (OutSec->getSize() + 0x8000 + 0xfffe) / 0xffff;
+      MipsPageEntries += (OutSec->getSize() + 0x8000 + 0xfffe) / 0xffff;
     }
-    EntriesNum += MipsLocalEntries;
+    EntriesNum += MipsPageEntries + MipsLocal.size() + MipsGlobal.size();
   }
   this->Header.sh_size = EntriesNum * sizeof(uintX_t);
 }
 
-template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
-  if (Config->EMachine == EM_MIPS) {
-    // Set the MSB of the second GOT slot. This is not required by any
-    // MIPS ABI documentation, though.
-    //
-    // There is a comment in glibc saying that "The MSB of got[1] of a
-    // gnu object is set to identify gnu objects," and in GNU gold it
-    // says "the second entry will be used by some runtime loaders".
-    // But how this field is being used is unclear.
-    //
-    // We are not really willing to mimic other linkers behaviors
-    // without understanding why they do that, but because all files
-    // generated by GNU tools have this special GOT value, and because
-    // we've been doing this for years, it is probably a safe bet to
-    // keep doing this for now. We really need to revisit this to see
-    // if we had to do this.
-    auto *P = reinterpret_cast<typename ELFT::Off *>(Buf);
-    P[1] = uintX_t(1) << (ELFT::Is64Bits ? 63 : 31);
-    for (std::pair<uintX_t, size_t> &L : MipsLocalGotPos) {
-      uint8_t *Entry = Buf + L.second * sizeof(uintX_t);
-      write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, L.first);
-    }
-    Buf += MipsLocalEntries * sizeof(uintX_t);
-  }
+template <class ELFT> void GotSection<ELFT>::writeMipsGot(uint8_t *&Buf) {
+  // Write 'page address' entries to the local part of the GOT.
+  Buf += MipsPageEntries * sizeof(uintX_t);
+  auto AddEntry = [&](const MipsGotSAPair &SA) {
+    uint8_t *Entry = Buf;
+    Buf += sizeof(uintX_t);
+    uintX_t VA = SA.first->template getVA<ELFT>(SA.second);
+    write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
+  };
+  std::for_each(std::begin(MipsLocal), std::end(MipsLocal), AddEntry);
+  std::for_each(std::begin(MipsGlobal), std::end(MipsGlobal), AddEntry);
+
+template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
+  if (Config->EMachine == EM_MIPS)
+    writeMipsGot(Buf);
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
     if (!B)
       continue;
-    // MIPS has special rules to fill up GOT entries.
-    // See "Global Offset Table" in Chapter 5 in the following document
-    // for detailed description:
-    // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    // As the first approach, we can just store addresses for all symbols.
-    if (Config->EMachine != EM_MIPS && B->isPreemptible())
+    if (B->isPreemptible())
       continue; // The dynamic linker will take care of it.
     uintX_t VA = B->getVA<ELFT>();
     write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
   }
 }
 
 template <class ELFT>
 PltSection<ELFT>::PltSection()

 // in compliance with MIPS ABI rules.
 // See "Global Offset Table" in Chapter 5 in the following document
 // for detailed description:
 // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
 static bool sortMipsSymbols(const std::pair<SymbolBody *, unsigned> &L,
                             const std::pair<SymbolBody *, unsigned> &R) {
   // Sort entries related to non-local preemptible symbols by GOT indexes.
   // All other entries go to the first part of GOT in arbitrary order.
-  bool LIsInLocalGot = !L.first->isInGot() || !L.first->isPreemptible();
-  bool RIsInLocalGot = !R.first->isInGot() || !R.first->isPreemptible();
-  if (LIsInLocalGot || RIsInLocalGot)
-    return !RIsInLocalGot;
+  if (!L.first->IsInGlobalMipsGot || !R.first->IsInGlobalMipsGot)
+    return !L.first->IsInGlobalMipsGot;
   return L.first->GotIndex < R.first->GotIndex;
 }
 
 static uint8_t getSymbolBinding(SymbolBody *Body) {
   Symbol *S = Body->symbol();
   uint8_t Visibility = S->Visibility;
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;

ELF/Relocations.h

enum RelExpr {
   R_GOT,
   R_GOTONLY_PC,
   R_GOTREL,
   R_GOT_FROM_END,
   R_GOT_OFF,
   R_GOT_PAGE_PC,
   R_GOT_PC,
   R_HINT,
-  R_MIPS_GOT_LOCAL,
   R_MIPS_GOT_LOCAL_PAGE,
+  R_MIPS_GOT_OFF,
   R_NEG_TLS,
   R_PAGE_PC,
   R_PC,
   R_PLT,
   R_PLT_PC,
   R_PLT_PAGE_PC,
   R_PPC_OPD,
   R_PPC_PLT_OPD,

ELF/Relocations.cpp

 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 
 namespace lld {
 namespace elf {
 
 static bool refersToGotEntry(RelExpr Expr) {
-  return Expr == R_GOT || Expr == R_GOT_OFF || Expr == R_MIPS_GOT_LOCAL ||
-         Expr == R_MIPS_GOT_LOCAL_PAGE || Expr == R_GOT_PAGE_PC ||
-         Expr == R_GOT_PC || Expr == R_GOT_FROM_END || Expr == R_TLSGD ||
-         Expr == R_TLSGD_PC || Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE;
+  return Expr == R_GOT || Expr == R_GOT_OFF || Expr == R_MIPS_GOT_LOCAL_PAGE ||
+         Expr == R_MIPS_GOT_OFF || Expr == R_GOT_PAGE_PC || Expr == R_GOT_PC ||
+         Expr == R_GOT_FROM_END || Expr == R_TLSGD || Expr == R_TLSGD_PC ||
+         Expr == R_TLSDESC || Expr == R_TLSDESC_PAGE;
 }
 
 static bool isPreemptible(const SymbolBody &Body, uint32_t Type) {
   // In case of MIPS GP-relative relocations always resolve to a definition
   // in a regular input file, ignoring the one-definition rule. So we,
   // for example, should not attempt to create a dynamic relocation even
   // if the target symbol is preemptible. There are two two MIPS GP-relative
   // relocations R_MIPS_GPREL16 and R_MIPS_GPREL32. But only R_MIPS_GPREL16
return Expr == R_PC || Expr == R_GOTREL || Expr == R_PAGE_PC ||
          Expr == R_RELAX_GOT_PC;
 }
 
 template <class ELFT>
 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
                                      const SymbolBody &Body) {
   // These expressions always compute a constant
   if (E == R_SIZE || E == R_GOT_FROM_END || E == R_GOT_OFF ||
-      E == R_MIPS_GOT_LOCAL || E == R_MIPS_GOT_LOCAL_PAGE ||
-      E == R_GOT_PAGE_PC || E == R_GOT_PC || E == R_PLT_PC || E == R_TLSGD_PC ||
-      E == R_TLSGD || E == R_PPC_PLT_OPD || E == R_TLSDESC_PAGE || E == R_HINT)
+      E == R_MIPS_GOT_LOCAL_PAGE || E == R_MIPS_GOT_OFF || E == R_GOT_PAGE_PC ||
+      E == R_GOT_PC || E == R_PLT_PC || E == R_TLSGD_PC || E == R_TLSGD ||
+      E == R_PPC_PLT_OPD || E == R_TLSDESC_PAGE || E == R_HINT)
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;
 
   if (isPreemptible(Body, Type))
if (Config->EMachine == EM_MIPS) {
     Addend += findMipsPairedAddend<ELFT>(SectionData, BufLoc, Body, &RI, End);
     if (Type == R_MIPS_LO16 && Expr == R_PC)
       // R_MIPS_LO16 expression has R_PC type iif the target is _gp_disp
       // symbol. In that case we should use the following formula for
       // calculation "AHL + GP - P + 4". Let's add 4 right here.
       // For details see p. 4-19 at
       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
       Addend += 4;
-    if (Expr == R_GOT_OFF)
-      Addend -= MipsGPOffset;
     if (Expr == R_GOTREL) {
       Addend -= MipsGPOffset;
       if (Body.isLocal())
         Addend += File.getMipsGp0();
     }
   }
   if (Config->Pic && Config->EMachine == EM_PPC64 && Type == R_PPC64_TOC)
     Addend += getPPC64TocBase();
if (needsPlt(Expr) || Expr == R_THUNK || refersToGotEntry(Expr) ||
       // to create a GOT entry for it.
       // If a non-preemptible symbol has a dynamic relocation against it,
       // dynamic linker takes it st_value, adds offset and writes down
       // result of the dynamic relocation. In case of preemptible symbol
       // dynamic linker performs symbol resolution, writes the symbol value
       // to the GOT entry and reads the GOT entry when it needs to perform
       // a dynamic relocation.
       // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf p.4-19
-      if (Config->EMachine == EM_MIPS && !Body.isInGot())
-        Out<ELFT>::Got->addEntry(Body);
+      if (Config->EMachine == EM_MIPS)
+        Out<ELFT>::Got->addMipsEntry(Body, Addend, Expr);
       continue;
     }
 
     if (Expr == R_THUNK)
       continue;
 
     // At this point we are done with the relocated position. Some relocations
     // also require us to create a got or plt entry.
if (needsPlt(Expr)) {
       Out<ELFT>::GotPlt->addEntry(Body);
       Out<ELFT>::RelaPlt->addReloc({Rel, Out<ELFT>::GotPlt,
                                     Body.getGotPltOffset<ELFT>(), !Preemptible,
                                     &Body, 0});
       continue;
     }
 
     if (refersToGotEntry(Expr)) {
-      if (Body.isInGot())
-        continue;
-      Out<ELFT>::Got->addEntry(Body);
-
-      if (Config->EMachine == EM_MIPS)
+      if (Config->EMachine == EM_MIPS) {
         // MIPS ABI has special rules to process GOT entries
         // and doesn't require relocation entries for them.
         // See "Global Offset Table" in Chapter 5 in the following document
         // for detailed description:
         // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+        Out<ELFT>::Got->addMipsEntry(Body, Addend, Expr);
         continue;
+      }
 
+      if (Body.isInGot())
+        continue;
+
+      Out<ELFT>::Got->addEntry(Body);
       if (Preemptible || (Config->Pic && !isAbsolute<ELFT>(Body))) {
         uint32_t DynType;
         if (Body.isTls())
           DynType = Target->TlsGotRel;
         else if (Preemptible)
           DynType = Target->GotRel;
         else
           DynType = Target->RelativeRel;

ELF/Symbols.h

public:
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t ThunkIndex = -1;
   uint32_t GlobalDynIndex = -1;
   bool isInGot() const { return GotIndex != -1U; }
   bool isInPlt() const { return PltIndex != -1U; }
   bool hasThunk() const { return ThunkIndex != -1U; }
 
   template <class ELFT>
   typename ELFT::uint getVA(typename ELFT::uint Addend = 0) const;
 
   template <class ELFT> typename ELFT::uint getGotOffset() const;
   template <class ELFT> typename ELFT::uint getGotVA() const;
   template <class ELFT> typename ELFT::uint getGotPltOffset() const;
   template <class ELFT> typename ELFT::uint getGotPltVA() const;
   template <class ELFT> typename ELFT::uint getPltVA() const;
   template <class ELFT> typename ELFT::uint getThunkVA() const;

 public:
   // True if the linker has to generate a copy relocation for this shared
   // symbol or if the symbol should point to its plt entry.
   unsigned NeedsCopyOrPltAddr : 1;
 
   // True if this is a local symbol.
   unsigned IsLocal : 1;
 
+  // True if this symbol has an entry in the global part of MIPS GOT.
+  unsigned IsInGlobalMipsGot : 1;
+
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type
   uint8_t StOther; // st_other field value
 
   // The Type field may also have this value. It means that we have not yet seen
   // a non-Lazy symbol with this name, so we don't know what its type is. The
   // Type field is normally set to this value for Lazy symbols unless we saw a
   // weak undefined symbol first, in which case we need to remember the original

ELF/Symbols.cpp

static typename ELFT::uint getSymVA(const SymbolBody &Body,
   case SymbolBody::DefinedBitcodeKind:
     llvm_unreachable("should have been replaced");
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 SymbolBody::SymbolBody(Kind K, uint32_t NameOffset, uint8_t StOther,
                        uint8_t Type)
-    : SymbolKind(K), NeedsCopyOrPltAddr(false), IsLocal(true), Type(Type),
-      StOther(StOther), NameOffset(NameOffset) {}
+    : SymbolKind(K), NeedsCopyOrPltAddr(false), IsLocal(true),
+      IsInGlobalMipsGot(false), Type(Type), StOther(StOther),
+      NameOffset(NameOffset) {}
 
 SymbolBody::SymbolBody(Kind K, StringRef Name, uint8_t StOther, uint8_t Type)
-    : SymbolKind(K), NeedsCopyOrPltAddr(false), IsLocal(false), Type(Type),
-      StOther(StOther), Name({Name.data(), Name.size()}) {}
+    : SymbolKind(K), NeedsCopyOrPltAddr(false), IsLocal(false),
+      IsInGlobalMipsGot(false), Type(Type), StOther(StOther),
+      Name({Name.data(), Name.size()}) {}
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // with the same name defined in other ELF executable or DSO.
 bool SymbolBody::isPreemptible() const {
   if (isLocal())
     return false;
 
   // Shared symbols resolve to the definition in the DSO. The exceptions are
typename ELFT::uint SymbolBody::getVA(typename ELFT::uint Addend) const {
   return OutVA + Addend;
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotVA() const {
   return Out<ELFT>::Got->getVA() + getGotOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotOffset() const {
-  return (Out<ELFT>::Got->getMipsLocalEntriesNum() + GotIndex) *
-         sizeof(typename ELFT::uint);
+  return GotIndex * sizeof(typename ELFT::uint);
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltVA() const {
   return Out<ELFT>::GotPlt->getVA() + getGotPltOffset<ELFT>();
 }
 
 template <class ELFT> typename ELFT::uint SymbolBody::getGotPltOffset() const {
   return GotPltIndex * sizeof(typename ELFT::uint);

ELF/Target.cpp

RelExpr MipsTargetInfo<ELFT>::getRelExpr(uint32_t Type,
   case R_MIPS_PCLO16:
     return R_PC;
   case R_MIPS_GOT16:
     if (S.isLocal())
       return R_MIPS_GOT_LOCAL_PAGE;
   // fallthrough
   case R_MIPS_CALL16:
   case R_MIPS_GOT_DISP:
-    if (!S.isPreemptible())
-      return R_MIPS_GOT_LOCAL;
-    return R_GOT_OFF;
+    return R_MIPS_GOT_OFF;
   case R_MIPS_GOT_PAGE:
     return R_MIPS_GOT_LOCAL_PAGE;
   }
 }
 
 template <class ELFT>
 uint32_t MipsTargetInfo<ELFT>::getDynRel(uint32_t Type) const {
   if (Type == R_MIPS_32 || Type == R_MIPS_64)

test/ELF/mips-64-disp.s

+# Check R_MIPS_GOT_DISP relocations against various kind of symbols.
+
+# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
+# RUN:         %p/Inputs/mips-pic.s -o %t.so.o
+# RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o
+# RUN: ld.lld %t.so.o -shared -o %t.so
+# RUN: ld.lld %t.exe.o %t.so -o %t.exe
+# RUN: llvm-objdump -d -t %t.exe | FileCheck %s
+# RUN: llvm-readobj -r -mips-plt-got %t.exe | FileCheck -check-prefix=GOT %s
+
+# REQUIRES: mips
+
+# CHECK:      __start:
+# CHECK-NEXT:    20000:   24 42 80 40   addiu   $2, $2, -32704
+# CHECK-NEXT:    20004:   24 42 80 20   addiu   $2, $2, -32736
+# CHECK-NEXT:    20008:   24 42 80 28   addiu   $2, $2, -32728
+# CHECK-NEXT:    2000c:   24 42 80 30   addiu   $2, $2, -32720
+# CHECK-NEXT:    20010:   24 42 80 38   addiu   $2, $2, -32712
+
+# CHECK: 0000000000020014     .text   00000000 foo
+# CHECK: 0000000000037ff0     .got    00000000 .hidden _gp
+# CHECK: 0000000000020000     .text   00000000 __start
+# CHECK: 0000000000000000 g F *UND*   00000000 foo1a
+
+# GOT:      Relocations [
+# GOT-NEXT: ]
+# GOT-NEXT: Primary GOT {
+# GOT-NEXT:   Canonical gp value: 0x37FF0
+# GOT-NEXT:   Reserved entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30000
+# GOT-NEXT:       Access: -32752
+# GOT-NEXT:       Initial: 0x0
+# GOT-NEXT:       Purpose: Lazy resolver
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30008
+# GOT-NEXT:       Access: -32744
+# GOT-NEXT:       Initial: 0x8000000000000000
+# GOT-NEXT:       Purpose: Module pointer (GNU extension)
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Local entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30010
+# GOT-NEXT:       Access: -32736
+# GOT-NEXT:       Initial: 0x20014
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30018
+# GOT-NEXT:       Access: -32728
+# GOT-NEXT:       Initial: 0x20004
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30020
+# GOT-NEXT:       Access: -32720
+# GOT-NEXT:       Initial: 0x20008
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30028
+# GOT-NEXT:       Access: -32712
+# GOT-NEXT:       Initial: 0x2000C
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Global entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30030
+# GOT-NEXT:       Access: -32704
+# GOT-NEXT:       Initial: 0x0
+# GOT-NEXT:       Value: 0x0
+# GOT-NEXT:       Type: Function
+# GOT-NEXT:       Section: Undefined
+# GOT-NEXT:       Name: foo1a
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Number of TLS and multi-GOT entries: 0
+# GOT-NEXT: }
+
+  .text
+  .global  __start
+__start:
+  addiu   $v0,$v0,%got_disp(foo1a)            # R_MIPS_GOT_DISP
+  addiu   $v0,$v0,%got_disp(foo)              # R_MIPS_GOT_DISP
+  addiu   $v0,$v0,%got_disp(.text+4)          # R_MIPS_GOT_DISP
+  addiu   $v0,$v0,%got_disp(.text+8)          # R_MIPS_GOT_DISP
+  addiu   $v0,$v0,%got_disp(.text+12)         # R_MIPS_GOT_DISP
+
+foo:
+  nop

test/ELF/mips-64-got.s

 # Check MIPS N64 ABI GOT relocations
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux \
 # RUN:         %p/Inputs/mips-pic.s -o %t.so.o
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.exe.o
 # RUN: ld.lld %t.so.o -shared -o %t.so
 # RUN: ld.lld %t.exe.o %t.so -o %t.exe
 # RUN: llvm-objdump -d -t %t.exe | FileCheck %s
 # RUN: llvm-readobj -r -mips-plt-got %t.exe | FileCheck -check-prefix=GOT %s
 
 # REQUIRES: mips
 
 # CHECK:      __start:
 
 # CHECK-NEXT:    20000:   df 82 80 20   ld      $2, -32736($gp)
-# CHECK-NEXT:    20004:   64 42 00 14   daddiu  $2,  $2, 20
-# CHECK-NEXT:    20008:   24 42 80 30   addiu   $2,  $2, -32720
+# CHECK-NEXT:    20004:   64 42 00 18   daddiu  $2,  $2, 24
+# CHECK-NEXT:    20008:   24 42 80 38   addiu   $2,  $2, -32712
 # CHECK-NEXT:    2000c:   24 42 80 28   addiu   $2,  $2, -32728
+# CHECK-NEXT:    20010:   24 42 80 30   addiu   $2,  $2, -32720
 
-# CHECK: 0000000000020014   .text   00000000 foo
+# CHECK: 0000000000020018   .text   00000000 foo
 # CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
 # CHECK: 0000000000020000   .text   00000000 __start
-# CHECK: 0000000000020010   .text   00000000 bar
+# CHECK: 0000000000020014   .text   00000000 bar
 
 # GOT:      Relocations [
 # GOT-NEXT: ]
 # GOT-NEXT: Primary GOT {
 # GOT-NEXT:   Canonical gp value: 0x37FF0
 # GOT-NEXT:   Reserved entries [
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x30000

 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x30010
 # GOT-NEXT:       Access: -32736
 # GOT-NEXT:       Initial: 0x20000
 # GOT-NEXT:     }
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x30018
 # GOT-NEXT:       Access: -32728
-# GOT-NEXT:       Initial: 0x20010
+# GOT-NEXT:       Initial: 0x20014
 # GOT-NEXT:     }
-# GOT-NEXT:   ]
-# GOT-NEXT:   Global entries [
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x30020
 # GOT-NEXT:       Access: -32720
+# GOT-NEXT:       Initial: 0x20018
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Global entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address: 0x30028
+# GOT-NEXT:       Access: -32712
 # GOT-NEXT:       Initial: 0x0
 # GOT-NEXT:       Value: 0x0
 # GOT-NEXT:       Type: Function
 # GOT-NEXT:       Section: Undefined
 # GOT-NEXT:       Name: foo1a
 # GOT-NEXT:     }
 # GOT-NEXT:   ]
 # GOT-NEXT:   Number of TLS and multi-GOT entries: 0
 # GOT-NEXT: }
 
   .text
   .global  __start, bar
 __start:
   ld      $v0,%got_page(foo)($gp)             # R_MIPS_GOT_PAGE
   daddiu  $v0,$v0,%got_ofst(foo)              # R_MIPS_GOT_OFST
   addiu   $v0,$v0,%got_disp(foo1a)            # R_MIPS_GOT_DISP
   addiu   $v0,$v0,%got_disp(bar)              # R_MIPS_GOT_DISP
+  addiu   $v0,$v0,%got_disp(foo)              # R_MIPS_GOT_DISP
 
 bar:
   nop
 foo:
   nop

test/ELF/mips-dynamic.s

 # DSO-NEXT:       SHF_WRITE
 # DSO-NEXT:     ]
 # DSO-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
 # DSO-NEXT:     Offset:
 # DSO-NEXT:     Size: 8
 # DSO:      ]
 # DSO:      DynamicSymbols [
 # DSO:          Name: @
-# DSO:          Name: __start@
 # DSO:          Name: _foo@
+# DSO:          Name: __start@
 # DSO:      ]
 # DSO:      DynamicSection [
 # DSO-NEXT:   Tag        Type                 Name/Value
 # DSO-DAG:    0x00000003 PLTGOT               [[GOTADDR]]
 # DSO-DAG:    0x70000001 MIPS_RLD_VERSION     1
 # DSO-DAG:    0x70000005 MIPS_FLAGS           NOTPOT
 # DSO-DAG:    0x70000006 MIPS_BASE_ADDRESS    0x0
 # DSO-DAG:    0x7000000A MIPS_LOCAL_GOTNO     2

test/ELF/mips-got16.s

 # CHECK-NEXT:    10000:       8f 88 80 18     lw      $8, -32744($gp)
 # CHECK-NEXT:    10004:       21 08 00 2c     addi    $8, $8, 44
 # CHECK-NEXT:    10008:       8f 88 80 1c     lw      $8, -32740($gp)
 # CHECK-NEXT:    1000c:       21 08 90 00     addi    $8, $8, -28672
 # CHECK-NEXT:    10010:       8f 88 80 20     lw      $8, -32736($gp)
 # CHECK-NEXT:    10014:       21 08 90 04     addi    $8, $8, -28668
 # CHECK-NEXT:    10018:       8f 88 80 20     lw      $8, -32736($gp)
 # CHECK-NEXT:    1001c:       21 08 10 04     addi    $8, $8, 4100
-# CHECK-NEXT:    10020:       8f 88 80 24     lw      $8, -32732($gp)
+# CHECK-NEXT:    10020:       8f 88 80 28     lw      $8, -32728($gp)
 # CHECK-NEXT:    10024:       21 08 10 08     addi    $8, $8, 4104
 # CHECK-NEXT:    10028:       8f 88 80 2c     lw      $8, -32724($gp)
 #
 # CHECK: SYMBOL TABLE:
 # CHECK: 00051008         .data           00000000 .hidden bar
 # CHECK: 00000000         *UND*           00000000 foo
 
 # GOT:      Relocations [

 # GOT-NEXT:       Access: -32736
 # GOT-NEXT:       Initial: 0x50000
 #                          ^-- (0x39000 + 0x10004 + 0x8000) & ~0xffff
 #                          ^-- (0x39000 + 0x18004 + 0x8000) & ~0xffff
 # GOT-NEXT:     }
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x20014
 # GOT-NEXT:       Access: -32732
-# GOT-NEXT:       Initial: 0x51008
-#                          ^-- 'bar' address
+# GOT-NEXT:       Initial: 0x0
+#                          ^-- redundant unused entry
 # GOT-NEXT:     }
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x20018
-# GOT-NEXT:       Access: -32728
-# GOT-NEXT:       Initial: 0x0
-#                          ^-- redundant unused entry
+# GOT-NEXT:       Access: -327
+# GOT-NEXT:       Initial: 0x51008
+#                          ^-- 'bar' address
 # GOT-NEXT:     }
 # GOT-NEXT:   ]
 # GOT-NEXT:   Global entries [
 # GOT-NEXT:     Entry {
 # GOT-NEXT:       Address: 0x2001C
 # GOT-NEXT:       Access: -32724
 # GOT-NEXT:       Initial: 0x0
 # GOT-NEXT:       Value: 0x0

test/ELF/mips-plt-copy.s

 # Check creating of R_MIPS_COPY and R_MIPS_JUMP_SLOT dynamic relocations
 # and corresponding PLT entries.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-dynamic.s -o %t.so.o
 # RUN: ld.lld %t.so.o -shared -o %t.so
 # RUN: ld.lld %t.o %t.so -o %t.exe
 # RUN: llvm-readobj -r -mips-plt-got %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rel.dyn {
-# CHECK-NEXT:     0x{{[0-9A-F]+}} R_MIPS_COPY data0 0x0
 # CHECK-NEXT:     0x{{[0-9A-F]+}} R_MIPS_COPY data1 0x0
+# CHECK-NEXT:     0x{{[0-9A-F]+}} R_MIPS_COPY data0 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Section ({{.*}}) .rel.plt {
 # CHECK-NEXT:     0x{{[0-9A-F]+}} R_MIPS_JUMP_SLOT foo0 0x0
 # CHECK-NEXT:     0x{{[0-9A-F]+}} R_MIPS_JUMP_SLOT foo1 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 # CHECK:      Primary GOT {

test/ELF/mips-sto-plt.s

 # Check assigning STO_MIPS_PLT flag to symbol needs a pointer equality.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-dynamic.s -o %t.so.o
 # RUN: ld.lld %t.so.o -shared -o %t.so
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o %t.so -o %t.exe
 # RUN: llvm-readobj -dt -mips-plt-got %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Symbol {
-# CHECK:        Name: foo0@
-# CHECK-NEXT:   Value: 0x0
+# CHECK:        Name: foo1@
+# CHECK-NEXT:   Value: 0x20050
 # CHECK-NEXT:   Size: 0
 # CHECK-NEXT:   Binding: Global
 # CHECK-NEXT:   Type: Function
-# CHECK-NEXT:   Other: 0
+# CHECK-NEXT:   Other [ (0x8)
+# CHECK-NEXT:     STO_MIPS_PLT
+# CHECK-NEXT:   ]
 # CHECK-NEXT:   Section: Undefined
 # CHECK-NEXT: }
 # CHECK:      Symbol {
-# CHECK:        Name: foo1@
-# CHECK-NEXT:   Value: 0x20050
+# CHECK:        Name: foo0@
+# CHECK-NEXT:   Value: 0x0
 # CHECK-NEXT:   Size: 0
 # CHECK-NEXT:   Binding: Global
 # CHECK-NEXT:   Type: Function
-# CHECK-NEXT:   Other [ (0x8)
-# CHECK-NEXT:     STO_MIPS_PLT
-# CHECK-NEXT:   ]
+# CHECK-NEXT:   Other: 0
 # CHECK-NEXT:   Section: Undefined
 # CHECK-NEXT: }
 
 # CHECK:      Primary GOT {
 # CHECK:        Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]