[sanitizer] Simplify ThreadDescriptorSize on i386/x86_64/s390

[MaskRay]

Summary

ThreadDescriptorSize is only used by lsan to scan thread-specific data keys in
the thread control block.

On TLS Variant II architectures (i386/x86_64/s390), our dl_iterate_phdr
based approach can cover the region from the first byte of the static
TLS block (static TLS surplus) to the thread pointer.
We just need to extend the range to include the first few members of
struct pthread. offsetof(struct pthread, specific_used) satisfies
the requirement and has not changed since 2007-05-10. We don't need to
update ThreadDescriptorSize for each glibc version.

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_linux_libcdep.cpp

201

we don't need atomic_load_relaxed on non-glibcversion path

207

why this works only for x86?

[vitalybuka]

There is few minor unanswered questions, but I don't know if this patch is still needed.

[MaskRay]

This should be unneeded after D100892. Now we can't delete the x86-64 struct pthread size switch because we keep using the old approach for x86-64.

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
 }
 
-// ThreadDescriptorSize() is only used by lsan to get the pointer to
-// thread-specific data keys in the thread control block.
+// ThreadDescriptorSize() is only used by lsan to scan 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
 // 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__)
+#if defined(__i386__) || defined(__x86_64__) || defined(__s390__)
+  // The size of a prefix of TCB including pthread::{specific_1stblock,specific}
+  // suffices. Just return offsetof(struct pthread, specific_used), which hasn't
+  // changed since 2007-05.
+  return FIRST_32_SECOND_64(524, 1552);
+#elif defined(__arm__)
   int major;
   int minor;
   int patch;
   if (GetLibcVersion(&major, &minor, &patch) && major == 2) {
-    /* sizeof(struct pthread) values from various glibc versions.  */
-    if (SANITIZER_X32)
-      val = 1728; // Assume only one particular version for x32.
     // For ARM sizeof(struct pthread) changed in Glibc 2.23.
-    else if (SANITIZER_ARM)
-      val = minor <= 22 ? 1120 : 1216;
-    else if (minor <= 3)
-      val = FIRST_32_SECOND_64(1104, 1696);
-    else if (minor == 4)
-      val = FIRST_32_SECOND_64(1120, 1728);
-    else if (minor == 5)
-      val = FIRST_32_SECOND_64(1136, 1728);
-    else if (minor <= 9)
-      val = FIRST_32_SECOND_64(1136, 1712);
-    else if (minor == 10)
-      val = FIRST_32_SECOND_64(1168, 1776);
-    else if (minor == 11 || (minor == 12 && patch == 1))
-      val = FIRST_32_SECOND_64(1168, 2288);
-    else if (minor <= 14)
-      val = FIRST_32_SECOND_64(1168, 2304);
-    else if (minor < 32)  // Unknown version
-      val = FIRST_32_SECOND_64(1216, 2304);
-    else  // minor == 32
-      val = FIRST_32_SECOND_64(1344, 2496);
   }
 #elif defined(__mips__)
   // TODO(sagarthakur): add more values as per different glibc versions.
   val = FIRST_32_SECOND_64(1152, 1776);
 #elif SANITIZER_RISCV64
   int major;
   int minor;
   int patch;
   if (GetLibcVersion(&major, &minor, &patch) && major == 2) {
     // TODO: consider adding an optional runtime check for an unknown (untested)
     // glibc version
     if (minor <= 28)  // WARNING: the highest tested version is 2.29
       val = 1772;     // no guarantees for this one
     else if (minor <= 31)
       val = 1772;  // tested against glibc 2.29, 2.31
     else
       val = 1936;  // tested against glibc 2.32
   }
 
 #elif defined(__aarch64__)
   // The sizeof (struct pthread) is the same from GLIBC 2.17 to 2.22.
   val = 1776;
 #elif defined(__powerpc64__)
   val = 1776; // from glibc.ppc64le 2.20-8.fc21
-#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;
 }
 
 #if defined(__mips__) || defined(__powerpc64__) || SANITIZER_RISCV64
 // TlsPreTcbSize includes size of struct pthread_descr and size of tcb

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

 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_LINUX
 
 #include "sanitizer_common/sanitizer_linux.h"
 
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_file.h"
 #include "gtest/gtest.h"
 
 #include <pthread.h>
 #include <sched.h>
 #include <stdlib.h>
 
 #include <algorithm>
 #include <vector>
 

 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
+#if (defined(__x86_64__) || defined(__i386__)) && SANITIZER_GLIBC
 // libpthread puts the thread descriptor at the end of stack space.
 void *thread_descriptor_size_test_func(void *arg) {
   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);
 }
 
 TEST(SanitizerLinux, ThreadDescriptorSize) {
   pthread_t tid;
   void *result;
   ASSERT_EQ(0, pthread_create(&tid, 0, thread_descriptor_size_test_func, 0));
   ASSERT_EQ(0, pthread_join(tid, &result));
-  EXPECT_EQ((uptr)result, ThreadDescriptorSize());
+  // On x86, ThreadDescriptorSize is the size of a prefix of struct pthread,
+  // which is smaller than the actual struct pthread size.
+  EXPECT_GT((uptr)result, ThreadDescriptorSize());
 }
 #endif
 
 TEST(SanitizerCommon, LibraryNameIs) {
   EXPECT_FALSE(LibraryNameIs("", ""));
 
   char full_name[256];
   const char *paths[] = { "", "/", "/path/to/" };