[ELF2] - TLS relocations implemented

[grimar]

Summary

• Implements R_X86_64_TPOFF32, R_X86_64_DTPOFF32 relocations.
• Implements PT_TLS header.

[davide]

If it's not a big amount of work, can you split PT_TLS and relocations in two different patches? If it is too much, forget about it.
Also, while I haven't reviewed his work very carefully, I think Michael Spencer is working on TLS as well, so I think you guys should coordinate to minimize the overlap.

[grimar]

In D13986#273214, @davide wrote:

If it's not a big amount of work, can you split PT_TLS and relocations in two different patches? If it is too much, forget about it.
Also, while I haven't reviewed his work very carefully, I think Michael Spencer is working on TLS as well, so I think you guys should coordinate to minimize the overlap.

I could split but just not sure how.
When I add some TLS data (variables) then R_X86_64_TPOFF32/R_X86_64_DTPOFF32 relocations are created and we need the size of TLS and its address to process them.
TLS info currently is calculated during headers creating.
At the same time TLS header will only present if we have some TLS data. And data means relocations.
So just not sure it is easy to split. Ideas are welcome.

[davide]

In D13986#273235, @grimar wrote:

In D13986#273214, @davide wrote:

If it's not a big amount of work, can you split PT_TLS and relocations in two different patches? If it is too much, forget about it.
Also, while I haven't reviewed his work very carefully, I think Michael Spencer is working on TLS as well, so I think you guys should coordinate to minimize the overlap.

I could split but just not sure how.
When I add some TLS data (variables) then R_X86_64_TPOFF32/R_X86_64_DTPOFF32 relocations are created and we need the size of TLS and its address to process them.
TLS info currently is calculated during headers creating.
At the same time TLS header will only present if we have some TLS data. And data means relocations.
So just not sure it is easy to split. Ideas are welcome.

Leave it as is then.

[ruiu]

ELF/OutputSections.h

330

TLS -> Tls

ELF/Writer.cpp

736

Too much code has been added to this function. It needs cleanup before adding more.

[grimar]

ELF/Writer.cpp

736

I agree. Its bulky now.
I`ll try to do something with it tomorrow.

[Bigcheese]

ELF/Writer.cpp

612–642

We don't need to handle the case of multiple disjoint TLS initialization blocks. The spec doesn't allow it. All this needs to do is add a phdr if it sees any allocated TLS section.

736

http://reviews.llvm.org/D13615 provides a much simpler implementation of the layout.

[grimar]

ELF/Writer.cpp

612–642

This code not about multiple disjoints. I tried to reproduce the same behavior as ld do.

There are 3 cases (first is cpp code, next is readelf output):

1. Both .tbss and .tdata

thread int i;
thread int a = 56;

Program Headers:

Type           Offset             VirtAddr           PhysAddr
               FileSiz            MemSiz              Flags  Align
LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
               0x0000000000000168 0x0000000000000168  R E    200000
LOAD           0x0000000000000168 0x0000000000600168 0x0000000000600168
               0x0000000000000004 0x0000000000000004  RW     200000
TLS            0x0000000000000168 0x0000000000600168 0x0000000000600168
               0x0000000000000004 0x0000000000000008  R      4
GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
               0x0000000000000000 0x0000000000000000  RW     10

Section to Segment mapping:

Segment Sections...
 00     .text .eh_frame 
 01     .tdata 
 02     .tdata .tbss 
 03

2. Only .tdata

__thread int a = 56;

Program Headers:

Type           Offset             VirtAddr           PhysAddr
               FileSiz            MemSiz              Flags  Align
LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
               0x0000000000000168 0x0000000000000168  R E    200000
LOAD           0x0000000000000168 0x0000000000600168 0x0000000000600168
               0x0000000000000004 0x0000000000000004  RW     200000
TLS            0x0000000000000168 0x0000000000600168 0x0000000000600168
               0x0000000000000004 0x0000000000000004  R      4
GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
               0x0000000000000000 0x0000000000000000  RW     10

Section to Segment mapping:

Segment Sections...
 00     .text .eh_frame 
 01     .tdata 
 02     .tdata 
 03

3. Only tbss

__thread int i;

Program Headers:

Type           Offset             VirtAddr           PhysAddr
               FileSiz            MemSiz              Flags  Align
LOAD           0x0000000000000000 0x0000000000400000 0x0000000000400000
               0x0000000000000130 0x0000000000000130  R E    200000
TLS            0x0000000000000130 0x0000000000601000 0x0000000000601000
               0x0000000000000000 0x0000000000000004  R      4
GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
               0x0000000000000000 0x0000000000000000  RW     10

Section to Segment mapping:

Segment Sections...
 00     .text .eh_frame 
 01     .tbss 
 02

As can be seen,

1. For tdata and tbss it leaves tdata as LOAD and converts tbss to TLS header.
2. For tdata only it leaves tdata as LOAD and emits TLS header after it.
3. For tbss only it converts it to TLS.

So output of my implementation is currently compietely equal to ld.

ELF/InputSection.cpp

if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPLTRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {
       SymVA = Out<ELFT>::Got->getEntryAddr(Body);
       Type = Target->getGotRefReloc();
     } else if (Target->relocPointsToGot(Type)) {
       SymVA = Out<ELFT>::Got->getVA();
       Type = Target->getPCRelReloc();
+    } else if (Body.isTLS()) {
+      const Elf_Sym &Sym = cast<ELFSymbolBody<ELFT>>(Body).Sym;
+      InputSectionBase<ELFT> *Section = File.getSection(Sym);
+      uintX_t SectionVA = Section->OutSec->getVA();
+      SymVA = SectionVA - Out<ELFT>::TLS->p_paddr - Out<ELFT>::TLS->p_memsz +
+              Section->getOffset(Sym);
     } else if (isa<SharedSymbol<ELFT>>(Body)) {
       continue;
     }
     Target->relocateOne(Buf, BufEnd, &RI, Type, BaseAddr,
                         SymVA + getAddend<ELFT>(RI));
   }
 }
 

ELF/OutputSections.h

template <class ELFT> struct Out {
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
+  static typename llvm::object::ELFFile<ELFT>::Elf_Phdr *TLS;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
 template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
 template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
+template <class ELFT> typename llvm::object::ELFFile<ELFT>::Elf_Phdr *Out<ELFT>::TLS;
 }
 }
 #endif

ELF/Target.cpp

void X86_64TargetInfo::relocateOne(uint8_t *Buf, uint8_t *BufEnd,
   case R_X86_64_32S:
     if (Type == R_X86_64_32 && !isUInt<32>(SA))
       error("R_X86_64_32 out of range");
     else if (!isInt<32>(SA))
       error("R_X86_64_32S out of range");
     write32le(Loc, SA);
     break;
   }
+  case R_X86_64_TPOFF32:
+  case R_X86_64_DTPOFF32:
+    write32le(Loc, SA);
+    break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 // Relocation masks following the #lo(value), #hi(value), #ha(value),
 // #higher(value), #highera(value), #highest(value), and #highesta(value)
 // macros defined in section 4.5.1. Relocation Types of the PPC-elf64abi

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::assignAddresses() {
 
   // Reserve space for Phdrs.
   int NumPhdrs = 2;   // 2 for PhdrPhdr and FileHeaderPhdr
   if (needsInterpSection())
     ++NumPhdrs;
   if (isOutputDynamic())
     ++NumPhdrs;
   uintX_t Last = PF_R;
+
+  bool HasTbss = false;
+  bool HasTdata = false;
+  bool InTls = false;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (!Sec->getSize() || !needsPhdr<ELFT>(Sec))
       continue;
+
+    bool EndPhdr = false;
+    if (Sec->getFlags() & SHF_TLS) {
+      if (Sec->getType() == SHT_PROGBITS)
+        HasTdata = true;
+      else
+        HasTbss = true;
+      EndPhdr = true;
+      InTls = true;
+    } else if (InTls) {
+      EndPhdr = true;
+      InTls = false;
+    }
+
     uintX_t Flags = toPhdrFlags(Sec->getFlags());
-    if (Last != Flags) {
+    if (EndPhdr || Last != Flags) {
       Last = Flags;
       ++NumPhdrs;
     }
   }
 
+  if (!HasTbss && HasTdata)
+    ++NumPhdrs;
+
   // Reserve space needed for the program header so that the array
   // will never be resized.
   Phdrs.reserve(NumPhdrs);
 
   // The first Phdr entry is PT_PHDR which describes the program header itself.
   Phdrs.emplace_back();
   Elf_Phdr *PhdrPhdr = &Phdrs.back();
   setPhdr(PhdrPhdr, PT_PHDR, PF_R, FileOff, VA, /*Align=*/8);
 
   FileOff += sizeof(Elf_Phdr) * NumPhdrs;
   VA += sizeof(Elf_Phdr) * NumPhdrs;
 
   Elf_Phdr *Interp = nullptr;
   if (needsInterpSection()) {
     Phdrs.emplace_back();
     Interp = &Phdrs.back();
   }
 
   // Create a Phdr for the file header.
   Phdrs.emplace_back();
   Elf_Phdr *FileHeader = &Phdrs.back();
   setPhdr(FileHeader, PT_LOAD, PF_R, 0, getVAStart(), Target->getPageSize());
 
+  InTls = false;
+  bool EmitTlsSec = false;
+  uintX_t TlsAlign = 0;
+  Elf_Phdr *TlsBegin = nullptr;
   SmallPtrSet<Elf_Phdr *, 8> Closed;
   for (OutputSectionBase<ELFT> *Sec : OutputSections) {
     if (Sec->getSize()) {
+
+      bool EndPhdr = false;
+      // When we have no .tdata/.tbss then no special TLS headers required.
+      // If we have only .tdata then 2 headers will be created: LOAD (.tdata)
+      // and TLS (emited).
+      // If we have only .tbss then its converted to TLS.
+      // For case when we have both: LOAD is created (from .tdata), .tbss is
+      // converted to TLS.
+      if (Sec->getFlags() & SHF_TLS) {
+        if (!HasTbss && HasTdata)
+          EmitTlsSec = true;
+        EndPhdr = true;
+        InTls = true;
+      } else if (InTls) {
+        EndPhdr = true;
+        InTls = false;
+      }
+
       uintX_t Flags = toPhdrFlags(Sec->getFlags());
       Elf_Phdr *Last = &Phdrs.back();
-      if (Last->p_flags != Flags || !needsPhdr<ELFT>(Sec)) {
+      if (EndPhdr || Last->p_flags != Flags || !needsPhdr<ELFT>(Sec)) {
         // Flags changed. End current Phdr and potentially create a new one.
         if (Closed.insert(Last).second) {
           Last->p_filesz = FileOff - Last->p_offset;
           Last->p_memsz = VA - Last->p_vaddr;
+
+          // We closed the .tdata header and need to emit PT_TLS now
+          if (EmitTlsSec && !InTls) {
+            EmitTlsSec = false;
+            assert(Phdrs.capacity() >= Phdrs.size() + 1);
+            Phdrs.emplace_back();
+            Elf_Phdr *PH = &Phdrs.back();
+            setPhdr(PH, PT_TLS, PF_R, TlsBegin->p_offset, TlsBegin->p_vaddr, TlsAlign);
+            PH->p_filesz = Last->p_filesz;
+            PH->p_memsz = Last->p_memsz;
+            Out<ELFT>::TLS = PH;
+            Closed.insert(PH);
+          }
         }
 
         if (needsPhdr<ELFT>(Sec)) {
-          VA = RoundUpToAlignment(VA, Target->getPageSize());
-          FileOff = RoundUpToAlignment(FileOff, Target->getPageSize());
+          uint64_t Align = Target->getPageSize();
+          if (InTls && TlsBegin)
+            Align = Sec->getAlign();
+          VA = RoundUpToAlignment(VA, Align);
+          FileOff = RoundUpToAlignment(FileOff, Align);
+          assert(Phdrs.capacity() >= Phdrs.size() + 1);
           Phdrs.emplace_back();
           Elf_Phdr *PH = &Phdrs.back();
-          setPhdr(PH, PT_LOAD, Flags, FileOff, VA, Target->getPageSize());
+          if (InTls && (Sec->getType() != SHT_PROGBITS)) {
+            setPhdr(PH, PT_TLS, PF_R, TlsBegin ? TlsBegin->p_offset : FileOff,
+                    TlsBegin ? TlsBegin->p_vaddr : VA, Sec->getAlign());
+            Out<ELFT>::TLS = PH;
+          } else {
+            setPhdr(PH, PT_LOAD, Flags, FileOff, VA, Align);
+          }
+
+          if (InTls && !TlsBegin) {
+            TlsBegin = PH;
+            TlsAlign = Sec->getAlign();
+          }
         }
       }
     }
 
     uintX_t Align = Sec->getAlign();
     uintX_t Size = Sec->getSize();
     if (Sec->getFlags() & SHF_ALLOC) {
       VA = RoundUpToAlignment(VA, Align);
       Sec->setVA(VA);
       VA += Size;
     }

test/elf2/tls-tbss-tdata.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: ld.lld2 %t -e main -o %t2
+// RUN: llvm-readobj -s %t2 | FileCheck --check-prefix=SECTION %s
+// RUN: llvm-readobj -program-headers %t2 | FileCheck --check-prefix=HEADER %s
+// RUN: llvm-objdump -d %t2 | FileCheck --check-prefix=RELOCS %s
+
+.globl TDATA1
+.section .tdata,"awT",@progbits
+.align 4
+.type TDATA1, @object
+.size TDATA1, 4
+TDATA1:
+.long 10
+.globl TDATA2
+.align 4
+.type TDATA2, @object
+.size TDATA2, 4
+TDATA2:
+.long 20
+.globl TBSS1
+.section .tbss,"awT",@nobits
+.align 4
+.type TBSS1, @object
+.size TBSS1, 4
+TBSS1:
+.zero 4
+.globl TBSS2
+.align 4
+.type TBSS2, @object
+.size TBSS2, 4
+TBSS2:
+.zero 4
+.text
+.globl main
+.type main, @function
+main:
+.LFB0:
+movl $1, %fs:TDATA1@tpoff
+movl $1, %fs:TDATA2@tpoff
+movl $1, %fs:TBSS1@tpoff
+movl $1, %fs:TBSS2@tpoff
+
+// SECTION:       Name: .tdata
+// SECTION-NEXT:  Type: SHT_PROGBITS
+// SECTION-NEXT:  Flags [
+// SECTION-NEXT:    SHF_ALLOC
+// SECTION-NEXT:    SHF_TLS
+// SECTION-NEXT:    SHF_WRITE
+// SECTION-NEXT:  ]
+// SECTION-NEXT:  Address: 0x12000
+// SECTION-NEXT:  Offset: 0x2000
+// SECTION-NEXT:  Size: 8
+// SECTION-NEXT:  Link: 0
+// SECTION-NEXT:  Info: 0
+// SECTION-NEXT:  AddressAlignment: 4
+// SECTION-NEXT:  EntrySize: 0
+// SECTION-NEXT:}
+// SECTION-NEXT:Section {
+// SECTION-NEXT:  Index: 3
+// SECTION-NEXT:  Name: .tbss
+// SECTION-NEXT:  Type: SHT_NOBITS
+// SECTION-NEXT:  Flags [
+// SECTION-NEXT:    SHF_ALLOC
+// SECTION-NEXT:    SHF_TLS
+// SECTION-NEXT:    SHF_WRITE
+// SECTION-NEXT:  ]
+// SECTION-NEXT:  Address: 0x12008
+// SECTION-NEXT:  Offset: 0x2008
+// SECTION-NEXT:  Size: 8
+// SECTION-NEXT:  Link: 0
+// SECTION-NEXT:  Info: 0
+// SECTION-NEXT:  AddressAlignment: 4
+// SECTION-NEXT:  EntrySize: 0
+
+// HEADER:         ProgramHeaders [
+// HEADER:         Type: PT_LOAD
+// HEADER:         Offset: 0x2000
+// HEADER-NEXT:    VirtualAddress: 0x12000
+// HEADER-NEXT:    PhysicalAddress: 0x12000
+// HEADER-NEXT:    FileSize: 8
+// HEADER-NEXT:    MemSize: 8
+// HEADER-NEXT:    Flags [
+// HEADER-NEXT:      PF_R
+// HEADER-NEXT:      PF_W
+// HEADER-NEXT:    ]
+// HEADER-NEXT:    Alignment: 4096
+// HEADER-NEXT:  }
+// HEADER-NEXT:  ProgramHeader {
+// HEADER-NEXT:    Type: PT_TLS
+// HEADER-NEXT:    Offset: 0x2000
+// HEADER-NEXT:    VirtualAddress: 0x12000
+// HEADER-NEXT:    PhysicalAddress: 0x12000
+// HEADER-NEXT:    FileSize: 8
+// HEADER-NEXT:    MemSize: 16
+// HEADER-NEXT:    Flags [
+// HEADER-NEXT:      PF_R (0x4)
+// HEADER-NEXT:    ]
+// HEADER-NEXT:    Alignment: 4
+// HEADER-NEXT:  }
+
+// RELOCS:        Disassembly of section .text:
+// RELOCS-NEXT:   main:
+// RELOCS-NEXT:   11000: 64 c7 04 25 f0 ff ff ff 01 00 00 00 movl $1, %fs:-16
+// RELOCS-NEXT:   1100c: 64 c7 04 25 f4 ff ff ff 01 00 00 00 movl $1, %fs:-12
+// RELOCS-NEXT:   11018: 64 c7 04 25 f8 ff ff ff 01 00 00 00 movl $1, %fs:-8
+// RELOCS-NEXT:   11024: 64 c7 04 25 fc ff ff ff 01 00 00 00 movl $1, %fs:-4

test/elf2/tls-tbss.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: ld.lld2 %t -e main -o %t2
+// RUN: llvm-readobj -s %t2 | FileCheck --check-prefix=SECTION %s
+// RUN: llvm-readobj -program-headers %t2 | FileCheck --check-prefix=HEADER %s
+// RUN: llvm-objdump -d %t2 | FileCheck --check-prefix=RELOCS %s
+
+.globl BSS1
+.section .tbss,"awT",@nobits
+.align 4
+.type BSS1, @object
+.size BSS1, 4
+BSS1:
+.zero 4
+.globl BSS2
+.align 4
+.type BSS2, @object
+.size BSS2, 4
+BSS2:
+.zero 4
+.text
+.globl main
+.type main, @function
+
+main:
+ movl $1, %fs:BSS1@tpoff
+ movl $1, %fs:BSS2@tpoff
+
+// SECTION:      Name: .tbss
+// SECTION-NEXT: Type: SHT_NOBITS
+// SECTION-NEXT: Flags [
+// SECTION-NEXT:   SHF_ALLOC
+// SECTION-NEXT:   SHF_TLS
+// SECTION-NEXT:   SHF_WRITE
+// SECTION-NEXT: ]
+// SECTION-NEXT: Address: 0x12000
+// SECTION-NEXT: Offset: 0x2000
+// SECTION-NEXT: Size: 8
+// SECTION-NEXT: Link: 0
+// SECTION-NEXT: Info: 0
+// SECTION-NEXT: AddressAlignment: 4
+// SECTION-NEXT: EntrySize: 0
+
+// HEADER:      ProgramHeaders [
+// HEADER:      Type: PT_TLS
+// HEADER-NEXT: Offset: 0x2000
+// HEADER-NEXT: VirtualAddress: 0x12000
+// HEADER-NEXT: PhysicalAddress: 0x12000
+// HEADER-NEXT: FileSize: 0
+// HEADER-NEXT: MemSize: 8
+// HEADER-NEXT: Flags [
+// HEADER-NEXT:   PF_R
+// HEADER-NEXT: ]
+// HEADER-NEXT: Alignment: 4
+
+// RELOCS:      Disassembly of section .text:
+// RELOCS-NEXT: main:
+// RELOCS-NEXT: 11000: 64 c7 04 25 f8 ff ff ff 01 00 00 00 movl $1, %fs:-8
+// RELOCS-NEXT: 1100c: 64 c7 04 25 fc ff ff ff 01 00 00 00 movl $1, %fs:-4

test/elf2/tls-tdata.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+// RUN: ld.lld2 %t -e main -o %t2
+// RUN: llvm-readobj -s %t2 | FileCheck --check-prefix=SECTION %s
+// RUN: llvm-readobj -program-headers %t2 | FileCheck --check-prefix=HEADER %s
+// RUN: llvm-objdump -d %t2 | FileCheck --check-prefix=RELOCS %s
+
+.globl TDATA1
+.section .tdata,"awT",@progbits
+.align 4
+.type TDATA1, @object
+.size TDATA1, 4
+TDATA1:
+.long 10
+.globl TDATA2
+.align 4
+.type TDATA2, @object
+.size TDATA2, 4
+TDATA2:
+.long 20
+.text
+.globl main
+.type main, @function
+main:
+movl $1, %fs:TDATA1@tpoff
+movl $1, %fs:TDATA2@tpoff
+
+// SECTION:        Name: .tdata
+// SECTION-NEXT:   Type: SHT_PROGBITS
+// SECTION-NEXT:   Flags [
+// SECTION-NEXT:     SHF_ALLOC
+// SECTION-NEXT:     SHF_TLS
+// SECTION-NEXT:     SHF_WRITE
+// SECTION-NEXT:   ]
+// SECTION-NEXT:   Address: 0x12000
+// SECTION-NEXT:   Offset: 0x2000
+// SECTION-NEXT:   Size: 8
+// SECTION-NEXT:   Link: 0
+// SECTION-NEXT:   Info: 0
+// SECTION-NEXT:   AddressAlignment: 4
+// SECTION-NEXT:   EntrySize: 0
+// SECTION-NEXT: }
+
+// HEADER:        ProgramHeader {
+// HEADER:        Type: PT_LOAD
+// HEADER:        Offset: 0x2000
+// HEADER-NEXT:   VirtualAddress: 0x12000
+// HEADER-NEXT:   PhysicalAddress: 0x12000
+// HEADER-NEXT:   FileSize: 8
+// HEADER-NEXT:   MemSize: 8
+// HEADER-NEXT:   Flags [
+// HEADER-NEXT:     PF_R
+// HEADER-NEXT:     PF_W
+// HEADER-NEXT:   ]
+// HEADER-NEXT:   Alignment: 4096
+// HEADER-NEXT: }
+// HEADER-NEXT: ProgramHeader {
+// HEADER-NEXT:   Type: PT_TLS
+// HEADER-NEXT:   Offset: 0x2000
+// HEADER-NEXT:   VirtualAddress: 0x12000
+// HEADER-NEXT:   PhysicalAddress: 0x12000
+// HEADER-NEXT:   FileSize: 8
+// HEADER-NEXT:   MemSize: 8
+// HEADER-NEXT:   Flags [
+// HEADER-NEXT:     PF_R
+// HEADER-NEXT:   ]
+// HEADER-NEXT:   Alignment: 4
+// HEADER-NEXT: }
+
+// RELOCS:       Disassembly of section .text:
+// RELOCS-NEXT:  main:
+// RELOCS-NEXT:  11000: 64 c7 04 25 f8 ff ff ff 01 00 00 00 movl $1, %fs:-8
+// RELOCS-NEXT:  1100c: 64 c7 04 25 fc ff ff ff 01 00 00 00 movl $1, %fs:-4