[lld][ELF][ARM] Implement static (initial exec) TLS model

[denis-protivensky]

Summary

Implement static TLS model for ARM. This includes handling of R_ARM_TLS_IE32 and R_ARM_TLS_LE32 relocs.

[ruiu]

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

325 ↗

(On Diff #22014)

Off topic, but I always wonder if we want to sprinkle debug outputs like this in the ELF writers. They are longer than actual code and might be too verbose.

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

116 ↗

(On Diff #22014)

Can you move the definition of ARMGotAtomContent here as a static local variable?

205 ↗

(On Diff #22014)

Can ref.target() return a null pointer? If not, you want to use dyn_cast instead of dyn_cast_or_null.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

41 ↗

(On Diff #22014)

If TP_TLS section is not found, it seems that this line will fail because tpOff has no value. Maybe you want to return a new _tpOff from the innermost block in the for loop and replace this line with llvm_unreachable?

Also you might want to use early return.

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

116 ↗

(On Diff #22014)

Good.

205 ↗

(On Diff #22014)

I think it shouldn't return null pointer. Some implementations use dyn_cast_or_null, this might have confused me. Will change to dyn_cast.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

41 ↗

(On Diff #22014)

You're right that it's better to have llvm_unreachable than fail with unknown error. Will change.

[denis-protivensky]

lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

325 ↗

(On Diff #22014)

I occasionally read them to find values used for some related groups of relocs when I don't want to debug or see that this will be faster than debugging.

[denis-protivensky]

Updated:

• reworked the code of tp_off calculation
• replaced dyn_cast_or_null with dyn_cast

Didn't change atom content variables to be static class variables because it becomes inconsistent with other platforms, and there are more places to change, so the diff will grow for no reason. I can update it further in a separate commit if requested.

[ruiu]

LGTM

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

207 ↗

(On Diff #22082)

I guess early return is preferred. You can return std::error_code() here so that you can remove "else" below.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

37 ↗

(On Diff #22082)

Can you add braces after this for?

[shankarke]

lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

50 ↗

(On Diff #22082)

only class declarations are allowed to be under anonymous namespace.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

33 ↗

(On Diff #22082)

you can remove the const and remove mutable from _tpOff too.

[denis-protivensky]

Updated:

• removed const and mutable in getTPOffset and made style cleanup
• made global variables static and out of anonymous namespace
• use early return in handleTLSIE32

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

33 ↗

(On Diff #22082)

I will do that, but I think lazy initialization is the case where using mutables does make sense.

[• shankar.easwaran]

LGTM

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.h

 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
 
 template <class ELFT> class ARMTargetLayout;
 
 class ARMTargetRelocationHandler final
     : public TargetRelocationHandler {
 public:
+  ARMTargetRelocationHandler(ARMTargetLayout<ARMELFType> &layout)
+      : _armLayout(layout) {}
+
   std::error_code applyRelocation(ELFWriter &, llvm::FileOutputBuffer &,
                                   const lld::AtomLayout &,
                                   const Reference &) const override;
+
+private:
+  ARMTargetLayout<ARMELFType> &_armLayout;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_RELOCATION_HANDLER_H

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationHandler.cpp

static Reference::Addend readAddend_THM_JUMP11(const uint8_t *location) {
   return llvm::SignExtend32<12>(imm11 << 1);
 }
 
 static Reference::Addend readAddend(const uint8_t *location,
                                     Reference::KindValue kindValue) {
   switch (kindValue) {
   case R_ARM_ABS32:
   case R_ARM_REL32:
+  case R_ARM_TLS_IE32:
+  case R_ARM_TLS_LE32:
     return (int32_t)read32le(location);
   case R_ARM_PREL31:
     return (int32_t)(read32le(location) & 0x7FFFFFFF);
   case R_ARM_THM_CALL:
   case R_ARM_THM_JUMP24:
     return readAddend_THM_CALL(location);
   case R_ARM_THM_JUMP11:
     return readAddend_THM_JUMP11(location);
DEBUG_WITH_TYPE(
       "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
       llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
       llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
       llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
       llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
   return relocR_ARM_THM_MOV(location, arg);
 }
 
+/// \brief R_ARM_TLS_IE32 - GOT(S) + A - P => S + A - P
+static void relocR_ARM_TLS_IE32(uint8_t *location, uint64_t P, uint64_t S,
+                                int64_t A) {
+  uint32_t result = (uint32_t)(S + A - P);
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
+  applyArmReloc(location, result);
+}
+
+/// \brief R_ARM_TLS_LE32 - S + A - tp => S + A + tpoff
+static void relocR_ARM_TLS_LE32(uint8_t *location, uint64_t P, uint64_t S,
+                                int64_t A, uint64_t tpoff) {
+  uint32_t result = (uint32_t)(S + A + tpoff);
+
+  DEBUG_WITH_TYPE(
+      "ARM", llvm::dbgs() << "\t\tHandle " << LLVM_FUNCTION_NAME << " -";
+      llvm::dbgs() << " S: 0x" << Twine::utohexstr(S);
+      llvm::dbgs() << " A: 0x" << Twine::utohexstr(A);
+      llvm::dbgs() << " P: 0x" << Twine::utohexstr(P);
+      llvm::dbgs() << " result: 0x" << Twine::utohexstr(result) << "\n");
+  applyArmReloc(location, result);
+}
+
 std::error_code ARMTargetRelocationHandler::applyRelocation(
     ELFWriter &writer, llvm::FileOutputBuffer &buf, const lld::AtomLayout &atom,
     const Reference &ref) const {
   uint8_t *atomContent = buf.getBufferStart() + atom._fileOffset;
   uint8_t *location = atomContent + ref.offsetInAtom();
   uint64_t targetVAddress = writer.addressOfAtom(ref.target());
   uint64_t relocVAddress = atom._virtualAddr + ref.offsetInAtom();
 
case R_ARM_THM_MOVW_ABS_NC:
     break;
   case R_ARM_THM_MOVT_ABS:
     relocR_ARM_THM_MOVT_ABS(location, relocVAddress, targetVAddress, addend);
     break;
   case R_ARM_PREL31:
     relocR_ARM_PREL31(location, relocVAddress, targetVAddress, addend,
                      addressesThumb);
     break;
+  case R_ARM_TLS_IE32:
+    relocR_ARM_TLS_IE32(location, relocVAddress, targetVAddress, addend);
+    break;
+  case R_ARM_TLS_LE32:
+    relocR_ARM_TLS_LE32(location, relocVAddress, targetVAddress, addend,
+                        _armLayout.getTPOffset());
+    break;
   default:
     return make_unhandled_reloc_error();
   }
 
   return std::error_code();
 }

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Debug.h"
 
 using namespace lld;
 using namespace lld::elf;
 using namespace llvm::ELF;
 
-namespace {
 // ARM B/BL instructions of static relocation veneer.
 // TODO: consider different instruction set for archs below ARMv5
 // (one as for Thumb may be used though it's less optimal).
-const uint8_t Veneer_ARM_B_BL_StaticAtomContent[8] = {
+static const uint8_t Veneer_ARM_B_BL_StaticAtomContent[8] = {
     0x04, 0xf0, 0x1f, 0xe5,  // ldr pc, [pc, #-4]
     0x00, 0x00, 0x00, 0x00   // <target_symbol_address>
 };
 
 // Thumb B/BL instructions of static relocation veneer.
 // TODO: consider different instruction set for archs above ARMv5
 // (one as for ARM may be used since it's more optimal).
-const uint8_t Veneer_THM_B_BL_StaticAtomContent[8] = {
+static const uint8_t Veneer_THM_B_BL_StaticAtomContent[8] = {
     0x78, 0x47,              // bx pc
     0x00, 0x00,              // nop
     0xfe, 0xff, 0xff, 0xea   // b <target_symbol_address>
 };
 
+// .got values
+static const uint8_t ARMGotAtomContent[4] = {0};
+
+namespace {
 /// \brief Atoms that hold veneer code.
 class VeneerAtom : public SimpleELFDefinedAtom {
   StringRef _section;
 
 public:
   VeneerAtom(const File &f, StringRef secName)
       : SimpleELFDefinedAtom(f), _section(secName) {}
 
DefinedAtom::CodeModel codeModel() const override {
     return DefinedAtom::codeARMThumb;
   }
 
   ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(Veneer_THM_B_BL_StaticAtomContent);
   }
 };
 
+/// \brief Atoms that are used by ARM dynamic linking
+class ARMGOTAtom : public GOTAtom {
+public:
+  ARMGOTAtom(const File &f, StringRef secName) : GOTAtom(f, secName) {}
+
+  ArrayRef<uint8_t> rawContent() const override {
+    return llvm::makeArrayRef(ARMGotAtomContent);
+  }
+
+  Alignment alignment() const override { return Alignment(2); }
+};
+
 class ELFPassFile : public SimpleFile {
 public:
   ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
void handleReference(const DefinedAtom &atom, const Reference &ref) {
     if (ref.kindNamespace() != Reference::KindNamespace::ELF)
       return;
     assert(ref.kindArch() == Reference::KindArch::ARM);
     switch (ref.kindValue()) {
     case R_ARM_JUMP24:
     case R_ARM_THM_JUMP24:
       static_cast<Derived *>(this)->handleVeneer(atom, ref);
       break;
+    case R_ARM_TLS_IE32:
+      static_cast<Derived *>(this)->handleTLSIE32(ref);
+      break;
     }
   }
 
 protected:
   std::error_code handleVeneer(const DefinedAtom &atom, const Reference &ref) {
     // Target symbol and relocated place should have different
     // instruction sets in order a veneer to be generated in between.
-    const auto *target = dyn_cast_or_null<DefinedAtom>(ref.target());
+    const auto *target = dyn_cast<DefinedAtom>(ref.target());
     if (!target || target->codeModel() == atom.codeModel())
       return std::error_code();
 
     // TODO: For unconditional jump instructions (R_ARM_CALL and R_ARM_THM_CALL)
     // fixup isn't possible without veneer generation for archs below ARMv5.
 
     // Veneers may only be generated for STT_FUNC target symbols
     // or for symbols located in sections different to the place of relocation.
default:
       llvm_unreachable("Unhandled reference type for veneer generation");
     }
 
     assert(veneer && "The veneer is not set");
     const_cast<Reference &>(ref).setTarget(veneer);
     return std::error_code();
   }
 
+  std::error_code handleTLSIE32(const Reference &ref) {
+    if (const auto *target = dyn_cast<DefinedAtom>(ref.target())) {
+      const_cast<Reference &>(ref).setTarget(
+          static_cast<Derived *>(this)->getTLSTPOFF32(target));
+      return std::error_code();
+    }
+    llvm_unreachable("R_ARM_TLS_IE32 reloc targets wrong atom type");
+  }
+
+  /// \brief Create a GOT entry for TLS with reloc type and addend specified.
+  template <Reference::KindValue R_ARM_TLS, Reference::Addend A = 0>
+  const GOTAtom *getGOTTLSEntry(const DefinedAtom *da) {
+    auto got = _gotMap.find(da);
+    if (got != _gotMap.end())
+      return got->second;
+    auto g = new (_file._alloc) ARMGOTAtom(_file, ".got");
+    g->addReferenceELF_ARM(R_ARM_TLS, 0, da, A);
+#ifndef NDEBUG
+    g->_name = "__got_tls_";
+    g->_name += da->name();
+#endif
+    _gotMap[da] = g;
+    _gotVector.push_back(g);
+    return g;
+  }
+
 public:
   ARMRelocationPass(const ELFLinkingContext &ctx) : _file(ctx), _ctx(ctx) {}
 
   /// \brief Do the pass.
   ///
   /// The goal here is to first process each reference individually. Each call
   /// to handleReference may modify the reference itself and/or create new
   /// atoms which must be stored in one of the maps below.
void perform(std::unique_ptr<MutableFile> &mf) override {
     for (const auto &atom : mf->defined()) {
       for (const auto &ref : *atom) {
         handleReference(*atom, *ref);
       }
     }
 
     // Add all created atoms to the link.
     uint64_t ordinal = 0;
+    for (auto &got : _gotVector) {
+      got->setOrdinal(ordinal++);
+      mf->addAtom(*got);
+    }
     for (auto &veneer : _veneerVector) {
       veneer->setOrdinal(ordinal++);
       mf->addAtom(*veneer);
     }
   }
 
 protected:
   /// \brief Owner of all the Atoms created by this pass.
   ELFPassFile _file;
   const ELFLinkingContext &_ctx;
 
+  /// \brief Map Atoms to their GOT entries.
+  llvm::DenseMap<const Atom *, GOTAtom *> _gotMap;
+
   /// \brief Map Atoms to their veneers.
   llvm::DenseMap<const Atom *, VeneerAtom *> _veneerMap;
 
+  /// \brief the list of GOT/PLT atoms
+  std::vector<GOTAtom *> _gotVector;
+
   /// \brief the list of veneer atoms.
   std::vector<VeneerAtom *> _veneerVector;
 };
 
 /// This implements the static relocation model. Meaning GOT and PLT entries are
 /// not created for references that can be directly resolved. These are
 /// converted to a direct relocation. For entries that do require a GOT or PLT
 /// entry, that entry is statically bound.
const VeneerAtom *getVeneer_THM_B_BL(const DefinedAtom *da,
     v->_name = "__";
     v->_name += da->name();
     v->_name += "_from_thumb";
 
     _veneerMap[da] = v;
     _veneerVector.push_back(v);
     return v;
   }
+
+  /// \brief Create a GOT entry for R_ARM_TLS_TPOFF32 reloc.
+  const GOTAtom *getTLSTPOFF32(const DefinedAtom *da) {
+    return getGOTTLSEntry<R_ARM_TLS_LE32>(da);
+  }
 };
 
 } // end of anon namespace
 
 std::unique_ptr<Pass>
 lld::elf::createARMRelocationPass(const ARMLinkingContext &ctx) {
   switch (ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
     if (ctx.isDynamic())
       llvm_unreachable("Unhandled output file type");
     return llvm::make_unique<ARMStaticRelocationPass>(ctx);
   default:
     llvm_unreachable("Unhandled output file type");
   }
 }

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
 class ARMLinkingContext;
 
 template <class ELFT> class ARMTargetLayout : public TargetLayout<ELFT> {
 public:
   ARMTargetLayout(ARMLinkingContext &context)
       : TargetLayout<ELFT>(context) {}
+
+  uint64_t getTPOffset() {
+    if (_tpOff.hasValue())
+      return *_tpOff;
+
+    for (const auto &phdr : *this->_programHeader) {
+      if (phdr->p_type == llvm::ELF::PT_TLS) {
+        _tpOff = llvm::RoundUpToAlignment(TCB_SIZE, phdr->p_align);
+        return *_tpOff;
+      }
+    }
+    llvm_unreachable("TLS segment not found");
+  }
+
+private:
+  // TCB block size of the TLS.
+  enum { TCB_SIZE = 0x8 };
+
+  // Cached value of the TLS offset from the $tp pointer.
+  llvm::Optional<uint64_t> _tpOff;
 };
 
 class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
 public:
   ARMTargetHandler(ARMLinkingContext &context);
 
   ARMTargetLayout<ARMELFType> &getTargetLayout() override {
     return *(_armTargetLayout.get());

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp

 #include "ARMLinkingContext.h"
 
 using namespace lld;
 using namespace elf;
 
 ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &context)
     : _context(context), _armTargetLayout(
           new ARMTargetLayout<ARMELFType>(context)),
-      _armRelocationHandler(new ARMTargetRelocationHandler()) {}
+      _armRelocationHandler(new ARMTargetRelocationHandler(
+          *_armTargetLayout.get())) {}
 
 void ARMTargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::ARM,
                         kindStrings);
 }
 
 std::unique_ptr<Writer> ARMTargetHandler::getWriter() {
   switch (this->_context.getOutputELFType()) {

lld/trunk/test/elf/ARM/rel-tls-ie32.test

+# Check handling of R_ARM_TLS_IE32 relocation.
+# RUN: yaml2obj -format=elf -docnum 1 %s > %t-tls.o
+# RUN: yaml2obj -format=elf -docnum 2 %s > %t-tlsv.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-tls.o %t-tlsv.o -o %t
+# RUN: llvm-objdump -s -t %t | FileCheck %s
+
+# CHECK: Contents of section .got:
+# CHECK: 401008 08000000 0c000000
+#  tp_off(i) = 0x08 ^^     ^^ tp_off(j) = 0x0c
+#               tp_off(i) + sizeof(i) =  tp_off(j)
+#                 0x08    +   0x04    =    0x0c
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400094 g     F .text  {{[0-9a-f]+}} main
+# CHECK: 00000000 g       .tdata 00000004 i
+#                  sizeof(i) = 0x04 ^^
+# CHECK: 00000004 g       .tdata 00000004 j
+
+# tls.o
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         80B400AF0C4B7B441B681DEE702FD2580A4B7B441B681DEE701FCB581A44084B7B441B681DEE701FCB585B0013441846BD465DF8047B70472E000000260000001C000000
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000038
+        Symbol:          i
+        Type:            R_ARM_TLS_IE32
+      - Offset:          0x000000000000003C
+        Symbol:          i
+        Type:            R_ARM_TLS_IE32
+      - Offset:          0x0000000000000040
+        Symbol:          j
+        Type:            R_ARM_TLS_IE32
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+Symbols:
+  Global:
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+      Value:           0x0000000000000001
+    - Name:            i
+      Type:            STT_TLS
+    - Name:            j
+      Type:            STT_TLS
+
+# tlsv.o
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .tdata
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
+    AddressAlign:    0x0000000000000004
+    Content:         05000000FBFFFFFF
+Symbols:
+  Global:
+    - Name:            i
+      Type:            STT_TLS
+      Section:         .tdata
+      Size:            0x0000000000000004
+    - Name:            j
+      Type:            STT_TLS
+      Section:         .tdata
+      Value:           0x0000000000000004
+      Size:            0x0000000000000004
+...

lld/trunk/test/elf/ARM/rel-tls-le32.test

+# Check handling of R_ARM_TLS_LE32 relocation.
+# RUN: yaml2obj -format=elf %s > %t-o.o
+# RUN: lld -flavor gnu -target arm -m armelf_linux_eabi -Bstatic \
+# RUN: --noinhibit-exec %t-o.o -o %t
+# RUN: llvm-objdump -s -t %t | FileCheck %s
+
+# CHECK: Contents of section .text:
+# CHECK: 4000b4 {{[0-9a-f]+}} 08000000
+#              tp_off = 0x000008 ^^
+# CHECK: SYMBOL TABLE:
+# CHECK: 00400094 g     F .text  {{[0-9a-f]+}} main
+# CHECK: 00000000 g       .tdata 00000004 i
+
+---
+FileHeader:
+  Class:           ELFCLASS32
+  Data:            ELFDATA2LSB
+  Type:            ET_REL
+  Machine:         EM_ARM
+  Flags:           [ EF_ARM_EABI_VER5 ]
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    AddressAlign:    0x0000000000000004
+    Content:         04B02DE500B08DE2703F1DEE10209FE5023093E70300A0E100D04BE204B09DE41EFF2FE100000000
+  - Name:            .rel.text
+    Type:            SHT_REL
+    Link:            .symtab
+    AddressAlign:    0x0000000000000004
+    Info:            .text
+    Relocations:
+      - Offset:          0x0000000000000024
+        Symbol:          i
+        Type:            R_ARM_TLS_LE32
+        Addend:          0
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC ]
+    AddressAlign:    0x0000000000000001
+    Content:         ''
+  - Name:            .tdata
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_WRITE, SHF_ALLOC, SHF_TLS ]
+    AddressAlign:    0x0000000000000004
+    Content:         '05000000'
+Symbols:
+  Global:
+    - Name:            i
+      Type:            STT_TLS
+      Section:         .tdata
+      Size:            0x0000000000000004
+    - Name:            main
+      Type:            STT_FUNC
+      Section:         .text
+...