Get test executables compiling on Windows.

[zturner]

Summary

Many of the test executables use pthreads directly. This isn't portable on Windows, so this patch converts these test to use C++11 threads and mutexes. Since Windows' implementation of std::thread classes throw and catch from header files, this patch also disables exceptions when compiling with clang on Windows.

[zturner]

Fixed some more places where tests don't compile on Windows.

[emaste]

A few minor nits, overall LGTM and still passes on FreeBSD.

test/expression_command/timeout/wait-a-while.cpp

8 ↗

(On Diff #12283)

git complained about trailing whitespace here

test/functionalities/attach_resume/Makefile

4 ↗

(On Diff #12283)

Perhaps a $(LPTHREAD) make var that is set to -lpthread or empty by an included header?

test/lldbtest.py

557 ↗

(On Diff #12283)

(Perhaps in a separate commit,) we should refactor the skipIf* decorators the same way I did expectedFailure*

test/make/Makefile.rules

83

probably clearer to put this with the other 32-bit cases below

test/make/uncaught_exception.h

6

Add newline

[tfiala]

Hey Zach,

I agree with Ed's comments. If you want to do any minor fixup there, I'll give the final a run on Linux (unless you want to do that part yourself - either way is fine).

[zturner]

Fix issues pointed out in review. Also removed all instances of Makefiles directly including -lpthread for the link arguments. Instead, libraries now set ENABLE_THREADS := YES in the Makefile, which translates to the correct thing in Makefile.rules

[tfiala]

Cool I'll give this a run over here this afternoon.

[tfiala]

Cool I'll give this a run over here this afternoon.

Okay, so "this afternoon" => next morning. Sorry - looking at this now.

[tfiala]

Hey Zachary,

LGTM.

Tested:
Ubuntu 14.04 x86_64 - clang-built lldb.
MacOSX 10.9.4 - Xcode 6 Beta 5-built lldb.

Test Failures:
Unrelated - seeing TestCallStopAndContinue.py fail on both Linux and MacOSX occasionally both without and with the patch. Should not block.

[zturner]

Closed by commit rL215562 (authored by @zturner).

test/make/Makefile.rules

 # And test/functionalities/archives/Makefile:
 # MAKE_DSYM := NO
 # ARCHIVE_NAME := libfoo.a
 # ARCHIVE_C_SOURCES := a.c b.c
 
 # Uncomment line below for debugging shell commands
 # SHELL = /bin/sh -x
 
+ROOT_DIR := $(shell dirname $(realpath $(lastword $(MAKEFILE_LIST))))/
+
 #----------------------------------------------------------------------
 # If ARCH is not defined, default to x86_64.
 # If OS is not defined, use 'uname -s' to determine the OS name.
 #----------------------------------------------------------------------
 ifeq "$(ARCH)" ""
   ARCH = x86_64
 endif
 
ifeq "$(OS)" "Darwin"
   DSFLAGS =
   DSYM = $(EXE).dSYM
   AR := libtool
   ARFLAGS := -static -o
 else
   # On non-Apple platforms, -arch becomes -m
   ARCHFLAG := -m
 
-  # i386,i686 -> 32
+  # i386, i686, x86 -> 32
   # amd64, x86_64, x64 -> 64
   ifeq "$(ARCH)" "amd64"
     override ARCH := $(subst amd64,64,$(ARCH))
   endif
+  ifeq "$(ARCH)" "x86"
+    override ARCH := $(subst x86,32,$(ARCH))
+  endif
   ifeq "$(ARCH)" "x86_64"
     override ARCH := $(subst x86_64,64,$(ARCH))
   endif
   ifeq "$(ARCH)" "x64"
     override ARCH := $(subst x64,64,$(ARCH))
   endif
   ifeq "$(ARCH)" "i386"
     override ARCH := $(subst i386,32,$(ARCH))

 cxx_compiler_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1)))))
 cxx_compiler = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_compiler_notdir,$(notdir $(1)))),$(call cxx_compiler_notdir,$(1)))
 
 # Function that returns the C++ linker, given $(CC) as arg.
 cxx_linker_notdir = $(if $(findstring clang,$(1)), $(subst clang,clang++,$(1)), $(if $(findstring icc,$(1)), $(subst icc,icpc,$(1)), $(if $(findstring llvm-gcc,$(1)), $(subst llvm-gcc,llvm-g++,$(1)), $(subst gcc,g++,$(1)))))
 cxx_linker = $(if $(findstring /,$(1)),$(join $(dir $(1)), $(call cxx_linker_notdir,$(notdir $(1)))),$(call cxx_linker_notdir,$(1)))
 
 #----------------------------------------------------------------------
+# Clang for Windows doesn't yet support exceptions
+#----------------------------------------------------------------------
+ifeq "$(OS)" "Windows_NT"
+  ifneq (,$(findstring clang,$(CC)))
+    CXXFLAGS += -fno-exceptions
+    CXXFLAGS += -include $(ROOT_DIR)uncaught_exception.h
+    CXXFLAGS += -D_HAS_EXCEPTIONS=0
+  endif
+endif
+
+#----------------------------------------------------------------------
 # C++ standard library options
 #----------------------------------------------------------------------
 ifeq (1,$(USE_LIBSTDCPP))
   # Clang requires an extra flag: -stdlib=libstdc++
   ifneq (,$(findstring clang,$(CC)))
     CXXFLAGS += -stdlib=libstdc++
     LDFLAGS += -stdlib=libstdc++
   endif

test/make/uncaught_exception.h

+// MSVC header files have compilation issues when compiling with exceptions disabled.  Notably,
+// this function is compiled out when _HAS_EXCEPTIONS=0, but this function is called from another
+// place even when _HAS_EXCEPTIONS=0.  So we define a dummy implementation as a workaround and
+// force include this header file.
+static void *__uncaught_exception() { return nullptr; }
 No newline at end of file

test/python_api/lldbutil/iter/Makefile

 LEVEL = ../../../make
 
 CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
+ifneq "$(OS)" "Windows_NT"
   LD_EXTRAS := -lpthread
+endif
 CXX_SOURCES := main.cpp
 MAKE_DSYM :=NO
 
 include $(LEVEL)/Makefile.rules

test/python_api/lldbutil/iter/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C includes
-#include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <unistd.h>
 
-pthread_t g_thread_1 = NULL;
-pthread_t g_thread_2 = NULL;
-pthread_t g_thread_3 = NULL;
+// C++ includes
+#include <chrono>
+#include <mutex>
+#include <random>
+#include <thread>
+
+std::thread g_thread_1;
+std::thread g_thread_2;
+std::thread g_thread_3;
+std::mutex g_mask_mutex;
 
 typedef enum {
     eGet,
     eAssign,
     eClearBits
 } MaskAction;
 
 uint32_t mask_access (MaskAction action, uint32_t mask = 0);
 
 uint32_t
 mask_access (MaskAction action, uint32_t mask)
 {
-    static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
     static uint32_t g_mask = 0;
-    ::pthread_mutex_lock (&g_mask_mutex);
+
+    std::lock_guard<std::mutex> lock(g_mask_mutex);
     switch (action)
     {
     case eGet:
         break;
 
     case eAssign:
         g_mask |= mask;
         break;
 
     case eClearBits:
         g_mask &= ~mask;
         break;
     }
-    uint32_t new_mask = g_mask;
-    ::pthread_mutex_unlock (&g_mask_mutex);
-    return new_mask;
+    return g_mask;
 }
 
 void *
 thread_func (void *arg)
 {
     uint32_t thread_index = *((uint32_t *)arg);
     uint32_t thread_mask = (1u << (thread_index));
     printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
 
+    std::default_random_engine generator;
+    std::uniform_int_distribution<int> distribution(0, 3000000);
+
     while (mask_access(eGet) & thread_mask)
     {
         // random micro second sleep from zero to 3 seconds
-        int usec = ::rand() % 3000000;
+        int usec = distribution(generator);
         printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
-        ::usleep (usec);
+
+        std::chrono::microseconds duration(usec);
+        std::this_thread::sleep_for(duration);
         printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
     }
     printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
     return NULL;
 }
 
 
 int main (int argc, char const *argv[])
 {
-    int err;
-    void *thread_result = NULL;
     uint32_t thread_index_1 = 1;
     uint32_t thread_index_2 = 2;
     uint32_t thread_index_3 = 3;
     uint32_t thread_mask_1 = (1u << thread_index_1);
     uint32_t thread_mask_2 = (1u << thread_index_2);
     uint32_t thread_mask_3 = (1u << thread_index_3);
 
     // Make a mask that will keep all threads alive
     mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
 
     // Create 3 threads
-    err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1);
-    err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2);
-    err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3);
+    g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
+    g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
+    g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
 
     char line[64];
     while (mask_access(eGet) != 0)
     {
         printf ("Enter thread index to kill or ENTER for all:\n");
         fflush (stdout);
         // Kill threads by index, or ENTER for all threads
 
while (mask_access(eGet) != 0)
 
         break;
     }
 
     // Clear all thread bits to they all exit
     mask_access (eClearBits, UINT32_MAX);
 
     // Join all of our threads
-    err = ::pthread_join (g_thread_1, &thread_result);
-    err = ::pthread_join (g_thread_2, &thread_result);
-    err = ::pthread_join (g_thread_3, &thread_result);
+    g_thread_1.join();
+    g_thread_2.join();
+    g_thread_3.join();
 
     return 0;
 }

test/python_api/lldbutil/process/Makefile

 LEVEL = ../../../make
 
 CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
+ifneq "$(OS)" "Windows_NT"
   LD_EXTRAS := -lpthread
+endif
 CXX_SOURCES := main.cpp
 MAKE_DSYM :=NO
 
 include $(LEVEL)/Makefile.rules

test/python_api/lldbutil/process/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C includes
-#include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <unistd.h>
 
-pthread_t g_thread_1 = NULL;
-pthread_t g_thread_2 = NULL;
-pthread_t g_thread_3 = NULL;
+// C++ includes
+#include <chrono>
+#include <mutex>
+#include <random>
+#include <thread>
+
+std::thread g_thread_1;
+std::thread g_thread_2;
+std::thread g_thread_3;
+std::mutex g_mask_mutex;
 
 typedef enum {
     eGet,
     eAssign,
     eClearBits
 } MaskAction;
 
 uint32_t mask_access (MaskAction action, uint32_t mask = 0);
 
 uint32_t
 mask_access (MaskAction action, uint32_t mask)
 {
-    static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
     static uint32_t g_mask = 0;
-    ::pthread_mutex_lock (&g_mask_mutex);
+
+    std::lock_guard<std::mutex> lock(g_mask_mutex);
     switch (action)
     {
     case eGet:
         break;
 
     case eAssign:
         g_mask |= mask;
         break;
 
     case eClearBits:
         g_mask &= ~mask;
         break;
     }
-    uint32_t new_mask = g_mask;
-    ::pthread_mutex_unlock (&g_mask_mutex);
-    return new_mask;
+    return g_mask;
 }
 
 void *
 thread_func (void *arg)
 {
     uint32_t thread_index = *((uint32_t *)arg);
     uint32_t thread_mask = (1u << (thread_index));
     printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
 
+    std::default_random_engine generator;
+    std::uniform_int_distribution<int> distribution(0, 3000000);
+
     while (mask_access(eGet) & thread_mask)
     {
         // random micro second sleep from zero to 3 seconds
-        int usec = ::rand() % 3000000;
+        int usec = distribution(generator);
+
         printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
-        ::usleep (usec);
+        std::chrono::microseconds duration(usec);
+        std::this_thread::sleep_for(duration);
         printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
     }
     printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
     return NULL;
 }
 
 
 int main (int argc, char const *argv[])
 {
     int err;
     void *thread_result = NULL;
     uint32_t thread_index_1 = 1;
     uint32_t thread_index_2 = 2;
     uint32_t thread_index_3 = 3;
     uint32_t thread_mask_1 = (1u << thread_index_1);
     uint32_t thread_mask_2 = (1u << thread_index_2);
     uint32_t thread_mask_3 = (1u << thread_index_3);
 
     // Make a mask that will keep all threads alive
     mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
 
     // Create 3 threads
-    err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1);
-    err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2);
-    err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3);
+    g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
+    g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
+    g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
 
     char line[64];
     while (mask_access(eGet) != 0)
     {
         printf ("Enter thread index to kill or ENTER for all:\n");
         fflush (stdout);
         // Kill threads by index, or ENTER for all threads
 
while (mask_access(eGet) != 0)
 
         break;
     }
 
     // Clear all thread bits to they all exit
     mask_access (eClearBits, UINT32_MAX);
 
     // Join all of our threads
-    err = ::pthread_join (g_thread_1, &thread_result);
-    err = ::pthread_join (g_thread_2, &thread_result);
-    err = ::pthread_join (g_thread_3, &thread_result);
+    g_thread_1.join();
+    g_thread_2.join();
+    g_thread_3.join();
 
     return 0;
 }

test/python_api/module_section/Makefile

 LEVEL = ../../make
 
 CFLAGS_EXTRAS := -D__STDC_LIMIT_MACROS
+ifneq "$(OS)" "Windows_NT"
   LD_EXTRAS := -lpthread
+endif
 CXX_SOURCES := main.cpp b.cpp c.cpp
 MAKE_DSYM :=NO
 
 include $(LEVEL)/Makefile.rules

test/python_api/module_section/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C includes
-#include <pthread.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <unistd.h>
 
-pthread_t g_thread_1 = NULL;
-pthread_t g_thread_2 = NULL;
-pthread_t g_thread_3 = NULL;
+// C++ includes
+#include <chrono>
+#include <mutex>
+#include <random>
+#include <thread>
+
+std::thread g_thread_1;
+std::thread g_thread_2;
+std::thread g_thread_3;
+std::mutex g_mask_mutex;
 
 typedef enum {
     eGet,
     eAssign,
     eClearBits
 } MaskAction;
 
 uint32_t mask_access (MaskAction action, uint32_t mask = 0);
 
 uint32_t
 mask_access (MaskAction action, uint32_t mask)
 {
-    static pthread_mutex_t g_mask_mutex = PTHREAD_MUTEX_INITIALIZER;
     static uint32_t g_mask = 0;
-    ::pthread_mutex_lock (&g_mask_mutex);
+
+    std::lock_guard<std::mutex> lock(g_mask_mutex);
     switch (action)
     {
     case eGet:
         break;
 
     case eAssign:
         g_mask |= mask;
         break;
 
     case eClearBits:
         g_mask &= ~mask;
         break;
     }
-    uint32_t new_mask = g_mask;
-    ::pthread_mutex_unlock (&g_mask_mutex);
-    return new_mask;
+    return g_mask;
 }
 
 void *
 thread_func (void *arg)
 {
     uint32_t thread_index = *((uint32_t *)arg);
     uint32_t thread_mask = (1u << (thread_index));
     printf ("%s (thread index = %u) startng...\n", __FUNCTION__, thread_index);
 
+    std::default_random_engine generator;
+    std::uniform_int_distribution<int> distribution(0, 3000000);
+
     while (mask_access(eGet) & thread_mask)
     {
         // random micro second sleep from zero to 3 seconds
-        int usec = ::rand() % 3000000;
+        int usec = distribution(generator);
+
         printf ("%s (thread = %u) doing a usleep (%d)...\n", __FUNCTION__, thread_index, usec);
-        ::usleep (usec);
+        std::chrono::microseconds duration(usec);
+        std::this_thread::sleep_for(duration);
         printf ("%s (thread = %u) after usleep ...\n", __FUNCTION__, thread_index); // Set break point at this line.
     }
     printf ("%s (thread index = %u) exiting...\n", __FUNCTION__, thread_index);
     return NULL;
 }
 
 
 int main (int argc, char const *argv[])
 {
     int err;
     void *thread_result = NULL;
     uint32_t thread_index_1 = 1;
     uint32_t thread_index_2 = 2;
     uint32_t thread_index_3 = 3;
     uint32_t thread_mask_1 = (1u << thread_index_1);
     uint32_t thread_mask_2 = (1u << thread_index_2);
     uint32_t thread_mask_3 = (1u << thread_index_3);
 
     // Make a mask that will keep all threads alive
     mask_access (eAssign, thread_mask_1 | thread_mask_2 | thread_mask_3); // And that line.
 
     // Create 3 threads
-    err = ::pthread_create (&g_thread_1, NULL, thread_func, &thread_index_1);
-    err = ::pthread_create (&g_thread_2, NULL, thread_func, &thread_index_2);
-    err = ::pthread_create (&g_thread_3, NULL, thread_func, &thread_index_3);
+    g_thread_1 = std::thread(thread_func, (void*)&thread_index_1);
+    g_thread_2 = std::thread(thread_func, (void*)&thread_index_2);
+    g_thread_3 = std::thread(thread_func, (void*)&thread_index_3);
 
     char line[64];
     while (mask_access(eGet) != 0)
     {
         printf ("Enter thread index to kill or ENTER for all:\n");
         fflush (stdout);
         // Kill threads by index, or ENTER for all threads
 
while (mask_access(eGet) != 0)
 
         break;
     }
 
     // Clear all thread bits to they all exit
     mask_access (eClearBits, UINT32_MAX);
 
     // Join all of our threads
-    err = ::pthread_join (g_thread_1, &thread_result);
-    err = ::pthread_join (g_thread_2, &thread_result);
-    err = ::pthread_join (g_thread_3, &thread_result);
+    g_thread_1.join();
+    g_thread_2.join();
+    g_thread_3.join();
 
     return 0;
 }

test/python_api/signals/main.cpp

 //===-- main.c --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 #include <stdio.h>
 #include <sys/types.h>
+#if defined(_WIN32)
+#include <windows.h>
+#else
 #include <unistd.h>
 #include <signal.h>
+#endif
 
 // This simple program is to test the lldb Python API related to process.
 
 int main (int argc, char const *argv[])
 {
+#if defined(_WIN32)
+    ::ExitProcess(1);
+#else
     kill(getpid(), SIGINT); // Set break point at this line and setup signal ignores.
+#endif
     return 0;
 }