[sanitizer] Define kPthreadDestructorIterations on POSIX systems.

[samsonov]

LGTM

lib/sanitizer_common/sanitizer_platform_limits_posix.h

18

I'd rather not include this (and would use int instead of uptr for kPthreadDestructorIterations).

[earthdok]

moved the constant to sanitizer_common.h as discussed

[earthdok]

Committed r192453

lib/sanitizer_common/sanitizer_linux.h

 
 // Read the name of the current binary from /proc/self/exe.
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len);
 // Cache the value of /proc/self/exe.
 void CacheBinaryName();
 
 // Call cb for each region mapped by map.
 void ForEachMappedRegion(link_map *map, void (*cb)(const void *, uptr));
-
-// PTHREAD_DESTRUCTOR_ITERATIONS from glibc.
-const uptr kPthreadDestructorIterations = 4;
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX
 #endif  // SANITIZER_LINUX_H

lib/sanitizer_common/sanitizer_platform_limits_posix.h

 // This file is a part of Sanitizer common code.
 //
 // Sizes and layouts of platform-specific POSIX data structures.
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
 #define SANITIZER_PLATFORM_LIMITS_POSIX_H
 
+#include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 
 namespace __sanitizer {
   extern unsigned struct_utsname_sz;
   extern unsigned struct_stat_sz;
   extern unsigned struct_stat64_sz;
   extern unsigned struct_rusage_sz;
   extern unsigned struct_passwd_sz;
#if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned IOCTL_SIOCNRSETPARMS;
   extern unsigned IOCTL_SNDCTL_DSP_GETISPACE;
   extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE;
   extern unsigned IOCTL_TIOCGSERIAL;
   extern unsigned IOCTL_TIOCSERGETMULTI;
   extern unsigned IOCTL_TIOCSERSETMULTI;
   extern unsigned IOCTL_TIOCSSERIAL;
 #endif
+
+// PTHREAD_DESTRUCTOR_ITERATIONS from libc.
+const uptr kPthreadDestructorIterations = 4;
 }  // namespace __sanitizer
 
 #endif
 

lib/sanitizer_common/tests/CMakeLists.txt

 include(CompilerRTCompile)
 
 set(SANITIZER_UNITTESTS
   sanitizer_allocator_test.cc
   sanitizer_atomic_test.cc
   sanitizer_common_test.cc
   sanitizer_flags_test.cc
   sanitizer_ioctl_test.cc
   sanitizer_libc_test.cc
   sanitizer_linux_test.cc
   sanitizer_list_test.cc
   sanitizer_mutex_test.cc
   sanitizer_nolibc_test.cc
+  sanitizer_posix_test.cc
   sanitizer_printf_test.cc
   sanitizer_scanf_interceptor_test.cc
   sanitizer_stackdepot_test.cc
   sanitizer_stacktrace_test.cc
   sanitizer_stoptheworld_test.cc
   sanitizer_suppressions_test.cc
   sanitizer_test_main.cc
   sanitizer_thread_registry_test.cc)

lib/sanitizer_common/tests/sanitizer_linux_test.cc

for (uptr j = 0; j < ARRAY_SIZE(suffixes); j++) {
         for (uptr m = 0; m < ARRAY_SIZE(wrong_names); m++)
           EXPECT_FALSE(LibraryNameIs(full_name, wrong_names[m]))
             << "Full name " << full_name
             << " matches base name " << wrong_names[m];
       }
     }
 }
 
-static pthread_key_t key;
-static bool destructor_executed;
-
-extern "C"
-void destructor(void *arg) {
-  uptr iter = reinterpret_cast<uptr>(arg);
-  if (iter > 1) {
-    ASSERT_EQ(0, pthread_setspecific(key, reinterpret_cast<void *>(iter - 1)));
-    return;
-  }
-  destructor_executed = true;
-}
-
-extern "C"
-void *thread_func(void *arg) {
-  return reinterpret_cast<void*>(pthread_setspecific(key, arg));
-}
-
-static void SpawnThread(uptr iteration) {
-  destructor_executed = false;
-  pthread_t tid;
-  ASSERT_EQ(0, pthread_create(&tid, 0, &thread_func,
-                              reinterpret_cast<void *>(iteration)));
-  void *retval;
-  ASSERT_EQ(0, pthread_join(tid, &retval));
-  ASSERT_EQ(0, retval);
-}
-
-TEST(SanitizerCommon, PthreadDestructorIterations) {
-  ASSERT_EQ(0, pthread_key_create(&key, &destructor));
-  SpawnThread(kPthreadDestructorIterations);
-  EXPECT_TRUE(destructor_executed);
-  SpawnThread(kPthreadDestructorIterations + 1);
-  EXPECT_FALSE(destructor_executed);
-}
-
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_LINUX

lib/sanitizer_common/tests/sanitizer_posix_test.cc

+//===-- sanitizer_posix_test.cc -------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Tests for POSIX-specific code.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_platform.h"
+#if SANITIZER_POSIX
+
+#include "sanitizer_common/sanitizer_platform_limits_posix.h"
+#include "gtest/gtest.h"
+
+#include <pthread.h>
+
+namespace __sanitizer {
+
+static pthread_key_t key;
+static bool destructor_executed;
+
+extern "C"
+void destructor(void *arg) {
+  uptr iter = reinterpret_cast<uptr>(arg);
+  if (iter > 1) {
+    ASSERT_EQ(0, pthread_setspecific(key, reinterpret_cast<void *>(iter - 1)));
+    return;
+  }
+  destructor_executed = true;
+}
+
+extern "C"
+void *thread_func(void *arg) {
+  return reinterpret_cast<void*>(pthread_setspecific(key, arg));
+}
+
+static void SpawnThread(uptr iteration) {
+  destructor_executed = false;
+  pthread_t tid;
+  ASSERT_EQ(0, pthread_create(&tid, 0, &thread_func,
+                              reinterpret_cast<void *>(iteration)));
+  void *retval;
+  ASSERT_EQ(0, pthread_join(tid, &retval));
+  ASSERT_EQ(0, retval);
+}
+
+TEST(SanitizerCommon, PthreadDestructorIterations) {
+  ASSERT_EQ(0, pthread_key_create(&key, &destructor));
+  SpawnThread(kPthreadDestructorIterations);
+  EXPECT_TRUE(destructor_executed);
+  SpawnThread(kPthreadDestructorIterations + 1);
+  EXPECT_FALSE(destructor_executed);
+}
+
+}  // namespace __sanitizer
+
+#endif  // SANITIZER_POSIX