[lld-macho] Fix TLV data initialization

[int3]

Summary

We were mishandling the case where both __tbss and __thread_data sections were
present.

TLVP relocations should be encoded as offsets from the start of __thread_data,
even if the symbol is actually located in __thread_bss. Previously, we were
writing the offset from the start of the containing section, which doesn't
really make sense since there's no way tlv_get_addr() can know which section a
given tlv$init symbol is in at runtime.

In addition, this patch ensures that we place __thread_data immediately before
__thread_bss. This is what ld64 does, likely for performance reasons. Zerofill
sections must also be at the end of their segments; we were already doing this,
but now we ensure that __thread_bss occurs before __bss, so that it's always
possible to have it contiguous with __thread_data.

Fixes llvm.org/PR48657.

[int3]

lld/MachO/Writer.cpp

590–593

ld64 has logic that does this, but I have no idea how we can actually test it -- it doesn't look like it's possible to create arbitrary S_ZEROFILL sections from assembly, at least if I'm reading MCSectionMachO.cpp correctly. I could remove this / replace it with an assert if anyone cares.

[smeenai]

lld/MachO/Writer.cpp

590–593

There's a .zerofill directive ... does that do what you want?

[int3]

lld/MachO/Writer.cpp

590–593

ooh yeah it does. I had been looking for modifiers to the .section directive... thanks!

[int3]

update bss.s test

[thakis]

Very nice!

lld/MachO/InputSection.cpp

50

fwiw I think of it as a single thread-local data memory area – it's kind of more like a segment than a section I suppose, and it implicitly consists of DATA,thread_data and DATA,thread_bss (and, per dyld code, everything in between -- which is why we don't want anything in between, since that'd uselessly waste memory)

lld/MachO/InputSection.h

78

very nit: swap order of ZEROFILL and REGULAR since REGULAR comes first in the TLV area in memory :)

lld/MachO/Writer.cpp

565

Are there zerofill sections in segments other than __DATA? __DATA_CONST I guess, but that can't be TLV. (I'm wondering about the plural "segments" here.)

[int3]

rephrase

lld/MachO/InputSection.cpp

50

good point -- rephrased

lld/MachO/Writer.cpp

565

"segments" is plural here because zerofill sections must be at the end of their segments regardless of which segment it is and whether they contain TLV. I'm speaking in generalities :)

(The bss.s test has a test for zerofill at in a non-__DATA segment.)

lld/MachO/InputSection.h

public:
 
   uint32_t align = 1;
   uint32_t flags = 0;
 
   ArrayRef<uint8_t> data;
   std::vector<Reloc> relocs;
 };
 
+inline uint8_t sectionType(uint32_t flags) {
+  return flags & llvm::MachO::SECTION_TYPE;
+}
+
 inline bool isZeroFill(uint32_t flags) {
-  return llvm::MachO::isVirtualSection(flags & llvm::MachO::SECTION_TYPE);
+  return llvm::MachO::isVirtualSection(sectionType(flags));
 }
 
 inline bool isThreadLocalVariables(uint32_t flags) {
-  return (flags & llvm::MachO::SECTION_TYPE) ==
-         llvm::MachO::S_THREAD_LOCAL_VARIABLES;
+  return sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_VARIABLES;
+}
+
+// These sections contain the data for initializing thread-local variables.
+inline bool isThreadLocalData(uint32_t flags) {
+  return sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_REGULAR ||
+         sectionType(flags) == llvm::MachO::S_THREAD_LOCAL_ZEROFILL;
 }
 
 inline bool isDebugSection(uint32_t flags) {
   return (flags & llvm::MachO::SECTION_ATTRIBUTES_USR) ==
          llvm::MachO::S_ATTR_DEBUG;
 }
 
 bool isCodeSection(InputSection *);

lld/MachO/InputSection.cpp

 //===- InputSection.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputSection.h"
 #include "InputFiles.h"
 #include "OutputSegment.h"
 #include "Symbols.h"
 #include "Target.h"
+#include "Writer.h"
 #include "lld/Common/Memory.h"
 #include "llvm/Support/Endian.h"
 
 using namespace llvm;
 using namespace llvm::MachO;
 using namespace llvm::support;
 using namespace lld;
 using namespace lld::macho;
void InputSection::writeTo(uint8_t *buf) {
 
   for (Reloc &r : relocs) {
     uint64_t referentVA = 0;
     if (auto *referentSym = r.referent.dyn_cast<Symbol *>()) {
       referentVA =
           target->resolveSymbolVA(buf + r.offset, *referentSym, r.type);
 
       if (isThreadLocalVariables(flags)) {
-        // References from thread-local variable sections are treated
-        // as offsets relative to the start of the referent section,
-        // instead of as absolute addresses.
+        // References from thread-local variable sections are treated as offsets
+        // relative to the start of the thread-local data memory area, which
+        // is initialized via copying all the TLV data sections (which are all
+        // contiguous).
         if (auto *defined = dyn_cast<Defined>(referentSym))
-          referentVA -= defined->isec->parent->addr;
+          referentVA -= firstTLVDataSection->addr;
       }
     } else if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
       referentVA = referentIsec->getVA();
     }
 
     uint64_t referentVal = referentVA + r.addend;
     if (r.pcrel)
       referentVal -= getVA() + r.offset;

lld/MachO/Writer.h

 //===- Writer.h -------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_MACHO_WRITER_H
 #define LLD_MACHO_WRITER_H
 
 #include <cstdint>
 
 namespace lld {
 namespace macho {
 
+class OutputSection;
+
 class LoadCommand {
 public:
   virtual ~LoadCommand() = default;
   virtual uint32_t getSize() const = 0;
   virtual void writeTo(uint8_t *buf) const = 0;
 };
 
 void writeResult();
 
 void createSyntheticSections();
 
+extern OutputSection *firstTLVDataSection;
+
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/Writer.cpp

static int sectionOrder(OutputSection *osec) {
   StringRef segname = osec->parent->name;
   // Sections are uniquely identified by their segment + section name.
   if (segname == segment_names::text) {
     return StringSwitch<int>(osec->name)
         .Case(section_names::header, -1)
         .Case(section_names::unwindInfo, std::numeric_limits<int>::max() - 1)
         .Case(section_names::ehFrame, std::numeric_limits<int>::max())
         .Default(0);
+  } else if (segname == segment_names::data) {
+    // For each thread spawned, dyld will initialize its TLVs by copying the
+    // address range from the start of the first thread-local data section to
+    // the end of the last one. We therefore arrange these sections contiguously
+    // to minimize the amount of memory used. Additionally, since zerofill
+    // sections must be at the end of their segments, and since TLV data
+    // sections can be zerofills, we end up putting all TLV data sections at the
+    // end of the segment.
+    switch (sectionType(osec->flags)) {
+    case S_THREAD_LOCAL_REGULAR:
+      return std::numeric_limits<int>::max() - 2;
+    case S_THREAD_LOCAL_ZEROFILL:
+      return std::numeric_limits<int>::max() - 1;
+    case S_ZEROFILL:
+      return std::numeric_limits<int>::max();
+    default:
+      return 0;
+    }
   } else if (segname == segment_names::linkEdit) {
     return StringSwitch<int>(osec->name)
         .Case(section_names::rebase, -8)
         .Case(section_names::binding, -7)
         .Case(section_names::weakBinding, -6)
         .Case(section_names::lazyBinding, -5)
         .Case(section_names::export_, -4)
         .Case(section_names::symbolTable, -3)
         .Case(section_names::indirectSymbolTable, -2)
         .Case(section_names::stringTable, -1)
         .Default(0);
   }
   // ZeroFill sections must always be the at the end of their segments,
   // otherwise subsequent sections may get overwritten with zeroes at runtime.
-  if (isZeroFill(osec->flags))
+  if (sectionType(osec->flags) == S_ZEROFILL)
     return std::numeric_limits<int>::max();
   return 0;
 }
 
 template <typename T, typename F>
 static std::function<bool(T, T)> compareByOrder(F ord) {
   return [=](T a, T b) { return ord(a) < ord(b); };
 }
 
static void sortSegmentsAndSections() {
   for (OutputSegment *seg : outputSegments) {
     seg->sortOutputSections(compareByOrder<OutputSection *>(sectionOrder));
     for (auto *osec : seg->getSections()) {
       // Now that the output sections are sorted, assign the final
       // output section indices.
       if (!osec->isHidden())
         osec->index = ++sectionIndex;
 
+      if (!firstTLVDataSection && isThreadLocalData(osec->flags))
+        firstTLVDataSection = osec;
+
       if (!isecPriorities.empty()) {
         if (auto *merged = dyn_cast<MergedOutputSection>(osec)) {
           llvm::stable_sort(merged->inputs,
                             [&](InputSection *a, InputSection *b) {
                               return isecPriorities[a] > isecPriorities[b];
                             });
         }
       }
void macho::createSyntheticSections() {
   in.exports = make<ExportSection>();
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.imageLoaderCache = make<ImageLoaderCacheSection>();
 }
+
+OutputSection *macho::firstTLVDataSection = nullptr;

lld/test/MachO/bss.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t.o
 # RUN: %lld -o %t %t.o
 # RUN: llvm-readobj --section-headers --macho-segment %t | FileCheck %s
 
-## Check that __bss takes up zero file size, is at file offset zero, and
-## appears at the end of its segment.
+## Check that __bss takes up zero file size, is at file offset zero, and appears
+## at the end of its segment. Also check that __tbss is placed immediately
+## before it.
+## Zerofill sections in other segments (i.e. not __DATA) should also be placed
+## at the end.
 
 # CHECK:        Index: 1
 # CHECK-NEXT:   Name: __data
 # CHECK-NEXT:   Segment: __DATA
 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Size: 0x8
 # CHECK-NEXT:   Offset: 4096
 # CHECK-NEXT:   Alignment: 0
 # CHECK-NEXT:   RelocationOffset: 0x0
 # CHECK-NEXT:   RelocationCount: 0
 # CHECK-NEXT:   Type: Regular (0x0)
 # CHECK-NEXT:   Attributes [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Reserved1: 0x0
 # CHECK-NEXT:   Reserved2: 0x0
 # CHECK-NEXT:   Reserved3: 0x0
 
 # CHECK:        Index: 2
+# CHECK-NEXT:   Name: __thread_bss
+# CHECK-NEXT:   Segment: __DATA
+# CHECK-NEXT:   Address:
+# CHECK-NEXT:   Size: 0x4
+# CHECK-NEXT:   Offset: 0
+# CHECK-NEXT:   Alignment: 0
+# CHECK-NEXT:   RelocationOffset: 0x0
+# CHECK-NEXT:   RelocationCount: 0
+# CHECK-NEXT:   Type: ThreadLocalZerofill (0x12)
+# CHECK-NEXT:   Attributes [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Reserved1: 0x0
+# CHECK-NEXT:   Reserved2: 0x0
+# CHECK-NEXT:   Reserved3: 0x0
+
+# CHECK:        Index: 3
 # CHECK-NEXT:   Name: __bss
 # CHECK-NEXT:   Segment: __DATA
 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Size: 0x8
 # CHECK-NEXT:   Offset: 0
 # CHECK-NEXT:   Alignment: 0
 # CHECK-NEXT:   RelocationOffset: 0x0
 # CHECK-NEXT:   RelocationCount: 0
 # CHECK-NEXT:   Type: ZeroFill (0x1)
 # CHECK-NEXT:   Attributes [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Reserved1: 0x0
 # CHECK-NEXT:   Reserved2: 0x0
 # CHECK-NEXT:   Reserved3: 0x0
 
-# CHECK:        Index: 3
-# CHECK-NEXT:   Name: __thread_bss
-# CHECK-NEXT:   Segment: __DATA
-# CHECK-NEXT:   Address: 0x100001010
-# CHECK-NEXT:   Size: 0x4
+# CHECK:        Index: 4
+# CHECK-NEXT:   Name: foo
+# CHECK-NEXT:   Segment: FOO
+# CHECK-NEXT:   Address:
+# CHECK-NEXT:   Size: 0x8
+# CHECK-NEXT:   Offset: 8192
+# CHECK-NEXT:   Alignment: 0
+# CHECK-NEXT:   RelocationOffset: 0x0
+# CHECK-NEXT:   RelocationCount: 0
+# CHECK-NEXT:   Type: Regular (0x0)
+# CHECK-NEXT:   Attributes [ (0x0)
+# CHECK-NEXT:   ]
+# CHECK-NEXT:   Reserved1: 0x0
+# CHECK-NEXT:   Reserved2: 0x0
+# CHECK-NEXT:   Reserved3: 0x0
+
+# CHECK:        Index: 5
+# CHECK-NEXT:   Name: bss
+# CHECK-NEXT:   Segment: FOO
+# CHECK-NEXT:   Address:
+# CHECK-NEXT:   Size: 0x8
 # CHECK-NEXT:   Offset: 0
 # CHECK-NEXT:   Alignment: 0
 # CHECK-NEXT:   RelocationOffset: 0x0
 # CHECK-NEXT:   RelocationCount: 0
-# CHECK-NEXT:   Type: ThreadLocalZerofill (0x12)
+# CHECK-NEXT:   Type: ZeroFill (0x1)
 # CHECK-NEXT:   Attributes [ (0x0)
 # CHECK-NEXT:   ]
 # CHECK-NEXT:   Reserved1: 0x0
 # CHECK-NEXT:   Reserved2: 0x0
 # CHECK-NEXT:   Reserved3: 0x0
 
 # CHECK:      Name: __DATA
 # CHECK-NEXT: Size:
 # CHECK-NEXT: vmaddr:
 # CHECK-NEXT: vmsize: 0x14
 # CHECK-NEXT: fileoff:
 # CHECK-NEXT: filesize: 8
 
+# CHECK:      Name: FOO
+# CHECK-NEXT: Size:
+# CHECK-NEXT: vmaddr:
+# CHECK-NEXT: vmsize: 0x10
+# CHECK-NEXT: fileoff:
+# CHECK-NEXT: filesize: 8
+
 .globl _main
 
 .text
 _main:
   movq $0, %rax
   retq
 
 .bss
 .zero 4
 
 .tbss _foo, 4
 .zero 4
 
 .data
 .quad 0x1234
+
+.zerofill FOO,bss,_zero_foo,0x8
+
+.section FOO,foo
+.quad 123

lld/test/MachO/tlv.s

 # REQUIRES: x86
-# RUN: mkdir -p %t
-# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/test.o
-
-# RUN: %lld -lSystem -o %t/test %t/test.o
-# RUN: llvm-readobj --file-headers %t/test | FileCheck %s --check-prefix=HEADER
-# RUN: llvm-objdump -D --bind --rebase %t/test | FileCheck %s
-
-# RUN: %lld -lSystem -pie -o %t/test %t/test.o
-# RUN: llvm-readobj --file-headers %t/test | FileCheck %s --check-prefix=HEADER
-# RUN: llvm-objdump -D --bind --rebase %t/test | FileCheck %s
+# RUN: rm -rf %t; split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/regular.s -o %t/regular.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/tbss.s -o %t/tbss.o
+
+# RUN: %lld -lSystem -no_pie -o %t/regular %t/regular.o
+# RUN: llvm-readobj --file-headers %t/regular | FileCheck %s --check-prefix=HEADER
+# RUN: llvm-objdump -d --bind --rebase %t/regular | FileCheck %s --check-prefixes=REG,LINKEDIT
+# RUN: llvm-objdump --macho --section=__DATA,__thread_vars %t/regular | \
+# RUN:   FileCheck %s --check-prefix=REG-TLVP
+
+# RUN: %lld -lSystem -pie %t/regular.o -o %t/regular-pie
+# RUN: llvm-readobj --file-headers %t/regular-pie | FileCheck %s --check-prefix=HEADER
+# RUN: llvm-objdump -d --bind --rebase %t/regular-pie | FileCheck %s --check-prefixes=REG,LINKEDIT
+# RUN: llvm-objdump --macho --section=__DATA,__thread_vars %t/regular-pie | \
+# RUN:   FileCheck %s --check-prefix=REG-TLVP
+
+# RUN: %lld -lSystem %t/tbss.o -o %t/tbss -e _f
+# RUN: llvm-objdump -d --bind --rebase %t/tbss | FileCheck %s --check-prefixes=TBSS,LINKEDIT
+# RUN: llvm-objdump --macho --section=__DATA,__thread_vars %t/tbss | \
+# RUN:   FileCheck %s --check-prefix=TBSS-TLVP
+
+# RUN: %lld -lSystem %t/regular.o %t/tbss.o -o %t/regular-and-tbss
+# RUN: llvm-objdump -d --bind --rebase %t/regular-and-tbss | FileCheck %s --check-prefixes=REG,TBSS,LINKEDIT
+# RUN: llvm-objdump --macho --section=__DATA,__thread_vars %t/regular-and-tbss | \
+# RUN:   FileCheck %s --check-prefix=REG-TBSS-TLVP
+# RUN: llvm-objdump --section-headers %t/regular-and-tbss | FileCheck %s --check-prefix=SECTION-ORDER
+
+## Check that we always put __thread_bss immediately after __thread_data,
+## regardless of the order of the input files.
+# RUN: %lld -lSystem %t/tbss.o %t/regular.o -o %t/regular-and-tbss
+# RUN: llvm-objdump --section-headers %t/regular-and-tbss | FileCheck %s --check-prefix=SECTION-ORDER
 
 # HEADER: MH_HAS_TLV_DESCRIPTORS
 
-# CHECK:       Disassembly of section __TEXT,__text:
-# CHECK-EMPTY:
-# CHECK-NEXT:  <_main>:
-# CHECK-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_foo>
-# CHECK-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_bar>
-# CHECK-NEXT:  retq
-# CHECK-EMPTY:
-# CHECK-NEXT:  Disassembly of section __DATA,__thread_data:
-# CHECK-EMPTY:
-# CHECK-NEXT:  <_foo$tlv$init>:
-# CHECK-NEXT:  00 00
-# CHECK-NEXT:  00 00
-# CHECK-EMPTY:
-# CHECK-NEXT:  <_bar$tlv$init>:
-# CHECK-NEXT:  00 00
-# CHECK-NEXT:  00 00
-# CHECK-EMPTY:
-# CHECK-NEXT:  Disassembly of section __DATA,__thread_vars:
-# CHECK-EMPTY:
-# CHECK-NEXT: <_foo>:
-# CHECK-NEXT:          ...
-# CHECK-EMPTY:
-# CHECK-NEXT:  <_bar>:
-# CHECK-NEXT:          ...
-# CHECK-NEXT:  04 00
-# CHECK-NEXT:  00 00
-# CHECK-NEXT:  00 00
-# CHECK-NEXT:  00 00
+# REG:       <_main>:
+# REG-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_foo>
+# REG-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_bar>
+# REG-NEXT:  retq
+
+# TBSS:       <_f>:
+# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_baz>
+# TBSS-NEXT:  leaq    {{.*}}(%rip), %rax  # {{.*}} <_qux>
+# TBSS-NEXT:  retq
+
+# REG-TLVP:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TLVP-NEXT: 00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00
+
+# TBSS-TLVP:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00
+
+# REG-TBSS-TLVP:      00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 08 00 00 00 00 00 00 00
+# REG-TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TBSS-TLVP-NEXT: 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+# REG-TBSS-TLVP-NEXT: 00 00 00 00 00 00 00 00 18 00 00 00 00 00 00 00
 
 ## Make sure we don't emit rebase opcodes for relocations in __thread_vars.
-# CHECK:       Rebase table:
-# CHECK-NEXT:  segment  section            address     type
-# CHECK-NEXT:  Bind table:
-# CHECK:       __DATA  __thread_vars   0x{{[0-9a-f]*}}  pointer 0 libSystem __tlv_bootstrap
-# CHECK:       __DATA  __thread_vars   0x{{[0-9a-f]*}}  pointer 0 libSystem __tlv_bootstrap
+# LINKEDIT:       Rebase table:
+# LINKEDIT-NEXT:  segment  section            address     type
+# LINKEDIT-NEXT:  Bind table:
+# LINKEDIT:       __DATA  __thread_vars   0x{{[0-9a-f]*}}  pointer 0 libSystem __tlv_bootstrap
+# LINKEDIT:       __DATA  __thread_vars   0x{{[0-9a-f]*}}  pointer 0 libSystem __tlv_bootstrap
+
+# SECTION-ORDER:      __thread_data
+# SECTION-ORDER:      more_thread_data
+# SECTION-ORDER-NEXT: __thread_bss
 
+#--- regular.s
 .globl _main
 _main:
   mov _foo@TLVP(%rip), %rax
   mov _bar@TLVP(%rip), %rax
   ret
 
 .section  __DATA,__thread_data,thread_local_regular
 _foo$tlv$init:
-  .space 4
+  .quad 123
+
+.section  __DATA,more_thread_data,thread_local_regular
 _bar$tlv$init:
-  .space 4
+  .quad 123
 
 .section  __DATA,__thread_vars,thread_local_variables
 .globl  _foo, _bar
 _foo:
   .quad __tlv_bootstrap
   .quad 0
   .quad _foo$tlv$init
 _bar:
   .quad __tlv_bootstrap
   .quad 0
   .quad _bar$tlv$init
+
+#--- tbss.s
+
+.globl _f
+_f:
+  mov _baz@TLVP(%rip), %rax
+  mov _qux@TLVP(%rip), %rax
+  ret
+
+.tbss _baz$tlv$init, 8, 3
+.tbss _qux$tlv$init, 8, 3
+
+.section  __DATA,__thread_vars,thread_local_variables
+_baz:
+  .quad __tlv_bootstrap
+  .quad 0
+  .quad _baz$tlv$init
+_qux:
+  .quad __tlv_bootstrap
+  .quad 0
+  .quad _qux$tlv$init