[ELF] Better handling of _GLOBAL_OFFSET_TABLE_

[evgeny777]

Summary

We have several pieces of assembly code which have something like following

.Lablel:
    _GLOBAL_OFFSET_TABLE_ - .Label

it works fine with ld/gold, but fails to link with lld (relocation cannot refer to absolute symbol)

Also this patch sets correct value for _GLOBAL_OFFSET_TABLE_, this is why one of existing test changed.

[ruiu]

Do you have any program that actually needs this change?

ELF/Symbols.h

321

Got -> GlobalOffsetTable

[evgeny777]

Yeah, otherwise I wouldn't bother doing this (but I can't share proprietary sources unfortunately).
Do you see any other issues, except name?

[ruiu]

I don't have any further comments, but can you please update the patch?

ELF/Relocations.cpp

402

Add a comment saying that a relative relocation against the beginning of .got can always be computed at link-time as each ELF module has its own .got section.

[pcc]

ELF/Writer.cpp

830–831

I think that if you create this symbol with addOptionalRegular you won't need a special case in Relocations.cpp.

[evgeny777]

Sure.

[evgeny777]

Peter, I tried doing this, but it forces dynamic reloc to .Label, which can reside in RO section.

[pcc]

In D34459#786952, @evgeny777 wrote:

Peter, I tried doing this, but it forces dynamic reloc to .Label, which can reside in RO section.

Does it help to set visibility to hidden?

[evgeny777]

Does it help to set visibility to hidden?

As you may noticed addOptionalRegular sets visibility to hidden by default. In my experiments I tried creating _GLOBAL_OFFSET_TABLE_ in a following way:

addOptionalRegular("_GLOBAL_OFFSET_TABLE_", InX::Got, 0, STV_HIDDEN, STB_LOCAL);

What troubles me with this approach is that the following can't be linked (ld/gold work fine):

ldr r0, =_GLOBAL_OFFSET_TABLE_

And one of lld test cases also fails.

[evgeny777]

Updated with a comment requested by @ruiu

ELF/Relocations.cpp

static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
   // 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.
   assert(AbsVal && RelE);
   if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
     return true;
 
+  // Relative relocation against the beginning of .got can always be computed
+  // at link-time as each ELF module has its own .got section.
+  if (&Body == ElfSym::GlobalOffsetTable)
+    return true;
+
   error("relocation " + toString(Type) + " cannot refer to absolute symbol: " +
         toString(Body) + getLocation<ELFT>(S, Body, RelOff));
   return true;
 }
 
 static RelExpr toPlt(RelExpr Expr) {
   if (Expr == R_PPC_OPD)
     return R_PPC_PLT_OPD;

ELF/Symbols.h

struct ElfSym {
   // edata and _edata
   static DefinedRegular *Edata1;
   static DefinedRegular *Edata2;
 
   // end and _end
   static DefinedRegular *End1;
   static DefinedRegular *End2;
 
+  // _GLOBAL_OFFSET_TABLE_
+  static DefinedRegular *GlobalOffsetTable;
+
   // _gp, _gp_disp and __gnu_local_gp symbols. Only for MIPS.
   static DefinedRegular *MipsGp;
   static DefinedRegular *MipsGpDisp;
   static DefinedRegular *MipsLocalGp;
 };
 
 // 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

ELF/Symbols.cpp

 
 DefinedRegular *ElfSym::Bss;
 DefinedRegular *ElfSym::Etext1;
 DefinedRegular *ElfSym::Etext2;
 DefinedRegular *ElfSym::Edata1;
 DefinedRegular *ElfSym::Edata2;
 DefinedRegular *ElfSym::End1;
 DefinedRegular *ElfSym::End2;
+DefinedRegular *ElfSym::GlobalOffsetTable;
 DefinedRegular *ElfSym::MipsGp;
 DefinedRegular *ElfSym::MipsGpDisp;
 DefinedRegular *ElfSym::MipsLocalGp;
 
 static uint64_t getSymVA(const SymbolBody &Body, int64_t &Addend) {
   switch (Body.kind()) {
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular>(Body);

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   // to the spec, means the symbol value is 0.
   // Unfortunately both gas and MC keep the _GLOBAL_OFFSET_TABLE_ symbol in
   // the object file.
   // The situation is even stranger on x86_64 where the assembly doesn't
   // need the magical symbol, but gas still puts _GLOBAL_OFFSET_TABLE_ as
   // an undefined symbol in the .o files.
   // Given that the symbol is effectively unused, we just create a dummy
   // hidden one to avoid the undefined symbol error.
+  ElfSym::GlobalOffsetTable =
       Symtab<ELFT>::X->addIgnored("_GLOBAL_OFFSET_TABLE_");
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!InX::DynSymTab)
     Symtab<ELFT>::X->addIgnored("__tls_get_addr");
 
template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
   if (LastRW) {
     Set(ElfSym::Edata1, LastRW->First, LastRW->p_filesz);
     Set(ElfSym::Edata2, LastRW->First, LastRW->p_filesz);
   }
 
   if (ElfSym::Bss)
     ElfSym::Bss->Section = findSectionInScript(".bss");
 
+  if (ElfSym::GlobalOffsetTable && InX::Got)
+    ElfSym::GlobalOffsetTable->Value = InX::Got->getVA();
+
   // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
   // be equal to the _gp symbol's value.
   if (Config->EMachine == EM_MIPS && !ElfSym::MipsGp->Value) {
     // Find GP-relative section with the lowest address
     // and use this address to calculate default _gp value.
     for (const OutputSectionCommand *Cmd : OutputSectionCommands) {
       OutputSection *OS = Cmd->Sec;
       if (OS->Flags & SHF_MIPS_GPREL) {

test/ELF/arm-got-relative.s

 function:
  .type function, %function
  bx lr
 
 // CHECK: Dynamic Relocations {
 // CHECK-NEXT:  0x204C R_ARM_GLOB_DAT function 0x0
 
 // CHECK: Name: _GLOBAL_OFFSET_TABLE_
-// CHECK-NEXT:    Value: 0x0
+// CHECK-NEXT:    Value: 0x2048
 // CHECK-NEXT:    Size:
 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: Absolute
 

test/ELF/arm-got-relative2.s

+// REQUIRES: arm
+// RUN: llvm-mc -position-independent -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
+// RUN: ld.lld %t.o -shared -o %t
+// RUN: llvm-readobj -s -symbols -dyn-relocations %t | FileCheck %s
+// RUN: llvm-objdump -d -triple=armv7a-none-linux-gnueabi %t | FileCheck -check-prefix=CODE %s
+ .syntax unified
+ .text
+ .globl _start
+ .align 2
+_start:
+ .type _start, %function
+ ldr r3, .LGOT
+ ldr r2, .LGOT+4
+.LPIC:
+ add r0, pc, r3
+ bx lr
+ .align 2
+.LGOT:
+ 
+.word _GLOBAL_OFFSET_TABLE_ - (.LPIC+8)
+ .word function(GOT)
+
+ .globl function
+ .align 2
+function:
+ .type function, %function
+ bx lr
+
+// CHECK: Dynamic Relocations {
+// CHECK-NEXT:  0x2048 R_ARM_GLOB_DAT function 0x0
+
+// CHECK: Name: _GLOBAL_OFFSET_TABLE_
+// CHECK-NEXT:    Value: 0x2048
+// CHECK-NEXT:    Size:
+// CHECK-NEXT:    Binding: Local
+// CHECK-NEXT:    Type: None
+// CHECK-NEXT:    Other [
+// CHECK-NEXT:      STV_HIDDEN
+// CHECK-NEXT:    ]
+// CHECK-NEXT:    Section: .got
+
+// CODE: Disassembly of section .text:
+// CODE-NEXT: _start:
+// CODE-NEXT:    1000:        08 30 9f e5    ldr     r3, [pc, #8]
+// CODE-NEXT:    1004:        08 20 9f e5    ldr     r2, [pc, #8]
+// CODE-NEXT:    1008:        03 00 8f e0    add     r0, pc, r3
+// CODE-NEXT:    100c:        1e ff 2f e1    bx      lr
+// CODE:$d.1:
+// (_GLOBAL_OFFSET_TABLE_ = 0x2048) - (0x1008 + 8) 0x1038
+// CODE-NEXT:    1010:        38 10 00 00
+// (Got(function) - GotBase = 0x4
+// CODE-NEXT:    1014:        00 00 00 00