[ELF][MIPS] Make _gp, _gp_disp, __gnu_local_gp global symbols

[atanasyan]

Summary

These MIPS specific symbols should be global because in general they can have an arbitrary value. By default this value is a fixed offset from .got section.

This patch adds more checks to the mips-gp-local.s test case but marks it as XFAIL because LLD does not allow redefinition of absolute symbols value by a linker script. This should be fixed by D27276.

[ruiu]

I wonder if

ELF/Relocations.cpp

351–353 ↗

(On Diff #80598)

Doesn't _gp_disp represents offset between _gp and .got? I'm not sure what you mean by "a function" in the above description.

[meadori]

Other than the one question above, LGTM. I tested this patch with my WIP patch for D27276. Thank you for fixing this.

ELF/Relocations.cpp

357 ↗

(On Diff #80598)

Is this related to the problem being discussed in D26133?

[atanasyan]

ELF/Relocations.cpp

351–353 ↗

(On Diff #80598)

Doesn't _gp_disp represents offset between _gp and .got? I'm not sure what you mean by "a function" in the above description.

By definition _gp_disp represents the offset between the beginning of the function and the _gp. This symbol is used in a position-independent function prologue in a combination with R_MIPS_HI16/LO16 relocations. So for each function _gp_disp has a unique value. Moreover we do not have to really define this symbol and put it to the symbol table. From the other side we need to define this symbol to escape "not defined symbol" error.

Your question gives me a good idea. Maybe it is better to add a new expression R_MIPS_GP_DISP for this case. So we will not mix these specific relocations with regular R_PC relocations and will be able to write checking more clear.

357 ↗

(On Diff #80598)

Is this related to the problem being discussed in D26133?

Yes and no. With D26133 we will not need this if condition. From the other side _gp_disp is not true absolute symbol but just a "marker". If we could suppress "symbol not found error" for _gp_disp we even would not need to define it, add to a symbol table etc.

[atanasyan]

Doesn't _gp_disp represents offset between _gp and .got? I'm not sure what you mean by "a function" in the above description.

Your question gives me a good idea. Maybe it is better to add a new expression R_MIPS_GP_DISP for this case. So we will not mix these specific relocations with regular R_PC relocations and will be able to write checking more clear.

Not so good as expected. The code is not reduced and we have to put new R_MIPS_GP_DISP expression type in too many place. So I prefer my initial patch.

[ruiu]

LGTM

lld/trunk/ELF/Relocations.cpp

static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
   if (!AbsVal && RelE)
     return true;
 
   // Relative relocation to an absolute value. This is normally unrepresentable,
   // but if the relocation refers to a weak undefined symbol, we allow it to
   // resolve to the image base. This is a little strange, but it allows us to
   // link function calls to such symbols. Normally such a call will be guarded
   // with a comparison, which will load a zero from the GOT.
+  // Another special case is MIPS _gp_disp symbol which represents offset
+  // between start of a function and '_gp' value and defined as absolute just
+  // to simplify the code.
   if (AbsVal && RelE) {
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
       return true;
+    if (&Body == ElfSym<ELFT>::MipsGpDisp)
+      return true;
     error(S.getLocation(RelOff) + ": relocation " + toString(Type) +
           " cannot refer to absolute symbol '" + toString(Body) +
           "' defined in " + toString(Body.File));
     return true;
   }
 
   return Target->usesOnlyLowPageBits(Type);
 }

lld/trunk/ELF/SymbolTable.h

public:
   void addCombinedLTOObject();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   ArrayRef<ObjectFile<ELFT> *> getObjectFiles() const { return ObjectFiles; }
   ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
   ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
 
   DefinedRegular<ELFT> *addAbsolute(StringRef Name,
-                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
+                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN,
+                                    uint8_t Type = llvm::ELF::STB_GLOBAL);
   DefinedRegular<ELFT> *addIgnored(StringRef Name,
                                    uint8_t Visibility = llvm::ELF::STV_HIDDEN);
 
   Symbol *addUndefined(StringRef Name);
   Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
                        uint8_t StOther, uint8_t Type, bool CanOmitFromDynSym,
                        InputFile *File);
 

lld/trunk/ELF/SymbolTable.cpp

for (InputFile *File : LTO->compile()) {
     DenseSet<CachedHashStringRef> DummyGroups;
     Obj->parse(DummyGroups);
     ObjectFiles.push_back(Obj);
   }
 }
 
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addAbsolute(StringRef Name,
-                                                     uint8_t Visibility) {
-  Symbol *Sym = addRegular(Name, Visibility, STT_NOTYPE, 0, 0, STB_GLOBAL,
-                           nullptr, nullptr);
+                                                     uint8_t Visibility,
+                                                     uint8_t Type) {
+  Symbol *Sym =
+      addRegular(Name, Visibility, STT_NOTYPE, 0, 0, Type, nullptr, nullptr);
   return cast<DefinedRegular<ELFT>>(Sym->body());
 }
 
 // Add Name as an "ignored" symbol. An ignored symbol is a regular
 // linker-synthesized defined symbol, but is only defined if needed.
 template <class ELFT>
 DefinedRegular<ELFT> *SymbolTable<ELFT>::addIgnored(StringRef Name,
                                                     uint8_t Visibility) {

lld/trunk/ELF/Symbols.h

template <class ELFT> struct ElfSym {
 
   // The content for _end and end symbols.
   static DefinedRegular<ELFT> *End;
   static DefinedRegular<ELFT> *End2;
 
   // The content for _gp_disp/__gnu_local_gp symbols for MIPS target.
   static DefinedRegular<ELFT> *MipsGpDisp;
   static DefinedRegular<ELFT> *MipsLocalGp;
-  static SymbolBody *MipsGp;
+  static DefinedRegular<ELFT> *MipsGp;
 };
 
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::EhdrStart;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::Etext;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::Etext2;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::Edata;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::Edata2;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::End;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::End2;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsGpDisp;
 template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsLocalGp;
-template <class ELFT> SymbolBody *ElfSym<ELFT>::MipsGp;
+template <class ELFT> DefinedRegular<ELFT> *ElfSym<ELFT>::MipsGp;
 
 // A real symbol object, SymbolBody, is usually stored within a Symbol. There's
 // always one Symbol for each symbol name. The resolver updates the SymbolBody
 // stored in the Body field of this object as it resolves symbols. Symbol also
 // holds computed properties of symbol names.
 struct Symbol {
   // Symbol binding. This is on the Symbol to track changes during resolution.
   // In particular:

lld/trunk/ELF/Target.cpp

RelExpr MipsTargetInfo<ELFT>::getRelExpr(uint32_t Type,
   case R_MIPS_GPREL16:
   case R_MIPS_GPREL32:
     return R_MIPS_GOTREL;
   case R_MIPS_26:
     return R_PLT;
   case R_MIPS_HI16:
   case R_MIPS_LO16:
   case R_MIPS_GOT_OFST:
-    // MIPS _gp_disp designates offset between start of function and 'gp'
-    // pointer into GOT. __gnu_local_gp is equal to the current value of
-    // the 'gp'. Therefore any relocations against them do not require
-    // dynamic relocation.
+    // R_MIPS_HI16/R_MIPS_LO16 relocations against _gp_disp calculate
+    // offset between start of function and 'gp' value which by default
+    // equal to the start of .got section. In that case we consider these
+    // relocations as relative.
     if (&S == ElfSym<ELFT>::MipsGpDisp)
       return R_PC;
     return R_ABS;
   case R_MIPS_PC32:
   case R_MIPS_PC16:
   case R_MIPS_PC19_S2:
   case R_MIPS_PC21_S2:
   case R_MIPS_PC26_S2:

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
   addOptionalRegular<ELFT>(S, In<ELFT>::RelaPlt, -1);
 }
 
 // The linker is expected to define some symbols depending on
 // the linking result. This function defines such symbols.
 template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   if (Config->EMachine == EM_MIPS) {
     // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
-    // so that it points to an absolute address which is relative to GOT.
-    // Default offset is 0x7ff0.
+    // so that it points to an absolute address which by default is relative
+    // to GOT. Default offset is 0x7ff0.
     // See "Global Data Symbols" in Chapter 6 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
-    ElfSym<ELFT>::MipsGp = addRegular("_gp", In<ELFT>::MipsGot, 0x7ff0)->body();
+    ElfSym<ELFT>::MipsGp =
+        Symtab<ELFT>::X->addAbsolute("_gp", STV_HIDDEN, STB_LOCAL);
 
     // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
-    // start of function and 'gp' pointer into GOT.
-    if (Symbol *S = addOptionalRegular("_gp_disp", In<ELFT>::MipsGot, 0))
-      ElfSym<ELFT>::MipsGpDisp = cast<DefinedRegular<ELFT>>(S->body());
+    // start of function and 'gp' pointer into GOT. To simplify relocation
+    // calculation we assign _gp value to it and calculate corresponding
+    // relocations as relative to this value.
+    if (Symtab<ELFT>::X->find("_gp_disp"))
+      ElfSym<ELFT>::MipsGpDisp =
+          Symtab<ELFT>::X->addAbsolute("_gp_disp", STV_HIDDEN, STB_LOCAL);
 
     // The __gnu_local_gp is a magic symbol equal to the current value of 'gp'
     // pointer. This symbol is used in the code generated by .cpload pseudo-op
     // in case of using -mno-shared option.
     // https://sourceware.org/ml/binutils/2004-12/msg00094.html
-    if (Symbol *S = addOptionalRegular("__gnu_local_gp", In<ELFT>::MipsGot, 0))
-      ElfSym<ELFT>::MipsLocalGp = cast<DefinedRegular<ELFT>>(S->body());
+    if (Symtab<ELFT>::X->find("__gnu_local_gp"))
+      ElfSym<ELFT>::MipsLocalGp =
+          Symtab<ELFT>::X->addAbsolute("__gnu_local_gp", STV_HIDDEN, STB_LOCAL);
   }
 
   // In the assembly for 32 bit x86 the _GLOBAL_OFFSET_TABLE_ symbol
   // is magical and is used to produce a R_386_GOTPC relocation.
   // The R_386_GOTPC relocation value doesn't actually depend on the
   // symbol value, so it could use an index of STN_UNDEF which, according
   // to the spec, means the symbol value is 0.
   // Unfortunately both gas and MC keep the _GLOBAL_OFFSET_TABLE_ symbol in
if (H.p_flags & PF_W)
       Set(ElfSym<ELFT>::Edata, ElfSym<ELFT>::Edata2, Val);
     else
       Set(ElfSym<ELFT>::Etext, ElfSym<ELFT>::Etext2, Val);
   }
 
   // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
   // be equal to the _gp symbol's value.
   if (Config->EMachine == EM_MIPS) {
-    uintX_t GpDisp = In<ELFT>::MipsGot->getGp() - In<ELFT>::MipsGot->getVA();
+    if (!ElfSym<ELFT>::MipsGp->Value)
+      ElfSym<ELFT>::MipsGp->Value = In<ELFT>::MipsGot->getVA() + 0x7ff0;
     if (ElfSym<ELFT>::MipsGpDisp)
-      ElfSym<ELFT>::MipsGpDisp->Value = GpDisp;
+      ElfSym<ELFT>::MipsGpDisp->Value = ElfSym<ELFT>::MipsGp->Value;
     if (ElfSym<ELFT>::MipsLocalGp)
-      ElfSym<ELFT>::MipsLocalGp->Value = GpDisp;
+      ElfSym<ELFT>::MipsLocalGp->Value = ElfSym<ELFT>::MipsGp->Value;
   }
 }
 
 template <class ELFT> void Writer<ELFT>::writeHeader() {
   uint8_t *Buf = Buffer->getBufferStart();
   memcpy(Buf, "\177ELF", 4);
 
   // Write the ELF header.

lld/trunk/test/ELF/basic-mips.s

 # CHECK-NEXT:     Name: _gp
 # CHECK-NEXT:     Value: 0x37FF0
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Local
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other [ (0x2)
 # CHECK-NEXT:       STV_HIDDEN (0x2)
 # CHECK-NEXT:     ]
-# CHECK-NEXT:     Section: .got
+# CHECK-NEXT:     Section: Absolute
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Symbol {
 # CHECK-NEXT:     Name: __start
 # CHECK-NEXT:     Value: 0x20000
 # CHECK-NEXT:     Size: 0
 # CHECK-NEXT:     Binding: Global (0x1)
 # CHECK-NEXT:     Type: None (0x0)
 # CHECK-NEXT:     Other: 0

lld/trunk/test/ELF/mips-64-disp.s

 # CHECK:      __start:
 # CHECK-NEXT:    20000:   24 42 80 40   addiu   $2, $2, -32704
 # CHECK-NEXT:    20004:   24 42 80 20   addiu   $2, $2, -32736
 # CHECK-NEXT:    20008:   24 42 80 28   addiu   $2, $2, -32728
 # CHECK-NEXT:    2000c:   24 42 80 30   addiu   $2, $2, -32720
 # CHECK-NEXT:    20010:   24 42 80 38   addiu   $2, $2, -32712
 
 # CHECK: 0000000000020014     .text   00000000 foo
-# CHECK: 0000000000037ff0     .got    00000000 .hidden _gp
+# CHECK: 0000000000037ff0     *ABS*   00000000 .hidden _gp
 # CHECK: 0000000000020000     .text   00000000 __start
 # CHECK: 0000000000000000 g F *UND*   00000000 foo1a
 
 # GOT:      Relocations [
 # GOT-NEXT: ]
 # GOT-NEXT: Primary GOT {
 # GOT-NEXT:   Canonical gp value: 0x37FF0
 # GOT-NEXT:   Reserved entries [

lld/trunk/test/ELF/mips-64-got.s

 
 # CHECK-NEXT:    20000:   df 82 80 20   ld      $2, -32736($gp)
 # CHECK-NEXT:    20004:   64 42 00 18   daddiu  $2,  $2, 24
 # CHECK-NEXT:    20008:   24 42 80 40   addiu   $2,  $2, -32704
 # CHECK-NEXT:    2000c:   24 42 80 30   addiu   $2,  $2, -32720
 # CHECK-NEXT:    20010:   24 42 80 38   addiu   $2,  $2, -32712
 
 # CHECK: 0000000000020018   .text   00000000 foo
-# CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
+# CHECK: 0000000000037ff0   *ABS*   00000000 .hidden _gp
 # CHECK: 0000000000020000   .text   00000000 __start
 # CHECK: 0000000000020014   .text   00000000 bar
 
 # GOT:      Relocations [
 # GOT-NEXT: ]
 # GOT-NEXT: Primary GOT {
 # GOT-NEXT:   Canonical gp value: 0x37FF0
 # GOT-NEXT:   Reserved entries [

lld/trunk/test/ELF/mips-64-gprel-so.s

 # Check setup of GP relative offsets in a function's prologue.
 
 # RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -shared -o %t.so
 # RUN: llvm-objdump -d -t %t.so | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Disassembly of section .text:
 # CHECK-NEXT: foo:
 # CHECK-NEXT:    10000:    3c 1c 00 01    lui     $gp, 1
 # CHECK-NEXT:    10004:    03 99 e0 2d    daddu   $gp, $gp, $25
 # CHECK-NEXT:    10008:    67 9c 7f f0    daddiu  $gp, $gp, 32752
 
-# CHECK: 0000000000027ff0   .got    00000000 .hidden _gp
+# CHECK: 0000000000027ff0   *ABS*   00000000 .hidden _gp
 # CHECK: 0000000000010000   .text   00000000 foo
 
   .text
   .global foo
 foo:
   lui     $gp,%hi(%neg(%gp_rel(foo)))
   daddu   $gp,$gp,$t9
   daddiu  $gp,$gp,%lo(%neg(%gp_rel(foo)))

lld/trunk/test/ELF/mips-64-rels.s

 #                                                    ^-- 0 - 0xfffffffffffe8010
 #                                                    ^-- %lo(0x17ff0)
 
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT:  10190 ffffffff fffe8014
 #                    ^-- 0x20004 - 0x37ff0 = 0xfffffffffffe8014
 
 # CHECK: 0000000000020004   .text   00000000 loc
-# CHECK: 0000000000037ff0   .got    00000000 .hidden _gp
+# CHECK: 0000000000037ff0   *ABS*   00000000 .hidden _gp
 # CHECK: 0000000000020000   .text   00000000 __start
 
 # REL:      Relocations [
 # REL-NEXT: ]
 
   .text
   .global  __start
 __start:

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

__start:
   .type  v1,@object
   .size  v1,4
 v1:
   .word 0
 
 # EXE_SYM: Sections:
 # EXE_SYM: .got 0000000c 0000000000030000 DATA
 # EXE_SYM: SYMBOL TABLE:
-# EXE_SYM: 00037ff0         .got     00000000 .hidden _gp
+# EXE_SYM: 00037ff0         *ABS*    00000000 .hidden _gp
 #          ^-- .got + GP offset (0x7ff0)
 # EXE_SYM: 00040000 g       .data    00000004 v1
 
 
 # EXE_GOT_BE: Contents of section .got:
 # EXE_GOT_BE:  30000 00000000 80000000 00040000
 #                    ^        ^        ^-- v1 (0x40000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)
 
 # EXE_GOT_EL: Contents of section .got:
 # EXE_GOT_EL:  30000 00000000 00000080 00000400
 #                    ^        ^        ^-- v1 (0x40000)
 #                    |        +-- 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 0000000000020000 DATA
 # DSO_SYM: SYMBOL TABLE:
-# DSO_SYM: 00027ff0         .got     00000000 .hidden _gp
+# DSO_SYM: 00027ff0         *ABS*    00000000 .hidden _gp
 #          ^-- .got + GP offset (0x7ff0)
 # DSO_SYM: 00030000 g       .data    00000004 v1
 
 # DSO_GOT_BE: Contents of section .got:
 # DSO_GOT_BE:  20000 00000000 80000000 00030000
 #                    ^        ^        ^-- v1 (0x30000)
 #                    |        +-- Module pointer (0x80000000)
 #                    +-- Lazy resolver (0x0)

lld/trunk/test/ELF/mips-gp-disp.s

 # EXT-SO:      Name: _gp_disp
 # EXT-SO-NEXT: Value: 0x20000
 
 # DIS:      Disassembly of section .text:
 # DIS-NEXT: __start:
 # DIS-NEXT:    10000:  3c 08 00 01  lui   $8, 1
 # DIS-NEXT:    10004:  21 08 7f f0  addi  $8, $8, 32752
 #                                                 ^-- 0x37ff0 & 0xffff
-# DIS: 00027ff0  .got  00000000 .hidden _gp
+# DIS: 00027ff0  *ABS*  00000000 .hidden _gp
 
 # REL:      Relocations [
 # REL-NEXT: ]
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(_gp_disp)
   addi   $t0,$t0,%lo(_gp_disp)
   lw     $v0,%call16(_foo)($gp)

lld/trunk/test/ELF/mips-gp-ext.s

 # Check that the linker use a value of _gp symbol defined
 # in a linker script to calculate GOT relocations.
 
+# FIXME: This test is xfailed because it depends on D27276 patch
+# that enables absolute symbols redefinition by a linker's script.
+# XFAIL: *
+
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
+
 # RUN: echo "SECTIONS { \
 # RUN:          .text : { *(.text) } \
 # RUN:          _gp = . + 0x100; \
-# RUN:          .got  : { *(.got) } }" > %t.script
-# RUN: ld.lld -shared -o %t.so --script %t.script %t.o
-# RUN: llvm-objdump -s -t %t.so | FileCheck %s
+# RUN:          .got  : { *(.got) } }" > %t.rel.script
+# RUN: ld.lld -shared -o %t.rel.so --script %t.rel.script %t.o
+# RUN: llvm-objdump -s -t %t.rel.so | FileCheck --check-prefix=REL %s
+
+# RUN: echo "SECTIONS { \
+# RUN:          .text : { *(.text) } \
+# RUN:          _gp = 0x200; \
+# RUN:          .got  : { *(.got) } }" > %t.abs.script
+# RUN: ld.lld -shared -o %t.abs.so --script %t.abs.script %t.o
+# RUN: llvm-objdump -s -t %t.abs.so | FileCheck --check-prefix=ABS %s
 
 # REQUIRES: mips
 
-# CHECK:      Contents of section .text:
-# CHECK-NEXT:  0000 3c080000 2108010c 8f82ffe4
-#                   ^-- %hi(_gp_disp)
-#                            ^-- %lo(_gp_disp)
-#                                     ^-- 8 - (0x10c - 0xe8)
-#                                         G - (GP - .got)
+# REL:      Contents of section .text:
+# REL-NEXT:  0000 3c080000 2108010c 8f82ffe4
+#                 ^-- %hi(_gp_disp)
+#                          ^-- %lo(_gp_disp)
+#                                   ^-- 8 - (0x10c - 0xe8)
+#                                       G - (GP - .got)
 
-# CHECK:      Contents of section .reginfo:
-# CHECK-NEXT:  0028 10000104 00000000 00000000 00000000
-# CHECK-NEXT:  0038 00000000 0000010c
-#                            ^-- _gp
+# REL:      Contents of section .reginfo:
+# REL-NEXT:  0028 10000104 00000000 00000000 00000000
+# REL-NEXT:  0038 00000000 0000010c
+#                          ^-- _gp
 
-# CHECK:      Contents of section .data:
-# CHECK-NEXT:  0100 fffffef4
-#                   ^-- 0-0x10c
+# REL:      Contents of section .data:
+# REL-NEXT:  0100 fffffef4
+#                 ^-- 0-0x10c
 
-# CHECK: 00000000         .text           00000000 foo
-# CHECK: 0000010c         .got            00000000 .hidden _gp_disp
-# CHECK: 0000010c         .text           00000000 .hidden _gp
+# REL: 00000000         .text           00000000 foo
+# REL: 0000010c         *ABS*           00000000 .hidden _gp_disp
+# REL: 0000010c         *ABS*           00000000 .hidden _gp
+
+# ABS:      Contents of section .text:
+# ABS-NEXT:  0000 3c080000 21080200 8f82fef0
+#                 ^-- %hi(_gp_disp)
+#                          ^-- %lo(_gp_disp)
+#                                   ^-- 8 - (0x200 - 0xe8)
+#                                       G - (GP - .got)
+
+# ABS:      Contents of section .reginfo:
+# ABS-NEXT:  0028 10000104 00000000 00000000 00000000
+# ABS-NEXT:  0038 00000000 00000200
+#                          ^-- _gp
+
+# ABS:      Contents of section .data:
+# ABS-NEXT:  0100 fffffe00
+#                 ^-- 0-0x200
+
+# ABS: 00000000         .text           00000000 foo
+# ABS: 00000200         *ABS*           00000000 .hidden _gp_disp
+# ABS: 00000200         *ABS*           00000000 .hidden _gp
 
   .text
 foo:
   lui    $t0, %hi(_gp_disp)
   addi   $t0, $t0, %lo(_gp_disp)
   lw     $v0, %call16(bar)($gp)
 
   .data
   .gpword foo

lld/trunk/test/ELF/mips-gp-local.s

 # Check handling of relocations against __gnu_local_gp symbol.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t.o
 # RUN: ld.lld -o %t.exe %t.o
 # RUN: llvm-objdump -d -t %t.exe | FileCheck %s
 
 # REQUIRES: mips
 
 # CHECK:      Disassembly of section .text:
 # CHECK-NEXT: __start:
 # CHECK-NEXT:    20000:  3c 08 00 03  lui   $8, 3
 # CHECK-NEXT:    20004:  21 08 7f f0  addi  $8, $8, 32752
 
-# CHECK: 00037ff0  .got  00000000 .hidden _gp
+# CHECK: 00037ff0  *ABS*  00000000 .hidden _gp
 
   .text
   .globl  __start
 __start:
   lui    $t0,%hi(__gnu_local_gp)
   addi   $t0,$t0,%lo(__gnu_local_gp)

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

 # DUMP: Contents of section .rodata:
 # DUMP:  0114 ffff0004 ffff0008
 #             ^ 0x10004 + 0x7ff0 - 0x27ff0
 #                      ^ 0x10008 + 0x7ff0 - 0x27ff0
 
 # DUMP: SYMBOL TABLE:
 # DUMP: 00010008         .text          00000000 bar
 # DUMP: 00010004         .text          00000000 foo
-# DUMP: 00027ff0         .got           00000000 .hidden _gp
+# DUMP: 00027ff0         *ABS*          00000000 .hidden _gp
 
 # ERR: error: {{.*}}mips-gp0-non-zero.o: unsupported non-zero ri_gp_value
 
   .text
   .global  __start
 __start:
   lw      $t0,%call16(__start)($gp)
 foo:
   nop
 bar:
   nop
 
   .section .rodata, "a"
 v:
   .gpword foo
   .gpword bar

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

 # CHECK: Contents of section .rodata:
 # CHECK:  0114 fffe8014 fffe8018
 #              ^ 0x10004 - 0x27ff0
 #                       ^ 0x10008 - 0x27ff0
 
 # CHECK: SYMBOL TABLE:
 # CHECK: 00010008         .text           00000000 bar
 # CHECK: 00010004         .text           00000000 foo
-# CHECK: 00027ff0         .got           00000000 .hidden _gp
+# CHECK: 00027ff0         *ABS*           00000000 .hidden _gp

lld/trunk/test/ELF/mips-hilo-gp-disp.s

 # EXE:      bar:
 # EXE-NEXT:  2000c:   3c 08 00 01   lui    $8, 1
 #                                              ^-- %hi(0x37ff0-0x2000c)
 # EXE-NEXT:  20010:   21 08 7f e4   addi   $8, $8, 32740
 #                                                  ^-- %lo(0x37ff0-0x20010+4)
 
 # EXE: SYMBOL TABLE:
 # EXE: 0002000c     .text   00000000 bar
-# EXE: 00037ff0     .got    00000000 .hidden _gp
+# EXE: 00037ff0     *ABS*   00000000 .hidden _gp
 # EXE: 00020000     .text   00000000 __start
 
 # SO:      Disassembly of section .text:
 # SO-NEXT: __start:
 # SO-NEXT:  10000:   3c 08 00 01   lui    $8, 1
 #                                             ^-- %hi(0x27ff0-0x10000)
 # SO-NEXT:  10004:   21 08 7f f0   addi   $8, $8, 32752
 #                                                 ^-- %lo(0x27ff0-0x10004+4)
 # SO:       bar:
 # SO-NEXT:   1000c:   3c 08 00 01   lui    $8, 1
 #                                              ^-- %hi(0x27ff0-0x1000c)
 # SO-NEXT:   10010:   21 08 7f e4   addi   $8, $8, 32740
 #                                                  ^-- %lo(0x27ff0-0x10010+4)
 
 # SO: SYMBOL TABLE:
 # SO: 0001000c     .text   00000000 bar
-# SO: 00027ff0     .got    00000000 .hidden _gp
+# SO: 00027ff0     *ABS*   00000000 .hidden _gp
 # SO: 00010000     .text   00000000 __start

lld/trunk/test/ELF/mips-n32-rels.s

 #                                                       ^-- 0 - 0xfffe8010
 #                                                       ^-- %lo(0x17ff0)
 
 # CHECK:      Contents of section .rodata:
 # CHECK-NEXT:  100f4 00020004
 #                    ^-- loc
 
 # CHECK: 00020004      .text   00000000 loc
-# CHECK: 00037ff0      .got    00000000 .hidden _gp
+# CHECK: 00037ff0      *ABS*   00000000 .hidden _gp
 # CHECK: 00020000 g  F .text   00000000 __start
 
 # ELF:      Format: ELF32-mips
 # ELF-NEXT: Arch: mips
 # ELF-NEXT: AddressSize: 32bit
 # ELF-NEXT: LoadName:
 # ELF-NEXT: ElfHeader {
 # ELF-NEXT:   Ident {