[sanitizer] Simplify GetTls with dl_iterate_phdr on Linux and use it on musl/FreeBSD

[MaskRay]

Summary

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

GetTls is the range of

• thread control block and optional TLS_PRE_TCB_SIZE
• static TLS blocks plus static TLS surplus

On glibc, lsan requires the range to include
pthread::{specific_1stblock,specific} so that allocations only referenced by
pthread_setspecific can be scanned.

This patch uses dl_iterate_phdr to collect TLS blocks. Find the one
with dlpi_tls_modid==1 as one of the initially loaded module, then find
consecutive ranges. The boundaries give us addr and size.

This allows us to drop the glibc internal _dl_get_tls_static_info and
InitTlsSize. However, huge glibc x86-64 binaries with numerous shared objects
may observe time complexity penalty, so exclude them for now. Use the simplified
method with non-Android Linux for now, but in theory this can be used with *BSD
and potentially other ELF OSes.

This removal of RISC-V __builtin_thread_pointer makes the code compilable more
compiler versions (added in Clang in 2020-03, added in GCC in 2020-07).

This simplification enables D99566 for TLS Variant I architectures.

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

and test/lsan/TestCases/many_tls_keys_pthread.cpp on glibc aarch64.

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

[MaskRay]

Delete InitTlsSize

[vitalybuka]

compiler-rt/lib/asan/asan_thread.cpp

325

can they be not alligned? maybe just add CHECK in AsanThread::Init, for both stack_top_ and stack_bottom_
either way there lines looks like a separate patch

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

323–328

Could be nicer with Min/Max

362

maybe we should preserve old implementation and CHECK() if it matches the new one and let it state for a few cycles on bots?

507

SANITIZER_LINUX includes SANITIZER_ANDROID

[MaskRay]

compiler-rt/lib/asan/asan_thread.cpp

325

Some asan tests manifest this.

With this block of change

// If stack and tls intersect, make them non-intersecting.
if (*tls_addr > *stk_addr && *tls_addr < *stk_addr + *stk_size) {
  CHECK_LE(*tls_addr + *tls_size, *stk_addr + *stk_size);
  *stk_size = *tls_addr - *stk_addr;
}

stack_top_ may not be a multiple of SHADOW_GRANULARITY.

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

323–328

The callback only supplies one argument void *data, which is cast to uptr *range. Using uptr *min, uptr *max would have more code which does not seem to improve readability...

362

I have tested aarch64-linux and powerpc64le-linux are good with the new approach.

riscv support is new and I think the risk possibility is low. Hope @EccoTheDolphin /@luismarques can confirm deleting the code is good.

With the above done, I'd rather delete the old implementation in this patch.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

323–328

I meant another thing, which is not useful as well.

330–332

is any link, to manual or source to confirm this for the future readers?

[MaskRay]

Drop assumption on dl_iterate_phdr order.

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

330–332

The way glibc/elf/dl-tls.c assigns TLS offsets to initially loaded modules should make this formula. However, I think it is probably better getting rid of this limitation which can probably make this use on more OSes and getting rid of more OSes specific code.

[vitalybuka]

few nits, but I am still confused about blocks outside alignment gap

compiler-rt/lib/asan/asan_rtl.cpp

571

THis way is more consistent

compiler-rt/lib/asan/asan_thread.cpp

324–325

PoisonShadow(stack_bottom_,
             RoundUpTo(stack_top_ - stack_bottom_, SHADOW_GRANULARITY), 0);

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

299

you can extend namespace scope and remove static

309–328

326–327

what is going to happens with gaps > alignment?
If it's impossible maybe just CHECK() for that
otherwise probably better to change GetThreadStackAndTls to return vector and let caller decide

[vitalybuka]

compiler-rt/lib/asan/asan_rtl.cpp

571

Actually PoisonShadow has CHECKs to I don't mind to keep this and below as is if it does not trigger.

[MaskRay]

compiler-rt/lib/asan/asan_rtl.cpp

571

I'll adjust top-bottom but keep bottom untouched.

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

299

https://llvm.org/docs/CodingStandards.html#anonymous-namespaces The llvm-project coding standard does not use anonymous namespace for static functions. Does compiler-rt do it differently?

326–327

A dynamic loader does not make gaps > alignment for static TLS blocks (which would simply waste space). The code uses alignment to check whether two consecutive TLS ranges should be merged.

If a range is out of reach, it means it belongs to a dynamic TLS block and there should not be any CHECK.

[MaskRay]

address comments

[MaskRay]

compiler-rt/lib/asan/asan_thread.cpp

324–325

Hmm, I'll move the round to where stack_top_ is initialized.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

299

Oh, I forgot this one.
Originally sanitizers were made with Google Style. Still it uses statics more often then unnamed namespace.
Lets keep static.

340

check-sanitizer gets

/usr/bin/ld: SANITIZER_TEST_OBJECTS.sanitizer_linux_test.cpp.x86_64.o: in function `__sanitizer::thread_self_offset_test_func(void*)':
/usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelf()'
/usr/bin/ld: /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelfOffset()'
/usr/bin/ld: /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelf()'
/usr/bin/ld: SANITIZER_TEST_OBJECTS.sanitizer_linux_test.cpp.x86_64.o: in function `__sanitizer::SanitizerLinux_ThreadSelfOffset_Test::TestBody()':
/usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelf()'
/usr/bin/ld: /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelfOffset()'
/usr/bin/ld: /usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelf()'
/usr/bin/ld: SANITIZER_TEST_OBJECTS.sanitizer_linux_test.cpp.x86_64.o: in function `__sanitizer::thread_descriptor_size_test_func(void*)':
/usr/local/google/home/vitalybuka/src/llvm.git/llvm-project/compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:208: undefined reference to `__sanitizer::ThreadSelf()'rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp:193: undefined reference to `__sanitizer::ThreadSelf()'

also it's still declared in sanitizer_linux.h and used in unittest

[MaskRay]

Delete check-sanitizer found tests.

Hack powerpc64 to use 1664. For unknown reasons it is needed for an internal test.

[MaskRay]

By intercepting pthread_setspecific, we can track thread-specific data keys for lsan in a better way and likely will be able to get rid of ThreadDescriptorSize() and TlsPreTcbSize().

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

340

Thanks. I did not know check-sanitizer. I used check-asan check-msan check-hwasan check-tsan check-ubsan check-cfi check-lsan ...

[vitalybuka]

compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp

188

Please keep ThreadDescriptorSize like this
ThreadDescriptorSize is version specific so we want to know if it executed on system with unexpected size

[MaskRay]

add back a unit test

[MaskRay]

Explain why we need the 1664 static TLS surplus.

Performed a large-scale testing internally and it looks good.

[thakis]

This possibly broke tsan: https://bugs.chromium.org/p/chromium/issues/detail?id=1195357

[phosek]

After this change, we're also seeing a leak being reported in BoringSSL when running on Debian 9 (stretch) which appears to be a false positive, see fxbug.dev/73487 for more details.

[MaskRay]

In D98926#2667197, @phosek wrote:

After this change, we're also seeing a leak being reported in BoringSSL when running on Debian 9 (stretch) which appears to be a false positive, see fxbug.dev/73487 for more details.

Is the false positive fixed by 58c62fd9768594ec8dd57e8320ba2396bf8b87e5 [sanitizer] Improve accuracy of GetTls on x86/s390? And note that the change only affects Linux, so Fuchsia is not affected.

I have found an approach to work around the Ubuntu 16.04 glibc 2.23 bug https://sourceware.org/pipermail/libc-alpha/2021-April/124697.html without making the code dirty.
I am testing it.

[MaskRay]

Fix Ubuntu 16.04 glibc 2.23

[jyknight]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

430

This seems not OK to call this here. I'm seeing an ASAN "stack-use-after-scope" arising from this change, which I believe is because of calling this function during thread setup, before the stack bounds have been set in asan.

#0 0x5620b775273b in __interceptor_confstr compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc:3713:5
#1 0x5620b77128ea in __sanitizer::GetLibcVersion(int*, int*, int*) compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:174:14
#2 0x5620b77129c5 in __sanitizer::GetTls(unsigned long*, unsigned long*) compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:424:7
#3 0x5620b7712e89 in __sanitizer::GetThreadStackAndTls(bool, unsigned long*, unsigned long*, unsigned long*, unsigned long*) compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:525:3
#4 0x5620b77a8f5d in __asan::AsanThread::SetThreadStackAndTls(__asan::AsanThread::InitOptions const*) compiler-rt/lib/asan/asan_thread.cpp:308:3
#5 0x5620b77a8b32 in __asan::AsanThread::Init(__asan::AsanThread::InitOptions const*) compiler-rt/lib/asan/asan_thread.cpp:235:3
#6 0x5620b77a9076 in __asan::AsanThread::ThreadStart(unsigned long long) compiler-rt/lib/asan/asan_thread.cpp:266:3

Probably should revert the change for now.

[DavidSpickett]

I've disabled many_tls_keys_pthread.cpp for AArch64 as it requires this change (https://reviews.llvm.org/rG34f8a7f93c98b7c189f9684d0d207ab42aca166f). The commit that enabled it wasn't caught in the initial revert.

If/when you reland it would make sense to include enabling this test as part of it. (passes on our bot when this change is included)

[MaskRay]

Fold D99871 into it

Keep InitTlsSize

[MaskRay]

Special case Linux x86-64

[MaskRay]

Update description

[morehouse]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

198

This is triggering "unused variable" errors on Android: https://lab.llvm.org/buildbot/#/builders/77/builds/5507

/var/lib/buildbot/sanitizer-buildbot6/sanitizer-x86_64-linux-android/build/llvm-project/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:198:12: error: unused variable 'g_use_dlpi_tls_data' [-Werror,-Wunused-variable]
static int g_use_dlpi_tls_data;

[morehouse]

PPC bots are also segfaulting during some MSan test after this patch: https://lab.llvm.org/buildbot/#/builders/19/builds/3665, https://lab.llvm.org/buildbot/#/builders/105/builds/8438

I'm not 100% sure, but I think it's likely this patch is the culprit.

******************** TEST 'UBSan-MemorySanitizer-powerpc64le :: TestCases/ImplicitConversion/integer-truncation.c' FAILED ********************
...
Exit Code: 254
Command Output (stderr):
--
clang-13: error: unable to execute command: Segmentation fault (core dumped)
clang-13: error: linker command failed due to signal (use -v to see invocation)

[Conanap]

As mentioned above, this seems to be causing segfaults on PPC buildbots; did some builds on a few revisions and this seems to be the cause.

[MaskRay]

In D98926#2694968, @morehouse wrote:

PPC bots are also segfaulting during some MSan test after this patch: https://lab.llvm.org/buildbot/#/builders/19/builds/3665, https://lab.llvm.org/buildbot/#/builders/105/builds/8438

I'm not 100% sure, but I think it's likely this patch is the culprit.

******************** TEST 'UBSan-MemorySanitizer-powerpc64le :: TestCases/ImplicitConversion/integer-truncation.c' FAILED ********************
...
Exit Code: 254
Command Output (stderr):
--
clang-13: error: unable to execute command: Segmentation fault (core dumped)
clang-13: error: linker command failed due to signal (use -v to see invocation)

Yes, I've reported it to @amyk . There may be a GNU ld 2.30 bug. I have tested the patch on a Ubunbu 18.04 machine with GNU ld 2.31: there is no segfault.
I think the bot may need to upgrade binutils - this is not the first time I've seen compiler/linker crashes on the ppc64le build bot - I don't even know how to work around it if we don't have more information about the nature.

The -Wunused-variable has been fixed by 376db8eaef3a06cf963eba9e8009048dc93689f0

[sylvestre.ledru]

@MaskRay
Seems that it caused
https://bugs.llvm.org/show_bug.cgi?id=50017
cannot link on s390x

could you please have a look?

[glaubitz]

Hello!

This seems to have broken the sanitizer build on Linux SPARC: http://lab.llvm.org:8014/#/builders/113/builds/756

[433/4593] Building CXX object projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonSymbolizerNoHooks.sparc.dir/sanitizer_symbolizer.cpp.o
[434/4593] Building CXX object projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonSymbolizerNoHooks.sparcv9.dir/sanitizer_symbolizer_posix_libcdep.cpp.o
[435/4593] Building CXX object projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonLibcNoHooks.sparc.dir/sanitizer_linux_libcdep.cpp.o
FAILED: projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonLibcNoHooks.sparc.dir/sanitizer_linux_libcdep.cpp.o 
/usr/bin/c++ -DHAVE_RPC_XDR_H=1 -D_DEBUG -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -Iprojects/compiler-rt/lib/sanitizer_common -I/var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/compiler-rt/lib/sanitizer_common -Iinclude -I/var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/llvm/include -I/var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/compiler-rt/lib/sanitizer_common/.. -fPIC -fvisibility-inlines-hidden -Werror=date-time -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -fdiagnostics-color -ffunction-sections -fdata-sections -Wall -std=c++14 -Wno-unused-parameter -O3   -m32 -fPIC -fno-builtin -fno-exceptions -fomit-frame-pointer -funwind-tables -fno-stack-protector -fvisibility=hidden -fno-lto -O3 -g -Wno-variadic-macros -nostdinc++ -fno-rtti -Wframe-larger-than=570 -DSANITIZER_SUPPORTS_WEAK_HOOKS=0 -UNDEBUG -std=c++14 -MD -MT projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonLibcNoHooks.sparc.dir/sanitizer_linux_libcdep.cpp.o -MF projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonLibcNoHooks.sparc.dir/sanitizer_linux_libcdep.cpp.o.d -o projects/compiler-rt/lib/sanitizer_common/CMakeFiles/RTSanitizerCommonLibcNoHooks.sparc.dir/sanitizer_linux_libcdep.cpp.o -c /var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp
/var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp: In function ‘void __sanitizer::GetTls(__sanitizer::uptr*, __sanitizer::uptr*)’:
/var/lib/buildbot/workers/debian-stadler-sparc64/clang-sparc64-linux-multistage/llvm/compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp:436:3: error: ‘GetStaticTlsBoundary’ was not declared in this scope
  436 |   GetStaticTlsBoundary(addr, size, &align);
      |   ^~~~~~~~~~~~~~~~~~~~

Shall I open a bug report for that?

[glaubitz]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

223

I think the end of this line should be ||, not && as otherwise GetStaticTlsBoundary() is referenced on SPARC but not defined.

434

This snippet will be used on SPARC calling GetStaticTlsBoundary while the definition above is not defined for just SANITIZER_FREEBSD || SANITIZER_LINUX but also requires on of the architecture definitions which causes the build to fail on SPARC.

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

223

I thought Linux architectures not listed in this list are irrelevant. (The file does not mention __sparc__.) But it turns out that Linux sparc does have some minimum amount of support. It doesn't implement GetTls, so tens of tests may fail.

Since this is now a generic implementation, you may try simply adding __sparc__ to the list.
Then add __sparc__ to a following list: #if defined(__x86_64__) || defined(__i386__) || defined(__s390__).

Likely the state will be no worse than the previous, probably slightly better.

I don't have a sparc so I cannot test, though.

[glaubitz]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

223

I thought Linux architectures not listed in this list are irrelevant.

I assume that means on these architectures SANITIZER_LINUX will not be defined, will it?

It doesn't implement GetTls, so tens of tests may fail.

Is it hard to implement?

Since this is now a generic implementation, you may try simply adding sparc to the list.

That's what I also tried and fixed the build for me.

I don't have a sparc so I cannot test, though.

Note: There are multiple SPARCs available in the GCC compile farm (https://gcc.gnu.org/wiki/CompileFarm), running both Solaris and Linux. The machine gcc202is running Debian unstable and I'm the admin of it.

[MaskRay]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

223

I thought Linux architectures not listed in this list are irrelevant.

I assume that means on these architectures SANITIZER_LINUX will not be defined, will it?

The other sparc OSes are sparc-rtems and sparc-solaris. The state is likely not very good, either.

https://en.wikipedia.org/wiki/SPARC : "... terminated SPARC design after the completion of the M8."

It doesn't implement GetTls, so tens of tests may fail.

Is it hard to implement?

It was tricky before this patch. This file needed to know the precise size of glibc struct pthread (see the long list enumerating x86-64 glibc struct sizes). It would add lots of maintenance burden and specifically one of the reasons I think we should do this patch. So figuring out a way supporting these things without adding complexity is my goal.

Note: There are multiple SPARCs available in the GCC compile farm (https://gcc.gnu.org/wiki/CompileFarm), running both Solaris and Linux. The machine gcc202is running Debian unstable and I'm the admin of it.

Registered. I can take a look at the build.

[glaubitz]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

223

https://en.wikipedia.org/wiki/SPARC : "... terminated SPARC design after the completion of the M8."

True, but Solaris on SPARC is still fully supported. Debian and Gentoo also still support SPARC.

It was tricky before this patch. This file needed to know the precise size of glibc struct pthread (see the long list enumerating x86-64 glibc struct sizes).

OK, but it should be feasible to figure this information out.

It would add lots of maintenance burden and specifically one of the reasons I think we should do this patch. So figuring out a way supporting these things without adding complexity is my goal.

Sounds like a very good idea. Thanks for doing this.

Registered. I can take a look at the build.

Thanks, much appreciated. Let me know when I can be of any help.

compiler-rt/lib/asan/asan_rtl.cpp

Report(
         "WARNING: ASan is ignoring requested __asan_handle_no_return: "
         "stack type: %s top: %p; bottom %p; size: %p (%zd)\n"
         "False positive error reports may follow\n"
         "For details see "
         "https://github.com/google/sanitizers/issues/189\n",
         type, top, bottom, top - bottom, top - bottom);
     return;
   }
-  PoisonShadow(bottom, top - bottom, 0);
+  PoisonShadow(bottom, RoundUpTo(top - bottom, SHADOW_GRANULARITY), 0);
 }
 
 static void UnpoisonDefaultStack() {
   uptr bottom, top;
 
   if (AsanThread *curr_thread = GetCurrentThread()) {
     int local_stack;
     const uptr page_size = GetPageSizeCached();

compiler-rt/lib/asan/asan_thread.cpp

 // from the caller of Init (which see, above).  It's only there to support
 // OS-specific implementations that need more information passed through.
 void AsanThread::SetThreadStackAndTls(const InitOptions *options) {
   DCHECK_EQ(options, nullptr);
   uptr tls_size = 0;
   uptr stack_size = 0;
   GetThreadStackAndTls(tid() == 0, &stack_bottom_, &stack_size, &tls_begin_,
                        &tls_size);
-  stack_top_ = stack_bottom_ + stack_size;
+  stack_top_ = RoundDownTo(stack_bottom_ + stack_size, SHADOW_GRANULARITY);
   tls_end_ = tls_begin_ + tls_size;
   dtls_ = DTLS_Get();
 
   if (stack_top_ != stack_bottom_) {
     int local;
     CHECK(AddrIsInStack((uptr)&local));
   }
 }
 
 #endif  // !SANITIZER_FUCHSIA && !SANITIZER_RTEMS
 
 void AsanThread::ClearShadowForThreadStackAndTLS() {
   if (stack_top_ != stack_bottom_)
     PoisonShadow(stack_bottom_, stack_top_ - stack_bottom_, 0);
   if (tls_begin_ != tls_end_) {
     uptr tls_begin_aligned = RoundDownTo(tls_begin_, SHADOW_GRANULARITY);
     uptr tls_end_aligned = RoundUpTo(tls_end_, SHADOW_GRANULARITY);
     FastPoisonShadowPartialRightRedzone(tls_begin_aligned,
                                         tls_end_ - tls_begin_aligned,
                                         tls_end_aligned - tls_end_, 0);
   }
 }
 

compiler-rt/lib/sanitizer_common/sanitizer_linux.h

private:
   pid_t pid_;
   int descriptor_ = -1;
   InternalMmapVector<char> buffer_;
 };
 
 // Exposed for testing.
 uptr ThreadDescriptorSize();
 uptr ThreadSelf();
-uptr ThreadSelfOffset();
 
 // Matches a library's file name against a base name (stripping path and version
 // information).
 bool LibraryNameIs(const char *full_name, const char *base_name);
 
 // Call cb for each region mapped by map.
 void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr));
 

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

#ifdef _CS_GNU_LIBC_VERSION
   *minor = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   *patch = (*p == '.') ? internal_simple_strtoll(p + 1, &p, 10) : 0;
   return true;
 #else
   return false;
 #endif
 }
 
-#if SANITIZER_GLIBC && !SANITIZER_GO
-static uptr g_tls_size;
-
-#ifdef __i386__
-#define CHECK_GET_TLS_STATIC_INFO_VERSION (!__GLIBC_PREREQ(2, 27))
-#else
-#define CHECK_GET_TLS_STATIC_INFO_VERSION 0
-#endif
-
-#if CHECK_GET_TLS_STATIC_INFO_VERSION
-#define DL_INTERNAL_FUNCTION __attribute__((regparm(3), stdcall))
-#else
-#define DL_INTERNAL_FUNCTION
+// True if we can use dlpi_tls_data. glibc before 2.25 may leave NULL (BZ
+// #19826) so dlpi_tls_data cannot be used.
+//
+// musl before 1.2.3 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
+#if !SANITIZER_GO
+static int g_use_dlpi_tls_data;
 #endif
 
-namespace {
-struct GetTlsStaticInfoCall {
-  typedef void (*get_tls_func)(size_t*, size_t*);
-};
-struct GetTlsStaticInfoRegparmCall {
-  typedef void (*get_tls_func)(size_t*, size_t*) DL_INTERNAL_FUNCTION;
-};
-
-template <typename T>
-void CallGetTls(void* ptr, size_t* size, size_t* align) {
-  typename T::get_tls_func get_tls;
-  CHECK_EQ(sizeof(get_tls), sizeof(ptr));
-  internal_memcpy(&get_tls, &ptr, sizeof(ptr));
-  CHECK_NE(get_tls, 0);
-  get_tls(size, align);
-}
-
-bool CmpLibcVersion(int major, int minor, int patch) {
-  int ma;
-  int mi;
-  int pa;
-  if (!GetLibcVersion(&ma, &mi, &pa))
-    return false;
-  if (ma > major)
-    return true;
-  if (ma < major)
-    return false;
-  if (mi > minor)
-    return true;
-  if (mi < minor)
-    return false;
-  return pa >= patch;
-}
-
-}  // namespace
-
+#if SANITIZER_GLIBC && !SANITIZER_GO
+__attribute__((unused)) static uptr g_tls_size;
 void InitTlsSize() {
-  // all current supported platforms have 16 bytes stack alignment
-  const size_t kStackAlign = 16;
-  void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
-  size_t tls_size = 0;
-  size_t tls_align = 0;
-  // On i?86, _dl_get_tls_static_info used to be internal_function, i.e.
-  // __attribute__((regparm(3), stdcall)) before glibc 2.27 and is normal
-  // function in 2.27 and later.
-  if (CHECK_GET_TLS_STATIC_INFO_VERSION && !CmpLibcVersion(2, 27, 0))
-    CallGetTls<GetTlsStaticInfoRegparmCall>(get_tls_static_info_ptr,
-                                            &tls_size, &tls_align);
-  else
-    CallGetTls<GetTlsStaticInfoCall>(get_tls_static_info_ptr,
-                                     &tls_size, &tls_align);
-  if (tls_align < kStackAlign)
-    tls_align = kStackAlign;
-  g_tls_size = RoundUpTo(tls_size, tls_align);
+  int major, minor, patch;
+  g_use_dlpi_tls_data =
+      GetLibcVersion(&major, &minor, &patch) && major == 2 && minor >= 25;
+
+#ifdef __x86_64__
+  void *get_tls_static_info = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
+  size_t tls_align;
+  ((void (*)(size_t *, size_t *))get_tls_static_info)(&g_tls_size, &tls_align);
+#endif
 }
 #else
 void InitTlsSize() { }
 #endif  // SANITIZER_GLIBC && !SANITIZER_GO
 
+// On glibc x86_64, ThreadDescriptorSize() needs to be precise due to the usage
+// of g_tls_size. On other targets, 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__)

 #elif defined(__s390__)
   val = FIRST_32_SECOND_64(1152, 1776); // valid for glibc 2.22
 #endif
   if (val)
     atomic_store_relaxed(&thread_descriptor_size, val);
   return val;
 }
 
-// The offset at which pointer to self is located in the thread descriptor.
-const uptr kThreadSelfOffset = FIRST_32_SECOND_64(8, 16);
-
-uptr ThreadSelfOffset() {
-  return kThreadSelfOffset;
-}
-
 #if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb
 // head structure. It lies before the static tls blocks.
 static uptr TlsPreTcbSize() {
 #if defined(__mips__)
   const uptr kTcbHead = 16; // sizeof (tcbhead_t)
 #elif defined(__powerpc64__)
   const uptr kTcbHead = 88; // sizeof (tcbhead_t)
 #elif SANITIZER_RISCV64
   const uptr kTcbHead = 16;  // sizeof (tcbhead_t)
 #endif
   const uptr kTlsAlign = 16;
   const uptr kTlsPreTcbSize =
       RoundUpTo(ThreadDescriptorSize() + kTcbHead, kTlsAlign);
   return kTlsPreTcbSize;
 }
 #endif
 
-uptr ThreadSelf() {
-  uptr descr_addr;
-#if defined(__i386__)
-  asm("mov %%gs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
-#elif defined(__x86_64__)
-  asm("mov %%fs:%c1,%0" : "=r"(descr_addr) : "i"(kThreadSelfOffset));
-#elif defined(__mips__)
-  // MIPS uses TLS variant I. The thread pointer (in hardware register $29)
-  // points to the end of the TCB + 0x7000. The pthread_descr structure is
-  // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
-  // TCB and the size of pthread_descr.
-  const uptr kTlsTcbOffset = 0x7000;
-  uptr thread_pointer;
-  asm volatile(".set push;\
-                .set mips64r2;\
-                rdhwr %0,$29;\
-                .set pop" : "=r" (thread_pointer));
-  descr_addr = thread_pointer - kTlsTcbOffset - TlsPreTcbSize();
-#elif defined(__aarch64__) || defined(__arm__)
-  descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer()) -
-                                      ThreadDescriptorSize();
-#elif SANITIZER_RISCV64
-  // https://github.com/riscv/riscv-elf-psabi-doc/issues/53
-  uptr thread_pointer = reinterpret_cast<uptr>(__builtin_thread_pointer());
-  descr_addr = thread_pointer - TlsPreTcbSize();
-#elif defined(__s390__)
-  descr_addr = reinterpret_cast<uptr>(__builtin_thread_pointer());
-#elif defined(__powerpc64__)
-  // PPC64LE uses TLS variant I. The thread pointer (in GPR 13)
-  // points to the end of the TCB + 0x7000. The pthread_descr structure is
-  // immediately in front of the TCB. TlsPreTcbSize() includes the size of the
-  // TCB and the size of pthread_descr.
-  const uptr kTlsTcbOffset = 0x7000;
-  uptr thread_pointer;
-  asm("addi %0,13,%1" : "=r"(thread_pointer) : "I"(-kTlsTcbOffset));
-  descr_addr = thread_pointer - TlsPreTcbSize();
-#else
-#error "unsupported CPU arch"
-#endif
-  return descr_addr;
-}
-#endif  // (x86_64 || i386 || MIPS) && SANITIZER_LINUX
+#if !SANITIZER_GO
+namespace {
+struct TlsBlock {
+  uptr begin, end, align;
+  size_t tls_modid;
+  bool operator<(const TlsBlock &rhs) const { return begin < rhs.begin; }
+};
+}  // namespace
 
-#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;
+extern "C" void *__tls_get_addr(size_t *);
+
+static int CollectStaticTlsBlocks(struct dl_phdr_info *info, size_t size,
+                                  void *data) {
+  if (!info->dlpi_tls_modid)
+    return 0;
+  uptr begin = (uptr)info->dlpi_tls_data;
+  if (!g_use_dlpi_tls_data) {
+    // Call __tls_get_addr as a fallback. This forces TLS allocation on glibc
+    // and FreeBSD.
+    size_t mod_and_off[2] = {info->dlpi_tls_modid, 0};
+    begin = (uptr)__tls_get_addr(mod_and_off);
+  }
+  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;
 }
 
-uptr ThreadSelf() {
-  return (uptr)ThreadSelfSegbase()[2];
+__attribute__((unused)) static void GetStaticTlsBoundary(uptr *addr, uptr *size,
+                                                         uptr *align) {
+  InternalMmapVector<TlsBlock> ranges;
+  dl_iterate_phdr(CollectStaticTlsBlocks, &ranges);
+  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) {
+    // This may happen with musl if no module uses PT_TLS.
+    *addr = 0;
+    *size = 0;
+    *align = 1;
+    return;
   }
-#endif  // SANITIZER_FREEBSD
+  // Find the maximum consecutive ranges. We consider two modules consecutive if
+  // the gap is smaller than the alignment. The dynamic loader places static TLS
+  // blocks this way not to waste space.
+  uptr l = one;
+  *align = ranges[l].align;
+  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_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
-#if defined(__x86_64__) || defined(__i386__) || defined(__s390__)
-  *addr = ThreadSelf();
-  *size = GetTlsSize();
+#elif SANITIZER_GLIBC && defined(__x86_64__)
+  // For x86-64, use an O(1) approach which requires precise
+  // ThreadDescriptorSize. g_tls_size was initialized in InitTlsSize.
+  asm("mov %%fs:16,%0" : "=r"(*addr));
+  *size = g_tls_size;
   *addr -= *size;
   *addr += ThreadDescriptorSize();
-#elif defined(__mips__) || defined(__aarch64__) || defined(__powerpc64__) || \
-    defined(__arm__) || SANITIZER_RISCV64
-  *addr = ThreadSelf();
-  *size = GetTlsSize();
-#else
-  *addr = 0;
-  *size = 0;
+#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);

 #else
 #error "Unknown OS"
 #endif
 }
 #endif
 
 #if !SANITIZER_GO
 uptr GetTlsSize() {
-#if SANITIZER_FREEBSD || SANITIZER_ANDROID || SANITIZER_NETBSD || \
+#if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_NETBSD || \
     SANITIZER_SOLARIS
   uptr addr, size;
   GetTls(&addr, &size);
   return size;
-#elif SANITIZER_GLIBC
-#if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
-  return RoundUpTo(g_tls_size + TlsPreTcbSize(), 16);
-#else
-  return g_tls_size;
-#endif
 #else
   return 0;
 #endif
 }
 #endif
 
 void GetThreadStackAndTls(bool main, uptr *stk_addr, uptr *stk_size,
                           uptr *tls_addr, uptr *tls_size) {
 #if SANITIZER_GO
   // Stub implementation for Go.
   *stk_addr = *stk_size = *tls_addr = *tls_size = 0;
 #else
   GetTls(tls_addr, tls_size);
 
   uptr stack_top, stack_bottom;
   GetThreadStackTopAndBottom(main, &stack_top, &stack_bottom);
   *stk_addr = stack_bottom;
   *stk_size = stack_top - stack_bottom;
 
   if (!main) {
     // If stack and tls intersect, make them non-intersecting.
     if (*tls_addr > *stk_addr && *tls_addr < *stk_addr + *stk_size) {
-      CHECK_GT(*tls_addr + *tls_size, *stk_addr);
-      CHECK_LE(*tls_addr + *tls_size, *stk_addr + *stk_size);
-      *stk_size -= *tls_size;
-      *tls_addr = *stk_addr + *stk_size;
+      if (*stk_addr + *stk_size < *tls_addr + *tls_size)
+        *tls_size = *stk_addr + *stk_size - *tls_addr;
+      *stk_size = *tls_addr - *stk_addr;
     }
   }
 #endif
 }
 
 #if !SANITIZER_FREEBSD
 typedef ElfW(Phdr) Elf_Phdr;
 #elif SANITIZER_WORDSIZE == 32 && __FreeBSD_version <= 902001  // v9.2

compiler-rt/lib/sanitizer_common/tests/sanitizer_linux_test.cpp

 }
 
 TEST(SanitizerCommon, SetEnvTest) {
   const char kEnvName[] = "ENV_FOO";
   SetEnv(kEnvName, "value");
   EXPECT_STREQ("value", getenv(kEnvName));
   unsetenv(kEnvName);
   EXPECT_EQ(0, getenv(kEnvName));
 }
 
 #if (defined(__x86_64__) || defined(__i386__)) && !SANITIZER_ANDROID
-void *thread_self_offset_test_func(void *arg) {
-  bool result =
-      *(uptr *)((char *)ThreadSelf() + ThreadSelfOffset()) == ThreadSelf();
-  return (void *)result;
-}
-
-TEST(SanitizerLinux, ThreadSelfOffset) {
-  EXPECT_TRUE((bool)thread_self_offset_test_func(0));
-  pthread_t tid;
-  void *result;
-  ASSERT_EQ(0, pthread_create(&tid, 0, thread_self_offset_test_func, 0));
-  ASSERT_EQ(0, pthread_join(tid, &result));
-  EXPECT_TRUE((bool)result);
-}
-
 // libpthread puts the thread descriptor at the end of stack space.
 void *thread_descriptor_size_test_func(void *arg) {
-  uptr descr_addr = ThreadSelf();
+  uptr descr_addr = (uptr)pthread_self();
   pthread_attr_t attr;
   pthread_getattr_np(pthread_self(), &attr);
   void *stackaddr;
   size_t stacksize;
   pthread_attr_getstack(&attr, &stackaddr, &stacksize);
   return (void *)((uptr)stackaddr + stacksize - descr_addr);
 }
 

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

TSAN_INTERCEPTOR(void*, malloc, uptr size) {
   {
     SCOPED_INTERCEPTOR_RAW(malloc, size);
     p = user_alloc(thr, pc, size);
   }
   invoke_malloc_hook(p, size);
   return p;
 }
 
+// In glibc<2.25, dynamic TLS blocks are allocated by __libc_memalign. Intercept
+// __libc_memalign so that (1) we can detect races (2) free will not be called
+// on libc internally allocated blocks.
 TSAN_INTERCEPTOR(void*, __libc_memalign, uptr align, uptr sz) {
-  SCOPED_TSAN_INTERCEPTOR(__libc_memalign, align, sz);
+  SCOPED_INTERCEPTOR_RAW(__libc_memalign, align, sz);
   return user_memalign(thr, pc, align, sz);
 }
 
 TSAN_INTERCEPTOR(void*, calloc, uptr size, uptr n) {
   if (in_symbolizer())
     return InternalCalloc(size, n);
   void *p = 0;
   {

compiler-rt/test/asan/TestCases/Linux/static_tls.cpp

 // REQUIRES: asan-64-bits
 // Regression test: __tls_get_addr interceptor must recognize static TLS.
 //
 // RUN: %clangxx_asan -DSHARED %s -shared -o %t-so.so -fPIC
 // RUN: %clangxx_asan %s -ldl -pthread -o %t %t-so.so
 // RUN: %env_asan_opts=verbosity=2 %run %t 2>&1 | FileCheck %s
 
 // CHECK: before
 // CHECK: __tls_get_addr: static tls
 // CHECK: after
 
 // XFAIL: aarch64
 // binutils 2.26 has a change that causes this test to fail on powerpc64.
-// UNSUPPORTED: powerpc64 
+// UNSUPPORTED: powerpc64
 
+/// We call __tls_get_addr early in GetTls to work around an issue for glibc<2.25,
+/// so we don't get a log for f().
+// REQUIRES: glibc-2.27
+
 #ifndef SHARED
 #include <stdio.h>
 
 unsigned *f();
 int main(int argc, char *argv[]) {
   fprintf(stderr, "before\n");
   f();
   fprintf(stderr, "after\n");
   return 0;
 }
 #else  // SHARED
 static __thread unsigned ThreadLocal;
 unsigned *f() {
   return &ThreadLocal;
 }
 #endif

compiler-rt/test/lsan/TestCases/many_tls_keys_pthread.cpp

 // Test that lsan handles tls correctly for many threads
 // RUN: LSAN_BASE="report_objects=1:use_stacks=0:use_registers=0"
 // RUN: %clangxx_lsan %s -o %t
 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=0" not %run %t 2>&1 | FileCheck %s
 // RUN: %env_lsan_opts=$LSAN_BASE:"use_tls=1" %run %t 2>&1
 // RUN: %env_lsan_opts="" %run %t 2>&1
 
 // On glibc, this requires the range returned by GetTLS to include
 // specific_1stblock and specific in `struct pthread`.
-// UNSUPPORTED: arm-linux, armhf-linux, aarch64
+// UNSUPPORTED: arm-linux, armhf-linux
 
 // TSD on NetBSD does not use TLS
 // UNSUPPORTED: netbsd
 
 #include <assert.h>
 #include <limits.h>
 #include <pthread.h>
 #include <stdlib.h>