[ELF2] - Implemented optimizations for @tlsld and @tlsgd

[grimar]

Summary

Implements @tlsld (LD to LE) and @tlsgd (GD to LE) optimizations.

Patch does not implement the GD->IE case for @tlsgd, I will implement it in separate patch.
This one partially intersects with http://reviews.llvm.org/D14713.

[grimar]

Updated test

[grimar]

Corrected formatting issues.

[ruiu]

ELF/InputSection.cpp

103 ↗

(On Diff #40777)

It is not obvious that Rels.begin() is a randomly-accessible iterator in this context, so this is a bit alarming. Probably it is better to write

size_t Idx = -1;
for (const RelType &RI : Rels) {
  ++Idx;
  ...
}

114 ↗

(On Diff #40777)

Instead of adding this condition, can you move this

if (Body.isTLS() && Target->isTlsOptimized(Type, &Body)) {
  ....
}

block above this line?

ELF/Target.cpp

366 ↗

(On Diff #40777)

return (Type == R_X86_64_TLSLD) || (Type == R_X86_64_DTPOFF32) ||

->

return Type == R_X86_64_TLSLD || Type == R_X86_64_DTPOFF32 ||

(We can assume that everybody knows == take higher precedence over || at least.)

377–378 ↗

(On Diff #40777)

What are these instructions?

385 ↗

(On Diff #40777)

Do not put a space before '!'.

410–411 ↗

(On Diff #40777)

Feels like these error checks are becoming more annoying than useful. I remember you mentioned to remove them. I agree with that. If these relocations are guaranteed to be used with only specific set of instructions, we don't always need to check for that condition (if users throw in garbage, it may output garbage).

If you remove this error check, you can remove BufStart from argument list?

[grimar]

ELF/InputSection.cpp

103 ↗

(On Diff #40777)

I need that to be able to skip relocations, not for counting ID. Please see below next parts of code:

// The next relocation should be against __tls_get_addr, so skip it.
  ++RelNdx;

114 ↗

(On Diff #40777)

Thats probably will not work.
I need to get the Body.

SymbolBody &Body = *File->getSymbolBody(SymIndex)->repl();

To do that we need to check/handle locals first that dont have it. That is done below:

   if (SymIndex < SymTab->sh_info) {
...
    }

What about if I remake isTlsLocalDynamicReloc() to isNoOptTlsLocalDynamicReloc() (NotOptimized + TlsLocalDynamicReloc) ? That should work everywhere in code.
(and the same for isTlsGlobalDynamicReloc())

ELF/Target.cpp

366 ↗

(On Diff #40777)

Ok

377–378 ↗

(On Diff #40777)

Its mentioned on p.23 of http://www.akkadia.org/drepper/tls.pdf. That is just prefixes that used to fill the whole sequence. For some reason not no-ops operations should be used.
p.65 contains the info about this one optimization where is told to do in that way either.

385 ↗

(On Diff #40777)

Ok

410–411 ↗

(On Diff #40777)

Yes, BufStart is not needed then. Lets do that.

[grimar]

Review comments addressed.

ELF/InputSection.cpp

114 ↗

(On Diff #40777)

My suggestion to remake function fill not work either because Body still required for Global Dynamic optimized check. Leaved that code as is.

ELF/Target.cpp

385 ↗

(On Diff #40777)

Removed the check.

[ruiu]

ELF/InputSection.cpp

103 ↗

(On Diff #40906)

That's too subtle. Is there any way to avoid that?

114 ↗

(On Diff #40906)

Remove () from (!Target->isTlsOptimized(...))

134 ↗

(On Diff #40906)

Ditto

[grimar]

ELF/InputSection.cpp

103 ↗

(On Diff #40906)

gold implements that via having and setting bool flag skip_call_tls_get_addr_ that skips the relocation if true. bfd uses the approach similiar to what I used. With using flag that could be done more strict I guess (we can check relocation type and symbol name). But I think there is no chance to avoid that at all. That relocation exist but should not be proccessed.

[ruiu]

ELF/InputSection.cpp

103 ↗

(On Diff #40906)

It is okay to update the index in side the loop. What I meant by too subtle is that it is not obvious that "I" may be updated by relocateTlsOptimize. It is passed by a reference that makes it almost impossible to imagine that case.

How about this. Change the signature of relocateTlsOptimize so that it returns an integer. If the next entry needs to be skipped, it returns 1. Otherwise 0. You can add that return value to I.

[grimar]

Review comments addressed.

ELF/InputSection.cpp

103 ↗

(On Diff #40906)

Well I cant say I like this, but I dont know much better solution atm.

114 ↗

(On Diff #40906)

Done.

134 ↗

(On Diff #40906)

Done.

[ruiu]

ELF/InputSection.cpp

142 ↗

(On Diff #41141)

Please add a comment here.

// By optimizing TLS relocations, it is sometimes needed to skip relocations
// that immediately follow TLS relocations. This function knows how many slots
// we need to skip.

ELF/Target.cpp

469 ↗

(On Diff #41141)

Please do not use int8_t just because it returns a small integer. If no specific size is in mind, use int.

469 ↗

(On Diff #41141)

Add a comment

// This function applies a TLS relocation with an optimization as described
// in the Ulrich's document. As a result of rewriting instructions at the relocation
// target, relocations immediately follow the TLS relocation (which would be applied
// to rewritten instructions) need to be skipped.
// This function returns a number of relocations that need to be skipped.

472–483 ↗

(On Diff #41141)

switch (Type) {
case R_X86_64_GOTTPOFF:
  relocateTlsIeToLe(...);
  return 0;
case R_X86_64_TLSLD:
  relocateTlsLdToLe(...);
  return 1;
case ...
}

[grimar]

Review comments addressed.

ELF/InputSection.cpp

142 ↗

(On Diff #41141)

Done.

ELF/Target.cpp

469 ↗

(On Diff #41141)

Done.

469 ↗

(On Diff #41141)

Done.

472–483 ↗

(On Diff #41141)

Done.

[ruiu]

LGTM

ELF/Target.cpp

491 ↗

(On Diff #41176)

need to be -> may have to be

[grimar]

ELF/Target.cpp

491 ↗

(On Diff #41176)

Done.

lld/trunk/ELF/InputSection.cpp

 }
 
 template <class ELFT>
 template <bool isRela>
 void InputSectionBase<ELFT>::relocate(
     uint8_t *Buf, uint8_t *BufEnd,
     iterator_range<const Elf_Rel_Impl<ELFT, isRela> *> Rels) {
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
-  for (const RelType &RI : Rels) {
+  size_t Num = Rels.end() - Rels.begin();
+  for (size_t I = 0; I < Num; ++I) {
+    const RelType &RI = *(Rels.begin() + I);
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
     uintX_t Offset = getOffset(RI.r_offset);
     if (Offset == (uintX_t)-1)
       continue;
 
     uint8_t *BufLoc = Buf + Offset;
     uintX_t AddrLoc = OutSec->getVA() + Offset;
 
-    if (Target->isTlsLocalDynamicReloc(Type)) {
+    if (Target->isTlsLocalDynamicReloc(Type) &&
+        !Target->isTlsOptimized(Type, nullptr)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getVA() +
                               Out<ELFT>::LocalModuleTlsIndexOffset +
                               getAddend<ELFT>(RI));
       continue;
     }
 
     // Handle relocations for local symbols -- they never get
     // resolved so we don't allocate a SymbolBody.
     const Elf_Shdr *SymTab = File->getSymbolTable();
     if (SymIndex < SymTab->sh_info) {
       uintX_t SymVA = getLocalRelTarget(*File, RI);
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc, SymVA);
       continue;
     }
 
     SymbolBody &Body = *File->getSymbolBody(SymIndex)->repl();
 
-    if (Target->isTlsGlobalDynamicReloc(Type)) {
+    if (Target->isTlsGlobalDynamicReloc(Type) &&
+        !Target->isTlsOptimized(Type, &Body)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getEntryAddr(Body) +
                               getAddend<ELFT>(RI));
       continue;
     }
 
-    if (Target->isTlsOptimized(Type, Body)) {
-      Target->relocateTlsOptimize(BufLoc, BufEnd, AddrLoc,
+    if (Target->isTlsOptimized(Type, &Body)) {
+      // By optimizing TLS relocations, it is sometimes needed to skip
+      // relocations that immediately follow TLS relocations. This function
+      // knows how many slots we need to skip.
+      I += Target->relocateTlsOptimize(BufLoc, BufEnd, Type, AddrLoc,
                                        getSymVA<ELFT>(Body));
       continue;
     }
 
     uintX_t SymVA = getSymVA<ELFT>(Body);
     if (Target->relocNeedsPlt(Type, Body)) {
       SymVA = Out<ELFT>::Plt->getEntryAddr(Body);
       Type = Target->getPltRefReloc(Type);
     } else if (Target->relocNeedsGot(Type, Body)) {

lld/trunk/ELF/Target.h

virtual void writePltEntry(uint8_t *Buf, uint64_t GotAddr,
                              uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                              int32_t Index, unsigned RelOff) const = 0;
   virtual bool isRelRelative(uint32_t Type) const;
   virtual bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const;
   virtual bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const = 0;
   virtual bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                            uint64_t P, uint64_t SA) const = 0;
-  virtual bool isTlsOptimized(unsigned Type, const SymbolBody &S) const;
-  virtual void relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
+  virtual bool isTlsOptimized(unsigned Type, const SymbolBody *S) const;
+  virtual unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
+                                       uint32_t Type, uint64_t P,
                                        uint64_t SA) const;
   virtual ~TargetInfo();
 
 protected:
   unsigned PageSize = 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.

lld/trunk/ELF/Target.cpp

void writePltEntry(uint8_t *Buf, uint64_t GotAddr, uint64_t GotEntryAddr,
                      uint64_t PltEntryAddr, int32_t Index,
                      unsigned RelOff) const override;
   bool relocNeedsCopy(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
   bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type, uint64_t P,
                    uint64_t SA) const override;
   bool isRelRelative(uint32_t Type) const override;
-  bool isTlsOptimized(unsigned Type, const SymbolBody &S) const override;
-  void relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
-                           uint64_t SA) const override;
+  bool isTlsOptimized(unsigned Type, const SymbolBody *S) const override;
+  unsigned relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
+                               uint64_t P, uint64_t SA) const override;
+
+private:
+  void relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
+                         uint64_t SA) const;
+  void relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
+                         uint64_t SA) const;
+  void relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
+                         uint64_t SA) const;
 };
 
 class PPC64TargetInfo final : public TargetInfo {
 public:
   PPC64TargetInfo();
   void writeGotPltEntry(uint8_t *Buf, uint64_t Plt) const override;
   void writePltZeroEntry(uint8_t *Buf, uint64_t GotEntryAddr,
                          uint64_t PltEntryAddr) const override;
TargetInfo *createTarget() {
   case EM_X86_64:
     return new X86_64TargetInfo();
   }
   error("Unknown target machine");
 }
 
 TargetInfo::~TargetInfo() {}
 
-bool TargetInfo::isTlsOptimized(unsigned Type, const SymbolBody &S) const {
+bool TargetInfo::isTlsOptimized(unsigned Type, const SymbolBody *S) const {
   return false;
 }
 
 uint64_t TargetInfo::getVAStart() const { return Config->Shared ? 0 : VAStart; }
 
 bool TargetInfo::relocNeedsCopy(uint32_t Type, const SymbolBody &S) const {
   return false;
 }
 
 unsigned TargetInfo::getGotRefReloc(unsigned Type) const { return GotRefReloc; }
 
 unsigned TargetInfo::getPltRefReloc(unsigned Type) const { return PCRelReloc; }
 
 bool TargetInfo::isRelRelative(uint32_t Type) const { return true; }
 
-void TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd, uint64_t P,
-                                     uint64_t SA) const {}
+unsigned TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
+                                         uint32_t Type, uint64_t P,
+                                         uint64_t SA) const {
+  return 0;
+}
 
 void TargetInfo::writeGotHeaderEntries(uint8_t *Buf) const {}
 
 void TargetInfo::writeGotPltHeaderEntries(uint8_t *Buf) const {}
 
 X86TargetInfo::X86TargetInfo() {
   CopyReloc = R_386_COPY;
   PCRelReloc = R_386_PC32;
if (Type == R_X86_64_32S || Type == R_X86_64_32 || Type == R_X86_64_PC32 ||
       Type == R_X86_64_64)
     if (auto *SS = dyn_cast<SharedSymbol<ELF64LE>>(&S))
       return SS->Sym.getType() == STT_OBJECT;
   return false;
 }
 
 bool X86_64TargetInfo::relocNeedsGot(uint32_t Type, const SymbolBody &S) const {
   if (Type == R_X86_64_GOTTPOFF)
-    return !isTlsOptimized(Type, S);
+    return !isTlsOptimized(Type, &S);
   return Type == R_X86_64_GOTTPOFF || Type == R_X86_64_GOTPCREL ||
          relocNeedsPlt(Type, S);
 }
 
 bool X86_64TargetInfo::isTlsDynReloc(unsigned Type) const {
   return Type == R_X86_64_GOTTPOFF;
 }
 
bool X86_64TargetInfo::isRelRelative(uint32_t Type) const {
   case R_X86_64_PLT32:
   case R_X86_64_DTPOFF32:
   case R_X86_64_DTPOFF64:
     return true;
   }
 }
 
 bool X86_64TargetInfo::isTlsOptimized(unsigned Type,
-                                      const SymbolBody &S) const {
-  if (Config->Shared || !S.isTLS())
+                                      const SymbolBody *S) const {
+  if (Config->Shared || (S && !S->isTLS()))
     return false;
-  return Type == R_X86_64_GOTTPOFF && !canBePreempted(&S, true);
+  return Type == R_X86_64_TLSLD || Type == R_X86_64_DTPOFF32 ||
+         (Type == R_X86_64_TLSGD && !canBePreempted(S, true)) ||
+         (Type == R_X86_64_GOTTPOFF && !canBePreempted(S, true));
+}
+
+// "Ulrich Drepper, ELF Handling For Thread-Local Storage" (5.5
+// x86-x64 linker optimizations, http://www.akkadia.org/drepper/tls.pdf) shows
+// how LD can be optimized to LE:
+//   leaq bar@tlsld(%rip), %rdi
+//   callq __tls_get_addr@PLT
+//   leaq bar@dtpoff(%rax), %rcx
+// Is converted to:
+//  .word 0x6666
+//  .byte 0x66
+//  mov %fs:0,%rax
+//  leaq bar@tpoff(%rax), %rcx
+void X86_64TargetInfo::relocateTlsLdToLe(uint8_t *Loc, uint8_t *BufEnd,
+                                         uint64_t P, uint64_t SA) const {
+  const uint8_t Inst[] = {
+      0x66, 0x66,                                          //.word 0x6666
+      0x66,                                                //.byte 0x66
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00 // mov %fs:0,%rax
+  };
+  memcpy(Loc - 3, Inst, sizeof(Inst));
+}
+
+// "Ulrich Drepper, ELF Handling For Thread-Local Storage" (5.5
+// x86-x64 linker optimizations, http://www.akkadia.org/drepper/tls.pdf) shows
+// how GD can be optimized to LE:
+//  .byte 0x66
+//  leaq x@tlsgd(%rip), %rdi
+//  .word 0x6666
+//  rex64
+//  call __tls_get_addr@plt
+// Is converted to:
+//  mov %fs:0x0,%rax
+//  lea x@tpoff,%rax
+void X86_64TargetInfo::relocateTlsGdToLe(uint8_t *Loc, uint8_t *BufEnd,
+                                         uint64_t P, uint64_t SA) const {
+  const uint8_t Inst[] = {
+      0x64, 0x48, 0x8b, 0x04, 0x25, 0x00, 0x00, 0x00, 0x00, // mov %fs:0x0,%rax
+      0x48, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00              // lea x@tpoff,%rax
+  };
+  memcpy(Loc - 4, Inst, sizeof(Inst));
+  relocateOne(Loc + 8, BufEnd, R_X86_64_TPOFF32, P, SA);
 }
 
 // In some conditions, R_X86_64_GOTTPOFF relocation can be optimized to
 // R_X86_64_TPOFF32 so that R_X86_64_TPOFF32 so that it does not use GOT.
 // This function does that. Read "ELF Handling For Thread-Local Storage,
 // 5.5 x86-x64 linker optimizations" (http://www.akkadia.org/drepper/tls.pdf)
 // by Ulrich Drepper for details.
-void X86_64TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
-                                           uint64_t P, uint64_t SA) const {
+void X86_64TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd,
   // Ulrich's document section 6.5 says that @gottpoff(%rip) must be
   // used in MOVQ or ADDQ instructions only.
   // "MOVQ foo@GOTTPOFF(%RIP), %REG" is transformed to "MOVQ $foo, %REG".
   // "ADDQ foo@GOTTPOFF(%RIP), %REG" is transformed to "LEAQ foo(%REG), %REG"
   // (if the register is not RSP/R12) or "ADDQ $foo, %RSP".
   // Opcodes info can be found at http://ref.x86asm.net/coder64.html#x48.
   uint8_t *Prefix = Loc - 3;
   uint8_t *Inst = Loc - 2;
void X86_64TargetInfo::relocateTlsIeToLe(uint8_t *Loc, uint8_t *BufEnd,
   else
     *Inst = IsMov ? 0xc7 : 0x8d;
   if (*Prefix == 0x4c)
     *Prefix = (IsMov || RspAdd) ? 0x49 : 0x4d;
   *RegSlot = (IsMov || RspAdd) ? (0xc0 | Reg) : (0x80 | Reg | (Reg << 3));
   relocateOne(Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
 }
 
+// This function applies a TLS relocation with an optimization as described
+// in the Ulrich's document. As a result of rewriting instructions at the
+// relocation target, relocations immediately follow the TLS relocation (which
+// would be applied to rewritten instructions) may have to be skipped.
+// This function returns a number of relocations that need to be skipped.
+unsigned X86_64TargetInfo::relocateTlsOptimize(uint8_t *Loc, uint8_t *BufEnd,
+                                               uint32_t Type, uint64_t P,
+                                               uint64_t SA) const {
+  switch (Type) {
+  case R_X86_64_GOTTPOFF:
+    relocateTlsIeToLe(Loc, BufEnd, P, SA);
+    return 0;
+  case R_X86_64_TLSLD:
+    relocateTlsLdToLe(Loc, BufEnd, P, SA);
+    // The next relocation should be against __tls_get_addr, so skip it
+    return 1;
+  case R_X86_64_TLSGD:
+    relocateTlsGdToLe(Loc, BufEnd, P, SA);
+    // The next relocation should be against __tls_get_addr, so skip it
+    return 1;
+  case R_X86_64_DTPOFF32:
+    relocateOne(Loc, BufEnd, R_X86_64_TPOFF32, P, SA);
+    return 0;
+  }
+  llvm_unreachable("Unknown TLS optimization");
+}
+
 void X86_64TargetInfo::relocateOne(uint8_t *Loc, uint8_t *BufEnd, uint32_t Type,
                                    uint64_t P, uint64_t SA) const {
   switch (Type) {
   case R_X86_64_PC32:
   case R_X86_64_GOTPCREL:
   case R_X86_64_PLT32:
   case R_X86_64_TLSLD:
   case R_X86_64_TLSGD:

lld/trunk/ELF/Writer.cpp

void Writer<ELFT>::scanRelocs(
   typedef Elf_Rel_Impl<ELFT, isRela> RelType;
   const ObjectFile<ELFT> &File = *C.getFile();
   for (const RelType &RI : Rels) {
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     SymbolBody *Body = File.getSymbolBody(SymIndex);
     uint32_t Type = RI.getType(Config->Mips64EL);
 
     if (Target->isTlsLocalDynamicReloc(Type)) {
+      if (Target->isTlsOptimized(Type, nullptr))
+        continue;
       if (Out<ELFT>::LocalModuleTlsIndexOffset == uint32_t(-1)) {
         Out<ELFT>::LocalModuleTlsIndexOffset =
             Out<ELFT>::Got->addLocalModuleTlsIndex();
         Out<ELFT>::RelaDyn->addReloc({&C, &RI});
       }
       continue;
     }
 
     // Set "used" bit for --as-needed.
     if (Body && Body->isUndefined() && !Body->isWeak())
       if (auto *S = dyn_cast<SharedSymbol<ELFT>>(Body->repl()))
         S->File->IsUsed = true;
 
     if (Body)
       Body = Body->repl();
 
     if (Body && Body->isTLS() && Target->isTlsGlobalDynamicReloc(Type)) {
+      if (Target->isTlsOptimized(Type, Body))
+        continue;
       if (Body->isInGot())
         continue;
       Out<ELFT>::Got->addDynTlsEntry(Body);
       Out<ELFT>::RelaDyn->addReloc({&C, &RI});
       Out<ELFT>::RelaDyn->addReloc({nullptr, nullptr});
       Body->setUsedInDynamicReloc();
       continue;
     }

lld/trunk/test/ELF/tls-opt.s

 // DISASM-NEXT: 1101c: 48 81 c4 f8 ff ff ff addq $-8, %rsp
 // DISASM-NEXT: 11023: 49 81 c4 f8 ff ff ff addq $-8, %r12
 // DISASM-NEXT: 1102a: 48 c7 c0 fc ff ff ff movq $-4, %rax
 // DISASM-NEXT: 11031: 49 c7 c7 fc ff ff ff movq $-4, %r15
 // DISASM-NEXT: 11038: 48 8d 80 fc ff ff ff leaq -4(%rax), %rax
 // DISASM-NEXT: 1103f: 4d 8d bf fc ff ff ff leaq -4(%r15), %r15
 // DISASM-NEXT: 11046: 48 81 c4 fc ff ff ff addq $-4, %rsp
 // DISASM-NEXT: 1104d: 49 81 c4 fc ff ff ff addq $-4, %r12
-
 // Corrupred output:
 // DISASM-NEXT: 11054: 48 8d 80 f8 ff ff ff leaq -8(%rax), %rax
 // DISASM-NEXT: 1105b: 48 d1 81 c4 f8 ff ff rolq -1852(%rcx)
 // DISASM-NEXT: 11062: ff 48 d1 decl -47(%rax)
 // DISASM-NEXT: 11065: 81 c4 f8 ff ff ff addl $4294967288, %esp
+// LD to LE:
+// DISASM-NEXT: 1106b: 66 66 66 64 48 8b 04 25 00 00 00 00 movq %fs:0, %rax
+// DISASM-NEXT: 11077: 48 8d 88 f8 ff ff ff                leaq -8(%rax), %rcx
+// DISASM-NEXT: 1107e: 66 66 66 64 48 8b 04 25 00 00 00 00 movq %fs:0, %rax
+// DISASM-NEXT: 1108a: 48 8d 88 fc ff ff ff                leaq -4(%rax), %rcx
+// GD to LE:
+// DISASM-NEXT: 11091: 64 48 8b 04 25 00 00 00 00          movq %fs:0, %rax
+// DISASM-NEXT: 1109a: 48 8d 80 f8 ff ff ff                leaq -8(%rax), %rax
+// DISASM-NEXT: 110a1: 64 48 8b 04 25 00 00 00 00          movq %fs:0, %rax
+// DISASM-NEXT: 110aa: 48 8d 80 fc ff ff ff                leaq -4(%rax), %rax
 
 .type tls0,@object
 .section .tbss,"awT",@nobits
 .globl tls0
 .align 4
 tls0:
  .long 0
  .size tls0, 4

  addq tls1@GOTTPOFF(%rip), %r15
  addq tls1@GOTTPOFF(%rip), %rsp
  addq tls1@GOTTPOFF(%rip), %r12
 
  //Invalid input case:
  xchgq tls0@gottpoff(%rip),%rax
  shlq tls0@gottpoff
  rolq tls0@gottpoff
+
+ //LD to LE:
+ leaq tls0@tlsld(%rip), %rdi
+ callq __tls_get_addr@PLT
+ leaq tls0@dtpoff(%rax),%rcx
+ leaq tls1@tlsld(%rip), %rdi
+ callq __tls_get_addr@PLT
+ leaq tls1@dtpoff(%rax),%rcx
+
+ //GD to LE:
+ .byte 0x66
+ leaq tls0@tlsgd(%rip),%rdi
+ .word 0x6666
+ rex64
+ call __tls_get_addr@plt
+ .byte 0x66
+ leaq tls1@tlsgd(%rip),%rdi
+ .word 0x6666
+ rex64
+ call __tls_get_addr@plt