[ELF] - Implemented some GD, LD and IE TLS access models for x86 target.

[grimar]

Summary

Main aim of the patch to introduce basic support for TLS access models for x86 target.
Models using @tlsgd, @tlsldm and @gotntpoff are implemented.
There are no any TLS optimizations yet - I plan to add them in another following patches.

[ruiu]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

Why do we need a different member variable than GotIndex?

ELF/OutputSections.h

3

getNumEntries

ELF/Target.cpp

27

  break;
}

[grimar]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

Thats needed for the next code sequence to work correctly:

leal tls0@tlsgd(,%ebx,1),%eax
call __tls_get_addr@plt
movl %gs:0,%eax
addl tls0@gotntpoff(%ebx),%eax

@tlsgd(x) - Allocates two contiguous entries in the GOT to hold a TLS_index structure.
@gotntpoff(x) - Allocates a entry in the GOT, and initializes it with the negative tlsoffset relative to the static TLS block. This is performed at runtime via the R_386_TLS_TPOFF relocation.

Problem is that next part of code terminates execution flow:

void Writer<ELFT>::scanRelocs(
.....
    if (Body && Body->isTLS() && Target->isTlsGlobalDynamicReloc(Type)) {
      if (Target->isTlsOptimized(Type, Body))
        continue;
      if (Body->isInGot())
        continue;

Make it continue and unable to move forward and create R_386_TLS_TPOFF relocation (and single entry) below at the end of that method.

[ruiu]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

Understood, but can you do that in a different way? I think the new variable is rather confusing, since symbols added to GOT using addDynTlsEntry are in GOT, but isInGot returns false for them (although they are in GOT).

[grimar]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

First of all: I reproduced the same situation on x64 target and decided to split patch for that from this one: http://reviews.llvm.org/D15105.

About making that in a different way:
I think we can`t avoid using additional index variable because we need to use different got entry ids for different places. I mean we must know id of dynamic tls entry and the normal tls entry and use them both.

But I dont see problem here for design. At fact we dont use isInGot() for GD reloc because it is special case and processed separately everywhere. So its even more confusing to have this to respond isInGot() call when this call looks like should never be used in according to current logic.

I prepared that separate patch to make code look more consistent with code for LocalModuleTlsIndexOffset to hightlight their special nature (also updated a test case for x64 there).

ELF/OutputSections.h

3

Will be fixed in update.

ELF/Target.cpp

27

Will be fixed in update.

[ruiu]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

Mostly my concern is about the name isInGot(). If something is in GOT, that function should return true no matter how that is in GOT, because the function is named is-in-got.

[grimar]

Updated patch to match the latest code.
Addressed review comments.

[grimar]

ELF/OutputSections.cpp

84 ↗

(On Diff #41356)

There is no more that code in this patch :) It dissolved during other commits, so I guess its fine now.

[ruiu]

LGTM with a few nits.

ELF/Target.cpp

338

Move this after R_386_PC32.

341

Offset -> V for consistency.

347

Move this before R_386_TLS_PC32 to sort.

[grimar]

ELF/Target.cpp

338

Done.

341

Done.

347

There is no R_386_TLS_PC32 here, I think you meant before R_386_TLS_LE. Moved there.

ELF/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
public:
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool addDynTlsEntry(SymbolBody *Sym);
   bool addLocalModelTlsIndex();
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
+  uintX_t getNumEntries() const { return Entries.size(); }
 
   // Returns the symbol which corresponds to the first entry of the global part
   // of GOT on MIPS platform. It is required to fill up MIPS-specific dynamic
   // table properties.
   // Returns nullptr if the global part is empty.
   const SymbolBody *getMipsFirstGlobalEntry() const;
 
   // Returns the number of entries in the local part of GOT including

ELF/Target.cpp

 #include "Error.h"
 #include "OutputSections.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ELF.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 namespace lld {
 namespace elf2 {
 

 
 void TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {}
 
 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
   GotReloc = R_386_GLOB_DAT;
   PltReloc = R_386_JUMP_SLOT;
+  TlsGotReloc = R_386_TLS_TPOFF;
+  TlsGlobalDynamicReloc = R_386_TLS_GD;
+  TlsLocalDynamicReloc = R_386_TLS_LDM;
+  TlsModuleIndexReloc = R_386_TLS_DTPMOD32;
+  TlsOffsetReloc = R_386_TLS_DTPOFF32;
   LazyRelocations = true;
   PltEntrySize = 16;
   PltZeroEntrySize = 16;
 }
 
 void X86TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {
   write32le(Buf, Out<ELF32LE>::Dynamic->getVA());
 }
 
 void X86TargetInfo::writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const {
   // Skip 6 bytes of "pushl (GOT+4)"
   write32le(Buf, Plt + 6);
 }
 
 unsigned X86TargetInfo::getDynReloc(unsigned Type) const {
   if (Type == R_386_TLS_LE)
     return R_386_TLS_TPOFF;
   if (Type == R_386_TLS_LE_32)
     return R_386_TLS_TPOFF32;
   return Type;
 }
 
 bool X86TargetInfo::isTlsDynReloc(unsigned Type) const {
-  if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32)
+  if (Type == R_386_TLS_LE || Type == R_386_TLS_LE_32 ||
+      Type == R_386_TLS_GOTIE)
     return Config->Shared;
   return false;
 }
 
 void X86TargetInfo::writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                                       uint64_t PltEntryAddr) const {
   // Executable files and shared object files have
   // separate procedure linkage tables.

 bool X86TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
   if (Type == R_386_32 || Type == R_386_16 || Type == R_386_8)
     if (auto *SS = dyn_cast<SharedSymbol<ELF32LE>>(&S))
       return SS->Sym.getType() == STT_OBJECT;
   return false;
 }
 
 bool X86TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
-  return Type == R_386_GOT32 || relocNeedsPlt(Type, S);
+  return Type == R_386_TLS_GOTIE || Type == R_386_GOT32 ||
+         relocNeedsPlt(Type, S);
 }
 
 bool X86TargetInfo::relocNeedsPlt(uint32_t Type, const SymbolBody &S) const {
   return Type == R_386_PLT32 || (Type == R_386_PC32 && S.isShared());
 }
 
 void X86TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                 uint64_t P, uint64_t SA) const {
case R_386_PC32:
     add32le(Loc, SA - P);
     break;
   case R_386_TLS_LE:
     write32le(Loc, SA - Out<ELF32LE>::TlsPhdr->p_memsz);
     break;
   case R_386_TLS_LE_32:
     write32le(Loc, Out<ELF32LE>::TlsPhdr->p_memsz - SA);
     break;
+  case R_386_TLS_GD:
+  case R_386_TLS_LDM:
+  case R_386_TLS_TPOFF: {
+    uint64_t Offset = SA - Out<ELF32LE>::Got->getVA() -
+                      Out<ELF32LE>::Got->getNumEntries() * 4;
+    checkInt<32>(Offset, Type);
+    write32le(Loc, Offset);
+    break;
+  }
+  case R_386_TLS_LDO_32:
+    write32le(Loc, SA);
+    break;
   default:
     error("unrecognized reloc " + Twine(Type));
   }
 }
 
 X86_64TargetInfo::X86_64TargetInfo() {
   CopyReloc = R_X86_64_COPY;
   PCRelReloc = R_X86_64_PC32;

test/ELF/tls-dynamic-i686.s

+// REQUIRES: x86
+// RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t
+// RUN: ld.lld -shared %t -o %tout
+// RUN: llvm-readobj -sections -relocations %tout | FileCheck %s
+// RUN: llvm-objdump -d %tout | FileCheck %s --check-prefix=DIS
+
+.type tls0,@object
+.section .tbss,"awT",@nobits
+.globl tls0
+.align 4
+tls0:
+ .long 0
+ .size tls0, 4
+
+.type  tls1,@object
+.globl tls1
+.align 4
+tls1:
+ .long 0
+ .size tls1, 4
+
+.section .text
+.globl _start
+_start:
+leal tls0@tlsgd(,%ebx,1),%eax
+call __tls_get_addr@plt
+
+leal tls1@tlsgd(,%ebx,1),%eax
+call __tls_get_addr@plt
+
+leal tls0@tlsldm(%ebx),%eax
+call __tls_get_addr@plt
+leal tls0@dtpoff(%eax),%edx
+
+leal tls1@tlsldm(%ebx),%eax
+call __tls_get_addr@plt
+leal tls1@dtpoff(%eax),%edx
+
+movl %gs:0,%eax
+addl tls0@gotntpoff(%ebx),%eax
+
+movl %gs:0,%eax
+addl tls1@gotntpoff(%ebx),%eax
+
+// CHECK:      Index: 10
+// CHECK-NEXT: Name: .got
+// CHECK-NEXT: Type: SHT_PROGBITS
+// CHECK-NEXT: Flags [
+// CHECK-NEXT:   SHF_ALLOC
+// CHECK-NEXT:   SHF_WRITE
+// CHECK-NEXT: ]
+// CHECK-NEXT: Address: 0x2068
+// CHECK-NEXT: Offset: 0x2068
+// 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: 0x2068 R_386_TLS_DTPMOD32 tls0 0x0
+// CHECK-NEXT: 0x206C R_386_TLS_DTPOFF32 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.
+// DIS-NEXT: 1000: 8d 04 1d e0 ff ff ff  leal -32(,%ebx), %eax
+// DIS-NEXT: 1007: e8 64 00 00 00        calll 100
+// DIS-NEXT: 100c: 8d 04 1d e8 ff ff ff  leal -24(,%ebx), %eax
+// DIS-NEXT: 1013: e8 58 00 00 00        calll 88
+// Local dynamic model:
+// -16 is a local module tls index offset.
+// DIS-NEXT: 1018: 8d 83 f0 ff ff ff leal -16(%ebx), %eax
+// DIS-NEXT: 101e: e8 4d 00 00 00    calll 77
+// DIS-NEXT: 1023: 8d 90 00 00 00 00 leal (%eax), %edx
+// DIS-NEXT: 1029: 8d 83 f0 ff ff ff leal -16(%ebx), %eax
+// DIS-NEXT: 102f: e8 3c 00 00 00    calll 60
+// DIS-NEXT: 1034: 8d 90 04 00 00 00 leal 4(%eax), %edx
+// Initial exec model:
+// DIS-NEXT: 103a: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DIS-NEXT: 1040: 03 83 f8 ff ff ff addl -8(%ebx), %eax
+// DIS-NEXT: 1046: 65 a1 00 00 00 00 movl %gs:0, %eax
+// DIS-NEXT: 104c: 03 83 fc ff ff ff addl -4(%ebx), %eax