[ELF] - Define linkerscript symbols early.

[grimar]

Summary

Currently symbols assigned or created by linkerscript are not processed early
enough. As a result it is not possible to version them or assign any other flags/properties.

Patch adds declareSymbols() method to script class. It allows to add
symbols early enough as undefined and that allows to version them properly.

[grimar]

• Added testcase from D36579, showing PR34121 is also fixed with this patch.

[grimar]

• Updated comments.

[ruiu]

It doesn't seems that "prefetch" is a right word to describe what you are doing in this patch. Prefetch is, well, fetching something early, but what you are doing in this patch is to define them early. Defining symbols is not fetching symbols.

[grimar]

• Addressed review comment about naming things.
• Updated implementation.

[ruiu]

ELF/LinkerScript.cpp

134–136

I do not understand this change.

144

Do not copy-n-paste the same comment all around.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

134–136

I reimplemented some parts. Does new version look better ?

[grimar]

Ping.

[grimar]

• Rebased/reimplemented after recent changes, added comments.

[ruiu]

ELF/Driver.cpp

1041

Remove "enough"

ELF/LinkerScript.cpp

132–134

You shouldn't use Ctx in this function. Basically, you shouldn't use Ctx as long as you can avoid it. This is important because adding a use of Ctx = more dependencies you will have.

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

132–134

Ok, I introduced DefineOnly argument instead.

[ruiu]

ELF/LinkerScript.cpp

132

I'm still not impressed by this change because it looks like this patch is making this function unnecessarily complicated.

If you add a boolean flag to an existing function and execute some pieces of code of the function only when the flag is true, you are effectively defining two separate functions sharing some amount of code. As a reader of this code, I need to think if the pieces of code that are not guarded by flag work correctly with and without that flag. It is hard to do.

[grimar]

• Addressed review comments.

[smeenai]

ELF/Driver.cpp

1043

Typo: proccessing -> processing

[ruiu]

ELF/LinkerScript.cpp

173–177

I don't think you need this.

[grimar]

• Addressed review comments.

ELF/Driver.cpp

1043

Fixed, thanks !

ELF/LinkerScript.cpp

173–177

Yes, you right. I tried to make logic handling PROVIDE nicer, so using early return
seemed both common and helpfull.
I found better approach for this diff it seems - to just drop the Provide flag after proccessing.

[grimar]

I'll try to update this with better version.

[grimar]

• Reimplemented in much simpler and (hopefully) better way.

[ruiu]

ELF/LinkerScript.cpp

133–136

This seems like an optimization that you can remove.

ELF/Writer.cpp

777–782

It is not clear to me why you need to change this.

[grimar]

ELF/LinkerScript.cpp

133–136

I think I can't remove it. It is used for following case. If we have script like:
"PROVIDE_HIDDEN(newsym = __ehdr_start + 5);" (linkerscript/symbol-reserved.s)

When addSymbol is called first time to define newsym early, newsym is undefined, so
if (Cmd->Provide && (!B || B->isDefined())) check passes through and we define
dummy newsym.

Next time when addSymbol called to set proper symbol value, if condition will not pass
because symbol is defined. To let it pass I had to drop Provide to disable check.

ELF/Writer.cpp

777–782

Because otherwise I would have "duplicate symbol: _gp" error with script like
"SECTIONS { .text : { *(.text) } _gp = ABSOLUTE(.) + 0x100; .got : { *(.got) } }"
I add _gp early, so addAbsolute would trigger the error without this check.

[ruiu]

ELF/LinkerScript.cpp

133–136

That's too complicated. It seems you are making this function do too many different things, so you need to dispatch inside the function. Can you redesign?

ELF/Writer.cpp

777–782

But if that's the case, that is applicable to all symbols. What if you linker scripts defines _gp_disp, for example?

[grimar]

• Addressed review comments.

ELF/LinkerScript.cpp

133–136

Done. What do you think about new version ?

ELF/Writer.cpp

777–782

Yeah, but them do not break any tests, so change for them can be prepared+committed separatelly.
(I did similar change in D36579 and it even has testcase, going to reuse it, but don't want to do that in this patch).

[ruiu]

ELF/LinkerScript.cpp

162

Please always write a function comment and choose an appropriate function name if a function is not trivial. Usually if there are more than one way to "handle" something, you should avoid naming a function "handle", as it is ambiguous. I expected that this function would handle assignments (because the function name says so), but at the beginning it returns if it is an assignment to ".", which is obviously odd.

191

Please avoid using some rarely used magical RAII class.

[grimar]

ELF/LinkerScript.cpp

191

Ok. Is this approach to swap/restore the expression looks fine for you in general ?
I feel it is a bit tricky though helps to simplify things.

[ruiu]

Sorry, I didn't even carefully read the code to understand what it is doing, as I don't really see the code of the RAII class. Please rewrite and upload again.

[grimar]

In D38239#924325, @ruiu wrote:

Sorry, I didn't even carefully read the code to understand what it is doing, as I don't really see the code of the RAII class. Please rewrite and upload again.

OK :)

[grimar]

Its now intersects with how we handle -defsym. Abandoning it for now, will try to revisit later.

[grimar]

• Rebased.
• Addressed review comments.

[smeenai]

ELF/LinkerScript.cpp

190

Why are defsym's handled differently than linker script assignments?

[grimar]

ELF/LinkerScript.cpp

190

Interesting. Initially I did that because investigated defsym.ll failture (error : duplicate symbol: bar2)
with this patch. I found different behavior of gold (and even observed its crash) and bfd, but now I see a error in my testcase.
I retested and both of them have equal behavior and assign versions to defsym symbols.
So I am going to update this patch tomorrow (will have to reinvestigate defsym.ll failture though)

Interesting point that when following code and script are used:

.global foo
foo:

VER1 { global: foo ; local: * ; } ;

Then gold allows to redefine foo:
ld.gold --defsym=foo=2 --version-script version.txt -shared test.o -o test.so

but bfd does not:

++ ld.bfd --defsym=foo=2 --version-script version.txt -shared test.o -o test.so
test.o: In function `foo':
(.text+0x0): multiple definition of `foo'

LLD 6.0.0 (trunk 319747) also links it fine without errors.
It looks like an issue of both gold and LLD for me.

[grimar]

I investigated it and problem is deeper than I expected.

With this patch (without check for Cmd->IsDefsym),
defsym.ll testcase fails with

ld.lld.EXE : error : duplicate symbol: bar2
>>> defined in <internal>
>>> defined in lto.tmp

It happens because of -defsym:
ld.lld %t.o %t1.o -shared -o %t.so -defsym=bar2=bar3

In this patch I define script symbols early and so define bar2, and
after LTO->compile()
it fails with duplicate error in SymbolTable::addRegular(), because
LTO returns defined symbol bar2 again.

I tried playing with Prevailing flag and undefining them before LTO,
but no luck for now.
May be somebody knows how this can/should be solved ?

[grimar]

So we could probably use replaceSymbol<Defined>, like we do in linkerscript to avoid the error,
for script symbols coming from LTO, but does not feel right probably.

[grimar]

Will try to do something else probably with it tomorrow anyways.

[grimar]

• Reimplemented.

I think correct solution is to add linker script symbols as undefined and
set flag for them, showing we know they be defined/adjusted later by script.
That looks cleaner and allows to avod multiple definition error I mentioned earlier.

Patch do this.

[grimar]

• Move declareSymbols() below fetchIfLazy calls.

[grimar]

Abandoning because alternative version was posted (D41987).

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   Config->HasDynSymTab =
       !SharedFiles.empty() || Config->Pic || Config->ExportDynamic;
 
   // Some symbols (such as __ehdr_start) are defined lazily only when there
   // are undefined symbols for them, so we add these to trigger that logic.
   for (StringRef Sym : Script->ReferencedSymbols)
     Symtab->addUndefined<ELFT>(Sym);
 
+  // We want to define symbols assigned by linker script early,
+  // so we can version them and change attributes before normal
+  // script commands processing where their values are finalized.
+  Script->defineSymbols();
+
   // Handle the `--undefined <sym>` options.
   for (StringRef S : Config->Undefined)
     Symtab->fetchIfLazy<ELFT>(S);
 
   // If an entry symbol is in a static archive, pull out that file now
   // to complete the symbol table. After this, no new names except a
   // few linker-synthesized ones will be added to the symbol table.
   Symtab->fetchIfLazy<ELFT>(Config->Entry);

ELF/LTO.cpp

 }
 
 void BitcodeCompiler::add(BitcodeFile &F) {
   lto::InputFile &Obj = *F.Obj;
   unsigned SymNum = 0;
   std::vector<SymbolBody *> Syms = F.getSymbols();
   std::vector<lto::SymbolResolution> Resols(Syms.size());
 
-  DenseSet<StringRef> ScriptSymbols;
-  for (BaseCommand *Base : Script->SectionCommands)
-    if (auto *Cmd = dyn_cast<SymbolAssignment>(Base))
-      ScriptSymbols.insert(Cmd->Name);
-
   // Provide a resolution to the LTO API for each symbol.
   for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     SymbolBody *B = Syms[SymNum];
     Symbol *Sym = B->symbol();
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     if (R.Prevailing)
       undefine(Sym);
 
     // We tell LTO to not apply interprocedural optimization for following
     // symbols because otherwise LTO would inline them while their values are
     // still not final:
     // 1) Aliased (with --defsym) or wrapped (with --wrap) symbols.
     // 2) Symbols redefined in linker script.
-    R.LinkerRedefined = !Sym->CanInline || ScriptSymbols.count(B->getName());
+    R.LinkerRedefined = !Sym->CanInline;
   }
   checkError(LTOObj->add(std::move(F.Obj), Resols));
 }
 
 // Merge all the bitcode files we have seen, codegen the result
 // and return the resulting ObjectFile(s).
 std::vector<InputFile *> BitcodeCompiler::compile() {
   std::vector<InputFile *> Ret;

ELF/LinkerScript.h

public:
   bool needsInterpSection();
 
   bool shouldKeep(InputSectionBase *S);
   void assignOffsets(OutputSection *Sec);
   void assignAddresses();
   void allocateHeaders(std::vector<PhdrEntry *> &Phdrs);
   void processSectionCommands(OutputSectionFactory &Factory);
 
+  void defineSymbols();
+
   // SECTIONS command list.
   std::vector<BaseCommand *> SectionCommands;
 
   // PHDRS command list.
   std::vector<PhdrsCommand> PhdrsCommands;
 
   bool HasSectionsCommand = false;
   bool ErrorOnMissingSection = false;

ELF/LinkerScript.cpp

error(Loc + ": unable to move location counter backward for: " +
           Ctx->OutSec->Name);
   Dot = Val;
 
   // Update to location counter means update to section size.
   if (InSec)
     Ctx->OutSec->Size = Dot - Ctx->OutSec->Addr;
 }
 
+static bool shouldProvide(SymbolAssignment *Cmd) {
+  assert(Cmd->Provide);
+  // If a symbol was in PROVIDE(), we need to define it only when
+  // it is a referenced undefined symbol.
+  SymbolBody *B = Symtab->find(Cmd->Name);
+  return B && B->isUndefined();
+}
+
 // This function is called from processSectionCommands,
 // while we are fixing the output section layout.
 void LinkerScript::addSymbol(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return;
 
-  // If a symbol was in PROVIDE(), we need to define it only when
-  // it is a referenced undefined symbol.
-  SymbolBody *B = Symtab->find(Cmd->Name);
-  if (Cmd->Provide && (!B || B->isDefined()))
+  if (Cmd->Provide && !shouldProvide(Cmd))
     return;
 
   // Define a symbol.
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   std::tie(Sym, std::ignore) = Symtab->insert(Cmd->Name, /*Type*/ 0, Visibility,
                                               /*CanOmitFromDynSym*/ false,
                                               /*File*/ nullptr);
   Sym->Binding = STB_GLOBAL;
   ExprValue Value = Cmd->Expression();
   SectionBase *Sec = Value.isAbsolute() ? nullptr : Value.Sec;
 
   // When this function is called, section addresses have not been
   // fixed yet. So, we may or may not know the value of the RHS
   // expression.
   //
   // For example, if an expression is `x = 42`, we know x is always 42.
   // However, if an expression is `x = .`, there's no way to know its
   // value at the moment.
   //
   // We want to set symbol values early if we can. This allows us to
   // use symbols as variables in linker scripts. Doing so allows us to
   // write expressions like this: `alignment = 16; . = ALIGN(., alignment)`.
   uint64_t SymValue = Value.Sec ? 0 : Value.getValue();
 
   replaceBody<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
                               Visibility, STT_NOTYPE, SymValue, 0, Sec);
   Cmd->Sym = cast<DefinedRegular>(Sym->body());
 }
 
+// Symbols defined in script should not be inlined by LTO. At the same time
+// we don't know their final values until late stages of link. Here we scan
+// over symbol assignment commands, create dummy symbols if needed and and set
+// appropriate flag.
+void LinkerScript::defineSymbols() {
+  assert(!Ctx);
+  for (BaseCommand *Base : SectionCommands) {
+    SymbolAssignment *Cmd = dyn_cast<SymbolAssignment>(Base);
+    if (!Cmd || Cmd->Name == ".")
+      continue;
+
+    // We don't define symbol that should not be provided. Otherwise we provide
+    // it below right here and drop the flag what allows addSymbol() to properly
+    // update symbol value later.
+    if (Cmd->Provide) {
+      if (!shouldProvide(Cmd))
+        continue;
+      Cmd->Provide = false;
+    }
+
+    // Define dummy symbol.
+    Symbol *Sym;
+    std::tie(Sym, std::ignore) =
+        Symtab->insert(Cmd->Name, 0, STV_DEFAULT, false, nullptr);
+    replaceBody<DefinedRegular>(Sym, nullptr, Cmd->Name, /*IsLocal=*/false,
+                                STV_DEFAULT, STT_NOTYPE, 0, 0, nullptr);
+    Sym->CanInline = false;
+  }
+}
+
 // This function is called from assignAddresses, while we are
 // fixing the output section addresses. This function is supposed
 // to set the final value for a given symbol assignment.
 void LinkerScript::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
   if (Cmd->Name == ".") {
     setDot(Cmd->Expression, Cmd->Location, InSec);
     return;
   }

ELF/Writer.cpp

 // 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 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
+    SymbolBody *Gp = Symtab->find("_gp");
+    if (!Gp || !isa<DefinedRegular>(Gp))
       ElfSym::MipsGp = Symtab->addAbsolute<ELFT>("_gp", STV_HIDDEN, STB_LOCAL);
+    else
+      ElfSym::MipsGp = dyn_cast<DefinedRegular>(Gp);
 
     // On MIPS O32 ABI, _gp_disp is a magic symbol designates offset between
     // start of function and 'gp' pointer into GOT.
     if (Symtab->find("_gp_disp"))
       ElfSym::MipsGpDisp =
           Symtab->addAbsolute<ELFT>("_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

test/ELF/linkerscript/symbols-synthetic.s

 # RUN:        PROVIDE_HIDDEN(_end_sec = ADDR(.text) + SIZEOF(.text)); }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 # RUN: llvm-objdump -t %t1 | FileCheck --check-prefix=IN-SEC %s
 
 # SIMPLE:      0000000000000128         .foo    00000000 .hidden _end_sec
 # SIMPLE-NEXT: 0000000000000120         .foo    00000000 _begin_sec
 # SIMPLE-NEXT: 0000000000000128         *ABS*   00000000 _end_sec_abs
 # SIMPLE-NEXT: 0000000000001048         .text   00000000 _start
+# SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
 # SIMPLE-NEXT: 0000000000000120         .foo    00000000 begin_foo
 # SIMPLE-NEXT: 0000000000000128         .foo    00000000 end_foo
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
 # SIMPLE-NEXT: 0000000000001000         .foo    00000000 begin_bar
 # SIMPLE-NEXT: 0000000000001004         .foo    00000000 end_bar
 # SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_2
-# SIMPLE-NEXT: 0000000000000ee4         *ABS*   00000000 size_foo_3
 # SIMPLE-NEXT: 0000000000001004         .eh_frame_hdr     00000000 __eh_frame_hdr_start
 # SIMPLE-NEXT: 0000000000001010         *ABS*             00000000 __eh_frame_hdr_start2
 # SIMPLE-NEXT: 0000000000001018         .eh_frame_hdr     00000000 __eh_frame_hdr_end
 # SIMPLE-NEXT: 0000000000001020         *ABS*             00000000 __eh_frame_hdr_end2
 
 # NO-SEC:       0000000000201000         .text     00000000 .hidden _begin_sec
 # NO-SEC-NEXT:  0000000000201001         .text     00000000 .hidden _end_sec
 

test/ELF/linkerscript/version-script.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+
+# RUN: echo "bar = foo; VERSION { V { global: foo; bar; local: *; }; }" > %t.script
+# RUN: ld.lld -T %t.script -shared --no-undefined-version %t.o -o %t.so
+# RUN: llvm-readobj -V %t.so | FileCheck %s
+
+## Check that we are able to version symbols defined in script.
+# CHECK:      Symbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Version: 0
+# CHECK-NEXT:     Name: @
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Version: 0
+# CHECK-NEXT:     Name: und@
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Version: 2
+# CHECK-NEXT:     Name: foo@@V
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Version: 2
+# CHECK-NEXT:     Name: bar@@V
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+
+# RUN: echo "bar = und; VERSION { V { global: foo; bar; local: *; }; }" > %t.script
+# RUN: not ld.lld -T %t.script -shared --no-undefined-version %t.o -o %t.so \
+# RUN:   2>&1 | FileCheck --check-prefix=ERR %s
+# ERR: symbol not found: und
+
+.global und
+
+.text
+.globl foo
+.type foo,@function
+foo:

test/ELF/lto/linker-script-symbols-assign.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
 ; RUN: echo "foo = 1;" > %t.script
 ; RUN: ld.lld -m elf_x86_64 %t.o -o %t2 --script %t.script -save-temps
 ; RUN: llvm-readobj -symbols %t2.lto.o | FileCheck %s
 
 ; CHECK-NOT: bar
-; CHECK:     Symbol {
-; CHECK:         Name: foo
-; CHECK-NEXT:    Value: 0x0
-; CHECK-NEXT:    Size: 4
-; CHECK-NEXT:    Binding: Weak
-; CHECK-NEXT:    Type: Object
-; CHECK-NEXT:    Other: 0
-; CHECK-NEXT:    Section: .bss.foo
-; CHECK-NEXT:  }
-; CHECK-NEXT:]
+; CHECK-NOT: foo
 
 ; RUN: llvm-readobj -symbols %t2 | FileCheck %s --check-prefix=VAL
 ; VAL:       Symbol {
 ; VAL:        Name: foo
 ; VAL-NEXT:   Value: 0x1
 ; VAL-NEXT:   Size:
 ; VAL-NEXT:   Binding: Global
 ; VAL-NEXT:   Type: None

test/ELF/lto/linker-script-symbols-ipo.ll

 ; IPO-NEXT:   201000: {{.*}} movl $1, %eax
 ; IPO-NEXT:   201005: {{.*}} retq
 
 ;; Check that LTO does not do IPO for symbols assigned by script.
 ; RUN: ld.lld  -m elf_x86_64 %t1.o %t2.o -o %t4 --script %t.script -save-temps
 ; RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=NOIPO
 ; NOIPO:      Disassembly of section .text:
 ; NOIPO:      foo:
-; NOIPO-NEXT:   201010: {{.*}} movl $2, %eax
+; NOIPO-NEXT:   201000: {{.*}} movl $2, %eax
 ; NOIPO:      _start:
-; NOIPO-NEXT:   201020: {{.*}} jmp -21 <foo>
+; NOIPO-NEXT:   201010: {{.*}} jmp -21 <foo>
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @bar() {
   ret i32 1
 }
 
 define i32 @foo() {
   ret i32 2
 }

test/ELF/mips-gp-ext.s

 # 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
 
 # REL:      Contents of section .text:
-# REL-NEXT:  0000 3c080000 2108010c 8f82fffc
+# REL-NEXT:  0000 3c080000 2108010c 8f82001c
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
-#                                   ^-- 8 - (0x10c - 0x100)
+#                                   ^-- 8 - (0x10c - 0x120)
 #                                       G - (GP - .got)
 
 # REL:      Contents of section .reginfo:
 # REL-NEXT:  0028 10000104 00000000 00000000 00000000
 # REL-NEXT:  0038 00000000 0000010c
 #                          ^-- _gp
 
 # REL:      Contents of section .data:
-# REL-NEXT:  00f0 fffffef4
+# REL-NEXT:  0110 fffffef4
 #                 ^-- 0-0x10c
 
 # REL: 00000000         .text           00000000 foo
 # REL: 00000000         *ABS*           00000000 .hidden _gp_disp
-# REL: 0000010c         *ABS*           00000000 .hidden _gp
+# REL: 0000010c         *ABS*           00000000  _gp
 
 # ABS:      Contents of section .text:
-# ABS-NEXT:  0000 3c080000 21080200 8f82ff08
+# ABS-NEXT:  0000 3c080000 21080200 8f82ff28
 #                 ^-- %hi(_gp_disp)
 #                          ^-- %lo(_gp_disp)
-#                                   ^-- 8 - (0x200 - 0x100)
+#                                   ^-- 8 - (0x200 - 0x120)
 #                                       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:  00f0 fffffe00
+# ABS-NEXT:  0110 fffffe00
 #                 ^-- 0-0x200
 
 # ABS: 00000000         .text           00000000 foo
 # ABS: 00000000         *ABS*           00000000 .hidden _gp_disp
-# ABS: 00000200         *ABS*           00000000 .hidden _gp
+# ABS: 00000200         *ABS*           00000000  _gp
 
   .text
 foo:
   lui    $t0, %hi(_gp_disp)
   addi   $t0, $t0, %lo(_gp_disp)
   lw     $v0, %call16(bar)($gp)
 
   .data
   .gpword foo