demo

[grimar]

Summary

temp

[• rafael]

ELF/OutputSections.cpp

315

Why are you still computing the number of relative relocations.

[grimar]

ELF/OutputSections.cpp

315

That patch was just a demo of what I am doing. This place did not affect anything if we are talk about perfomance.

ELF/Config.h

struct Configuration {
   bool StripAll;
   bool StripDebug;
   bool SysvHash = true;
   bool Threads;
   bool Trace;
   bool Verbose;
   bool VersionScript = false;
   bool WarnCommon;
+  bool ZCombreloc;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t EMachine = llvm::ELF::EM_NONE;

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->Optimize = getInteger(Args, OPT_O, 1);
   Config->LtoO = getInteger(Args, OPT_lto_O, 2);
   if (Config->LtoO > 3)
     error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));
   Config->LtoJobs = getInteger(Args, OPT_lto_jobs, 1);
   if (Config->LtoJobs == 0)
     error("number of threads must be > 0");
 
+  Config->ZCombreloc = !hasZOption(Args, "nocombreloc");
   Config->ZExecStack = hasZOption(Args, "execstack");
   Config->ZNodelete = hasZOption(Args, "nodelete");
   Config->ZNow = hasZOption(Args, "now");
   Config->ZOrigin = hasZOption(Args, "origin");
   Config->ZRelro = !hasZOption(Args, "norelro");
 
   if (Config->Relocatable)
     Config->StripAll = false;

ELF/OutputSections.h

 
 template <class ELFT>
 class RelocationSection final : public OutputSectionBase<ELFT> {
   typedef typename ELFT::Rel Elf_Rel;
   typedef typename ELFT::Rela Elf_Rela;
   typedef typename ELFT::uint uintX_t;
 
 public:
-  RelocationSection(StringRef Name);
+  RelocationSection(StringRef Name, bool Sort);
   void addReloc(const DynamicReloc<ELFT> &Reloc);
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
+  uint64_t getRelativeCount() { return NumRelativeRels; }
 
   bool Static = false;
 
 private:
+  bool Sort;
+  uint64_t NumRelativeRels = 0;
+
   std::vector<DynamicReloc<ELFT>> Relocs;
 };
 
 template <class ELFT>
 class OutputSection final : public OutputSectionBase<ELFT> {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;

ELF/OutputSections.cpp

 }
 
 template <class ELFT> void PltSection<ELFT>::finalize() {
   this->Header.sh_size =
       Target->PltZeroSize + Entries.size() * Target->PltEntrySize;
 }
 
 template <class ELFT>
-RelocationSection<ELFT>::RelocationSection(StringRef Name)
+RelocationSection<ELFT>::RelocationSection(StringRef Name, bool Sort)
     : OutputSectionBase<ELFT>(Name, Config->Rela ? SHT_RELA : SHT_REL,
-                              SHF_ALLOC) {
+                              SHF_ALLOC),
+      Sort(Sort) {
   this->Header.sh_entsize = Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT>
 void RelocationSection<ELFT>::addReloc(const DynamicReloc<ELFT> &Reloc) {
+  if (Reloc.Type == Target->RelativeRel)
+    ++NumRelativeRels;
   Relocs.push_back(Reloc);
 }
 
+template <class ELFT, class RelTy>
+static bool compRelocations(const RelTy &A, const RelTy &B) {
+  return A.r_offset < B.r_offset;
+}
+
 template <class ELFT> void RelocationSection<ELFT>::writeTo(uint8_t *Buf) {
+  uint8_t *BufBegin = Buf;
   for (const DynamicReloc<ELFT> &Rel : Relocs) {
     auto *P = reinterpret_cast<Elf_Rela *>(Buf);
     Buf += Config->Rela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
     SymbolBody *Sym = Rel.Sym;
 
     if (Config->Rela)
       P->r_addend = Rel.UseSymVA ? Sym->getVA<ELFT>(Rel.Addend) : Rel.Addend;
     P->r_offset = Rel.OffsetInSec + Rel.OffsetSec->getVA();
     uint32_t SymIdx = (!Rel.UseSymVA && Sym) ? Sym->DynsymIndex : 0;
     P->setSymbolAndType(SymIdx, Rel.Type, Config->Mips64EL);
   }
+
+  // Sort relocations by r_offset, breaking ties with other conditions.
+  // Doing this does not change the semantics nor the file format, but
+  // some dynamic linker can load executables/DSOs faster when the
+  // relocation table is sorted.
+  // http://www.airs.com/blog/archives/186
+  if (Sort) {
+    if (Config->Rela)
+      std::sort((Elf_Rela *)BufBegin, (Elf_Rela *)BufBegin + Relocs.size(),
+                compRelocations<ELFT, Elf_Rela>);
+    else
+      std::sort((Elf_Rel *)BufBegin, (Elf_Rel *)BufBegin + Relocs.size(),
+                compRelocations<ELFT, Elf_Rel>);
+  }
 }
 
 template <class ELFT> unsigned RelocationSection<ELFT>::getRelocOffset() {
   return this->Header.sh_entsize * Relocs.size();
 }
 
 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Static ? Out<ELFT>::SymTab->SectionIndex

ELF/Writer.cpp

template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
   typedef typename ELFT::Ehdr Elf_Ehdr;
 
   // Create singleton output sections.
   DynamicSection<ELFT> Dynamic(*Symtab);
   EhFrameHeader<ELFT> EhFrameHdr;
   GotSection<ELFT> Got;
   InterpSection<ELFT> Interp;
   PltSection<ELFT> Plt;
-  RelocationSection<ELFT> RelaDyn(Config->Rela ? ".rela.dyn" : ".rel.dyn");
+  RelocationSection<ELFT> RelaDyn(Config->Rela ? ".rela.dyn" : ".rel.dyn",
+                                  Config->ZCombreloc);
   StringTableSection<ELFT> DynStrTab(".dynstr", true);
   StringTableSection<ELFT> ShStrTab(".shstrtab", false);
   SymbolTableSection<ELFT> DynSymTab(*Symtab, DynStrTab);
   VersionTableSection<ELFT> VerSym;
   VersionNeedSection<ELFT> VerNeed;
 
   OutputSectionBase<ELFT> ElfHeader("", 0, SHF_ALLOC);
   ElfHeader.setSize(sizeof(Elf_Ehdr));
template <class ELFT> void elf::writeResult(SymbolTable<ELFT> *Symtab) {
 
   if (Config->GnuHash)
     GnuHashTab.reset(new GnuHashTableSection<ELFT>);
   if (Config->SysvHash)
     HashTab.reset(new HashTableSection<ELFT>);
   if (Target->UseLazyBinding) {
     StringRef S = Config->Rela ? ".rela.plt" : ".rel.plt";
     GotPlt.reset(new GotPltSection<ELFT>);
-    RelaPlt.reset(new RelocationSection<ELFT>(S));
+    RelaPlt.reset(new RelocationSection<ELFT>(S, false /*Sort*/));
   }
   if (!Config->StripAll) {
     StrTab.reset(new StringTableSection<ELFT>(".strtab", false));
     SymTabSec.reset(new SymbolTableSection<ELFT>(*Symtab, *StrTab));
   }
   if (Config->EMachine == EM_MIPS && !Config->Shared) {
     // 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.

test/ELF/aarch64-abs64-dyn.s

bar:
         .data
         .xword foo
         .xword bar
 
 // RUN: ld.lld -shared -o %t.so %t.o
 // RUN: llvm-readobj -symbols -dyn-relocations %t.so | FileCheck %s
 
 // CHECK:      Dynamic Relocations {
-// CHECK-NEXT:   {{.*}} R_AARCH64_ABS64 foo 0x0
 // CHECK-NEXT:   {{.*}} R_AARCH64_RELATIVE - [[BAR_ADDR:.*]]
+// CHECK-NEXT:   {{.*}} R_AARCH64_ABS64 foo 0x0
 // CHECK-NEXT: }
 
 // CHECK:      Symbols [
 // CHECK:        Symbol {
 // CHECK:          Name: bar
 // CHECK-NEXT:     Value: [[BAR_ADDR]]

test/ELF/aarch64-tls-ie.s

 #RELOC-NEXT:   Size: 16
 #RELOC-NEXT:   Link: 0
 #RELOC-NEXT:   Info: 0
 #RELOC-NEXT:   AddressAlignment: 8
 #RELOC-NEXT:   EntrySize: 0
 #RELOC-NEXT: }
 #RELOC:      Relocations [
 #RELOC-NEXT:  Section ({{.*}}) .rela.dyn {
-#RELOC-NEXT:    0x120B0 R_AARCH64_TLS_TPREL64 foo 0x0
 #RELOC-NEXT:    0x120B8 R_AARCH64_TLS_TPREL64 bar 0x0
+#RELOC-NEXT:    0x120B0 R_AARCH64_TLS_TPREL64 foo 0x0
 #RELOC-NEXT:  }
 #RELOC-NEXT:]
 
 # Page(0x120B0) - Page(0x11000) = 0x1000 = 4096
 # 0x120B0 & 0xff8 = 0xB0 = 176
 # Page(0x120B8) - Page(0x11000) = 0x1000 = 4096
 # 0x120B8 & 0xff8 = 0xB8 = 184
 #CHECK: Disassembly of section .text:

test/ELF/combrelocs.s

+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: ld.lld -shared %t -o %t2
+# RUN: llvm-readobj -r --expand-relocs --dynamic-table %t2 | FileCheck %s
+
+# CHECK:      Relocations [
+# CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x1007
+# CHECK-NEXT:       Type: R_X86_64_RELATIVE
+# CHECK-NEXT:       Symbol: - (0)
+# CHECK-NEXT:       Addend: 0x1007
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x1017
+# CHECK-NEXT:       Type: R_X86_64_RELATIVE
+# CHECK-NEXT:       Symbol: -
+# CHECK-NEXT:       Addend: 0x1017
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x102F
+# CHECK-NEXT:       Type: R_X86_64_RELATIVE
+# CHECK-NEXT:       Symbol: -
+# CHECK-NEXT:       Addend: 0x1018
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x101F
+# CHECK-NEXT:       Type: R_X86_64_64
+# CHECK-NEXT:       Symbol: external1
+# CHECK-NEXT:       Addend: 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x100F
+# CHECK-NEXT:       Type: R_X86_64_64
+# CHECK-NEXT:       Symbol: external2
+# CHECK-NEXT:       Addend: 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x1027
+# CHECK-NEXT:       Type: R_X86_64_64
+# CHECK-NEXT:       Symbol: external2
+# CHECK-NEXT:       Addend: 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:     Relocation {
+# CHECK-NEXT:       Offset: 0x20A0
+# CHECK-NEXT:       Type: R_X86_64_TPOFF64
+# CHECK-NEXT:       Symbol: tls
+# CHECK-NEXT:       Addend: 0x0
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK:      DynamicSection [
+# CHECK-NEXT:   Tag                Type                 Name/Value
+# CHECK:        0x000000006FFFFFF9 RELACOUNT            3
+
+# RUN: ld.lld -z nocombreloc -shared %t -o %t2
+# RUN: llvm-readobj -r --expand-relocs --dynamic-table %t2 | \
+# RUN:    FileCheck --check-prefix=NOCOMB %s
+
+# NOCOMB:      Relocations [
+# NOCOMB-NEXT:    Section ({{.*}}) .rela.dyn {
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x2090
+# NOCOMB-NEXT:        Type: R_X86_64_TPOFF64
+# NOCOMB-NEXT:        Symbol: tls
+# NOCOMB-NEXT:        Addend: 0x0
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x1007
+# NOCOMB-NEXT:        Type: R_X86_64_RELATIVE
+# NOCOMB-NEXT:        Symbol: -
+# NOCOMB-NEXT:        Addend: 0x1007
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x100F
+# NOCOMB-NEXT:        Type: R_X86_64_64
+# NOCOMB-NEXT:        Symbol: external2
+# NOCOMB-NEXT:        Addend: 0x0
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x1017
+# NOCOMB-NEXT:        Type: R_X86_64_RELATIVE
+# NOCOMB-NEXT:        Symbol: -
+# NOCOMB-NEXT:        Addend: 0x1017
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x101F
+# NOCOMB-NEXT:        Type: R_X86_64_64
+# NOCOMB-NEXT:        Symbol: external1
+# NOCOMB-NEXT:        Addend: 0x0
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x1027
+# NOCOMB-NEXT:        Type: R_X86_64_64
+# NOCOMB-NEXT:        Symbol: external2
+# NOCOMB-NEXT:        Addend: 0x0
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:      Relocation {
+# NOCOMB-NEXT:        Offset: 0x102F
+# NOCOMB-NEXT:        Type: R_X86_64_RELATIVE
+# NOCOMB-NEXT:        Symbol: -
+# NOCOMB-NEXT:        Addend: 0x1018
+# NOCOMB-NEXT:      }
+# NOCOMB-NEXT:    }
+# NOCOMB-NEXT:  ]
+# NOCOMB:      DynamicSection [
+# NOCOMB-NEXT:   Tag                Type
+# NOCOMB-NOT:    0x000000006FFFFFF9 RELACOUNT
+
+## Code emits few different types of relocations to check 
+## that their sorting order is correct and DT_RELACOUNT entry
+## is created and has correct value.
+.data
+.global obj
+.type obj,%object
+.size obj,26
+obj:
+.zero 26
+
+.section .tbss,"awT",@nobits
+.globl _tbss
+tbss:
+ .long 0
+
+.text
+.globl _start
+_start:
+ addq tls@GOTTPOFF(%rip), %rax
+
+foo:
+ .quad foo
+ .quad external2
+
+  
+ .hidden bar
+ .global bar
+bar:
+ .quad bar
+ .quad external1
+ .quad external2
+ .quad bar + 1

test/ELF/gotpcrelx.s

 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
 // CHECK-NEXT: Address: 0x2090
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x2090 R_X86_64_GLOB_DAT foo 0x0
 // CHECK-NEXT:     0x2098 R_X86_64_GLOB_DAT bar 0x0
+// CHECK-NEXT:     0x2090 R_X86_64_GLOB_DAT foo 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/i386-got-and-copy.s

 # REQUIRES: x86
 
 # If there are two relocations such that the first one requires
 # dynamic COPY relocation, the second one requires GOT entry
 # creation, linker should create both - dynamic relocation
 # and GOT entry.
 
 # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux \
 # RUN:         %S/Inputs/copy-in-shared.s -o %t.so.o
 # RUN: llvm-mc -filetype=obj -triple=i386-pc-linux %s -o %t.o
 # RUN: ld.lld %t.so.o -shared -o %t.so
 # RUN: ld.lld %t.o %t.so -o %t.exe
 # RUN: llvm-readobj -r %t.exe | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section (4) .rel.dyn {
+# CHECK-NEXT:     0x{{[0-9A-F]+}} R_386_GLOB_DAT foo
 # CHECK-NEXT:     0x{{[0-9A-F]+}} R_386_COPY foo
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
   .text
   .global _start
 _start:
   movl $foo, (%esp)     # R_386_32 - requires R_386_COPY relocation
   movl foo@GOT, %eax    # R_386_GOT32 - requires GOT entry

test/ELF/local-got-pie.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -pie
 // RUN: llvm-readobj -s -r %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 
 .globl _start
 _start:
  call foo@gotpcrel
 
  .hidden foo
  .global foo
 foo:
  nop
 
-// 0x20A0 - 1001 - 5 = 4250
+// 0x20B0 - 0x1000 - 5 = 4267
 // DISASM:      Disassembly of section .text:
 // DISASM-NEXT: _start:
-// DISASM-NEXT:   1000: {{.*}} callq 4251
+// DISASM-NEXT:   1000: {{.*}} callq 4267
 // DISASM:      foo:
 // DISASM-NEXT:   1005: {{.*}} nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x20A0
+// CHECK-NEXT: Address: 0x20B0
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x20A0 R_X86_64_RELATIVE - 0x1005
+// CHECK-NEXT:     0x20B0 R_X86_64_RELATIVE - 0x1005
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/local-got-shared.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld %t.o -o %t -shared
 // RUN: llvm-readobj -s -r %t | FileCheck %s
 // RUN: llvm-objdump -d %t | FileCheck --check-prefix=DISASM %s
 
 bar:
   call foo@gotpcrel
 
         .hidden foo
         .global foo
 foo:
         nop
 
-// 0x2090 - 0x1000 - 5 = 4235
+// 0x20A0 - 0x1001 - 5 = 4251
 // DISASM:      bar:
-// DISASM-NEXT:   1000: {{.*}} callq 4235
+// DISASM-NEXT:   1000: {{.*}} callq 4251
 
 // DISASM:      foo:
 // DISASM-NEXT:   1005: {{.*}} nop
 
 // CHECK:      Name: .got
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_WRITE
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x2090
+// CHECK-NEXT: Address: 0x20A0
 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size: 8
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x2090 R_X86_64_RELATIVE - 0x1005
+// CHECK-NEXT:     0x20A0 R_X86_64_RELATIVE - 0x1005
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]

test/ELF/relative-dynamic-reloc-ppc64.s

 // RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 // REQUIRES: ppc
 
 // Test that we create R_PPC64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
+// CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[FOO_ADDR:.*]]
+// CHECK-NEXT:     0x[[FOO_ADDR]] R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_PPC64_RELATIVE - 0x[[BAR_ADDR]]
 // CHECK-NEXT:     0x20010 R_PPC64_RELATIVE - 0x20009
 // CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[ZED_ADDR:.*]]
-// CHECK-NEXT:     0x{{.*}} R_PPC64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x20028 R_PPC64_ADDR64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar

test/ELF/relative-dynamic-reloc.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 // RUN: ld.lld -shared %t.o -o %t.so
 // RUN: llvm-readobj -t -r -dyn-symbols %t.so | FileCheck %s
 
 // Test that we create R_X86_64_RELATIVE relocations but don't put any
 // symbols in the dynamic symbol table.
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section ({{.*}}) .rela.dyn {
-// CHECK-NEXT:     0x[[FOO_ADDR:.*]] R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
+// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[FOO_ADDR:.*]]
+// CHECK-NEXT:     0x[[FOO_ADDR]] R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x[[BAR_ADDR:.*]] R_X86_64_RELATIVE - 0x[[BAR_ADDR]]
 // CHECK-NEXT:     0x2010 R_X86_64_RELATIVE - 0x2009
 // CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[ZED_ADDR:.*]]
-// CHECK-NEXT:     0x{{.*}} R_X86_64_RELATIVE - 0x[[FOO_ADDR]]
 // CHECK-NEXT:     0x2028 R_X86_64_64 external 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 // CHECK:      Symbols [
 // CHECK:        Name: foo
 // CHECK-NEXT:   Value: 0x[[FOO_ADDR]]
 // CHECK:        Name: bar

test/ELF/tls-dynamic-i686.s

 // CHECK-NEXT: Size: 32
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 4
 // CHECK-NEXT: EntrySize: 0
 
 // CHECK: Relocations [
 // CHECK:      Section ({{.+}}) .rel.dyn {
+// CHECK-NEXT: 0x2078 R_386_TLS_DTPMOD32 - 0x0
 // CHECK-NEXT: 0x2068 R_386_TLS_DTPMOD32 tls0 0x0
 // CHECK-NEXT: 0x206C R_386_TLS_DTPOFF32 tls0 0x0
+// CHECK-NEXT: 0x2080 R_386_TLS_TPOFF tls0 0x0
 // CHECK-NEXT: 0x2070 R_386_TLS_DTPMOD32 tls1 0x0
 // CHECK-NEXT: 0x2074 R_386_TLS_DTPOFF32 tls1 0x0
-// CHECK-NEXT: 0x2078 R_386_TLS_DTPMOD32 - 0x0
-// CHECK-NEXT: 0x2080 R_386_TLS_TPOFF tls0 0x0
 // CHECK-NEXT: 0x2084 R_386_TLS_TPOFF tls1 0x0
 // CHECK-NEXT: }
 
 // DIS:      Disassembly of section .text:
 // DIS-NEXT: _start:
 // General dynamic model:
 // -32 and -24 are first and second GOT entries offsets.
 // Each one is a pair of records.

test/ELF/tls-got.s

 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: }
 
 // CHECK:      Relocations [
 // CHECK-NEXT:   Section (4) .rela.dyn {
-// CHECK-NEXT:     [[ADDR]] R_X86_64_TPOFF64 tls1 0x0
 // CHECK-NEXT:     0x120B8 R_X86_64_TPOFF64 tls0 0x0
+// CHECK-NEXT:     [[ADDR]] R_X86_64_TPOFF64 tls1 0x0
 // CHECK-NEXT:   }
 // CHECK-NEXT: ]
 
 //0x11000 + 4249 + 7 = 0x120B0
 //0x1100A + 4247 + 7 = 0x120B8
 //0x11014 + 4237 + 7 = 0x120B8
 //DISASM:      Disassembly of section .text:
 //DISASM-NEXT: main: