[ASan tests] Make simple pthread tests compile and pass on Windows

[kcc]

lib/asan/tests/asan_test_utils.h

44

I'd prefer this code to be in a separate .h file included here.

58

maybe win32_pthread_foo ?

[timurrrr]

Moved the pthread wrappers to sanitizer_common/tests, also restructured stuff a little bit

[timurrrr]

lib/asan/tests/asan_test_utils.h

44

Done -- and moved to sanitizer_common/tests as in fact we use pthread stuff in sanitizer tests too.

58

On the second thought, I think we don't need macros at all there?

[kcc]

LGTM with a small nit

lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h

66

#endif // _WIN32

[timurrrr]

Landed as r208674.

lib/asan/tests/asan_test_utils.h

 
 #if !defined(ASAN_EXTERNAL_TEST_CONFIG)
 # define INCLUDED_FROM_ASAN_TEST_UTILS_H
 # include "asan_test_config.h"
 # undef INCLUDED_FROM_ASAN_TEST_UTILS_H
 #endif
 
 #include "sanitizer_test_utils.h"
+#include "sanitizer_pthread_wrappers.h"
+
 #include <stdio.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include <stdint.h>
 #include <assert.h>
 #include <algorithm>
 
 #if !defined(_WIN32)
-#include <strings.h>
-#include <pthread.h>
-#include <sys/mman.h>
-#include <setjmp.h>
+# include <strings.h>
+# include <sys/mman.h>
+# include <setjmp.h>
 #endif
 
 #ifdef __linux__
 # include <sys/prctl.h>
 # include <sys/types.h>
 # include <sys/stat.h>
 # include <fcntl.h>
 #include <unistd.h>
 #endif
 
 #if !defined(__APPLE__) && !defined(__FreeBSD__)
 #include <malloc.h>
 #endif
 
-// Check that pthread_create/pthread_join return success.
-#define PTHREAD_CREATE(a, b, c, d) ASSERT_EQ(0, pthread_create(a, b, c, d))
-#define PTHREAD_JOIN(a, b) ASSERT_EQ(0, pthread_join(a, b))
-
 #if ASAN_HAS_EXCEPTIONS
 # define ASAN_THROW(x) throw (x)
 #else
 # define ASAN_THROW(x)
 #endif
 
 typedef uint8_t   U1;
 typedef uint16_t  U2;
 typedef uint32_t  U4;
 typedef uint64_t  U8;
 
 static const int kPageSize = 4096;
 
 const size_t kLargeMalloc = 1 << 24;
 

lib/sanitizer_common/tests/CMakeLists.txt

set(SANITIZER_UNITTESTS
   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)
 
 set(SANITIZER_TEST_HEADERS
+  sanitizer_pthread_wrappers.h
   sanitizer_test_utils.h)
 foreach(header ${SANITIZER_HEADERS})
   list(APPEND SANITIZER_TEST_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../${header})
 endforeach()
 
 set(SANITIZER_TEST_CFLAGS_COMMON
   ${COMPILER_RT_GTEST_CFLAGS}
   -I${COMPILER_RT_SOURCE_DIR}/include

lib/sanitizer_common/tests/sanitizer_pthread_wrappers.h

+//===-- sanitizer_pthread_wrappers.h ----------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is a part of *Sanitizer runtime.
+// It provides handy wrappers for thread manipulation, that:
+//  a) assert on any failure rather than returning an error code
+//  b) defines pthread-like interface on platforms where where <pthread.h>
+//     is not supplied by default.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SANITIZER_PTHREAD_WRAPPERS_H
+#define SANITIZER_PTHREAD_WRAPPERS_H
+
+#include "sanitizer_test_utils.h"
+
+#include "gtest/gtest.h"
+
+#if !defined(_WIN32)
+# include <pthread.h>
+// Simply forward the arguments and check that the pthread functions succeed.
+# define PTHREAD_CREATE(a, b, c, d) ASSERT_EQ(0, pthread_create(a, b, c, d))
+# define PTHREAD_JOIN(a, b) ASSERT_EQ(0, pthread_join(a, b))
+#else
+typedef HANDLE pthread_t;
+
+struct PthreadHelperCreateThreadInfo {
+  void *(*start_routine)(void *);
+  void *arg;
+};
+
+inline DWORD WINAPI PthreadHelperThreadProc(void *arg) {
+  PthreadHelperCreateThreadInfo *start_data =
+      reinterpret_cast<PthreadHelperCreateThreadInfo*>(arg);
+  void *ret = (start_data->start_routine)(start_data->arg);
+  delete start_data;
+  return (DWORD)ret;
+}
+
+inline void PTHREAD_CREATE(pthread_t *thread, void *attr,
+                           void *(*start_routine)(void *), void *arg) {
+  ASSERT_EQ(0, attr) << "Thread attributes are not supported yet.";
+  PthreadHelperCreateThreadInfo *data = new PthreadHelperCreateThreadInfo;
+  data->start_routine = start_routine;
+  data->arg = arg;
+  *thread = CreateThread(0, 0, PthreadHelperThreadProc, data, 0, 0);
+  ASSERT_NE(nullptr, *thread) << "Failed to create a thread.";
+}
+
+inline void PTHREAD_JOIN(pthread_t thread, void **value_ptr) {
+  ASSERT_EQ(0, value_ptr) << "Nonzero value_ptr is not supported yet.";
+  ASSERT_EQ(WAIT_OBJECT_0, WaitForSingleObject(thread, INFINITE));
+  ASSERT_NE(0, CloseHandle(thread));
+}
+
+inline void pthread_exit(void *retval) {
+  ASSERT_EQ(0, retval) << "Nonzero retval is not supported yet.";
+  ExitThread((DWORD)retval);
+}
+#endif
+
+#endif  // SANITIZER_PTHREAD_WRAPPERS_H

lib/sanitizer_common/tests/sanitizer_test_utils.h

 // This file is a part of *Sanitizer runtime.
 // Common unit tests utilities.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_TEST_UTILS_H
 #define SANITIZER_TEST_UTILS_H
 
+#if defined(_WIN32)
+// <windows.h> should always be the first include on Windows.
+# include <windows.h>
+// MSVS headers define max/min as macros, so std::max/min gets crazy.
+# undef max
+# undef min
+#endif
+
 #include <stdint.h>
 
 #if defined(_MSC_VER)
 # define NOINLINE __declspec(noinline)
 #else  // defined(_MSC_VER)
 # define NOINLINE __attribute__((noinline))
 #endif  // defined(_MSC_VER)