[sanitizer] Use dl_iterate_phdr based GetTls on musl and FreeBSD

[MaskRay]

Summary

... so that FreeBSD specific GetTls code can be removed. This also
helps FreeBSD arm64/powerpc64 which don't have GetTls implementation yet.

Note: as of musl 1.2.2 and FreeBSD 12.2, dlpi_tls_data returned by
dl_iterate_phdr is not desired: https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=254774

This can be worked around by using __tls_get_addr({modid,0}) instead
of dlpi_tls_data. The workaround can be shared with the workaround for glibc<2.25.

This fixes some tests on Alpine Linux x86-64 (musl)

test/lsan/Linux/cleanup_in_tsd_destructor.c
test/lsan/Linux/fork.cpp
test/lsan/Linux/fork_threaded.cpp
test/lsan/Linux/use_tls_static.cpp
test/lsan/many_tls_keys_thread.cpp

test/msan/tls_reuse.cpp

The number of sanitizer test failures does not change on FreeBSD/amd64 12.2.

[vitalybuka]

it does not apply on the HEAD

[MaskRay]

Abandoned in favor of D98926

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

 #endif
 }
 
 // ThreadDescriptorSize() is only used by lsan to get the pointer to
 // thread-specific data keys in the thread control block.
 #if (defined(__x86_64__) || defined(__i386__) || defined(__mips__) ||       \
      defined(__aarch64__) || defined(__powerpc64__) || defined(__s390__) || \
      defined(__arm__) || SANITIZER_RISCV64) &&                              \
-    SANITIZER_LINUX && !SANITIZER_ANDROID
+    (SANITIZER_FREEBSD || SANITIZER_LINUX) && !SANITIZER_ANDROID
 // sizeof(struct pthread) from glibc.
 static atomic_uintptr_t thread_descriptor_size;
 
 uptr ThreadDescriptorSize() {
   uptr val = atomic_load_relaxed(&thread_descriptor_size);
   if (val)
     return val;
 #if defined(__x86_64__) || defined(__i386__) || defined(__arm__)
struct TlsBlock {
   uptr begin, end, align;
   size_t tls_modid;
   bool operator<(const TlsBlock &rhs) const { return begin < rhs.begin; }
 };
 }  // namespace
 
 extern "C" void *__tls_get_addr(size_t *);
 
-static int TouchTlsBlock(struct dl_phdr_info *info, size_t size,
+static int CollectStaticTlsBlocks(struct dl_phdr_info *info, size_t size,
                                   void *data) {
+  if (!info->dlpi_tls_data)
+    return 0;
+  uptr begin = (uptr)info->dlpi_tls_data;
+  if ((uptr)data & 1) {
+    data = (void *)((uptr)data - 1);
+  } else {
     size_t mod_and_off[2] = {info->dlpi_tls_modid, 0};
     if (mod_and_off[0] != 0)
       __tls_get_addr(mod_and_off);
-  return 0;
+    begin = (uptr)__tls_get_addr(mod_and_off);
   }
-
-static int CollectStaticTlsBlocks(struct dl_phdr_info *info, size_t size,
-                                  void *data) {
-  if (!info->dlpi_tls_data)
-    return 0;
-  const uptr begin = (uptr)info->dlpi_tls_data;
   for (unsigned i = 0; i != info->dlpi_phnum; ++i)
     if (info->dlpi_phdr[i].p_type == PT_TLS) {
       static_cast<InternalMmapVector<TlsBlock> *>(data)->push_back(
           TlsBlock{begin, begin + info->dlpi_phdr[i].p_memsz,
                    info->dlpi_phdr[i].p_align, info->dlpi_tls_modid});
       break;
     }
   return 0;
 }
 
 static void GetStaticTlsBoundary(uptr *addr, uptr *size, uptr *align) {
   InternalMmapVector<TlsBlock> ranges;
-  dl_iterate_phdr(CollectStaticTlsBlocks, &ranges);
+  // musl as of 1.2.2 and FreeBSD as of 12.2 incorrectly set dlpi_tls_data to
+  // the TLS initialization image
+  // https://bugs.freebsd.org/bugzilla/show_bug.cgi?id=254774
+  //
+  // Set the low bit if we can use dlpi_tls_data. glibc from 2.25 onwards (BZ
+  // #19826) sets dlpi_tls_data to non-NULL. grte/v4-2.19 is patched to include
+  // a similar patch.
+  int major, minor, patch;
+  void *data = &ranges;
+  if (GetLibcVersion(&major, &minor, &patch) && major == 2 &&
+      (minor >= 25 || minor == 19))
+    data = (void *)((uptr)data | 1);
+
+  dl_iterate_phdr(CollectStaticTlsBlocks, data);
   uptr len = ranges.size();
   Sort(ranges.begin(), len);
   // Find the range with tls_modid=1. For glibc, because libc.so uses PT_TLS,
   // this module is guaranteed to exist and is one of the initially loaded
   // modules.
   uptr one = 0;
   while (one != len && ranges[one].tls_modid != 1) ++one;
   if (one == len) {
while (l != 0 && ranges[l].begin < ranges[l - 1].end + ranges[l - 1].align)
     *align = Max(*align, ranges[--l].align);
   uptr r = one + 1;
   while (r != len && ranges[r].begin < ranges[r - 1].end + ranges[r - 1].align)
     *align = Max(*align, ranges[r++].align);
   *addr = ranges[l].begin;
   *size = ranges[r - 1].end - ranges[l].begin;
 }
 #endif  // !SANITIZER_GO
-#endif  // (x86_64 || i386 || mips || ...) && SANITIZER_LINUX &&
-        // !SANITIZER_ANDROID
-
-#if SANITIZER_FREEBSD
-static void **ThreadSelfSegbase() {
-  void **segbase = 0;
-#if defined(__i386__)
-  // sysarch(I386_GET_GSBASE, segbase);
-  __asm __volatile("mov %%gs:0, %0" : "=r" (segbase));
-#elif defined(__x86_64__)
-  // sysarch(AMD64_GET_FSBASE, segbase);
-  __asm __volatile("movq %%fs:0, %0" : "=r" (segbase));
-#else
-#error "unsupported CPU arch"
-#endif
-  return segbase;
-}
-
-uptr ThreadSelf() {
-  return (uptr)ThreadSelfSegbase()[2];
-}
-#endif  // SANITIZER_FREEBSD
+#endif  // (x86_64 || i386 || mips || ...) && (SANITIZER_FREEBSD ||
+        // SANITIZER_LINUX) && !SANITIZER_ANDROID
 
 #if SANITIZER_NETBSD
 static struct tls_tcb * ThreadSelfTlsTcb() {
   struct tls_tcb *tcb = nullptr;
 #ifdef __HAVE___LWP_GETTCB_FAST
   tcb = (struct tls_tcb *)__lwp_gettcb_fast();
 #elif defined(__HAVE___LWP_GETPRIVATE_FAST)
   tcb = (struct tls_tcb *)__lwp_getprivate_fast();
if (&__libc_get_static_tls_bounds) {
     __libc_get_static_tls_bounds(&start_addr, &end_addr);
     *addr = reinterpret_cast<uptr>(start_addr);
     *size =
         reinterpret_cast<uptr>(end_addr) - reinterpret_cast<uptr>(start_addr);
   } else {
     *addr = 0;
     *size = 0;
   }
-#elif SANITIZER_LINUX
-  // glibc before 2.25 (BZ #19826) does not set dlpi_tls_data. Call
-  // __tls_get_addr to force allocation. For safety, skip grte/v4-2.19 for now.
-  int major, minor, patch;
-  if (GetLibcVersion(&major, &minor, &patch) && major == 2 && minor < 25 &&
-      minor != 19)
-    dl_iterate_phdr(TouchTlsBlock, nullptr);
-
+#elif SANITIZER_FREEBSD || SANITIZER_LINUX
   uptr align;
   GetStaticTlsBoundary(addr, size, &align);
 #if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
   if (SANITIZER_GLIBC) {
 #if defined(__s390__)
     align = Max<uptr>(align, 16);
 #else
     align = Max<uptr>(align, 64);
 #endif
   }
   const uptr tp = RoundUpTo(*addr + *size, align);
 
   // lsan requires the range to additionally cover the static TLS surplus
   // (elf/dl-tls.c defines 1664). Otherwise there may be false positives for
   // allocations only referenced by tls in dynamically loaded modules.
   if (SANITIZER_GLIBC)
     *size += 1644;
+  else if (SANITIZER_FREEBSD)
+    *size += 128;  // RTLD_STATIC_TLS_EXTRA
 
   // Extend the range to include the thread control block. On glibc, lsan needs
   // the range to include pthread::{specific_1stblock,specific} so that
   // allocations only referenced by pthread_setspecific can be scanned. This may
   // underestimate by at most TLS_TCB_ALIGN-1 bytes but it should be fine
   // because the number of bytes after pthread::specific is larger.
   *addr = tp - RoundUpTo(*size, align);
   *size = tp - *addr + ThreadDescriptorSize();
 #else
   if (SANITIZER_GLIBC)
     *size += 1664;
+  else if (SANITIZER_FREEBSD)
+    *size += 128;  // RTLD_STATIC_TLS_EXTRA
 #if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
   const uptr pre_tcb_size = TlsPreTcbSize();
   *addr -= pre_tcb_size;
   *size += pre_tcb_size;
 #else
   // arm and aarch64 reserve two words at TP, so this underestimates the range.
   // However, this is sufficient for the purpose of finding the pointers to
   // thread-specific data keys.
   const uptr tcb_size = ThreadDescriptorSize();
   *addr -= tcb_size;
   *size += tcb_size;
 #endif
 #endif
-#elif SANITIZER_FREEBSD
-  void** segbase = ThreadSelfSegbase();
-  *addr = 0;
-  *size = 0;
-  if (segbase != 0) {
-    // tcbalign = 16
-    // tls_size = round(tls_static_space, tcbalign);
-    // dtv = segbase[1];
-    // dtv[2] = segbase - tls_static_space;
-    void **dtv = (void**) segbase[1];
-    *addr = (uptr) dtv[2];
-    *size = (*addr == 0) ? 0 : ((uptr) segbase[0] - (uptr) dtv[2]);
-  }
 #elif SANITIZER_NETBSD
   struct tls_tcb * const tcb = ThreadSelfTlsTcb();
   *addr = 0;
   *size = 0;
   if (tcb != 0) {
     // Find size (p_memsz) of dlpi_tls_modid 1 (TLS block of the main program).
     // ld.elf_so hardcodes the index 1.
     dl_iterate_phdr(GetSizeFromHdr, size);