[LLD][ELF] Define _GLOBAL_OFFSET_TABLE_ to base of .got for ARM

[peter.smith]

Summary

On many architectures gcc and clang will recognize _GLOBAL_OFFSET_TABLE_ - . and produce a relocation that can be processed without needing to know the value of _GLOBAL_OFFSET_TABLE_. For ARM gcc produces R_ARM_BASE_PREL but clang produces the more general R_ARM_REL32 to _GLOBAL_OFFSET_TABLE_. To evaluate this relocation correctly _GLOBAL_OFFSET_TABLE_ must be defined to be the base of the GOT (R_ARM_BASE_PREL evaluates to this value).

If/when llvm-mc is changed to recognize _GLOBAL_OFFSET_TABLE_ - . this change will not be necessary for new objects. However there may still be old objects and versions of clang so I think it is worth making the change in lld as well as fixing llvm-mc (pr33511).

This partially fixes pr31159, the R_ARM_REL32 relocation error messages disappear but there are a couple more relocation errors relating to R_ARM_GOTOFF32, I think that these are unrelated to _GLOBAL_OFFSET_TABLE_ though.

[peter.smith]

I've updated the patch to support the general case of _GLOBAL_OFFSET_TABLE_ across the supported architectures.

Based on binutils the x86 and x86_64 architectures traditionally have the _GLOBAL_OFFSET_TABLE_ set to the base of the .got.plt which by default in gold and bfd puts .got immediately before .got.plt. In lld .got may be separate to .got.plt so I've used the end of .got in the same way as the _FROM_END relocations in x86 and x86_64. All other architectures use the base of the .got. Of the supported architectures only ARM and X86 seem to make a lot of use of _GLOBAL_OFFSET_TABLE_.
In addition:

• Defining _GLOBAL_OFFSET_TABLE_ as a symbol reveals that R_GOTONLY_PC is missing from isRelExprOneOf in isStaticLinkTimeConstant
• _GLOBAL_OFFSET_TABLE_ can't be used absolutely in tests with --shared (this is the same with gold and bfd)
• I've added tests for all the architectures that use _GLOBAL_OFFSET_TABLE_

I've not added a test for PPC32 as I don't think the port is complete enough for GOT generation anyway. PPC64 uses .TOC. instead of _GLOBAL_OFFSET_TABLE_.

Although I've not done so in this patch, adding the target specific GotBaseSymOff would allow us to merge the RelExpr GOT_ONLYPC and GOT_ONLYPC_FROM_END and the other _FROM_END relocations.

This should make lld able to handle older objects including those from the current version of clang better. If this is not considered worthwhile let me know and I'll abandon the revision.

[ruiu]

Yes, overall looking good, but I have one question.

ELF/Writer.cpp

1145–1147 ↗

(On Diff #103381)

Doesn't this always succeed unless the -r option is given? It seems _GLOBAL_OFFSET_TABLE_ is added unconditionally, so find should return something non-null.

[peter.smith]

I've updated the diff to record that we've added the _GLOBAL_OFFSET_TABLE_ symbol (addOptionalRegular will only define it if it is referenced). Assuming there are no more comments I'll commit it on Monday.

[peter.smith]

As per message on Friday I've committed 306282. I'm happy to make further changes or revert quickly if this causes any problems.

ELF/Writer.cpp

1145–1147 ↗

(On Diff #103381)

The code that adds the _GLOBAL_OFFSET_TABLE_ symbol uses addOptionalRegular which will only define the symbol if it is referenced so the find can return null. In any case, as per Rafael's suggestion I've recorded that the symbol was added so we don't need to look it up at this point.

[ruiu]

LGTM

lld/trunk/ELF/Arch/PPC.cpp

 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 namespace {
 class PPC final : public TargetInfo {
 public:
-  PPC() {}
+  PPC() { GotBaseSymOff = 0x8000; }
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S,
                      const uint8_t *Loc) const override;
 };
 } // namespace
 
 void PPC::relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const {
   switch (Type) {

lld/trunk/ELF/Arch/X86.cpp

public:
   void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
 };
 } // namespace
 
 X86::X86() {
+  GotBaseSymOff = -1;
   CopyRel = R_386_COPY;
   GotRel = R_386_GLOB_DAT;
   PltRel = R_386_JUMP_SLOT;
   IRelativeRel = R_386_IRELATIVE;
   RelativeRel = R_386_RELATIVE;
   TlsGotRel = R_386_TLS_TPOFF;
   TlsModuleIndexRel = R_386_TLS_DTPMOD32;
   TlsOffsetRel = R_386_TLS_DTPOFF32;

lld/trunk/ELF/Arch/X86_64.cpp

 
 private:
   void relaxGotNoPic(uint8_t *Loc, uint64_t Val, uint8_t Op,
                      uint8_t ModRm) const;
 };
 } // namespace
 
 template <class ELFT> X86_64<ELFT>::X86_64() {
+  GotBaseSymOff = -1;
   CopyRel = R_X86_64_COPY;
   GotRel = R_X86_64_GLOB_DAT;
   PltRel = R_X86_64_JUMP_SLOT;
   RelativeRel = R_X86_64_RELATIVE;
   IRelativeRel = R_X86_64_IRELATIVE;
   TlsGotRel = R_X86_64_TPOFF64;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;

lld/trunk/ELF/Relocations.cpp

 // dynamic relocation so that the relocation will be fixed at load-time.
 template <class ELFT>
 static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
                                      const SymbolBody &Body,
                                      InputSectionBase &S, uint64_t RelOff) {
   // These expressions always compute a constant
   if (isRelExprOneOf<R_SIZE, R_GOT_FROM_END, R_GOT_OFF, R_MIPS_GOT_LOCAL_PAGE,
                      R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
-                     R_MIPS_TLSGD, R_GOT_PAGE_PC, R_GOT_PC,
+                     R_MIPS_TLSGD, R_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC,
                      R_GOTONLY_PC_FROM_END, R_PLT_PC, R_TLSGD_PC, R_TLSGD,
                      R_PPC_PLT_OPD, R_TLSDESC_CALL, R_TLSDESC_PAGE, R_HINT>(E))
     return true;
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
   if (E == R_GOT || E == R_PLT || E == R_TLSDESC)
     return Target->usesOnlyLowPageBits(Type) || !Config->Pic;

lld/trunk/ELF/Target.h

public:
   unsigned DefaultMaxPageSize = 4096;
 
   // On FreeBSD x86_64 the first page cannot be mmaped.
   // On Linux that is controled by vm.mmap_min_addr. At least on some x86_64
   // installs that is 65536, so the first 15 pages cannot be used.
   // Given that, the smallest value that can be used in here is 0x10000.
   uint64_t DefaultImageBase = 0x10000;
 
+  // Offset of _GLOBAL_OFFSET_TABLE_ from base of .got section. Use -1 for
+  // end of .got
+  uint64_t GotBaseSymOff = 0;
+
   uint32_t CopyRel;
   uint32_t GotRel;
   uint32_t PltRel;
   uint32_t RelativeRel;
   uint32_t IRelativeRel;
   uint32_t TlsDescRel;
   uint32_t TlsGotRel;
   uint32_t TlsModuleIndexRel;

lld/trunk/ELF/Writer.cpp

private:
   OutputSection *findSection(StringRef Name);
   OutputSection *findSectionInScript(StringRef Name);
   OutputSectionCommand *findSectionCommand(StringRef Name);
 
   std::vector<PhdrEntry> Phdrs;
 
   uint64_t FileSize;
   uint64_t SectionHeaderOff;
+
+  bool HasGotBaseSym = false;
 };
 } // anonymous namespace
 
 StringRef elf::getOutputSectionName(StringRef Name) {
   // ".zdebug_" is a prefix for ZLIB-compressed sections.
   // Because we decompressed input sections, we want to remove 'z'.
   if (Name.startswith(".zdebug_"))
     return Saver.save("." + Name.substr(2));
if (Config->EMachine == EM_MIPS) {
     // 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 (Symtab<ELFT>::X->find("__gnu_local_gp"))
       ElfSym::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
-  // 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.
-  Symtab<ELFT>::X->addIgnored("_GLOBAL_OFFSET_TABLE_");
+  // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention to
+  // be at some offset from the base of the .got section, usually 0 or the end
+  // of the .got
+  InputSection *GotSection = (InX::MipsGot) ? cast<InputSection>(InX::MipsGot)
+                                            : cast<InputSection>(InX::Got);
+  HasGotBaseSym = addOptionalRegular<ELFT>("_GLOBAL_OFFSET_TABLE_", GotSection,
+                                           Target->GotBaseSymOff) != nullptr;
 
   // __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");
 
for (SyntheticSection *SS : Sections)
     if (SS && SS->getParent() && !SS->empty())
       Fn(SS);
 }
 
 // We need to add input synthetic sections early in createSyntheticSections()
 // to make them visible from linkescript side. But not all sections are always
 // required to be in output. For example we don't need dynamic section content
 // sometimes. This function filters out such unused sections from the output.
-static void removeUnusedSyntheticSections(std::vector<OutputSection *> &V) {
+static void removeUnusedSyntheticSections(std::vector<OutputSection *> &V,
+                                          bool HasGotBaseSym) {
   // All input synthetic sections that can be empty are placed after
   // all regular ones. We iterate over them all and exit at first
   // non-synthetic.
   for (InputSectionBase *S : llvm::reverse(InputSections)) {
     SyntheticSection *SS = dyn_cast<SyntheticSection>(S);
     if (!SS)
       return;
     OutputSection *OS = SS->getParent();
     if (!SS->empty() || !OS)
       continue;
+    if ((SS == InX::Got || SS == InX::MipsGot) && HasGotBaseSym)
+      continue;
     OS->Sections.erase(std::find(OS->Sections.begin(), OS->Sections.end(), SS));
     SS->Live = false;
     // If there are no other sections in the output section, remove it from the
     // output.
     if (OS->Sections.empty())
       V.erase(std::find(V.begin(), V.end(), OS));
   }
 }
for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     }
   }
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)
     return;
 
   addPredefinedSections();
-  removeUnusedSyntheticSections(OutputSections);
+  removeUnusedSyntheticSections(OutputSections, HasGotBaseSym);
 
   clearOutputSections();
   sortSections();
 
   // Now that we have the final list, create a list of all the
   // OutputSectionCommands for convenience.
   for (BaseCommand *Base : Script->Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base))

lld/trunk/test/ELF/arm-got-relative.s

  .type _start, %function
  ldr r3, .LGOT
  ldr r2, .LGOT+4
 .LPIC:
  add r0, pc, r3
  bx lr
  .align 2
 .LGOT:
- // gas implicitly uses (GOT_PREL) for _GLOBAL_OFFSET_TABLE_ in PIC
- // llvm-mc needs the (GOT_PREL) suffix or it generates R_ARM_REL32
- .word _GLOBAL_OFFSET_TABLE_(GOT_PREL) - (.LPIC+8)
+ // gas implicitly uses (R_ARM_BASE_PREL) for _GLOBAL_OFFSET_TABLE_ in PIC
+ // llvm-mc generates R_ARM_REL32, this will need updating when MC changes
+ .word _GLOBAL_OFFSET_TABLE_ - (.LPIC+8)
  .word function(GOT)
 
  .globl function
  .align 2
 function:
  .type function, %function
  bx lr
 
 // CHECK: Dynamic Relocations {
-// CHECK-NEXT:  0x204C R_ARM_GLOB_DAT function 0x0
+// CHECK-NEXT:  0x2048 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
+// 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:        04 00 00 00
+// (Got(function) - GotBase = 0x0
+// CODE-NEXT:    1014:        00 00 00 00

lld/trunk/test/ELF/global-offset-table-position-aarch64.s

+// RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %s -o %t
+// RUN: ld.lld -shared %t -o %t2
+// RUN: llvm-readobj -t %t2 | FileCheck %s
+// REQUIRES: aarch64
+.globl  a
+.type   a,@object
+.comm   a,4,4
+
+.globl  f
+.type   f,@function
+f:
+ adrp   x0, :got:a
+ ldr    x0, [x0, #:got_lo12:a]
+
+.global _start
+.type _start,@function
+_start:
+ bl f
+.data
+.long _GLOBAL_OFFSET_TABLE_ - .
+
+// CHECK: Name: _GLOBAL_OFFSET_TABLE_ (11)
+// CHECK-NEXT:     Value: 0x30090
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local (0x0)
+// CHECK-NEXT:     Type: None (0x0)
+// CHECK-NEXT:     Other [ (0x2)
+// CHECK-NEXT:       STV_HIDDEN (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Section: .got

lld/trunk/test/ELF/global-offset-table-position-arm.s

+// RUN: llvm-mc -filetype=obj -triple=armv7a-linux-gnueabihf %s -o %t
+// RUN: ld.lld -shared %t -o %t2
+// RUN: llvm-readobj -t %t2 | FileCheck %s
+// REQUIRES: arm
+
+// The ARM _GLOBAL_OFFSET_TABLE_ should be defined at the start of the .got
+.globl  a
+.type   a,%object
+.comm   a,4,4
+
+.globl  f
+.type   f,%function
+f:
+ ldr r2, .L1
+.L0:
+ add r2, pc
+.L1:
+.word _GLOBAL_OFFSET_TABLE_ - (.L0+4)
+.word a(GOT)
+
+.global _start
+.type _start,%function
+_start:
+ bl f
+.data
+
+// CHECK:     Name: _GLOBAL_OFFSET_TABLE_
+// CHECK-NEXT:     Value: 0x3068
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None
+// CHECK-NEXT:     Other [ (0x2)
+// CHECK-NEXT:       STV_HIDDEN (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Section: .got

lld/trunk/test/ELF/global-offset-table-position-i386.s

+// RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t
+// RUN: ld.lld -shared %t -o %t2
+// RUN: llvm-readobj -t %t2 | FileCheck %s
+// REQUIRES: x86
+
+// The X86 _GLOBAL_OFFSET_TABLE_ is defined at the end of the .got section.
+.globl  a
+.type   a,@object
+.comm   a,4,4
+
+.globl  f
+.type   f,@function
+f:
+addl    $_GLOBAL_OFFSET_TABLE_, %eax
+movl    a@GOT(%eax), %eax
+
+.global _start
+.type _start,@function
+_start:
+addl    $_GLOBAL_OFFSET_TABLE_, %eax
+calll   f@PLT
+
+// CHECK:     Name: _GLOBAL_OFFSET_TABLE_ (1)
+// CHECK-NEXT:     Value: 0x306C
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local (0x0)
+// CHECK-NEXT:     Type: None (0x0)
+// CHECK-NEXT:     Other [ (0x2)
+// CHECK-NEXT:       STV_HIDDEN (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Section: .got (0xA)

lld/trunk/test/ELF/global-offset-table-position-mips.s

+// RUN: llvm-mc -filetype=obj -triple=mips64-unknown-linux %s -o %t
+// RUN: ld.lld -shared %t -o %t2
+// RUN: llvm-readobj -t %t2 | FileCheck %s
+
+// REQUIRES: mips
+
+// The Mips _GLOBAL_OFFSET_TABLE_ should be defined at the start of the .got
+
+.globl  a
+.hidden a
+.type   a,@object
+.comm   a,4,4
+
+.globl  f
+.type   f,@function
+f:
+ ld      $v0,%got_page(a)($gp)
+ daddiu  $v0,$v0,%got_ofst(a)
+
+.global _start
+.type _start,@function
+_start:
+ lw      $t0,%call16(f)($gp)
+ .word _GLOBAL_OFFSET_TABLE_ - .
+// CHECK:     Name: _GLOBAL_OFFSET_TABLE_ (1)
+// CHECK-NEXT:     Value: 0x20000
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local (0x0)
+// CHECK-NEXT:     Type: None (0x0)
+// CHECK-NEXT:     Other [ (0x2)
+// CHECK-NEXT:       STV_HIDDEN (0x2)
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Section: .got (0x9)

lld/trunk/test/ELF/global-offset-table-position.s

+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: ld.lld -shared %t -o %t2
+// RUN: llvm-readobj -t %t2 | FileCheck %s
+// REQUIRES: x86
+
+// The X86_64 _GLOBAL_OFFSET_TABLE_ is defined at the end of the .got section.
+.globl  a
+.type   a,@object
+.comm   a,4,4
+
+.globl  f
+.type   f,@function
+f:
+movq  a@GOTPCREL(%rip), %rax
+
+.global _start
+.type _start,@function
+_start:
+callq f@PLT
+.data
+.long _GLOBAL_OFFSET_TABLE_ - .
+
+// CHECK:     Name: _GLOBAL_OFFSET_TABLE_
+// CHECK-NEXT:     Value: 0x30D8
+// CHECK-NEXT:     Size: 0
+// CHECK-NEXT:     Binding: Local
+// CHECK-NEXT:     Type: None (0x0)
+// CHECK-NEXT:     Other [
+// CHECK-NEXT:       STV_HIDDEN
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Section: .got

lld/trunk/test/ELF/global_offset_table_shared.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
 // RUN: ld.lld -shared %t -o %t2
 // RUN: llvm-readobj -t %t2 | FileCheck %s
-.long _GLOBAL_OFFSET_TABLE_
+.long _GLOBAL_OFFSET_TABLE_ - .
 
 // CHECK:      Name: _GLOBAL_OFFSET_TABLE_
-// CHECK-NEXT: Value:
+// CHECK-NEXT: Value: 0x2060
 // CHECK-NEXT: Size: 0
 // CHECK-NEXT: Binding: Local
+// CHECK-NEXT: Type: None
+// CHECK-NEXT: Other [ (0x2)
+// CHECK-NEXT: STV_HIDDEN (0x2)
+// CHECK-NEXT:    ]
+// CHECK-NEXT: Section: .got