[ELF][MIPS] Multi-GOT implementation

[atanasyan]

Summary

Almost all entries inside MIPS GOT are referenced by signed 16-bit index. Zero entry lies approximately in the middle of the GOT. So the total number of GOT entries cannot exceed ~16384 for 32-bit architecture and ~8192 for 64-bit architecture. This limitation makes impossible to link rather large application like for example LLVM+Clang. There are two workaround for this problem. The first one is using the -mxgot compiler's flag. It enables using a 32-bit index to access GOT entries. But each access requires two assembly instructions two load GOT entry index to a register. Another workaround is multi-GOT. This patch implements it.

Here is a brief description of multi-GOT for detailed one see the following link https://dmz-portal.mips.com/wiki/MIPS_Multi_GOT.

If the sum of local, global and tls entries is less than 64K only single got is enough. Otherwise, multi-got is created. Series of primary and multiple secondary GOTs have the following layout:

- Primary GOT
    Header
    Local entries
    Global entries
    Relocation only entries
    TLS entries

- Secondary GOT
    Local entries
    Global entries
    TLS entries
...

All GOT entries required by relocations from a single input file entirely belong to either primary or one of secondary GOTs. To reference GOT entries each GOT has its own _gp value points to the "middle" of the GOT. In the code this value loaded to the register which is used for GOT access.

MIPS 32 function's prologue:

lui     v0,0x0
0: R_MIPS_HI16  _gp_disp
addiu   v0,v0,0
4: R_MIPS_LO16  _gp_disp

MIPS 64 function's prologue:

lui     at,0x0
14: R_MIPS_GPREL16  main

Dynamic linker does not know anything about secondary GOTs and cannot use a regular MIPS mechanism for GOT entries initialization. So we have to use an approach accepted by other architectures and create dynamic relocations R_MIPS_REL32 to initialize global entries (and local in case of PIC code) in secondary GOTs. But ironically MIPS dynamic linker requires GOT entries and correspondingly ordered dynamic symbol table entries to deal with dynamic relocations. To handle this problem relocation-only section in the primary GOT contains entries for all symbols referenced in global parts of secondary GOTs. Although the sum of local and normal global entries of the primary got should be less than 64K, the size of the primary got (including relocation-only entries can be greater than 64K, because parts of the primary got that overflow the 64K limit are used only by the dynamic linker at dynamic link-time and not by 16-bit gp-relative addressing at run-time.

The patch affects common LLD code in the following places:

• Added new hidden -mips-got-size flag. This flag required to set low maximum size of a single GOT to be able to test the implementation using small test cases.
• Added InputFile argument to the getRelocTargetVA function. The same symbol referenced by GOT relocation from different input file might be allocated in different GOT. So result of relocation depends on the file.
• Added new ctor to the DynamicReloc class. This constructor records settings of dynamic relocation which used to adjust address of 64kb page lies inside a specific output section.

With the patch LLD is able to link all LLVM+Clang+LLD applications and libraries for MIPS 32/64 targets.

[emaste]

I had ELF/mips-got-and-copy.s fail for me with this applied, with .../mips-got-and-copy.s.tmp.o:(.text+0xC): relocation R_MIPS_GOT16 out of range

[atanasyan]

In D31528#715540, @emaste wrote:

I had ELF/mips-got-and-copy.s fail for me with this applied, with .../mips-got-and-copy.s.tmp.o:(.text+0xC): relocation R_MIPS_GOT16 out of range

Is the error reproduced each time? I just made a clean build with the patch and did not see the error.

[emaste]

In D31528#715638, @atanasyan wrote:

Is the error reproduced each time? I just made a clean build with the patch and did not see the error.

This was in a clean build with the patch, while I'm setting up a new development desktop. It was actually my first build; I saw the error, reverted the patch, and did not see it again, but I haven't yet confirmed it's always reproducible.

[ruiu]

This is not your fault, but I have to say that this MIPS GOT layout is very odd, too different from other architectures, and too complicated. I want to avoid supporting this unless I'm convinced that it is absolutely necessary. It seems to me that MIPS needs a clean, common new ABI. Only the MIPS ABI imposes a lot of restrictions on the size of GOT sections and the order of GOT section members, even though MIPS as a processor is an ordinary RISC ISA. This change would really hurt maintainability of LLD which I already found some MIPS-specific behavior is hard to keep it right when editing code for all the other architectures.

I wonder what is the performance penalty you would have to pay when you use the -mxgot option. With the option, you'll need three instructions as opposed to a single instruction to access an GOT entry. Does that actually make observable difference in performance?

ELF/DriverUtils.cpp

31

Do you need this?

[emaste]

One other note, I tried linking the FreeBSD base system on mips64 with this patch applied (since we require mxgot or multigot to be able to link the entirety of the base system), and have a reproducible segfault in lld. A reproducer is at https://people.freebsd.org/~emaste/lld/lld-mips.tar. It seems the crash is reproducible after reverting the patch, so I'll submit a bug for it shortly.

I also tried a debug build with and without this patch (twice each), and reproduced the ELF/mips-got-and-copy.s issue with the patch and not without. Since it didn't happen for you I'll try to collect some more detail about the failure.

[atanasyan]

In D31528#716728, @emaste wrote:

I also tried a debug build with and without this patch (twice each), and reproduced the ELF/mips-got-and-copy.s issue with the patch and not without. Since it didn't happen for you I'll try to collect some more detail about the failure.

Thanks a lot for your help. BTW what tools and libraries do you use to build LLD: Clang (what version?) or gcc, libc++ or libstdc++?

[emaste]

In D31528#716759, @atanasyan wrote:

Thanks a lot for your help. BTW what tools and libraries do you use to build LLD: Clang (what version?) or gcc, libc++ or libstdc++?

This is the integrated tool-chain in FreeBSD-current, with one non-default configuration: using LLD as /usr/bin/ld. So it's Clang, LLD, and libc++ 4.0.0, ELF Tool Chain objcopy / strip, and FreeBSD's libc & libthr (== libpthread).

[emaste]

I compared the tmp objects in the failing and passing case using diffoscope and noticed one unexpected difference, although it does not appear to be root cause of the failure.

With stat() differences elided I see:

--- fail
+++ work
├── file list
│ @@ -1,3 +1,4 @@
│ +mips-got-and-copy.s.tmp.exe
│  mips-got-and-copy.s.tmp.o
│  mips-got-and-copy.s.tmp.so
│  mips-got-and-copy.s.tmp.so.o
├── mips-got-and-copy.s.tmp.so
├── readelf --wide --symbols {}
│ │ @@ -1,16 +1,16 @@
│ │  
│ │  Symbol table '.dynsym' contains 6 entries:
│ │     Num:    Value  Size Type    Bind   Vis      Ndx Name
│ │       0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
│ │ -     1: 00010008     0 FUNC    GLOBAL DEFAULT    7 foo1
│ │ -     2: 00010004     0 FUNC    GLOBAL DEFAULT    7 foo0
│ │ +     1: 00010000     0 NOTYPE  GLOBAL DEFAULT    7 _foo
│ │ +     2: 00020000     4 OBJECT  GLOBAL DEFAULT    8 data0
│ │       3: 00020004     4 OBJECT  GLOBAL DEFAULT    8 data1
│ │ -     4: 00020000     4 OBJECT  GLOBAL DEFAULT    8 data0
│ │ -     5: 00010000     0 NOTYPE  GLOBAL DEFAULT    7 _foo
│ │ +     4: 00010004     0 FUNC    GLOBAL DEFAULT    7 foo0
│ │ +     5: 00010008     0 FUNC    GLOBAL DEFAULT    7 foo1
│ │  
│ │  Symbol table '.symtab' contains 8 entries:
│ │     Num:    Value  Size Type    Bind   Vis      Ndx Name
│ │       0: 00000000     0 NOTYPE  LOCAL  DEFAULT  UND 
│ │       1: 00028000     0 NOTYPE  LOCAL  HIDDEN   ABS _gp
│ │       2: 000001c0     0 NOTYPE  LOCAL  HIDDEN     5 _DYNAMIC
│ │       3: 00010000     0 NOTYPE  GLOBAL DEFAULT    7 _foo
├── readelf --wide --decompress --hex-dump=.hash {}
│ │ @@ -1,7 +1,7 @@
│ │  
│ │  Hex dump of section '.hash':
│ │ -  0x00000188 00000006 00000006 00000002 00000001 ................
│ │ -  0x00000198 00000004 00000003 00000000 00000005 ................
│ │ +  0x00000188 00000006 00000006 00000004 00000005 ................
│ │ +  0x00000198 00000002 00000003 00000000 00000001 ................
│ │    0x000001a8 00000000 00000000 00000000 00000000 ................
│ │    0x000001b8 00000000 00000000                   ........

so for some reason the sort order for .dynsym is reversed between the two cases.

[atanasyan]

• Removed unused MIPS specific fields from the SymbolBody class.
• Update comments.

[atanasyan]

• Rebase the patch
• Fix GOT entry allocation for symbols which have related dynamic copy relocations

[arichardson]

In D31528#715906, @ruiu wrote:

This is not your fault, but I have to say that this MIPS GOT layout is very odd, too different from other architectures, and too complicated. I want to avoid supporting this unless I'm convinced that it is absolutely necessary. It seems to me that MIPS needs a clean, common new ABI. Only the MIPS ABI imposes a lot of restrictions on the size of GOT sections and the order of GOT section members, even though MIPS as a processor is an ordinary RISC ISA. This change would really hurt maintainability of LLD which I already found some MIPS-specific behavior is hard to keep it right when editing code for all the other architectures.

I wonder what is the performance penalty you would have to pay when you use the -mxgot option. With the option, you'll need three instructions as opposed to a single instruction to access an GOT entry. Does that actually make observable difference in performance?

-mxgot does not seem to be enough to run many binaries on FreeBSD mips64. I think this is because local static variables are still accessed using a single 16 bit offset and for larger programs this is not sufficient. I am currently trying to build postgres for MIPS FreeBSD and without the multigot patch I can't link it although all source files are being compiled with -mxgot.

[atanasyan]

• Rebased against the trunk
• Added a comment

[atanasyan]

• Rebased against the trunk

Ping?

[atanasyan]

Rebased against the trunk.

[atanasyan]

• Rebased against the trunk

[atanasyan]

Rebased against the trunk.

Is there any chance of getting review for this patch on the next week or so?

[atanasyan]

Ping?

[atanasyan]

Rebased against the trunk.

Any chance to get review before LLD 6 or 7 release?

[atanasyan]

Rebased against the trunk.

[arichardson]

We have been using this patch successfully for building CheriBSD (FreeBSD running on the CHERI CPU) for the last few months. Without it we can't build the base system even if we use -mxgot for every object.
The same problem happens when building upstream FreeBSD for MIPS64 so it would be great if this patch could be merged before the next LLD release.

[atanasyan]

Rebased against the trunk.

[atanasyan]

• Rebased against the trunk.
• Celebrated the first half a year of the patch reviewing.

[atanasyan]

Rebased against the trunk.

[ruiu]

I'll make more changes to Relocations.cpp and other files, so you might want to rebase all at once.

[brad]

Rebase and get this in for 6?

[atanasyan]

Rebased against the trunk.

[arichardson]

I would be really great if this patch could be added to LLD soon. I believe this is the last change needed before we can use LLD to build the whole FreeBSD MIPS base system.

Could you rebase this on the latest master please? I tried updating our LLD fork (which includes this patch) to Jan 1st and am now getting three test failures:

Failing Tests (3):
    lld :: ELF/mips-got-redundant.s
    lld :: ELF/mips-got16.s
    lld :: ELF/mips-mgot.s

I have not debugged yet whether if this is because I didn't resolve the merge conflicts correctly or whether LLD has changed in a way that breaks the tests.

[arichardson]

As this patch is essential for being able to link any of our code I did some bisection and it turns out that the tests start failing after rL320472 (D38361).

It is not obvious to me why that commit would break the multigot implementation but here are my findings so far:

Before that commit the mips .got section is 112 bytes (good) for the mips-mgot.s test and afterwards it's only 108 bytes (bad). It also makes rela.dyn go from 184 (good) bytes to 96 bytes (bad).

Passing test case before rL320472:

Contents of section .got:
 60000 00000000 80000000 00010000 00010030  ...............0
 60010 00020000 00030000 00040000 00050000  ................
 60020 00060000 00070000 00000000 00000000  ................
 60030 00000004 00000000 00000000 00000000  ................
 60040 00000000 00020000 00030000 00040000  ................
 60050 00050000 00060000 00070000 00000000  ................
 60060 00000000 00000000 00000000 00000000  ................

Broken GOT afterwards:

Contents of section .got:
 60000 00000000 80000000 00020000 00030000  ................
 60010 00010000 00010030 00000000 00000004  .......0........
 60020 00000000 00000000 00000000 00000000  ................
 60030 00020000 00030000 00040000 00050000  ................
 60040 00000000 00070000 00000000 00000000  ................
 60050 00000000 00000000 00000000 00000000  ................
 60060 00000000 00000000 00000000           ............

[atanasyan]

In D31528#975779, @arichardson wrote:

As this patch is essential for being able to link any of our code I did some bisection and it turns out that the tests start failing after rL320472 (D38361).

I found the reason of the regression. Working on the fix.

[atanasyan]

Rebased against the trunk and fixed calculation of a GOT entries number.

[grimar]

Few quick minor comments/suggestions.

ELF/DriverUtils.cpp

31

Seems unused.

ELF/InputFiles.h

100

May be type could be Optional<> ?

ELF/SyntheticSections.cpp

758

Does not seem assert is needed here. It anyways will either assert or crash on error,
not a huge difference probably. I would simplify:

if (Sym->isTls())
    return G.Tls.find(Sym)->second * Config->Wordsize;
if (Sym->IsPreemptible)
    return G.Global.find(Sym)->second * Config->Wordsize;
...

The same in getGlobalDynOffset and other places.

ELF/SyntheticSections.h

342

Looks it can be MapVector<InputFile *, FileGot>.
Then probably you will not need to add InputFile::MipsGotIndex member.

400

Excessive space: uint64_t OffsetInSec

[atanasyan]

I'm going to submit updated patch soon.

ELF/DriverUtils.cpp

31

Without this line I get the following error message because Options.td includes the HelpHidden flag:

In file included from /home/simon/work/lld/git/tools/lld/ELF/DriverUtils.cpp:48:
tools/lld/ELF/Options.inc:201:87: error: use of undeclared identifier 'HelpHidden'; did you mean 'llvm::opt::HelpHidden'?

ELF/InputFiles.h

100

OK

ELF/SyntheticSections.cpp

758

OK. Good point.

ELF/SyntheticSections.h

342

While we collect requests for GOT entries, each input file containing GOT relocations has its own entry in the Gots container. But in the MipsGotSection::build method number of separated GOTs is reduced my merging and multiple files might start to refer a single GOT. So we need something like MapVector<InputFile *, FileGot *>. That makes more complicated at least GOT writing because we will not be able to iterate the Gots container and write each entry but have to extract unique GOT.

400

OK

[atanasyan]

• Addressing review comments
• Fixing some typos

[atanasyan]

We have a chance to celebrate the first anniversary of this patch in a couple of months. Is it possible to escape this dubious holiday?

[emaste]

In D31528#987543, @atanasyan wrote:

We have a chance to celebrate the first anniversary of this patch in a couple of months. Is it possible to escape this dubious holiday?

I certainly hope so! In FreeBSD we've been using lld as the linker for arm64 for a little while, and the migration is in various states of progress for amd64 (should be complete soon), armv7, and i386. MIPS is probably the next architecture for us to start working on switching if this patch lands.

[atanasyan]

Ping?

[atanasyan]

Ping?

[atanasyan]

Rebased against the trunk.

[arichardson]

Thank you very much for updating this patch! I have just made the switch in CheriBSD to completely stop using ld.bfd and so far everything I have tested is working.

ELF/SyntheticSections.cpp

1100

This could probably use the 4 argument overload since there is no addend.

1109

Same for the following 3 calls.

ELF/SyntheticSections.h

399

RelType Type

[atanasyan]

• Addressing review comments

[atanasyan]

Ping?

[atanasyan]

Ping? In less than four weeks we will celebrate the first anniversary of this patch.

[atanasyan]

Ping?

[atanasyan]

Ping? Any chance to push this patch this year?

[atanasyan]

Ping?

[atanasyan]

Rebased against the trunk.

[atanasyan]

Let's celebrate the first anniversary of the patch.

[atanasyan]

Ping?

[emaste]

Happy belated birthday Multi-GOT patch

[atanasyan]

Rebased against the trunk.

[arichardson]

Thank you very much for updating this patch! I will be merging from upstream LLVM soon and having this rebased makes the merging so much easier.

(Also happy belated birthday D31528. Hopefully it will not have a second birthday...)

[atanasyan]

Rebased against the trunk.

[atanasyan]

Rebased against the trunk.

[atanasyan]

Ping?

[atanasyan]

Ping?

[arichardson]

As I have mentioned before, having this patch is the difference between LLD being completely unusable for our purposes (linking FreeBSD MIPS n64) and being able to replace BFD.

We have been carrying this in our fork for about a year now and I have not noticed any issues. Thank you very much for updating the patch so frequently since otherwise merging from upstream would be much harder.

@ruiu any chace you could review this? The patch also has the advantage that it removes two MIPS-specific members from Symbol and moves all the MIPS GOT handling to the MipsGotSection class instead.

[atanasyan]

Ping?

@ruiu could I use a post-commit review option in that case?

[emaste]

In D31528#1114868, @atanasyan wrote:

Ping?

@ruiu could I use a post-commit review option in that case?

I very much hope so.

[atanasyan]

Rebased against the trunk.

@ruiu I asked you about a possibility of post-commit review nine days ago. It looks like even getting a 'yes/no' answer requires days of waiting.

[grimar]

I think that:

1. Simon is obviously an expert in MIPS. We have probably no other good reviewers on this platform here anyways.
2. Patch has no critical stylish issues. I added few minor nits though. Anything else can be fixed after.
3. It already took really too long to progress.
4. Patch mostly affects MIPS parts of the LLD code (so it is isolated).
5. Post-commit reviews are OK in general practice.
6. It is important and desired patch for FreeBSD.

Given that. LGTM.

ELF/SyntheticSections.cpp

787–794

Early return?

if (Gots.empty())
  return nullptr;

992

Doesn't seem you need this.

[brad]

OpenBSD/mips64 is looking at switching to LLVM/Clang and this would be required for us when we look at using lld for the linker.

[arichardson]

ELF/DriverUtils.cpp

31

It seems like this is now already included two lines further down

[atanasyan]

Thanks for all for your support, review and comments.

ELF/Config.h

struct Configuration {
   Target2Policy Target2;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint64_t ErrorLimit = 20;
   uint64_t ImageBase;
   uint64_t MaxPageSize;
+  uint64_t MipsGotSize;
   uint64_t ZStackSize;
   unsigned LTOPartitions;
   unsigned LTOO;
   unsigned Optimize;
   unsigned ThinLTOJobs;
 
   // The following config options do not directly correspond to any
   // particualr command line options.

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->GdbIndex = Args.hasArg(OPT_gdb_index);
   Config->ICF = Args.hasArg(OPT_icf);
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LTOAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LTONewPmPasses = getString(Args, OPT_lto_newpm_passes);
   Config->LTOO = getInteger(Args, OPT_lto_O, 2);
   Config->LTOPartitions = getInteger(Args, OPT_lto_partitions, 1);
   Config->MapFile = getString(Args, OPT_Map);
+  Config->MipsGotSize = getInteger(Args, OPT_mips_got_size, 0xfff0);
   Config->NoGnuUnique = Args.hasArg(OPT_no_gnu_unique);
   Config->NoUndefinedVersion = Args.hasArg(OPT_no_undefined_version);
   Config->Nostdlib = Args.hasArg(OPT_nostdlib);
   Config->OFormatBinary = isOutputFormatBinary(Args);
   Config->Omagic = Args.hasArg(OPT_omagic);
   Config->OptRemarksFilename = getString(Args, OPT_opt_remarks_filename);
   Config->OptRemarksWithHotness = Args.hasArg(OPT_opt_remarks_with_hotness);
   Config->Optimize = getInteger(Args, OPT_O, 1);

ELF/DriverUtils.cpp

 #include "llvm/ADT/Triple.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 
 using namespace llvm;
+using namespace llvm::opt;
 using namespace llvm::sys;
 
 using namespace lld;
 using namespace lld::elf;
 
 // Create OptTable
 
 // Create prefix string literals used in Options.td

ELF/InputFiles.h

public:
   // have ELF type (i.e. ELF{32,64}{LE,BE}) and target machine type.
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;
   uint8_t OSABI = 0;
 
   // Cache for toString(). Only toString() should use this member.
   mutable std::string ToStringCache;
 
+  // Index of MIPS GOT built for this file.
+  size_t MipsGotIndex = -1;
+
 protected:
   InputFile(Kind K, MemoryBufferRef M);
   std::vector<InputSectionBase *> Sections;
 
 private:
   const Kind FileKind;
 };
 

ELF/InputSection.cpp

case R_AARCH64_TSTBR14:
     return P + 4;
   default:
     return A;
   }
 }
 
 template <class ELFT>
 static typename ELFT::uint
-getRelocTargetVA(uint32_t Type, int64_t A, typename ELFT::uint P,
-                 const SymbolBody &Body, RelExpr Expr) {
+getRelocTargetVA(const InputFile &File, uint32_t Type, int64_t A,
+                 typename ELFT::uint P, const SymbolBody &Body, RelExpr Expr) {
   switch (Expr) {
   case R_ABS:
   case R_RELAX_GOT_PC_NOPIC:
     return Body.getVA(A);
   case R_GOT:
   case R_RELAX_TLS_GD_TO_IE_ABS:
     return Body.getGotVA<ELFT>() + A;
   case R_GOTONLY_PC:
getRelocTargetVA(const InputFile &File, uint32_t Type, int64_t A,
   case R_GOT_PC:
   case R_RELAX_TLS_GD_TO_IE:
     return Body.getGotVA<ELFT>() + A - P;
   case R_HINT:
   case R_NONE:
   case R_TLSDESC_CALL:
     llvm_unreachable("cannot relocate hint relocs");
   case R_MIPS_GOTREL:
-    return Body.getVA(A) - In<ELFT>::MipsGot->getGp();
+    return Body.getVA(A) - In<ELFT>::MipsGot->getGp(&File);
   case R_MIPS_GOT_GP:
-    return In<ELFT>::MipsGot->getGp() + A;
+    return In<ELFT>::MipsGot->getGp(&File) + A;
   case R_MIPS_GOT_GP_PC: {
     // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target
     // is _gp_disp symbol. In that case we should use the following
     // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    uint64_t V = In<ELFT>::MipsGot->getGp() + A - P;
+    uint64_t V = In<ELFT>::MipsGot->getGp(&File) + A - P;
     if (Type == R_MIPS_LO16)
       V += 4;
     return V;
   }
   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 In<ELFT>::MipsGot->getVA() +
-           In<ELFT>::MipsGot->getPageEntryOffset(Body, A) -
-           In<ELFT>::MipsGot->getGp();
+           In<ELFT>::MipsGot->getPageEntryOffset(File, Body, A) -
+           In<ELFT>::MipsGot->getGp(&File);
   case R_MIPS_GOT_OFF:
   case R_MIPS_GOT_OFF32:
     // 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 In<ELFT>::MipsGot->getVA() +
-           In<ELFT>::MipsGot->getBodyEntryOffset(Body, A) -
-           In<ELFT>::MipsGot->getGp();
+           In<ELFT>::MipsGot->getBodyEntryOffset(File, Body, A) -
+           In<ELFT>::MipsGot->getGp(&File);
   case R_MIPS_TLSGD:
-    return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() +
-           In<ELFT>::MipsGot->getGlobalDynOffset(Body) -
-           In<ELFT>::MipsGot->getGp();
+    return In<ELFT>::MipsGot->getVA() +
+           In<ELFT>::MipsGot->getGlobalDynOffset(File, Body) -
+           In<ELFT>::MipsGot->getGp(&File);
   case R_MIPS_TLSLD:
-    return In<ELFT>::MipsGot->getVA() + In<ELFT>::MipsGot->getTlsOffset() +
-           In<ELFT>::MipsGot->getTlsIndexOff() - In<ELFT>::MipsGot->getGp();
+    return In<ELFT>::MipsGot->getVA() +
+           In<ELFT>::MipsGot->getTlsIndexOffset(File) -
+           In<ELFT>::MipsGot->getGp(&File);
   case R_PAGE_PC:
   case R_PLT_PAGE_PC:
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
       return getAArch64Page(A);
     return getAArch64Page(Body.getVA(A)) - getAArch64Page(P);
   case R_PC:
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak()) {
       // On ARM and AArch64 a branch to an undefined weak resolves to the
if (Expr != R_ABS) {
       error(this->getLocation<ELFT>(Offset) + ": has non-ABS reloc");
       return;
     }
 
     uintX_t AddrLoc = this->OutSec->Addr + Offset;
     uint64_t SymVA = 0;
     if (!Sym.isTls() || Out::TlsPhdr)
       SymVA = SignExtend64<sizeof(uintX_t) * 8>(
-          getRelocTargetVA<ELFT>(Type, Addend, AddrLoc, Sym, R_ABS));
+          getRelocTargetVA<ELFT>(*File, Type, Addend, AddrLoc, Sym, R_ABS));
     Target->relocateOne(BufLoc, Type, SymVA);
   }
 }
 
 template <class ELFT> elf::ObjectFile<ELFT> *InputSectionBase::getFile() const {
   return cast_or_null<elf::ObjectFile<ELFT>>(File);
 }
 
void InputSectionBase::relocate(uint8_t *Buf, uint8_t *BufEnd) {
   const unsigned Bits = sizeof(uintX_t) * 8;
   for (const Relocation &Rel : Relocations) {
     uint64_t Offset = getOffset(Rel.Offset);
     uint8_t *BufLoc = Buf + Offset;
     uint32_t Type = Rel.Type;
 
     uintX_t AddrLoc = getOutputSection()->Addr + Offset;
     RelExpr Expr = Rel.Expr;
-    uint64_t TargetVA = SignExtend64<Bits>(
-        getRelocTargetVA<ELFT>(Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr));
+    uint64_t TargetVA = SignExtend64<Bits>(getRelocTargetVA<ELFT>(
+        *File, Type, Rel.Addend, AddrLoc, *Rel.Sym, Expr));
 
     switch (Expr) {
     case R_RELAX_GOT_PC:
     case R_RELAX_GOT_PC_NOPIC:
       Target->relaxGot(BufLoc, TargetVA);
       break;
     case R_RELAX_TLS_IE_TO_LE:
       Target->relaxTlsIeToLe(BufLoc, Type, TargetVA);

ELF/Options.td

 def opt_remarks_with_hotness: Flag<["--"], "opt-remarks-with-hotness">,
   HelpText<"Include hotness informations in the optimization remarks file">;
 def save_temps: F<"save-temps">;
 def thinlto_cache_dir: J<"thinlto-cache-dir=">,
   HelpText<"Path to ThinLTO cached object file directory">;
 def thinlto_cache_policy: S<"thinlto-cache-policy">,
   HelpText<"Pruning policy for the ThinLTO cache">;
 def thinlto_jobs: J<"thinlto-jobs=">, HelpText<"Number of ThinLTO jobs">;
+
+// Hidden option used for testing MIPS multi-GOT implementation.
+def mips_got_size: S<"mips-got-size">, Flags<[HelpHidden]>,
+  HelpText<"Max size of a single MIPS GOT. 0x10000 by default.">;

ELF/Relocations.cpp

 }
 
 // This function is similar to the `handleTlsRelocation`. MIPS does not
 // support any relaxations for TLS relocations so by factoring out MIPS
 // handling in to the separate function we can simplify the code and do not
 // pollute other `handleTlsRelocation` by MIPS `ifs` statements.
 // Mips has a custom MipsGotSection that handles the writing of GOT entries
 // without dynamic relocations.
-template <class ELFT>
 static unsigned handleMipsTlsRelocation(uint32_t Type, SymbolBody &Body,
                                         InputSectionBase &C, uint64_t Offset,
                                         int64_t Addend, RelExpr Expr) {
   if (Expr == R_MIPS_TLSLD) {
-    if (In<ELFT>::MipsGot->addTlsIndex() && Config->Pic)
-      In<ELFT>::RelaDyn->addReloc({Target->TlsModuleIndexRel, In<ELFT>::MipsGot,
-                                   In<ELFT>::MipsGot->getTlsIndexOff(), false,
-                                   nullptr, 0});
+    InX::MipsGot->addTlsIndex(*C.File);
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
-
   if (Expr == R_MIPS_TLSGD) {
-    if (In<ELFT>::MipsGot->addDynTlsEntry(Body) && Body.isPreemptible()) {
-      uint64_t Off = In<ELFT>::MipsGot->getGlobalDynOffset(Body);
-      In<ELFT>::RelaDyn->addReloc(
-          {Target->TlsModuleIndexRel, In<ELFT>::MipsGot, Off, false, &Body, 0});
-      if (Body.isPreemptible())
-        In<ELFT>::RelaDyn->addReloc({Target->TlsOffsetRel, In<ELFT>::MipsGot,
-                                     Off + Config->Wordsize, false, &Body, 0});
-    }
+    InX::MipsGot->addDynTlsEntry(*C.File, Body);
     C.Relocations.push_back({Expr, Type, Offset, Addend, &Body});
     return 1;
   }
   return 0;
 }
 
 // This function is similar to the `handleMipsTlsRelocation`. ARM also does not
 // support any relaxations for TLS relocations. ARM is logically similar to Mips
if (!(C.Flags & SHF_ALLOC))
     return 0;
 
   if (!Body.isTls())
     return 0;
 
   if (Config->EMachine == EM_ARM)
     return handleARMTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr);
   if (Config->EMachine == EM_MIPS)
-    return handleMipsTlsRelocation<ELFT>(Type, Body, C, Offset, Addend, Expr);
+    return handleMipsTlsRelocation(Type, Body, C, Offset, Addend, Expr);
 
   bool IsPreemptible = isPreemptible(Body, Type);
   if (isRelExprOneOf<R_TLSDESC, R_TLSDESC_PAGE, R_TLSDESC_CALL>(Expr) &&
       Config->Shared) {
     if (In<ELFT>::Got->addDynTlsEntry(Body)) {
       uint64_t Off = In<ELFT>::Got->getGlobalDynOffset(Body);
       In<ELFT>::RelaDyn->addReloc({Target->TlsDescRel, In<ELFT>::Got, Off,
                                    !IsPreemptible, &Body, 0});
if (needsGot(Expr)) {
       if (Config->EMachine == EM_MIPS) {
         // MIPS ABI has special rules to process GOT entries and doesn't
         // require relocation entries for them. A special case is TLS
         // relocations. In that case dynamic loader applies dynamic
         // relocations to initialize TLS 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
-        In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
-        if (Body.isTls() && Body.isPreemptible())
-          In<ELFT>::RelaDyn->addReloc({Target->TlsGotRel, In<ELFT>::MipsGot,
-                                       Body.getGotOffset(), false, &Body, 0});
+        In<ELFT>::MipsGot->addEntry(*Sec.File, Body, Addend, Expr);
       } else if (!Body.isInGot()) {
         addGotEntry<ELFT>(Body, Preemptible);
       }
     }
 
     if (!needsPlt(Expr) && !needsGot(Expr) && isPreemptible(Body, Type)) {
       // We don't know anything about the finaly symbol. Just ask the dynamic
       // linker to handle the relocation for us.
if (!needsPlt(Expr) && !needsGot(Expr) && isPreemptible(Body, Type)) {
       // 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)
-        In<ELFT>::MipsGot->addEntry(Body, Addend, Expr);
+        In<ELFT>::MipsGot->addEntry(*Sec.File, Body, Addend, Expr);
       continue;
     }
 
     // If the relocation points to something in the file, we can process it.
     bool IsConstant =
         isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, Sec, Rel.r_offset);
 
     // If the output being produced is position independent, the final value

ELF/Symbols.h

public:
 
   // True the symbol should point to its PLT entry.
   // For SharedSymbol only.
   unsigned NeedsPltAddr : 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;
-
-  // True if this symbol is referenced by 32-bit GOT relocations.
-  unsigned Is32BitMipsGot : 1;
-
   // True if this symbol is in the Iplt sub-section of the Plt.
   unsigned IsInIplt : 1;
 
   // True if this symbol is in the Igot sub-section of the .got.plt or .got.
   unsigned IsInIgot : 1;
 
   // The following fields have the same meaning as the ELF symbol attributes.
   uint8_t Type;    // symbol type

ELF/Symbols.cpp

case SymbolBody::LazyObjectKind:
     return 0;
   }
   llvm_unreachable("invalid symbol kind");
 }
 
 SymbolBody::SymbolBody(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
                        uint8_t Type)
     : SymbolKind(K), NeedsCopy(false), NeedsPltAddr(false), IsLocal(IsLocal),
-      IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
-      IsInIgot(false), Type(Type), StOther(StOther), Name(Name) {}
+      IsInIplt(false), IsInIgot(false), Type(Type), StOther(StOther),
+      Name(Name) {}
 
 // 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

ELF/SyntheticSections.h

 class MipsGotSection final : public SyntheticSection {
 public:
   MipsGotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void updateAllocSize() override;
   void finalizeContents() override;
   bool empty() const override;
-  void addEntry(SymbolBody &Sym, int64_t Addend, RelExpr Expr);
-  bool addDynTlsEntry(SymbolBody &Sym);
-  bool addTlsIndex();
-  uint64_t getPageEntryOffset(const SymbolBody &B, int64_t Addend) const;
-  uint64_t getBodyEntryOffset(const SymbolBody &B, int64_t Addend) const;
-  uint64_t getGlobalDynOffset(const SymbolBody &B) const;
+
+  // Join separate GOTs built for each input file to generate
+  // primary and optional multiple secondary GOTs.
+  template <class ELFT>
+  void build();
+
+  void addEntry(InputFile &File, SymbolBody &Sym, int64_t Addend, RelExpr Expr);
+  void addDynTlsEntry(InputFile &File, SymbolBody &Sym);
+  void addTlsIndex(InputFile &File);
+
+  uint64_t getPageEntryOffset(const InputFile &F, const SymbolBody &B,
+                              int64_t Addend) const;
+  uint64_t getBodyEntryOffset(const InputFile &F, const SymbolBody &B,
+                              int64_t Addend) const;
+  uint64_t getGlobalDynOffset(const InputFile &F, const SymbolBody &B) const;
+  uint64_t getTlsIndexOffset(const InputFile &F) const;
 
   // 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 *getFirstGlobalEntry() const;
 
   // Returns the number of entries in the local part of GOT including
   // the number of reserved entries.
   unsigned getLocalEntriesNum() const;
 
-  // Returns offset of TLS part of the MIPS GOT table. This part goes
-  // after 'local' and 'global' entries.
-  uint64_t getTlsOffset() const;
-
-  uint32_t getTlsIndexOff() const { return TlsIndexOff; }
-
-  uint64_t getGp() const;
+  // Return _gp value for primary GOT (nullptr) or particular input file.
+  uint64_t getGp(const InputFile *F = nullptr) const;
 
 private:
   // MIPS GOT consists of three parts: local, global and tls. Each part
   // contains different types of entries. Here is a layout of GOT:
   // - Header entries                |
   // - Page entries                  |   Local part
   // - Local entries (16-bit access) |
   // - Local entries (32-bit access) |
private:
   //   symbols. They need to be initialized by dynamic linker and they ordered
   //   exactly as the corresponding entries in the dynamic symbols table.
   // Reloc-only global entries:
   //   These entries created for symbols that are referenced by dynamic
   //   relocations R_MIPS_REL32. These entries are not accessed with gp-relative
   //   addressing, but MIPS ABI requires that these entries be present in GOT.
   // TLS entries:
   //   Entries created by TLS relocations.
+  //
+  // If the sum of local, global and tls entries is less than 64K only single
+  // got is enough. Otherwise, multi-got is created. Series of primary and
+  // multiple secondary GOTs have the following layout:
+  // - Primary GOT
+  //     Header
+  //     Local entries
+  //     Global entries
+  //     Relocation only entries
+  //     TLS entries
+  //
+  // - Secondary GOT
+  //     Local entries
+  //     Global entries
+  //     TLS entries
+  // ...
+  //
+  // All GOT entries required by relocations from a single input file entirely
+  // belong to either primary or one of secondary GOTs. To reference GOT entries
+  // each GOT has its own _gp value points to the "middle" of the GOT.
+  // In the code this value loaded to the register which is used for GOT access.
+  //
+  // MIPS 32 function's prologue:
+  //   lui     v0,0x0
+  //   0: R_MIPS_HI16  _gp_disp
+  //   addiu   v0,v0,0
+  //   4: R_MIPS_LO16  _gp_disp
+  //
+  // MIPS 64:
+  //   lui     at,0x0
+  //   14: R_MIPS_GPREL16  main
+  //
+  // Dynamic linker does not know anything about secondary GOTs and cannot
+  // use a regular MIPS mechanism for GOT entries initialization. So we have
+  // to use an approach accepted by other architectures and create dynamic
+  // relocations R_MIPS_REL32 to initialize global entries (and local in case
+  // of PIC code) in secondary GOTs. But ironically MIPS dynamic linker
+  // requires GOT entries and correspondingly ordered dynamic symbol table
+  // entries to deal with dynamic relocations. To handle this problem
+  // relocation-only section in the primary GOT contains entries for all
+  // symbols referenced in global parts of secondary GOTs. Although the sum
+  // of local and normal global entries of the primary got should be less
+  // than 64K, the size of the primary got (including relocation-only entries
+  // can be greater than 64K, because parts of the primary got that overflow
+  // the 64K limit are used only by the dynamic linker at dynamic link-time
+  // and not by 16-bit gp-relative addressing at run-time.
+  //
+  // For complete multi-GOT description see the following link
+  // https://dmz-portal.mips.com/wiki/MIPS_Multi_GOT
 
   // Number of "Header" entries.
   static const unsigned HeaderEntriesNum = 2;
-  // Number of allocated "Page" entries.
-  uint32_t PageEntriesNum = 0;
-  // Map output sections referenced by MIPS GOT relocations
-  // to the first index of "Page" entries allocated for this section.
-  llvm::SmallMapVector<const OutputSection *, size_t, 16> PageIndexMap;
 
-  typedef std::pair<const SymbolBody *, uint64_t> GotEntry;
-  typedef std::vector<GotEntry> GotEntries;
-  // Map from Symbol-Addend pair to the GOT index.
-  llvm::DenseMap<GotEntry, size_t> EntryIndexMap;
-  // Local entries (16-bit access).
-  GotEntries LocalEntries;
-  // Local entries (32-bit access).
-  GotEntries LocalEntries32;
+  uint64_t Size = 0;
 
-  // Normal and reloc-only global entries.
-  GotEntries GlobalEntries;
+  size_t LocalEntriesNum = 0;
 
-  // TLS entries.
-  std::vector<const SymbolBody *> TlsEntries;
+  // Symbol and addend.
+  typedef std::pair<SymbolBody *, int64_t> GotEntry;
 
-  uint32_t TlsIndexOff = -1;
-  uint64_t Size = 0;
+  struct FileGot {
+    InputFile *File = nullptr;
+    size_t StartIndex = 0;
+
+    // Map output sections referenced by MIPS GOT relocations
+    // to the first index of "Page" entries allocated for this section.
+    llvm::SmallMapVector<const OutputSection *, size_t, 16> PageIndexMap;
+    // Maps from Symbol+Addend pair or just Symbol to the GOT entry index.
+    llvm::MapVector<GotEntry, size_t> Local16;
+    llvm::MapVector<GotEntry, size_t> Local32;
+    llvm::MapVector<SymbolBody *, size_t> Global;
+    llvm::MapVector<SymbolBody *, size_t> Relocs;
+    llvm::MapVector<SymbolBody *, size_t> Tls;
+    // Set of symbols referenced by dynamic TLS relocations.
+    llvm::MapVector<SymbolBody *, size_t> DynTlsSymbols;
+
+    size_t getEntriesNum() const;
+    size_t getPageEntriesNum() const;
+    size_t getIndexEntriesNum() const;
+
+    bool isOverflow() const;
+  };
+
+  // Container of GOT created for each input file.
+  // After building a final series of GOTs this container
+  // holds primary ans secondaty GOT's.
+  std::vector<FileGot> Gots;
+
+  // Return (and create if necessary) `FileGot`.
+  FileGot &getGot(InputFile &F);
+
+  // Try to merge two GOTs. In case of success the `Dst` contains
+  // result of merging and the function returns true. In case of
+  // ovwerflow the `Dst` is unchanged and the function returns false.
+  bool tryMergeGots(FileGot & Dst, FileGot & Src, bool IsPrimary);
 };
 
 class GotPltSection final : public SyntheticSection {
 public:
   GotPltSection();
   void addEntry(SymbolBody &Sym);
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
   bool empty() const override { return Entries.empty(); }

 };
 
 class DynamicReloc {
 public:
   DynamicReloc(uint32_t Type, const InputSectionBase *InputSec,
                uint64_t OffsetInSec, bool UseSymVA, SymbolBody *Sym,
                int64_t Addend)
       : Type(Type), Sym(Sym), InputSec(InputSec), OffsetInSec(OffsetInSec),
-        UseSymVA(UseSymVA), Addend(Addend) {}
+        UseSymVA(UseSymVA), Addend(Addend), OutputSec(nullptr) {}
+  // This constructor records dynamic relocation settings used by MIPS
+  // multi-GOT implementation. It's to relocate addresses of 64kb pages
+  // lie inside the output section.
+  DynamicReloc(uint32_t Type, const InputSectionBase *InputSec,
+               uint64_t  OffsetInSec, const OutputSection *OutputSec,
+               int64_t Addend)
+      : Type(Type), Sym(nullptr), InputSec(InputSec), OffsetInSec(OffsetInSec),
+        UseSymVA(false), Addend(Addend), OutputSec(OutputSec) {}
 
   uint64_t getOffset() const;
   int64_t getAddend() const;
   uint32_t getSymIndex() const;
   const InputSectionBase *getInputSec() const { return InputSec; }
 
   uint32_t Type;
 
 private:
   SymbolBody *Sym;
   const InputSectionBase *InputSec = nullptr;
   uint64_t OffsetInSec;
   bool UseSymVA;
   int64_t Addend;
+  const OutputSection *OutputSec;
 };
 
 template <class ELFT> class DynamicSection final : public SyntheticSection {
   typedef typename ELFT::Dyn Elf_Dyn;
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;

ELF/SyntheticSections.cpp

 #include "Memory.h"
 #include "OutputSections.h"
 #include "Strings.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Threads.h"
 #include "Writer.h"
 #include "lld/Config/Version.h"
+#include "llvm/ADT/SetOperations.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugPubTable.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/RandomNumberGenerator.h"
 #include "llvm/Support/SHA1.h"
 #include "llvm/Support/xxhash.h"

 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   this->template relocate<ELFT>(Buf, Buf + Size);
 }
 
 MipsGotSection::MipsGotSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE | SHF_MIPS_GPREL, SHT_PROGBITS, 16,
                        ".got") {}
 
-void MipsGotSection::addEntry(SymbolBody &Sym, int64_t Addend, RelExpr Expr) {
-  // 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
+void MipsGotSection::addEntry(InputFile &File, SymbolBody &Sym, int64_t Addend,
+                              RelExpr Expr) {
+  FileGot &G = getGot(File);
   if (Expr == R_MIPS_GOT_LOCAL_PAGE) {
-    // 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 *DefSym = cast<DefinedRegular>(&Sym);
-    PageIndexMap.insert({DefSym->Section->getOutputSection(), 0});
-    return;
-  }
-  if (Sym.isTls()) {
-    // GOT entries created for MIPS TLS relocations behave like
-    // almost GOT entries from other ABIs. They go to the end
-    // of the global offset table.
-    Sym.GotIndex = TlsEntries.size();
-    TlsEntries.push_back(&Sym);
-    return;
-  }
-  auto AddEntry = [&](SymbolBody &S, uint64_t A, GotEntries &Items) {
-    if (S.isInGot() && !A)
-      return;
-    size_t NewIndex = Items.size();
-    if (!EntryIndexMap.insert({{&S, A}, NewIndex}).second)
-      return;
-    Items.emplace_back(&S, A);
-    if (!A)
-      S.GotIndex = NewIndex;
-  };
-  if (Sym.isPreemptible()) {
-    // Ignore addends for preemptible symbols. They got single GOT entry anyway.
-    AddEntry(Sym, 0, GlobalEntries);
-    Sym.IsInGlobalMipsGot = true;
-  } else if (Expr == R_MIPS_GOT_OFF32) {
-    AddEntry(Sym, Addend, LocalEntries32);
-    Sym.Is32BitMipsGot = true;
-  } else {
-    // Hold local GOT entries accessed via a 16-bit index separately.
-    // That allows to write them in the beginning of the GOT and keep
-    // their indexes as less as possible to escape relocation's overflow.
-    AddEntry(Sym, Addend, LocalEntries);
-  }
+    G.PageIndexMap.insert({DefSym->Section->getOutputSection(), 0});
+  } else if (Sym.isTls())
+    G.Tls.insert({&Sym, 0});
+  else if (Sym.isPreemptible() && Expr == R_ABS)
+    G.Relocs.insert({&Sym, 0});
+  else if (Sym.isPreemptible())
+    G.Global.insert({&Sym, 0});
+  else if (Expr == R_MIPS_GOT_OFF32)
+    G.Local32.insert({{&Sym, Addend}, 0});
+  else
+    G.Local16.insert({{&Sym, Addend}, 0});
+
+void MipsGotSection::addDynTlsEntry(InputFile &File, SymbolBody &Sym) {
+  getGot(File).DynTlsSymbols.insert({&Sym, 0});
 }
 
-bool MipsGotSection::addDynTlsEntry(SymbolBody &Sym) {
-  if (Sym.GlobalDynIndex != -1U)
-    return false;
-  Sym.GlobalDynIndex = TlsEntries.size();
-  // Global Dynamic TLS entries take two GOT slots.
-  TlsEntries.push_back(nullptr);
-  TlsEntries.push_back(&Sym);
-  return true;
+void MipsGotSection::addTlsIndex(InputFile &File) {
+  getGot(File).DynTlsSymbols.insert({nullptr, 0});
 }
 
-// Reserves TLS entries for a TLS module ID and a TLS block offset.
-// In total it takes two GOT slots.
-bool MipsGotSection::addTlsIndex() {
-  if (TlsIndexOff != uint32_t(-1))
-    return false;
-  TlsIndexOff = TlsEntries.size() * Config->Wordsize;
-  TlsEntries.push_back(nullptr);
-  TlsEntries.push_back(nullptr);
-  return true;
+size_t MipsGotSection::FileGot::getEntriesNum() const {
+  return getPageEntriesNum() + Local16.size() + Global.size() + Relocs.size() +
+         Tls.size() + DynTlsSymbols.size() * 2;
 }
 
 static uint64_t getMipsPageAddr(uint64_t Addr) {
   return (Addr + 0x8000) & ~0xffff;
 }
 
 static uint64_t getMipsPageCount(uint64_t Size) {
   return (Size + 0xfffe) / 0xffff + 1;
 }
 
-uint64_t MipsGotSection::getPageEntryOffset(const SymbolBody &B,
+size_t MipsGotSection::FileGot::getPageEntriesNum() const {
+  size_t Num = 0;
+  for (const std::pair<const OutputSection *, size_t> &P : PageIndexMap)
+    Num += getMipsPageCount(P.first->Size);
+  return Num;
+}
+
+size_t MipsGotSection::FileGot::getIndexEntriesNum() const {
+  size_t Count = getPageEntriesNum() + Local16.size() + Global.size();
+  // If there are relocation-only entries in the GOT, TLS entries
+  // are allocated after them. TLS entries should be addressable
+  // by 16-bit index so count both reloc-only and TLS entries.
+  if (!Tls.empty() || !DynTlsSymbols.empty())
+    Count += Relocs.size() + Tls.size() + DynTlsSymbols.size() * 2;
+  return Count;
+}
+
+MipsGotSection::FileGot &MipsGotSection::getGot(InputFile &F) {
+  if (F.MipsGotIndex == size_t(-1)) {
+    Gots.emplace_back();
+    Gots.back().File = &F;
+    F.MipsGotIndex = Gots.size() - 1;
+  }
+  return Gots[F.MipsGotIndex];
+}
+
+uint64_t MipsGotSection::getPageEntryOffset(const InputFile &F,
+                                            const SymbolBody &B,
                                             int64_t Addend) const {
+  const FileGot &G = Gots[F.MipsGotIndex];
   const OutputSection *OutSec =
       cast<DefinedRegular>(&B)->Section->getOutputSection();
   uint64_t SecAddr = getMipsPageAddr(OutSec->Addr);
   uint64_t SymAddr = getMipsPageAddr(B.getVA(Addend));
-  uint64_t Index = PageIndexMap.lookup(OutSec) + (SymAddr - SecAddr) / 0xffff;
-  assert(Index < PageEntriesNum);
-  return (HeaderEntriesNum + Index) * Config->Wordsize;
+  uint64_t Index = G.PageIndexMap.lookup(OutSec) + (SymAddr - SecAddr) / 0xffff;
+  return Index * Config->Wordsize;
 }
 
-uint64_t MipsGotSection::getBodyEntryOffset(const SymbolBody &B,
+uint64_t MipsGotSection::getBodyEntryOffset(const InputFile &F,
+                                            const SymbolBody &B,
                                             int64_t Addend) const {
-  // Calculate offset of the GOT entries block: TLS, global, local.
-  uint64_t Index = HeaderEntriesNum + PageEntriesNum;
-  if (B.isTls())
-    Index += LocalEntries.size() + LocalEntries32.size() + GlobalEntries.size();
-  else if (B.IsInGlobalMipsGot)
-    Index += LocalEntries.size() + LocalEntries32.size();
-  else if (B.Is32BitMipsGot)
-    Index += LocalEntries.size();
-  // Calculate offset of the GOT entry in the block.
-  if (B.isInGot())
-    Index += B.GotIndex;
-  else {
-    auto It = EntryIndexMap.find({&B, Addend});
-    assert(It != EntryIndexMap.end());
-    Index += It->second;
-  }
-  return Index * Config->Wordsize;
+  const FileGot &G = Gots[F.MipsGotIndex];
+  SymbolBody *Body = const_cast<SymbolBody *>(&B);
+  if (B.isTls()) {
+    auto E = G.Tls.find(Body);
+    assert(E != G.Tls.end());
+    return E->second * Config->Wordsize;
+  }
+  if (B.isPreemptible()) {
+    auto E = G.Global.find(Body);
+    assert(E != G.Global.end());
+    return E->second * Config->Wordsize;
+  }
+  auto E = G.Local16.find({Body, Addend});
+  assert(E != G.Local16.end());
+  return E->second * Config->Wordsize;
+
+uint64_t MipsGotSection::getTlsIndexOffset(const InputFile &F) const {
+  const FileGot &G = Gots[F.MipsGotIndex];
+  auto E = G.DynTlsSymbols.find(nullptr);
+  assert(E != G.DynTlsSymbols.end());
+  return E->second * Config->Wordsize;
+}
+
+uint64_t MipsGotSection::getGlobalDynOffset(const InputFile &F,
+                                            const SymbolBody &B) const {
+  const FileGot &G = Gots[F.MipsGotIndex];
+  auto E = G.DynTlsSymbols.find(const_cast<SymbolBody *>(&B));
+  assert(E != G.DynTlsSymbols.end());
+  return E->second * Config->Wordsize;
 }
 
-uint64_t MipsGotSection::getTlsOffset() const {
-  return (getLocalEntriesNum() + GlobalEntries.size()) * Config->Wordsize;
+const SymbolBody *MipsGotSection::getFirstGlobalEntry() const {
+  if (!Gots.empty()) {
+    const FileGot &PrimGot = Gots.front();
+    if (!PrimGot.Global.empty())
+      return PrimGot.Global.front().first;
+    if (!PrimGot.Relocs.empty())
+      return PrimGot.Relocs.front().first;
+  }
+  return nullptr;
 }
 
-uint64_t MipsGotSection::getGlobalDynOffset(const SymbolBody &B) const {
-  return B.GlobalDynIndex * Config->Wordsize;
+unsigned MipsGotSection::getLocalEntriesNum() const {
+  if (Gots.empty())
+    return HeaderEntriesNum;
+  return HeaderEntriesNum + Gots.front().getPageEntriesNum() +
+         Gots.front().Local16.size();
+}
+
+bool MipsGotSection::tryMergeGots(FileGot &Dst, FileGot &Src, bool IsPrimary) {
+  FileGot Tmp = Dst;
+  set_union(Tmp.PageIndexMap, Src.PageIndexMap);
+  set_union(Tmp.Local16, Src.Local16);
+  set_union(Tmp.Global, Src.Global);
+  set_union(Tmp.Relocs, Src.Relocs);
+  set_union(Tmp.Tls, Src.Tls);
+  set_union(Tmp.DynTlsSymbols, Src.DynTlsSymbols);
+
+  size_t Count = (IsPrimary ? HeaderEntriesNum : 0) + Tmp.getIndexEntriesNum();
+  if (Count * Config->Wordsize > Config->MipsGotSize)
+    return false;
+
+  std::swap(Tmp, Dst);
+  return true;
 }
 
-const SymbolBody *MipsGotSection::getFirstGlobalEntry() const {
-  return GlobalEntries.empty() ? nullptr : GlobalEntries.front().first;
+void MipsGotSection::finalizeContents() { updateAllocSize(); }
+
+void MipsGotSection::updateAllocSize() {
+  Size = HeaderEntriesNum * Config->Wordsize;
+  for (const FileGot &G : Gots)
+    Size += G.getEntriesNum() * Config->Wordsize;
 }
 
-unsigned MipsGotSection::getLocalEntriesNum() const {
-  return HeaderEntriesNum + PageEntriesNum + LocalEntries.size() +
-         LocalEntries32.size();
+template <class ELFT> void MipsGotSection::build() {
+  if (Gots.empty())
+    return;
+
+  std::vector<FileGot> MergedGots(1);
+
+  // For each GOT move non-preemptible symbols from the `Global`
+  // to `Local16` list. Preemptible symbol might become non-preemptible
+  // one if, for example, it gets a related copy relocation.
+  for (FileGot &Got : Gots) {
+    for (auto &P: Got.Global)
+      if (!P.first->isPreemptible())
+        Got.Local16.insert({{P.first, 0}, 0});
+    Got.Global.remove_if([&](const std::pair<SymbolBody *, size_t> &P) {
+      return !P.first->isPreemptible();
+    });
   }
 
-void MipsGotSection::finalizeContents() {
-  updateAllocSize();
+  // For each GOT remove "reloc-only" entry if there is "global"
+  // entry for the same symbol. And add local entries which indexed
+  // using 32-bit value at the end of 16-bit entries.
+  for (FileGot &Got : Gots) {
+    Got.Relocs.remove_if([&](const std::pair<SymbolBody *, size_t> &P) {
+      return Got.Global.count(P.first);
+    });
+    set_union(Got.Local16, Got.Local32);
+    Got.Local32.clear();
   }
 
-void MipsGotSection::updateAllocSize() {
-  PageEntriesNum = 0;
-  for (std::pair<const OutputSection *, size_t> &P : PageIndexMap) {
+  // Evaluate number of "reloc-only" entries in the resulting GOT.
+  // To do that put all unique "reloc-only" and "global" entries
+  // from all GOTs to the future primary GOT.
+  FileGot *PrimGot = &MergedGots.front();
+  for (FileGot &Got : Gots) {
+    set_union(PrimGot->Relocs, Got.Global);
+    set_union(PrimGot->Relocs, Got.Relocs);
+    Got.Relocs.clear();
+  }
+
+  // Merge GOTs. Try to join as much as possible GOTs but do not
+  // exceed maximum GOT size. In case of overflow create new GOT
+  // and continue merging.
+  for (FileGot &SrcGot : Gots) {
+    FileGot &DstGot = MergedGots.back();
+    InputFile *File = SrcGot.File;
+    if (!tryMergeGots(DstGot, SrcGot, &DstGot == PrimGot)) {
+      MergedGots.emplace_back();
+      std::swap(MergedGots.back(), SrcGot);
+    }
+    File->MipsGotIndex = MergedGots.size() - 1;
+  }
+  std::swap(Gots, MergedGots);
+
+  // Reduce number of "reloc-only" entries in the primary GOT
+  // by substracting "global" entries exist in the primary GOT.
+  PrimGot = &Gots.front();
+  PrimGot->Relocs.remove_if([&](const std::pair<SymbolBody *, size_t> &P) {
+    return PrimGot->Global.count(P.first);
+  });
+
+  // Calculate indexes for each GOT entry.
+  size_t Index = HeaderEntriesNum;
+  for (FileGot &Got : Gots) {
+    Got.StartIndex = &Got == PrimGot ? 0 : Index;
+    for (std::pair<const OutputSection *, size_t> &P : Got.PageIndexMap) {
       // For each output section referenced by GOT page relocations calculate
       // and save into PageIndexMap 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. And take in account the case when the section intersects
       // page boundaries.
-    P.second = PageEntriesNum;
-    PageEntriesNum += getMipsPageCount(P.first->Size);
+      P.second = Index;
+      Index += getMipsPageCount(P.first->Size);
+    }
+    for (auto &P: Got.Local16)
+      P.second = Index++;
+    for (auto &P: Got.Global)
+      P.second = Index++;
+    for (auto &P: Got.Relocs)
+      P.second = Index++;
+    for (auto &P: Got.Tls)
+      P.second = Index++;
+    for (auto &P: Got.DynTlsSymbols) {
+      P.second = Index;
+      Index += 2;
+    }
+  }
+
+  // Update SymbolBody::GotIndex field to use this
+  // value later in the `sortMipsSymbols` function.
+  for (auto &P : PrimGot->Global)
+    P.first->GotIndex = P.second;
+  for (auto &P : PrimGot->Relocs)
+    P.first->GotIndex = P.second;
+
+  // Create dynamic relocations.
+  for (FileGot &Got : Gots) {
+    // Create dynamic relocations for TLS entries.
+    for (std::pair<SymbolBody *, size_t> &P : Got.Tls) {
+      uint64_t Offset = P.second * Config->Wordsize;
+      if (P.first->isPreemptible())
+        In<ELFT>::RelaDyn->addReloc(
+            {Target->TlsGotRel, this, Offset, false, P.first, 0});
+    }
+    for (std::pair<SymbolBody *, size_t> &P : Got.DynTlsSymbols) {
+      uint64_t Offset = P.second * Config->Wordsize;
+      if (P.first == nullptr) {
+        if (!Config->Pic)
+          continue;
+        In<ELFT>::RelaDyn->addReloc(
+            {Target->TlsModuleIndexRel, this, Offset, false, nullptr, 0});
+      } else {
+        if (!P.first->isPreemptible())
+          continue;
+        In<ELFT>::RelaDyn->addReloc(
+            {Target->TlsModuleIndexRel, this, Offset, false, P.first, 0});
+        Offset += Config->Wordsize;
+        In<ELFT>::RelaDyn->addReloc(
+            {Target->TlsOffsetRel, this, Offset, false, P.first, 0});
+      }
+    }
+
+    // Do not create dynamic relocations for non-TLS
+    // entries in the primary GOT.
+    if (&Got == PrimGot)
+      continue;
+
+    // Dynamic relocations for "global" entries.
+    for (const std::pair<SymbolBody *, size_t> &P : Got.Global) {
+      uint64_t Offset = P.second * Config->Wordsize;
+      In<ELFT>::RelaDyn->addReloc(
+          {Target->RelativeRel, this, Offset, false, P.first, 0});
+    }
+    if (!Config->Pic)
+      continue;
+    // Dynamic relocations for "local" entries in case of PIC.
+    for (const std::pair<const OutputSection *, size_t> &L : Got.PageIndexMap) {
+      size_t PageCount = getMipsPageCount(L.first->Size);
+      for (size_t PI = 0; PI < PageCount; ++PI) {
+        uint64_t Offset = (L.second + PI) * Config->Wordsize;
+        In<ELFT>::RelaDyn->addReloc({Target->RelativeRel, this, Offset, L.first,
+                                     int64_t(PI * 0x10000)});
+      }
+    }
+    for (const std::pair<GotEntry, size_t> &P : Got.Local16) {
+      uint64_t Offset = P.second * Config->Wordsize;
+      In<ELFT>::RelaDyn->addReloc({Target->RelativeRel, this, Offset, true,
+                                   P.first.first, P.first.second});
+    }
   }
-  Size = (getLocalEntriesNum() + GlobalEntries.size() + TlsEntries.size()) *
-         Config->Wordsize;
 }
 
 bool MipsGotSection::empty() const {
   // We add the .got section to the result for dynamic MIPS target because
   // its address and properties are mentioned in the .dynamic section.
   return Config->Relocatable;
 }
 
-uint64_t MipsGotSection::getGp() const {
+uint64_t MipsGotSection::getGp(const InputFile *F) const {
+  if (!F || F->MipsGotIndex == 0 || F->MipsGotIndex == size_t(-1))
     return ElfSym::MipsGp->getVA(0);
+  return this->getVA() + Gots[F->MipsGotIndex].StartIndex * Config->Wordsize +
+         0x7ff0;
 }
 
 static uint64_t readUint(uint8_t *Buf) {
   if (Config->Is64)
     return read64(Buf, Config->Endianness);
   return read32(Buf, Config->Endianness);
 }
 
 static void writeUint(uint8_t *Buf, uint64_t Val) {
void MipsGotSection::writeTo(uint8_t *Buf) {
   //
   // 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.
   writeUint(Buf + Config->Wordsize, (uint64_t)1 << (Config->Wordsize * 8 - 1));
-  Buf += HeaderEntriesNum * Config->Wordsize;
+  for (const FileGot &G : Gots) {
     // Write 'page address' entries to the local part of the GOT.
-  for (std::pair<const OutputSection *, size_t> &L : PageIndexMap) {
+    for (const std::pair<const OutputSection *, size_t> &L : G.PageIndexMap) {
       size_t PageCount = getMipsPageCount(L.first->Size);
       uint64_t FirstPageAddr = getMipsPageAddr(L.first->Addr);
       for (size_t PI = 0; PI < PageCount; ++PI) {
-      uint8_t *Entry = Buf + (L.second + PI) * Config->Wordsize;
-      writeUint(Entry, FirstPageAddr + PI * 0x10000);
+        uint8_t *Addr = Buf + (L.second + PI) * Config->Wordsize;
+        writeUint(Addr, FirstPageAddr + PI * 0x10000);
       }
     }
-  Buf += PageEntriesNum * Config->Wordsize;
-  auto AddEntry = [&](const GotEntry &SA) {
-    uint8_t *Entry = Buf;
-    Buf += Config->Wordsize;
-    const SymbolBody *Body = SA.first;
-    uint64_t VA = Body->getVA(SA.second);
-    writeUint(Entry, VA);
-  };
-  std::for_each(std::begin(LocalEntries), std::end(LocalEntries), AddEntry);
-  std::for_each(std::begin(LocalEntries32), std::end(LocalEntries32), AddEntry);
-  std::for_each(std::begin(GlobalEntries), std::end(GlobalEntries), AddEntry);
-  // Initialize TLS-related GOT entries. If the entry has a corresponding
-  // dynamic relocations, leave it initialized by zero. Write down adjusted
-  // TLS symbol's values otherwise. To calculate the adjustments use offsets
-  // for thread-local storage.
+    // Local, global, TLS, reloc-only  entries.
+    // If TLS entry has a corresponding dynamic relocations, leave it
+    // initialized by zero. Write down adjusted TLS symbol's values otherwise.
+    // To calculate the adjustments use offsets for thread-local storage.
     // https://www.linux-mips.org/wiki/NPTL
-  if (TlsIndexOff != -1U && !Config->Pic)
-    writeUint(Buf + TlsIndexOff, 1);
-  for (const SymbolBody *B : TlsEntries) {
-    if (!B || B->isPreemptible())
-      continue;
-    uint64_t VA = B->getVA();
-    if (B->GotIndex != -1U) {
-      uint8_t *Entry = Buf + B->GotIndex * Config->Wordsize;
-      writeUint(Entry, VA - 0x7000);
-    }
-    if (B->GlobalDynIndex != -1U) {
-      uint8_t *Entry = Buf + B->GlobalDynIndex * Config->Wordsize;
-      writeUint(Entry, 1);
-      Entry += Config->Wordsize;
-      writeUint(Entry, VA - 0x8000);
+    for (const std::pair<GotEntry, size_t> &P : G.Local16) {
+      uint8_t *Addr = Buf + P.second * Config->Wordsize;
+      writeUint(Addr, P.first.first->getVA(P.first.second));
+    }
+    // Write VA to the primary GOT only. For secondary GOTs that
+    // will be done by REL32 dynamic relocations.
+    if (&G == &Gots.front()) {
+      for (const std::pair<const SymbolBody *, size_t> &P : G.Global) {
+        uint8_t *Addr = Buf + P.second * Config->Wordsize;
+        writeUint(Addr, P.first->getVA(0));
+      }
+    }
+    for (const std::pair<SymbolBody *, size_t> &P : G.Relocs) {
+      uint8_t *Addr = Buf + P.second * Config->Wordsize;
+      writeUint(Addr, P.first->getVA(0));
+    }
+    for (const std::pair<SymbolBody *, size_t> &P : G.Tls) {
+      uint8_t *Addr = Buf + P.second * Config->Wordsize;
+      uint64_t VA = P.first->getVA();
+      writeUint(Addr, P.first->isPreemptible() ? VA : VA - 0x7000);
+    }
+    for (const std::pair<SymbolBody *, size_t> &P : G.DynTlsSymbols) {
+      if (P.first == nullptr) {
+        if (!Config->Pic)
+          writeUint(Buf + P.second * Config->Wordsize, 1);
+      } else {
+        if (!P.first->isPreemptible()) {
+          uint8_t *Addr = Buf + P.second * Config->Wordsize;
+          writeUint(Addr, 1);
+          writeUint(Addr + Config->Wordsize, P.first->getVA() - 0x8000);
+        }
+      }
     }
   }
 }
 
 GotPltSection::GotPltSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotPltEntrySize, ".got.plt") {}
 
for (const SymbolBody *B : Entries) {
     Target->writeGotPlt(Buf, *B);
     Buf += Config->Wordsize;
   }
 }
 
 // On ARM the IgotPltSection is part of the GotSection, on other Targets it is
 // part of the .got.plt
 IgotPltSection::IgotPltSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        Target->GotPltEntrySize,
                        Config->EMachine == EM_ARM ? ".got" : ".got.plt") {}
 
 void IgotPltSection::addEntry(SymbolBody &Sym) {
   Sym.IsInIgot = true;
   Sym.GotPltIndex = Entries.size();
   Entries.push_back(&Sym);
 }
 
 size_t IgotPltSection::getSize() const {
   return Entries.size() * Target->GotPltEntrySize;
 }
 
 void IgotPltSection::writeTo(uint8_t *Buf) {
   for (const SymbolBody *B : Entries) {
     Target->writeIgotPlt(Buf, *B);
     Buf += Config->Wordsize;

 
 uint64_t DynamicReloc::getOffset() const {
   return InputSec->OutSec->Addr + InputSec->getOffset(OffsetInSec);
 }
 
 int64_t DynamicReloc::getAddend() const {
   if (UseSymVA)
     return Sym->getVA(Addend);
+  if (!OutputSec)
     return Addend;
+  return getMipsPageAddr(OutputSec->Addr) + Addend;
 }
 
 uint32_t DynamicReloc::getSymIndex() const {
   if (Sym && !UseSymVA)
     return Sym->DynsymIndex;
   return 0;
 }
 
template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
   uint8_t *BufBegin = Buf;
   for (const DynamicReloc &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rela *>(Buf);
     Buf += Config->IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
 
     if (Config->IsRela)
       P->r_addend = Rel.getAddend();
     P->r_offset = Rel.getOffset();
-    if (Config->EMachine == EM_MIPS && Rel.getInputSec() == In<ELFT>::MipsGot)
-      // Dynamic relocation against MIPS GOT section make deal TLS entries
-      // allocated in the end of the GOT. We need to adjust the offset to take
-      // in account 'local' and 'global' GOT entries.
-      P->r_offset += In<ELFT>::MipsGot->getTlsOffset();
     P->setSymbolAndType(Rel.getSymIndex(), Rel.Type, Config->IsMips64EL);
   }
 
   if (Sort) {
     if (Config->IsRela)
       std::stable_sort((Elf_Rela *)BufBegin,
                        (Elf_Rela *)BufBegin + Relocs.size(),
                        compRelocations<ELFT, Elf_Rela>);

 // 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 SymbolTableEntry &L,
                             const SymbolTableEntry &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.Symbol->IsInGlobalMipsGot;
-  bool RIsInLocalGot = !R.Symbol->IsInGlobalMipsGot;
-  if (LIsInLocalGot || RIsInLocalGot)
-    return !RIsInLocalGot;
+  if (!L.Symbol->isInGot() || !R.Symbol->isInGot())
+    return !L.Symbol->isInGot();
   return L.Symbol->GotIndex < R.Symbol->GotIndex;
 }
 
 // Finalize a symbol table. The ELF spec requires that all local
 // symbols precede global symbols, so we sort symbol entries in this
 // function. (For .dynsym, we don't do that because symbols for
 // dynamic linking are inherently all globals.)
 template <class ELFT> void SymbolTableSection<ELFT>::finalizeContents() {

 IgotPltSection *InX::IgotPlt;
 MipsGotSection *InX::MipsGot;
 MipsRldMapSection *InX::MipsRldMap;
 PltSection *InX::Plt;
 PltSection *InX::Iplt;
 StringTableSection *InX::ShStrTab;
 StringTableSection *InX::StrTab;
 
+template void MipsGotSection::build<ELF32LE>();
+template void MipsGotSection::build<ELF32BE>();
+template void MipsGotSection::build<ELF64LE>();
+template void MipsGotSection::build<ELF64BE>();
+
 template void PltSection::addEntry<ELF32LE>(SymbolBody &Sym);
 template void PltSection::addEntry<ELF32BE>(SymbolBody &Sym);
 template void PltSection::addEntry<ELF64LE>(SymbolBody &Sym);
 template void PltSection::addEntry<ELF64BE>(SymbolBody &Sym);
 
 template InputSection *elf::createCommonSection<ELF32LE>();
 template InputSection *elf::createCommonSection<ELF32BE>();
 template InputSection *elf::createCommonSection<ELF64LE>();

ELF/Writer.cpp

if (In<ELFT>::DynSymTab && S->includeInDynsym()) {
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)
     return;
 
+  if (In<ELFT>::MipsGot)
+    In<ELFT>::MipsGot->template build<ELFT>();
+
   // So far we have added sections from input object files.
   // This function adds linker-created Out::* sections.
   addPredefinedSections();
   removeUnusedSyntheticSections(OutputSections);
 
   sortSections();
 
   // This is a bit of a hack. A value of 0 means undef, so we set it
template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
   if (LastRO)
     Set(ElfSym::Etext, ElfSym::Etext2, LastRO->First, LastRO->p_filesz);
   if (LastRW)
     Set(ElfSym::Edata, ElfSym::Edata2, LastRW->First, LastRW->p_filesz);
 
   if (ElfSym::Bss)
     ElfSym::Bss->Section = findSection(".bss");
 
-  // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
-  // be equal to the _gp symbol's value.
   if (Config->EMachine == EM_MIPS) {
     if (!ElfSym::MipsGp->Value) {
       // Find GP-relative section with the lowest address
       // and use this address to calculate default _gp value.
       uint64_t Gp = -1;
       for (const OutputSection *OS : OutputSections)
         if ((OS->Flags & SHF_MIPS_GPREL) && OS->Addr < Gp)
           Gp = OS->Addr;

test/ELF/Inputs/mips-mgot-1.s

+  .text
+  .global foo1
+foo1:
+  addiu  $2, $2, %gottprel(tls0)  # tls got entry
+  addiu  $2, $2, %gottprel(tls1)  # tls got entry
+
+  .section .tdata,"awT",%progbits
+  .global tls1
+tls1:
+  .word 0

test/ELF/Inputs/mips-mgot-2.s

+  .text
+  .global foo2
+foo2:
+  lw     $2, %got(.data)($gp)     # page entry
+  addi   $2, $2, %lo(.data)
+  lw     $2, %call16(foo0)($gp)   # global entry
+  lw     $2, %call16(foo2)($gp)   # global entry
+  addiu  $2, $2, %tlsgd(tls0)     # tls gd entry
+  addiu  $2, $2, %gottprel(tls0)  # tls got entry
+
+  .data
+  .space 0x20000
+
+  .section .tdata,"awT",%progbits
+  .global tls2
+tls2:
+  .word 0

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-got-and-copy.s

 # REQUIRES: mips
 
 # If there are two relocations such that the first one requires
 # dynamic COPY relocation, the second one requires GOT entry
 # creation, linker should create both - dynamic relocation
 # and GOT entry.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:         %S/Inputs/mips-dynamic.s -o %t.so.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.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
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
-# CHECK-NEXT:     0x[[DATA0:[0-9A-F]+]] R_MIPS_COPY data0
 # CHECK-NEXT:     0x[[DATA1:[0-9A-F]+]] R_MIPS_COPY data1
+# CHECK-NEXT:     0x[[DATA0:[0-9A-F]+]] R_MIPS_COPY data0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
 # CHECK-NEXT:   Canonical gp value:
 # CHECK-NEXT:   Reserved entries [
 # CHECK:        ]
 # CHECK-NEXT:   Local entries [
 # CHECK-NEXT:     Entry {
 # CHECK-NEXT:       Address:
 # CHECK-NEXT:       Access: -32744
 # CHECK-NEXT:       Initial: 0x[[DATA0]]
 # CHECK-NEXT:     }
-# CHECK-NEXT:   ]
-# CHECK-NEXT:   Global entries [
 # CHECK-NEXT:     Entry {
 # CHECK-NEXT:       Address:
 # CHECK-NEXT:       Access: -32740
 # CHECK-NEXT:       Initial: 0x[[DATA1]]
-# CHECK-NEXT:       Value: 0x[[DATA1]]
-# CHECK-NEXT:       Type: Object
-# CHECK-NEXT:       Section: .bss
-# CHECK-NEXT:       Name: data1@
 # CHECK-NEXT:     }
 # CHECK-NEXT:   ]
+# CHECK-NEXT:   Global entries [
+# CHECK-NEXT:   ]
 # CHECK-NEXT:   Number of TLS and multi-GOT entries: 0
 # CHECK-NEXT: }
 
   .text
   .global __start
 __start:
   # Case A: 'got' relocation goes before 'copy' relocation
   lui    $t0,%hi(data0)         # R_MIPS_HI16 - requires R_MISP_COPY relocation
   addi   $t0,$t0,%lo(data0)
   lw     $t0,%got(data0)($gp)   # R_MIPS_GOT16 - requires GOT entry
 
   # Case B: 'copy' relocation goes before 'got' relocation
   lw     $t0,%got(data1)($gp)   # R_MIPS_GOT16 - requires GOT entry
   lui    $t0,%hi(data1)         # R_MIPS_HI16 - requires R_MISP_COPY relocation
   addi   $t0,$t0,%lo(data1)

test/ELF/mips-got-weak.s

 # Check R_MIPS_GOT16 relocation against weak symbols.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -o %t1.so
 # RUN: llvm-readobj -r -dt -dynamic-table -mips-plt-got %t1.so \
-# RUN:   | FileCheck -check-prefix=NOSYM %s
+# RUN:   | FileCheck -check-prefixes=CHECK,NOSYM %s
 # RUN: ld.lld %t.o -shared -Bsymbolic -o %t2.so
 # RUN: llvm-readobj -r -dt -dynamic-table -mips-plt-got %t2.so \
-# RUN:   | FileCheck -check-prefix=SYM %s
+# RUN:   | FileCheck -check-prefixes=CHECK,SYM %s
 
 # REQUIRES: mips
 
-# NOSYM:      Relocations [
-# NOSYM-NEXT: ]
+# CHECK:      Relocations [
+# CHECK-NEXT: ]
 
 # NOSYM:        Symbol {
 # NOSYM:          Name: foo
 # NOSYM-NEXT:     Value: 0x20000
 # NOSYM-NEXT:     Size: 0
 # NOSYM-NEXT:     Binding: Weak
 # NOSYM-NEXT:     Type: None
 # NOSYM-NEXT:     Other: 0
 # NOSYM-NEXT:     Section: .data
 # NOSYM-NEXT:   }
-# NOSYM-NEXT:   Symbol {
-# NOSYM-NEXT:     Name: bar
-# NOSYM-NEXT:     Value: 0x0
-# NOSYM-NEXT:     Size: 0
-# NOSYM-NEXT:     Binding: Weak
-# NOSYM-NEXT:     Type: None
-# NOSYM-NEXT:     Other: 0
-# NOSYM-NEXT:     Section: Undefined
-# NOSYM-NEXT:   }
-# NOSYM-NEXT:   Symbol {
-# NOSYM-NEXT:     Name: sym
+
+# CHECK:        Symbol {
+# CHECK:          Name: bar
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Weak
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+
+# NOSYM:        Symbol {
+# NOSYM:          Name: sym
 # NOSYM-NEXT:     Value: 0x20004
 # NOSYM-NEXT:     Size: 0
 # NOSYM-NEXT:     Binding: Global
 # NOSYM-NEXT:     Type: None
 # NOSYM-NEXT:     Other: 0
 # NOSYM-NEXT:     Section: .data
 # NOSYM-NEXT:   }
-# NOSYM-NEXT: ]
 
-# NOSYM:      0x70000011 MIPS_SYMTABNO        4
-# NOSYM-NEXT: 0x7000000A MIPS_LOCAL_GOTNO     2
-# NOSYM-NEXT: 0x70000013 MIPS_GOTSYM          0x1
-
-# NOSYM:      Primary GOT {
-# NOSYM-NEXT:   Canonical gp value:
-# NOSYM-NEXT:   Reserved entries [
-# NOSYM-NEXT:     Entry {
-# NOSYM-NEXT:       Address:
-# NOSYM-NEXT:       Access: -32752
-# NOSYM-NEXT:       Initial: 0x0
-# NOSYM-NEXT:       Purpose: Lazy resolver
-# NOSYM-NEXT:     }
-# NOSYM-NEXT:     Entry {
-# NOSYM-NEXT:       Address:
-# NOSYM-NEXT:       Access: -32748
-# NOSYM-NEXT:       Initial: 0x80000000
-# NOSYM-NEXT:       Purpose: Module pointer (GNU extension)
-# NOSYM-NEXT:     }
-# NOSYM-NEXT:   ]
-# NOSYM-NEXT:   Local entries [
+# CHECK:      0x70000011 MIPS_SYMTABNO        4
+
+# SYM:        0x7000000A MIPS_LOCAL_GOTNO     4
+# SYM:        0x70000013 MIPS_GOTSYM          0x3
+
+# NOSYM:      0x7000000A MIPS_LOCAL_GOTNO     2
+# NOSYM:      0x70000013 MIPS_GOTSYM          0x1
+
+# CHECK:      Primary GOT {
+# CHECK-NEXT:   Canonical gp value:
+# CHECK-NEXT:   Reserved entries [
+# CHECK:        ]
+
+# SYM:         Local entries [
+# SYM-NEXT:       Entry {
+# SYM-NEXT:         Address:
+# SYM-NEXT:         Access: -32744
+# SYM-NEXT:         Initial: 0x20000
+# SYM-NEXT:       }
+# SYM-NEXT:       Entry {
+# SYM-NEXT:         Address:
+# SYM-NEXT:         Access: -32740
+# SYM-NEXT:         Initial: 0x20004
+# SYM-NEXT:       }
+# SYM-NEXT:     ]
+
+# NOSYM:        Local entries [
 # NOSYM-NEXT:   ]
+
+# SYM-NEXT:     Global entries [
+# SYM-NEXT:       Entry {
+# SYM-NEXT:         Address:
+# SYM-NEXT:         Access: -32736
+# SYM-NEXT:         Initial: 0x0
+# SYM-NEXT:         Value: 0x0
+# SYM-NEXT:         Type: None
+# SYM-NEXT:         Section: Undefined
+# SYM-NEXT:         Name: bar
+# SYM-NEXT:       }
+# SYM-NEXT:     ]
+
 # NOSYM-NEXT:   Global entries [
 # NOSYM-NEXT:     Entry {
 # NOSYM-NEXT:       Address:
 # NOSYM-NEXT:       Access: -32744
 # NOSYM-NEXT:       Initial: 0x20000
 # NOSYM-NEXT:       Value: 0x20000
 # NOSYM-NEXT:       Type: None
 # NOSYM-NEXT:       Section: .data

 # NOSYM-NEXT:       Access: -32736
 # NOSYM-NEXT:       Initial: 0x20004
 # NOSYM-NEXT:       Value: 0x20004
 # NOSYM-NEXT:       Type: None
 # NOSYM-NEXT:       Section: .data
 # NOSYM-NEXT:       Name: sym
 # NOSYM-NEXT:     }
 # NOSYM-NEXT:   ]
-# NOSYM-NEXT:   Number of TLS and multi-GOT entries: 0
-# NOSYM-NEXT: }
 
-# SYM:      Relocations [
-# SYM-NEXT: ]
-
-# SYM:        Symbol {
-# SYM:          Name: bar
-# SYM-NEXT:     Value: 0x0
-# SYM-NEXT:     Size: 0
-# SYM-NEXT:     Binding: Weak
-# SYM-NEXT:     Type: None
-# SYM-NEXT:     Other: 0
-# SYM-NEXT:     Section: Undefined
-# SYM-NEXT:   }
-# SYM-NEXT: ]
-
-# SYM:      0x70000011 MIPS_SYMTABNO        4
-# SYM-NEXT: 0x7000000A MIPS_LOCAL_GOTNO     4
-# SYM-NEXT: 0x70000013 MIPS_GOTSYM          0x3
-
-# SYM:      Primary GOT {
-# SYM-NEXT:   Canonical gp value:
-# SYM-NEXT:   Reserved entries [
-# SYM-NEXT:     Entry {
-# SYM-NEXT:       Address:
-# SYM-NEXT:       Access: -32752
-# SYM-NEXT:       Initial: 0x0
-# SYM-NEXT:       Purpose: Lazy resolver
-# SYM-NEXT:     }
-# SYM-NEXT:     Entry {
-# SYM-NEXT:       Address:
-# SYM-NEXT:       Access: -32748
-# SYM-NEXT:       Initial: 0x80000000
-# SYM-NEXT:       Purpose: Module pointer (GNU extension)
-# SYM-NEXT:     }
-# SYM-NEXT:   ]
-# SYM-NEXT:   Local entries [
-# SYM-NEXT:     Entry {
-# SYM-NEXT:       Address:
-# SYM-NEXT:       Access: -32744
-# SYM-NEXT:       Initial: 0x20000
-# SYM-NEXT:     }
-# SYM-NEXT:     Entry {
-# SYM-NEXT:       Address:
-# SYM-NEXT:       Access: -32740
-# SYM-NEXT:       Initial: 0x20004
-# SYM-NEXT:     }
-# SYM-NEXT:   ]
-# SYM-NEXT:   Global entries [
-# SYM-NEXT:     Entry {
-# SYM-NEXT:       Address:
-# SYM-NEXT:       Access: -32736
-# SYM-NEXT:       Initial: 0x0
-# SYM-NEXT:       Value: 0x0
-# SYM-NEXT:       Type: None
-# SYM-NEXT:       Section: Undefined
-# SYM-NEXT:       Name: bar
-# SYM-NEXT:     }
-# SYM-NEXT:   ]
-# SYM-NEXT:   Number of TLS and multi-GOT entries: 0
-# SYM-NEXT: }
+# CHECK:        Number of TLS and multi-GOT entries: 0
+# CHECK-NEXT: }
 
   .text
   .global  sym
   .weak    foo,bar
 func:
   lw      $t0,%got(foo)($gp)
   lw      $t0,%got(bar)($gp)
   lw      $t0,%got(sym)($gp)
 
   .data
   .weak foo
 foo:
   .word 0
 sym:
   .word 0

test/ELF/mips-mgot.s

+# Check MIPS multi-GOT layout.
+
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t0.o
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
+# RUN:         %p/Inputs/mips-mgot-1.s -o %t1.o
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
+# RUN:         %p/Inputs/mips-mgot-2.s -o %t2.o
+# RUN: ld.lld -shared -mips-got-size 52 %t0.o %t1.o %t2.o -o %t.so
+# RUN: llvm-objdump -s -section=.got -t %t.so | FileCheck %s
+# RUN: llvm-readobj -r -dt -mips-plt-got %t.so | FileCheck -check-prefix=GOT %s
+
+# REQUIRES: mips
+
+# CHECK:      Contents of section .got:
+# CHECK-NEXT:  60000 00000000 80000000 00010000 00010030
+# CHECK-NEXT:  60010 00020000 00030000 00040000 00050000
+# CHECK-NEXT:  60020 00060000 00070000 00000000 00000000
+# CHECK-NEXT:  60030 00000004 00000000 00000000 00000000
+# CHECK-NEXT:  60040 00000000 00020000 00030000 00040000
+# CHECK-NEXT:  60050 00050000 00060000 00070000 00000000
+# CHECK-NEXT:  60060 00000000 00000000 00000000 00000000
+
+# CHECK: SYMBOL TABLE:
+# CHECK: 00000000 l       .tdata          00000000 loc0
+# CHECK: 00010000         .text           00000000 foo0
+# CHECK: 00000000 g       .tdata          00000000 tls0
+# CHECK: 00010020         .text           00000000 foo1
+# CHECK: 00000004 g       .tdata          00000000 tls1
+# CHECK: 00010030         .text           00000000 foo2
+# CHECK: 00000008 g       .tdata          00000000 tls2
+
+# GOT:      Relocations [
+# GOT-NEXT:   Section (7) .rel.dyn {
+# GOT-NEXT:     0x60010 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60014 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60018 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x6001C R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60020 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60024 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60044 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60048 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x6004C R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60050 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60054 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60058 R_MIPS_REL32 - 0x0
+# GOT-NEXT:     0x60028 R_MIPS_REL32 foo0 0x0
+# GOT-NEXT:     0x6005C R_MIPS_REL32 foo0 0x0
+# GOT-NEXT:     0x60060 R_MIPS_REL32 foo2 0x0
+# GOT-NEXT:     0x6003C R_MIPS_TLS_DTPMOD32 - 0x0
+# GOT-NEXT:     0x60030 R_MIPS_TLS_TPREL32 tls1 0x0
+# GOT-NEXT:     0x6002C R_MIPS_TLS_TPREL32 tls0 0x0
+# GOT-NEXT:     0x60034 R_MIPS_TLS_DTPMOD32 tls0 0x0
+# GOT-NEXT:     0x60038 R_MIPS_TLS_DTPREL32 tls0 0x0
+# GOT-NEXT:     0x60064 R_MIPS_TLS_TPREL32 tls0 0x0
+# GOT-NEXT:     0x60068 R_MIPS_TLS_DTPMOD32 tls0 0x0
+# GOT-NEXT:     0x6006C R_MIPS_TLS_DTPREL32 tls0 0x0
+# GOT-NEXT:   }
+# GOT-NEXT: ]
+
+# GOT:      DynamicSymbols [
+# GOT:        Symbol {
+# GOT:          Name: foo0
+# GOT-NEXT:     Value: 0x10000
+# GOT:        }
+# GOT-NEXT:   Symbol {
+# GOT-NEXT:     Name: foo2
+# GOT-NEXT:     Value: 0x10030
+# GOT:        }
+# GOT-NEXT: ]
+
+# GOT:      Primary GOT {
+# GOT-NEXT:   Canonical gp value: 0x67FF0
+# GOT-NEXT:   Reserved entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address:
+# GOT-NEXT:       Access: -32752
+# GOT-NEXT:       Initial: 0x0
+# GOT-NEXT:       Purpose: Lazy resolver
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address:
+# GOT-NEXT:       Access: -32748
+# GOT-NEXT:       Initial: 0x80000000
+# GOT-NEXT:       Purpose: Module pointer (GNU extension)
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Local entries [
+# GOT-NEXT:   ]
+# GOT-NEXT:   Global entries [
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address:
+# GOT-NEXT:       Access: -32744
+# GOT-NEXT:       Initial: 0x10000
+# GOT-NEXT:       Value: 0x10000
+# GOT-NEXT:       Type: None
+# GOT-NEXT:       Section: .text
+# GOT-NEXT:       Name: foo0
+# GOT-NEXT:     }
+# GOT-NEXT:     Entry {
+# GOT-NEXT:       Address:
+# GOT-NEXT:       Access: -32740
+# GOT-NEXT:       Initial: 0x10030
+# GOT-NEXT:       Value: 0x10030
+# GOT-NEXT:       Type: None
+# GOT-NEXT:       Section: .text
+# GOT-NEXT:       Name: foo2
+# GOT-NEXT:     }
+# GOT-NEXT:   ]
+# GOT-NEXT:   Number of TLS and multi-GOT entries: 24
+# GOT-NEXT: }
+
+  .text
+  .global foo0
+foo0:
+  lw     $2, %got(.data)($gp)     # page entry
+  addi   $2, $2, %lo(.data)
+  lw     $2, %call16(foo0)($gp)   # global entry
+  addiu  $2, $2, %tlsgd(tls0)     # tls gd entry
+  addiu  $2, $2, %gottprel(tls0)  # tls got entry
+  addiu  $2, $2, %tlsldm(loc0)    # tls ld entry
+
+  .data
+  .space 0x20000
+
+  .section .tdata,"awT",%progbits
+  .global tls0
+tls0:
+loc0:
+  .word 0

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-DAG:      0x{{[0-9A-F]+}} R_MIPS_COPY data0 0x0
+# CHECK-DAG:      0x{{[0-9A-F]+}} R_MIPS_COPY data1 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-DAG:      0x{{[0-9A-F]+}} R_MIPS_JUMP_SLOT foo0 0x0
+# CHECK-DAG:      0x{{[0-9A-F]+}} R_MIPS_JUMP_SLOT foo1 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 # CHECK:      Primary GOT {
 # CHECK:        Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]

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: 0x[[FOO1:[0-9A-F]+]]
 # 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:   ]
 # CHECK:      PLT GOT {
 # CHECK:        Entries [
 # CHECK-NEXT:     Entry {
 # CHECK-NEXT:       Address:
 # CHECK-NEXT:       Initial:
 # CHECK-NEXT:       Value: 0x0
 # CHECK-NEXT:       Type: Function
 # CHECK-NEXT:       Section: Undefined
 # CHECK-NEXT:       Name: foo0
 # CHECK-NEXT:     }
 # CHECK-NEXT:     Entry {
 # CHECK-NEXT:       Address:
 # CHECK-NEXT:       Initial:
-# CHECK-NEXT:       Value: 0x20050
+# CHECK-NEXT:       Value: 0x[[FOO1]]
 # CHECK-NEXT:       Type: Function
 # CHECK-NEXT:       Section: Undefined
 # CHECK-NEXT:       Name: foo1
 # CHECK-NEXT:     }
 # CHECK-NEXT:   ]
 
   .text
   .globl __start
 __start:
   jal    foo0               # R_MIPS_26 against 'foo0' from DSO
   lui    $t0,%hi(foo1)      # R_MIPS_HI16/LO16 against 'foo1' from DSO
   addi   $t0,$t0,%lo(foo1)
 
 loc:
   nop

test/ELF/mips-tls-64.s

 
 # RUN: ld.lld -shared %t.o %t.so -o %t-out.so
 # RUN: llvm-objdump -d -s -t %t-out.so | FileCheck -check-prefix=DIS-SO %s
 # RUN: llvm-readobj -r -mips-plt-got %t-out.so | FileCheck -check-prefix=SO %s
 
 # REQUIRES: mips
 
 # DIS:      __start:
-# DIS-NEXT:    20000:   24 62 80 20   addiu   $2, $3, -32736
-# DIS-NEXT:    20004:   24 62 80 30   addiu   $2, $3, -32720
-# DIS-NEXT:    20008:   24 62 80 38   addiu   $2, $3, -32712
-# DIS-NEXT:    2000c:   24 62 80 48   addiu   $2, $3, -32696
-# DIS-NEXT:    20010:   24 62 80 58   addiu   $2, $3, -32680
+# DIS-NEXT:    20000:   24 62 80 30   addiu   $2, $3, -32720
+# DIS-NEXT:    20004:   24 62 80 20   addiu   $2, $3, -32736
+# DIS-NEXT:    20008:   24 62 80 40   addiu   $2, $3, -32704
+# DIS-NEXT:    2000c:   24 62 80 50   addiu   $2, $3, -32688
+# DIS-NEXT:    20010:   24 62 80 28   addiu   $2, $3, -32728
 
 # DIS:      Contents of section .got:
 # DIS-NEXT:  30010 00000000 00000000 80000000 00000000
-# DIS-NEXT:  30020 00000000 00000000 00000000 00000000
-# DIS-NEXT:  30030 00000000 00000000 00000000 00000001
-# DIS-NEXT:  30040 00000000 00000000 00000000 00000001
-# DIS-NEXT:  30050 ffffffff ffff8004 ffffffff ffff9004
+# DIS-NEXT:  30020 00000000 00000000 ffffffff ffff9004
+# DIS-NEXT:  30030 00000000 00000000 00000000 00000000
+# DIS-NEXT:  30040 00000000 00000001 00000000 00000000
+# DIS-NEXT:  30050 00000000 00000001 ffffffff ffff8004
 
 # DIS: 0000000000000000 l       .tdata          00000000 loc
 # DIS: 0000000000000004 g       .tdata          00000000 bar
 # DIS: 0000000000000000 g       *UND*           00000000 foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rela.dyn {
-# CHECK-NEXT:     0x30020 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# CHECK-NEXT:     0x30028 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# CHECK-NEXT:     0x30030 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x30020 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x30030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# CHECK-NEXT:     0x30038 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
 # CHECK-NEXT:   Canonical gp value: 0x38000
 # CHECK-NEXT:   Reserved entries [
 # CHECK:        ]
 # CHECK-NEXT:   Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Number of TLS and multi-GOT entries: 8
-#               ^-- -32736 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 foo
-#               ^-- -32728                     R_MIPS_TLS_DTPREL64 foo
-#               ^-- -32720 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo
-#               ^-- -32712 R_MIPS_TLS_LDM      1 loc
-#               ^-- -32704                     0 loc
-#               ^-- -32696 R_MIPS_TLS_GD       1 bar
-#               ^-- -32688                     VA - 0x8000 bar
-#               ^-- -32680 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
+#               ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo
+#               ^-- -32728 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
+#               ^-- -32720 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 foo
+#               ^-- -32712                     R_MIPS_TLS_DTPREL64 foo
+#               ^-- -32704 R_MIPS_TLS_LDM      1 loc
+#               ^-- -32696                     0 loc
+#               ^-- -32688 R_MIPS_TLS_GD       1 bar
+#               ^-- -32680                     VA - 0x8000 bar
 
 # DIS-SO:      Contents of section .got:
 # DIS-SO-NEXT:  20000 00000000 00000000 80000000 00000000
-# DIS-SO-NEXT:  20010 00000000 00000000 00000000 00000000
+# DIS-SO-NEXT:  20010 00000000 00000000 00000000 00000004
 # DIS-SO-NEXT:  20020 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20030 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20040 00000000 00000000 00000000 00000000
 
 # SO:      Relocations [
 # SO-NEXT:   Section (7) .rela.dyn {
-# SO-NEXT:     0x20028 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE - 0x0
-# SO-NEXT:     0x20038 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20040 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20048 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
-# SO-NEXT:     0x20010 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# SO-NEXT:     0x20018 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
-# SO-NEXT:     0x20020 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x20030 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE - 0x0
+# SO-NEXT:     0x20010 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x20020 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x20028 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE foo 0x0
+# SO-NEXT:     0x20018 R_MIPS_TLS_TPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
+# SO-NEXT:     0x20040 R_MIPS_TLS_DTPMOD64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
+# SO-NEXT:     0x20048 R_MIPS_TLS_DTPREL64/R_MIPS_NONE/R_MIPS_NONE bar 0x0
 # SO-NEXT:   }
 # SO-NEXT: ]
 # SO-NEXT: Primary GOT {
 # SO-NEXT:   Canonical gp value: 0x27FF0
 # SO-NEXT:   Reserved entries [
 # SO:        ]
 # SO-NEXT:   Local entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Global entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Number of TLS and multi-GOT entries: 8
-#            ^-- -32736 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 foo
-#            ^-- -32728                     R_MIPS_TLS_DTPREL64 foo
-#            ^-- -32720 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo
-#            ^-- -32712 R_MIPS_TLS_LDM      R_MIPS_TLS_DTPMOD64 loc
-#            ^-- -32704                     0 loc
-#            ^-- -32696 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 bar
-#            ^-- -32688                     R_MIPS_TLS_DTPREL64 bar
-#            ^-- -32680 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  bar
+#            ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  foo
+#            ^-- -32728 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL64  bar
+#            ^-- -32720 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 foo
+#            ^-- -32712                     R_MIPS_TLS_DTPREL64 foo
+#            ^-- -32704 R_MIPS_TLS_LDM      R_MIPS_TLS_DTPMOD64 loc
+#            ^-- -32696                     0 loc
+#            ^-- -32688 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD64 bar
+#            ^-- -32680                     R_MIPS_TLS_DTPREL64 bar
 
   .text
   .global  __start
 __start:
   addiu $2, $3, %tlsgd(foo)     # R_MIPS_TLS_GD
   addiu $2, $3, %gottprel(foo)  # R_MIPS_TLS_GOTTPREL
   addiu $2, $3, %tlsldm(loc)    # R_MIPS_TLS_LDM
   addiu $2, $3, %tlsgd(bar)     # R_MIPS_TLS_GD
   addiu $2, $3, %gottprel(bar)  # R_MIPS_TLS_GOTTPREL
 
  .section .tdata,"awT",%progbits
  .global bar
 loc:
  .word 0
 bar:
  .word 0

test/ELF/mips-tls-static.s

 # Check handling TLS related relocations and symbols when linking
 # a static executable.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t
 # RUN: ld.lld -static %t -o %t.exe
 # RUN: llvm-objdump -s -t %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Contents of section .data:
 # CHECK-NEXT:  30000 0002000c ffff8004 ffff9004
 # CHECK:      Contents of section .got:
-# CHECK-NEXT:  30010 00000000 80000000 00000001 ffff8000
-# CHECK-NEXT:  30020 00000001 00000000 ffff9000
+# CHECK-NEXT:  30010 00000000 80000000 ffff9000 00000001
+# CHECK-NEXT:  30020 ffff8000 00000001 00000000
 #
 # CHECK: SYMBOL TABLE:
 # CHECK: 0002000c         .text           00000000 __tls_get_addr
 # CHECK: 00000000 g       .tdata          00000000 tls1
 
   .text
   .global __start
 __start:

test/ELF/mips-tls.s

 
 # RUN: ld.lld -shared %t.o %t.so -o %t-out.so
 # RUN: llvm-objdump -d -s -t %t-out.so | FileCheck -check-prefix=DIS-SO %s
 # RUN: llvm-readobj -r -mips-plt-got %t-out.so | FileCheck -check-prefix=SO %s
 
 # REQUIRES: mips
 
 # DIS:      __start:
-# DIS-NEXT:    20000:   24 62 80 18   addiu   $2, $3, -32744
-# DIS-NEXT:    20004:   24 62 80 20   addiu   $2, $3, -32736
-# DIS-NEXT:    20008:   24 62 80 24   addiu   $2, $3, -32732
-# DIS-NEXT:    2000c:   24 62 80 2c   addiu   $2, $3, -32724
-# DIS-NEXT:    20010:   24 62 80 34   addiu   $2, $3, -32716
+# DIS-NEXT:    20000:   24 62 80 20   addiu   $2, $3, -32736
+# DIS-NEXT:    20004:   24 62 80 18   addiu   $2, $3, -32744
+# DIS-NEXT:    20008:   24 62 80 28   addiu   $2, $3, -32728
+# DIS-NEXT:    2000c:   24 62 80 30   addiu   $2, $3, -32720
+# DIS-NEXT:    20010:   24 62 80 1c   addiu   $2, $3, -32740
 
 # DIS:      Contents of section .got:
-# DIS-NEXT:  30010 00000000 80000000 00000000 00000000
-# DIS-NEXT:  30020 00000000 00000001 00000000 00000001
-# DIS-NEXT:  30030 ffff8004 ffff9004
+# DIS-NEXT:  30010 00000000 80000000 00000000 ffff9004
+# DIS-NEXT:  30020 00000000 00000000 00000001 00000000
+# DIS-NEXT:  30030 00000001 ffff8004
 
 # DIS: 00000000 l       .tdata          00000000 loc
 # DIS: 00000004 g       .tdata          00000000 bar
 # DIS: 00000000 g       *UND*           00000000 foo
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (7) .rel.dyn {
-# CHECK-NEXT:     0x30018 R_MIPS_TLS_DTPMOD32 foo 0x0
-# CHECK-NEXT:     0x3001C R_MIPS_TLS_DTPREL32 foo 0x0
-# CHECK-NEXT:     0x30020 R_MIPS_TLS_TPREL32 foo 0x0
+# CHECK-NEXT:     0x30018 R_MIPS_TLS_TPREL32 foo 0x0
+# CHECK-NEXT:     0x30020 R_MIPS_TLS_DTPMOD32 foo 0x0
+# CHECK-NEXT:     0x30024 R_MIPS_TLS_DTPREL32 foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 # CHECK-NEXT: Primary GOT {
 # CHECK-NEXT:   Canonical gp value: 0x38000
 # CHECK-NEXT:   Reserved entries [
 # CHECK:        ]
 # CHECK-NEXT:   Local entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Global entries [
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Number of TLS and multi-GOT entries: 8
-#               ^-- -32744 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 foo
-#               ^-- -32740                     R_MIPS_TLS_DTPREL32 foo
-#               ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo
-#               ^-- -32732 R_MIPS_TLS_LDM      1 loc
-#               ^-- -32728                     0 loc
-#               ^-- -32724 R_MIPS_TLS_GD       1 bar
-#               ^-- -32720                     VA - 0x8000 bar
-#               ^-- -32716 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
+#               ^-- -32744 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo
+#               ^-- -32740 R_MIPS_TLS_GOTTPREL VA - 0x7000 bar
+#               ^-- -32736 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 foo
+#               ^-- -32732                     R_MIPS_TLS_DTPREL32 foo
+#               ^-- -32728 R_MIPS_TLS_LDM      1 loc
+#               ^-- -32724                     0 loc
+#               ^-- -32720 R_MIPS_TLS_GD       1 bar
+#               ^-- -32716                     VA - 0x8000 bar
 
 # DIS-SO:      Contents of section .got:
-# DIS-SO-NEXT:  20000 00000000 80000000 00000000 00000000
+# DIS-SO-NEXT:  20000 00000000 80000000 00000000 00000004
 # DIS-SO-NEXT:  20010 00000000 00000000 00000000 00000000
 # DIS-SO-NEXT:  20020 00000000 00000000
 
 # SO:      Relocations [
 # SO-NEXT:   Section (7) .rel.dyn {
-# SO-NEXT:     0x20014 R_MIPS_TLS_DTPMOD32 - 0x0
-# SO-NEXT:     0x2001C R_MIPS_TLS_DTPMOD32 bar 0x0
-# SO-NEXT:     0x20020 R_MIPS_TLS_DTPREL32 bar 0x0
-# SO-NEXT:     0x20024 R_MIPS_TLS_TPREL32 bar 0x0
-# SO-NEXT:     0x20008 R_MIPS_TLS_DTPMOD32 foo 0x0
-# SO-NEXT:     0x2000C R_MIPS_TLS_DTPREL32 foo 0x0
-# SO-NEXT:     0x20010 R_MIPS_TLS_TPREL32 foo 0x0
+# SO-NEXT:     0x20018 R_MIPS_TLS_DTPMOD32 - 0x0
+# SO-NEXT:     0x20008 R_MIPS_TLS_TPREL32 foo 0x0
+# SO-NEXT:     0x20010 R_MIPS_TLS_DTPMOD32 foo 0x0
+# SO-NEXT:     0x20014 R_MIPS_TLS_DTPREL32 foo 0x0
+# SO-NEXT:     0x2000C R_MIPS_TLS_TPREL32 bar 0x0
+# SO-NEXT:     0x20020 R_MIPS_TLS_DTPMOD32 bar 0x0
+# SO-NEXT:     0x20024 R_MIPS_TLS_DTPREL32 bar 0x0
 # SO-NEXT:   }
 # SO-NEXT: ]
 # SO-NEXT: Primary GOT {
 # SO-NEXT:   Canonical gp value: 0x27FF0
 # SO-NEXT:   Reserved entries [
 # SO:        ]
 # SO-NEXT:   Local entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Global entries [
 # SO-NEXT:   ]
 # SO-NEXT:   Number of TLS and multi-GOT entries: 8
-#            ^-- -32744 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 foo
-#            ^-- -32740 R_MIPS_TLS_DTPREL32 foo
-#            ^-- -32736 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo
-#            ^-- -32732 R_MIPS_TLS_LDM      R_MIPS_TLS_DTPMOD32 loc
-#            ^-- -32728 0 loc
-#            ^-- -32724 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 bar
-#            ^-- -32720 R_MIPS_TLS_DTPREL32 bar
-#            ^-- -32716 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  bar
+#            ^-- -32744 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  foo
+#            ^-- -32740 R_MIPS_TLS_GOTTPREL R_MIPS_TLS_TPREL32  bar
+#            ^-- -32736 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 foo
+#            ^-- -32732 R_MIPS_TLS_DTPREL32 foo
+#            ^-- -32728 R_MIPS_TLS_LDM      R_MIPS_TLS_DTPMOD32 loc
+#            ^-- -32724 0 loc
+#            ^-- -32720 R_MIPS_TLS_GD       R_MIPS_TLS_DTPMOD32 bar
+#            ^-- -32716 R_MIPS_TLS_DTPREL32 bar
 
   .text
   .global  __start
 __start:
   addiu $2, $3, %tlsgd(foo)     # R_MIPS_TLS_GD
   addiu $2, $3, %gottprel(foo)  # R_MIPS_TLS_GOTTPREL
   addiu $2, $3, %tlsldm(loc)    # R_MIPS_TLS_LDM
   addiu $2, $3, %tlsgd(bar)     # R_MIPS_TLS_GD
   addiu $2, $3, %gottprel(bar)  # R_MIPS_TLS_GOTTPREL
 
  .section .tdata,"awT",%progbits
  .global bar
 loc:
  .word 0
 bar:
  .word 0