[elf2] Implement R_X86_64_TPOFF32.

[Bigcheese]

Summary

This does not support TPOFF32 relocations to local symbols as the address calculations are separate. Support for this will be a separate patch.

[ruiu]

ELF/OutputSections.h

356

Let's typedef uintX_t here to avoid line wrapping.

374

This name is too long. How about TlsTemplateVA?

[Bigcheese]

ELF/OutputSections.h

374

Initialization image is the term of art for this. How about TlsInitImageVA?

[ruiu]

ELF/OutputSections.h

374

I think I still kind of like template (mainly because it's just one word), and that's used in Ulrich Drepper's document too (http://www.akkadia.org/drepper/tls.pdf)

[Bigcheese]

Change name and simplify uintX_t.

[Bigcheese]

ELF/OutputSections.h

375

In 2 places vs the 18 uses of initialization image.

[ruiu]

LGTM with a few nits.

ELF/OutputSections.cpp

648

Remove () from "(A + B) - C".

ELF/OutputSections.h

356

Nothing wrong with the template aliasing, but that's different from other code. Use typedef instead for consistency.

typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;

375

I have no strong preference, so I'm OK with InitImage.

[Bigcheese]

r251998

ELF/OutputSections.h

private:
   uint32_t DtFlags = 0;
   uint32_t DtFlags1 = 0;
 };
 
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   static DynamicSection<ELFT> *Dynamic;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
   static OutputSection<ELFT> *Bss;
   static OutputSectionBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   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>::uintX_t ThreadInitializationImageVA;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 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>::uintX_t
+    Out<ELFT>::ThreadInitializationImageVA;
 }
 }
 #endif

ELF/OutputSections.cpp

case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
     return D.Section.getVA() + D.Sym.st_value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
   case SymbolBody::DefinedRegularKind: {
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> &SC = DR.Section;
+    if (DR.Sym.getType() == STT_TLS)
+      return (SC.OutSec->getVA() + SC.getOffset(DR.Sym)) -
+             Out<ELFT>::ThreadInitializationImageVA;
     return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
   }
   case SymbolBody::DefinedCommonKind:
     return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
   case SymbolBody::SharedKind: {
     auto &SS = cast<SharedSymbol<ELFT>>(S);
     if (SS.needsCopy())
       return Out<ELFT>::Bss->getVA() + SS.OffsetInBSS;

ELF/Target.cpp

void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
   case R_X86_64_32:
   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:
+    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

if (Sec->getSize()) {
           Elf_Phdr *PH = &Phdrs[++PhdrIdx];
           setPhdr(PH, PT_LOAD, Flags, FileOff, VA, 0, Target->getPageSize());
         }
       }
     }
 
     if (Sec->getSize() && (Sec->getFlags() & SHF_ALLOC) &&
         (Sec->getFlags() & SHF_TLS)) {
-      if (!TlsPhdr.p_vaddr)
+      if (!TlsPhdr.p_vaddr) {
         setPhdr(&TlsPhdr, PT_TLS, PF_R, FileOff, VA, 0, Sec->getAlign());
+        Out<ELFT>::ThreadInitializationImageVA = VA;
+      }
       if (Sec->getType() != SHT_NOBITS)
         VA = RoundUpToAlignment(VA, Sec->getAlign());
       uintX_t TVA = RoundUpToAlignment(VA + ThreadBSSOffset, Sec->getAlign());
       Sec->setVA(TVA);
       TlsPhdr.p_memsz += Sec->getSize();
       if (Sec->getType() == SHT_NOBITS) {
         ThreadBSSOffset = TVA - VA + Sec->getSize();
       } else {

test/elf2/tls.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 // RUN: ld.lld2 %t -o %tout
-// RUN: llvm-readobj -sections -program-headers %tout | FileCheck %s
+// RUN: llvm-readobj -symbols -sections -program-headers %tout | FileCheck %s
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
 
 .global _start
 _start:
+  movl %fs:a@tpoff, %eax
+  movl %fs:b@tpoff, %eax
+  movl %fs:c@tpoff, %eax
+  movl %fs:d@tpoff, %eax
 
+  .global a
   .section  .tbss,"awT",@nobits
+a:
   .long 0
 
+  .global b
   .section  .tdata,"awT",@progbits
+b:
   .long 1
 
+  .global c
   .section  .thread_bss,"awT",@nobits
+c:
   .long 0
 
+  .global d
   .section  .thread_data,"awT",@progbits
+d:
   .long 2
 
 // CHECK:          Name: .tdata
 // CHECK-NEXT:     Type: SHT_PROGBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE

 // CHECK-NEXT:     Name: .thread_bss
 // CHECK-NEXT:     Type: SHT_NOBITS
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_TLS
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
 
-// 0x1100C = TBSS_ADDR + 4
+// 0x1200C = TBSS_ADDR + 4
 
-// CHECK-NEXT:     Address: 0x1100C
+// CHECK-NEXT:     Address: 0x1200C
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     Size: 4
 // CHECK-NEXT:     Link:
 // CHECK-NEXT:     Info:
 // CHECK-NEXT:     AddressAlignment:
 // CHECK-NEXT:     EntrySize:
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Section {
 // CHECK-NEXT:     Index:
 // CHECK-NEXT:     Name:
 // CHECK-NEXT:     Type:
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       SHF_ALLOC
 // CHECK-NEXT:       SHF_WRITE
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Address: [[TBSS_ADDR]]
 
+// CHECK:      Symbols [
+// CHECK:          Name: a
+// CHECK-NEXT:     Value: 0x8
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: TLS
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .tbss
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: b
+// CHECK-NEXT:     Value: 0x0
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: TLS
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .tdata
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: c
+// CHECK-NEXT:     Value: 0xC
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: TLS
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .thread_bss
+// CHECK-NEXT:   }
+// CHECK-NEXT:   Symbol {
+// CHECK-NEXT:     Name: d
+// CHECK-NEXT:     Value: 0x4
+// CHECK-NEXT:     Size:
+// CHECK-NEXT:     Binding: Global
+// CHECK-NEXT:     Type: TLS
+// CHECK-NEXT:     Other: 0
+// CHECK-NEXT:     Section: .thread_data
+// CHECK-NEXT:   }
+
 // Check that the TLS NOBITS sections weren't added to the R/W PT_LOAD's size.
 
 // CHECK:      ProgramHeaders [
 // CHECK:          Type: PT_LOAD
 // CHECK:          Type: PT_LOAD
+// CHECK:          Type: PT_LOAD
 // CHECK:          FileSize: 8
 // CHECK-NEXT:     MemSize: 8
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       PF_R
 // CHECK-NEXT:       PF_W
 // CHECK-NEXT:     ]
 // CHECK:          Type: PT_TLS
 // CHECK-NEXT:     Offset:
 // CHECK-NEXT:     VirtualAddress: [[TDATA_ADDR]]
 // CHECK-NEXT:     PhysicalAddress: [[TDATA_ADDR]]
 // CHECK-NEXT:     FileSize: 8
 // CHECK-NEXT:     MemSize: 16
 // CHECK-NEXT:     Flags [
 // CHECK-NEXT:       PF_R
 // CHECK-NEXT:     ]
 // CHECK-NEXT:     Alignment:
 // CHECK-NEXT:   }
+
+// DIS:      Disassembly of section .text:
+// DIS-NEXT: _start:
+// DIS-NEXT:    11000: {{.+}} movl    %fs:8, %eax
+// DIS-NEXT:    11008: {{.+}} movl    %fs:0, %eax
+// DIS-NEXT:    11010: {{.+}} movl    %fs:12, %eax
+// DIS-NEXT:    11018: {{.+}} movl    %fs:4, %eax