[ELF2] Add mandatory .dynamic section entries on MIPS.

[ikudrin]

Summary

The MIPS target requires specific dynamic section entries to be defined.

• DT_MIPS_RLD_VERSION and DT_MIPS_FLAGS store predefined values.
• DT_MIPS_BASE_ADDRESS holds base VA.
• DT_MIPS_LOCAL_GOTNO holds the number of local GOT entries.
• DT_MIPS_SYMTABNO holds the number of .dynsym entries.
• DT_MIPS_GOTSYM holds the index of the .dynsym entry which corresponds to the first entry of global part of GOT.
• DT_MIPS_RLD_MAP holds the address to the reserved space in the data segment
• DT_MIPS_PLTGOT points to the .got.plt section if it exists
• DT_PLTGOT holds the address of the GOT section.

See "Dynamic Section" in Chapter 5 in the following document for detailed information:
ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf

[atanasyan]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

Do you read MIPS ABI? DT_MIPS_PLTGOT is used in the non-PIC MIPS code only. PIC MIPS code uses DT_PLTGOT entry but this entry points to the .got section.

659 ↗

(On Diff #39543)

What is the case covered by this if statement?

ELF/OutputSections.h

121 ↗

(On Diff #39543)

What is the meaning of the "First" here: Lazy resolver, first local entry of first global entry?

[ikudrin]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

The logic of this line: if we have .plt.got section, then store its address to DT_MIPS_PLTGOT entry. Is something wrong here?
Please note, the DT_PLTGOT entry for MIPS target is mentioned a bit later in this function.

659 ↗

(On Diff #39543)

We can have global entries in the GOT or it may consist of reserved and local entries only. In the later case, we'll have to change the expression "Target->getGotHeaderEntriesNum()" to something more reasonable when local GOT entries are added.

ELF/OutputSections.h

121 ↗

(On Diff #39543)

For MIPS, it's the first global entry, because we don't have SymbolBody for anything else.
For all other targets it's just the first entry of the GOT, although nobody is interested in it.

[ikudrin]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

Moreover, the logic here is the same as in this patch for the old lld: http://reviews.llvm.org/rL200630.

[atanasyan]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

If MIPS dynamic binary has a .got section, DT_PLTGOT entry should point to it. The DT_MIPS_PLTGOT entry should point to the .got.plt entry if MIPS dynamic binary is non-PIC.

https://sourceware.org/ml/binutils/2008-07/txt00000.txt

659 ↗

(On Diff #39543)

Maybe it is better at first to complete GOT implementation and add local entries support and then add dynamic entries support.

ELF/OutputSections.h

121 ↗

(On Diff #39543)

In that case "First" might confuse. Because you have to read code to realize that the "First" means first global but sometimes just first entry. If you ask somebody familiar with MIPS what is the first GOT entry he or she answers that it is either "Lazy resolver" entry or "first local entry"

[atanasyan]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

No, old lld works correctly at least in that case. Do you use any MIPS toolchain as a reference implementation?

$ cat test.c
void foo() {}

$ mips-linux-gnu-gcc -fPIC test.c -shared
$ readelf -a a.out
...
[16] .got              PROGBITS        000107c0
...
0x00000003 (PLTGOT)                     0x107c0

[ikudrin]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

I can't catch. This patch even includes the test which checks that DT_PLTGOT holds an address of .got section:

# EXE:          Name: .got
. . .
# EXE-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
. . .
# EXE-DAG:    0x00000003 PLTGOT               [[GOTADDR]]

ELF/OutputSections.h

121 ↗

(On Diff #39543)

Let's rename it to something like getFirstGlobal() maybe?

[atanasyan]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

Oh, my bad. Handling of dynamic entries are spread among the code. I did not catch that you handle both DT_PLTGOT and DT_MIPS_PLTGOT entries. You are right.

ELF/OutputSections.h

121 ↗

(On Diff #39543)

It is okay to me. Is it acceptable for other targets?

[ikudrin]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

OK, I'll add a comment to explain it.

ELF/OutputSections.h

121 ↗

(On Diff #39543)

I think it over till Monday.

[ikudrin]

• Add explanatory comments.
• Add the GotSection::getMipsLocalEntriesNum() method.
• Rename GotSection::getFirstEntry() -> getMipsFirstGlobalEntry().

[ikudrin]

ELF/OutputSections.cpp

491 ↗

(On Diff #39543)

See the comment in the writeTo() method.

659 ↗

(On Diff #39543)

I'm afraid in that case the patch will be postponed for a while. Right now, I don't have time to implement local GOT entries.

[ruiu]

ELF/OutputSections.cpp

96–99 ↗

(On Diff #39674)

I don't know why you needed this function. If it's just a forwarder, why don't you call Target->getGotHeaderEntriesNum() instead of this function?

473 ↗

(On Diff #39674)

Add a blank line.

ELF/OutputSections.h

121 ↗

(On Diff #39674)

Add a blank line before the start of the comment.

126 ↗

(On Diff #39674)

Ditto

ELF/Target.cpp

157 ↗

(On Diff #39674)

This and removal of getVAStart from Writer are good changes but not related to this patch. Please submit as a separate commit. (You don't need another pre-commit code review for that.)

[ikudrin]

ELF/OutputSections.cpp

96–99 ↗

(On Diff #39674)

The Target->getGOTHeaderEntriesNum returns the number of the "reserved" GOT entries. This function returns the count of all entries of the local part of GOT, which contains not only the reserved entries but also entries for local symbols. So, the meanings are different.

Even though GotSection does not support entries for local symbols for now, the result is correct and we can use it to write the DT_MIPS_LOCAL_GOTNO dynamic section entry. When the support is added, we will have to update only this function, not DynamicSection::writeTo() method, so the changes will be more local.

[ikudrin]

• Extract getVAStart() change as a separate patch.
• Rebase on the top.
• Add comments and blank lines.

[atanasyan]

LGTM

[ruiu]

LGTM

lld/trunk/ELF/OutputSections.h

public:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   uint32_t addLocalModuleTlsIndex();
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) 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 *getMipsFirstGlobalEntry() const;
+
+  // Returns the number of entries in the local part of GOT including
+  // the number of reserved entries. This method is MIPS-specific.
+  unsigned getMipsLocalEntriesNum() const;
+
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT>
 class GotPltSection final : public OutputSectionBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
template <class ELFT> struct Out {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   static DynamicSection<ELFT> *Dynamic;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
+  static OutputSection<ELFT> *MipsRldMap;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
   static Elf_Phdr *TlsPhdr;
   static uint32_t LocalModuleTlsIndexOffset;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
+template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;

lld/trunk/ELF/OutputSections.cpp

 }
 
 template <class ELFT>
 typename GotSection<ELFT>::uintX_t
 GotSection<ELFT>::getEntryAddr(const SymbolBody &B) const {
   return this->getVA() + B.GotIndex * sizeof(uintX_t);
 }
 
+template <class ELFT>
+const SymbolBody *GotSection<ELFT>::getMipsFirstGlobalEntry() const {
+  return Entries.empty() ? nullptr : Entries.front();
+}
+
+template <class ELFT>
+unsigned GotSection<ELFT>::getMipsLocalEntriesNum() const {
+  // TODO: Update when the suppoort of GOT entries for local symbols is added.
+  return Target->getGotHeaderEntriesNum();
+}
+
 template <class ELFT> void GotSection<ELFT>::finalize() {
   this->Header.sh_size =
       (Target->getGotHeaderEntriesNum() + Entries.size()) * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotHeaderEntries(Buf);
   Buf += Target->getGotHeaderEntriesNum() * sizeof(uintX_t);

 template <class ELFT>
 DynamicSection<ELFT>::DynamicSection(SymbolTable<ELFT> &SymTab)
     : OutputSectionBase<ELFT>(".dynamic", llvm::ELF::SHT_DYNAMIC,
                               llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE),
       SymTab(SymTab) {
   Elf_Shdr &Header = this->Header;
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
   Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
+
+  // .dynamic section is not writable on MIPS.
+  // See "Special Section" in Chapter 4 in the following document:
+  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+  if (Config->EMachine == EM_MIPS)
+    Header.sh_flags = llvm::ELF::SHF_ALLOC;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (this->Header.sh_size)
     return; // Already finalized.
 
   Elf_Shdr &Header = this->Header;
   Header.sh_link = Out<ELFT>::DynStrTab->SectionIndex;
 
   unsigned NumEntries = 0;
   if (Out<ELFT>::RelaDyn->hasRelocs()) {
     ++NumEntries; // DT_RELA / DT_REL
     ++NumEntries; // DT_RELASZ / DT_RELSZ
     ++NumEntries; // DT_RELAENT / DT_RELENT
   }
   if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
     ++NumEntries; // DT_JMPREL
     ++NumEntries; // DT_PLTRELSZ
-    ++NumEntries; // DT_PLTGOT
+    ++NumEntries; // DT_PLTGOT / DT_MIPS_PLTGOT
     ++NumEntries; // DT_PLTREL
   }
 
   ++NumEntries; // DT_SYMTAB
   ++NumEntries; // DT_SYMENT
   ++NumEntries; // DT_STRTAB
   ++NumEntries; // DT_STRSZ
   if (Out<ELFT>::GnuHashTab)
if (Config->ZOrigin) {
     DtFlags |= DF_ORIGIN;
     DtFlags1 |= DF_1_ORIGIN;
   }
 
   if (DtFlags)
     ++NumEntries; // DT_FLAGS
   if (DtFlags1)
     ++NumEntries; // DT_FLAGS_1
+
+  if (Config->EMachine == EM_MIPS) {
+    ++NumEntries; // DT_MIPS_RLD_VERSION
+    ++NumEntries; // DT_MIPS_FLAGS
+    ++NumEntries; // DT_MIPS_BASE_ADDRESS
+    ++NumEntries; // DT_MIPS_SYMTABNO
+    ++NumEntries; // DT_MIPS_LOCAL_GOTNO
+    ++NumEntries; // DT_MIPS_GOTSYM;
+    ++NumEntries; // DT_PLTGOT
+    if (Out<ELFT>::MipsRldMap)
+      ++NumEntries; // DT_MIPS_RLD_MAP
+  }
+
   ++NumEntries; // DT_NULL
 
   Header.sh_size = NumEntries * Header.sh_entsize;
 }
 
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
 
if (Out<ELFT>::RelaDyn->hasRelocs()) {
     WritePtr(IsRela ? DT_RELA : DT_REL, Out<ELFT>::RelaDyn->getVA());
     WriteVal(IsRela ? DT_RELASZ : DT_RELSZ, Out<ELFT>::RelaDyn->getSize());
     WriteVal(IsRela ? DT_RELAENT : DT_RELENT,
              IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel));
   }
   if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
     WritePtr(DT_JMPREL, Out<ELFT>::RelaPlt->getVA());
     WriteVal(DT_PLTRELSZ, Out<ELFT>::RelaPlt->getSize());
-    WritePtr(DT_PLTGOT, Out<ELFT>::GotPlt->getVA());
+    // On MIPS, the address of the .got.plt section is stored in
+    // the DT_MIPS_PLTGOT entry because the DT_PLTGOT entry points to
+    // the .got section. See "Dynamic Section" in the following document:
+    // https://sourceware.org/ml/binutils/2008-07/txt00000.txt
+    WritePtr((Config->EMachine == EM_MIPS) ? DT_MIPS_PLTGOT : DT_PLTGOT,
+             Out<ELFT>::GotPlt->getVA());
     WriteVal(DT_PLTREL, Out<ELFT>::RelaPlt->isRela() ? DT_RELA : DT_REL);
   }
 
   WritePtr(DT_SYMTAB, Out<ELFT>::DynSymTab->getVA());
   WritePtr(DT_SYMENT, sizeof(Elf_Sym));
   WritePtr(DT_STRTAB, Out<ELFT>::DynStrTab->getVA());
   WriteVal(DT_STRSZ, Out<ELFT>::DynStrTab->data().size());
   if (Out<ELFT>::GnuHashTab)
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   if (InitSym)
     WritePtr(DT_INIT, getSymVA<ELFT>(*InitSym));
   if (FiniSym)
     WritePtr(DT_FINI, getSymVA<ELFT>(*FiniSym));
   if (DtFlags)
     WriteVal(DT_FLAGS, DtFlags);
   if (DtFlags1)
     WriteVal(DT_FLAGS_1, DtFlags1);
+
+  // See "Dynamic Section" in Chapter 5 in the following document
+  // for detailed description:
+  // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+  if (Config->EMachine == EM_MIPS) {
+    WriteVal(DT_MIPS_RLD_VERSION, 1);
+    WriteVal(DT_MIPS_FLAGS, RHF_NOTPOT);
+    WritePtr(DT_MIPS_BASE_ADDRESS, Target->getVAStart());
+    WriteVal(DT_MIPS_SYMTABNO, Out<ELFT>::DynSymTab->getNumSymbols());
+    WriteVal(DT_MIPS_LOCAL_GOTNO, Out<ELFT>::Got->getMipsLocalEntriesNum());
+    if (const SymbolBody *B = Out<ELFT>::Got->getMipsFirstGlobalEntry())
+      WriteVal(DT_MIPS_GOTSYM, B->getDynamicSymbolTableIndex());
+    else
+      WriteVal(DT_MIPS_GOTSYM, Out<ELFT>::DynSymTab->getNumSymbols());
+    WritePtr(DT_PLTGOT, Out<ELFT>::Got->getVA());
+    if (Out<ELFT>::MipsRldMap)
+      WritePtr(DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap->getVA());
+  }
+
   WriteVal(DT_NULL, 0);
 }
 
 template <class ELFT>
 OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t sh_type,
                                    uintX_t sh_flags)
     : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
 

lld/trunk/ELF/Writer.cpp

if (isOutputDynamic()) {
     if (Out<ELFT>::HashTab)
       OutputSections.push_back(Out<ELFT>::HashTab);
     OutputSections.push_back(Out<ELFT>::Dynamic);
     OutputSections.push_back(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
       OutputSections.push_back(Out<ELFT>::RelaDyn);
     if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs())
       OutputSections.push_back(Out<ELFT>::RelaPlt);
+    // This is a MIPS specific section to hold a space within the data segment
+    // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
+    // See "Dynamic section" in Chapter 5 in the following document:
+    // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
+    if (Config->EMachine == EM_MIPS && !Config->Shared) {
+      Out<ELFT>::MipsRldMap = new (SecAlloc.Allocate())
+          OutputSection<ELFT>(".rld_map", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
+      Out<ELFT>::MipsRldMap->setSize(ELFT::Is64Bits ? 8 : 4);
+      Out<ELFT>::MipsRldMap->updateAlign(ELFT::Is64Bits ? 8 : 4);
+      OutputSections.push_back(Out<ELFT>::MipsRldMap);
+    }
   }
-  if (!Out<ELFT>::Got->empty())
+
+  // We add the .got section to the result for dynamic MIPS target because
+  // its address and properties are mentioned in the .dynamic section.
+  if (!Out<ELFT>::Got->empty() ||
+      (isOutputDynamic() && Config->EMachine == EM_MIPS))
     OutputSections.push_back(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
     OutputSections.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
     OutputSections.push_back(Out<ELFT>::Plt);
 
   std::stable_sort(OutputSections.begin(), OutputSections.end(),
                    compareOutputSections<ELFT>);

lld/trunk/test/elf2/Inputs/mips-dynamic.s

+  .text
+  .globl _foo
+_foo:
+  nop

lld/trunk/test/elf2/mips-dynamic.s

+# Check MIPS specific .dynamic section entries.
+
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
+# RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %p/Inputs/mips-dynamic.s -o %td.o
+# RUN: ld.lld2 -shared %td.o -o %td.so
+
+# RUN: ld.lld2 %t.o %td.so -o %t.exe
+# RUN: llvm-readobj -sections -dynamic-table %t.exe \
+# RUN:   | FileCheck -check-prefix=EXE %s
+
+# RUN: ld.lld2 -shared %t.o %td.so -o %t.so
+# RUN: llvm-readobj -sections -dyn-symbols -dynamic-table %t.so \
+# RUN:   | FileCheck -check-prefix=DSO %s
+
+# REQUIRES: mips
+
+# EXE:      Sections [
+# EXE:          Name: .dynamic
+# EXE-NEXT:     Type: SHT_DYNAMIC
+# EXE-NEXT:     Flags [
+# EXE-NEXT:       SHF_ALLOC
+# EXE-NEXT:     ]
+# EXE:          Name: .rld_map
+# EXE-NEXT:     Type: SHT_PROGBITS
+# EXE-NEXT:     Flags [
+# EXE-NEXT:       SHF_ALLOC
+# EXE-NEXT:       SHF_WRITE
+# EXE-NEXT:     ]
+# EXE-NEXT:     Address: [[RLDMAPADDR:0x[0-9a-f]+]]
+# EXE-NEXT:     Offset:
+# EXE-NEXT:     Size: 4
+# EXE:          Name: .got
+# EXE-NEXT:     Type: SHT_PROGBITS
+# EXE-NEXT:     Flags [ (0x10000003)
+# EXE-NEXT:       SHF_ALLOC
+# EXE-NEXT:       SHF_WRITE
+# EXE-NEXT:     ]
+# EXE-NEXT:     Address: [[GOTADDR:0x[0-9a-f]+]]
+# EXE-NEXT:     Offset:
+# EXE-NEXT:     Size: 8
+# EXE:      ]
+# EXE:      DynamicSection [
+# EXE-NEXT:   Tag        Type                 Name/Value
+# EXE-DAG:    0x00000003 PLTGOT               [[GOTADDR]]
+# EXE-DAG:    0x70000001 MIPS_RLD_VERSION     1
+# EXE-DAG:    0x70000005 MIPS_FLAGS           NOTPOT
+# EXE-DAG:    0x70000006 MIPS_BASE_ADDRESS
+# EXE-DAG:    0x7000000A MIPS_LOCAL_GOTNO     2
+# EXE-DAG:    0x70000011 MIPS_SYMTABNO        1
+# EXE-DAG:    0x70000013 MIPS_GOTSYM          0x1
+# EXE-DAG:    0x70000016 MIPS_RLD_MAP         [[RLDMAPADDR]]
+# EXE:      ]
+
+# DSO:      Sections [
+# DSO:          Name: .dynamic
+# DSO-NEXT:     Type: SHT_DYNAMIC
+# DSO-NEXT:     Flags [
+# DSO-NEXT:       SHF_ALLOC
+# DSO-NEXT:     ]
+# DSO:          Name: .got
+# DSO-NEXT:     Type: SHT_PROGBITS
+# DSO-NEXT:     Flags [ (0x10000003)
+# DSO-NEXT:       SHF_ALLOC
+# 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: _gp@
+# DSO:          Name: __start@
+# DSO:          Name: _foo@
+# 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
+# DSO-DAG:    0x70000011 MIPS_SYMTABNO        4
+# DSO-DAG:    0x70000013 MIPS_GOTSYM          0x4
+# DSO:      ]
+
+  .text
+  .globl  __start,_foo
+  .type _foo,@function
+__start:
+  nop

lld/trunk/test/elf2/mips-got-relocs.s

 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # v1GotAddr (0x3000c) - _gp (0x37ff4) = -0x7fe8 => 0x8018 = 32792
 # EXE_DIS_BE:  20000:  3c 02 80 18  lui $2, 32792
 # EXE_DIS_EL:  20000:  18 80 02 3c  lui $2, 32792
 
 # DSO_SYM: Sections:
-# DSO_SYM: .got 0000000c 0000000000020034 DATA
+# DSO_SYM: .got 0000000c 0000000000020004 DATA
 # DSO_SYM: SYMBOL TABLE:
-# DSO_SYM: 00028024         *ABS*    00000000 _gp
+# DSO_SYM: 00027ff4         *ABS*    00000000 _gp
 #          ^-- .got + GP offset (0x7ff0)
 # DSO_SYM: 00020000 g       .data    00000004 v1
 
 # DSO_GOT_BE: Contents of section .got:
-# DSO_GOT_BE:  20034 00000000 80000000 00020000
+# DSO_GOT_BE:  20004 00000000 80000000 00020000
 #                    ^        ^        ^-- v1 (0x20000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # DSO_GOT_EL: Contents of section .got:
-# DSO_GOT_EL:  20034 00000000 00000080 00000200
+# DSO_GOT_EL:  20004 00000000 00000080 00000200
 #                    ^        ^        ^-- v1 (0x20000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
-# v1GotAddr (0x2003c) - _gp (0x28024) = -0x7fe8 => 0x8018 = 32792
+# v1GotAddr (0x2000c) - _gp (0x27ff4) = -0x7fe8 => 0x8018 = 32792
 # DSO_DIS_BE:  10000:  3c 02 80 18  lui $2, 32792
 # DSO_DIS_EL:  10000:  18 80 02 3c  lui $2, 32792
 
 # NORELOC:      Relocations [
 # NORELOC-NEXT: ]
 
 # SHFLAGS:      Name: .got
 # SHFLAGS-NEXT: Type: SHT_PROGBITS
 # SHFLAGS-NEXT: Flags [ (0x10000003)
 #                        ^-- SHF_MIPS_GPREL | SHF_ALLOC | SHF_WRITE