MingW compilation (windows). Includes various refactoring to improve portability.

llvm-svn: 189107

Author: xen2

lldb/CMakeLists.txt

@@ -71,6 +71,10 @@ if (CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
   endif() 
 endif()
 
+if ( CMAKE_SYSTEM_NAME MATCHES "Windows" )
+  add_definitions( -DLLDB_DISABLE_PYTHON )
+endif ()
+
 macro(add_lldb_definitions)
   # We don't want no semicolons on LLDB_DEFINITIONS:
   foreach(arg ${ARGN})
@@ -182,7 +186,7 @@ macro(add_lldb_library name)
   #endif()
 
   if(LLDB_USED_LIBS)
-    if (CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+    if (CMAKE_SYSTEM_NAME MATCHES "Linux" OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD" OR CMAKE_SYSTEM_NAME MATCHES "Windows")
       target_link_libraries(${name} -Wl,--start-group ${LLDB_USED_LIBS} -Wl,--end-group)
     else()
       target_link_libraries(${name} ${LLDB_USED_LIBS})
@@ -260,7 +264,9 @@ endif()
 
 #add_subdirectory(include)
 add_subdirectory(docs)
-add_subdirectory(scripts)
+if (NOT CMAKE_SYSTEM_NAME MATCHES "Windows")
+  add_subdirectory(scripts)
+endif()
 add_subdirectory(source)
 add_subdirectory(test)
 add_subdirectory(tools)

lldb/Makefile

@@ -28,18 +28,22 @@ LEVEL := $(LLDB_LEVEL)/../..
 # Include LLVM common makefile.
 include $(LEVEL)/Makefile.common
 
-# Set Python include directory
-PYTHON_INC_DIR = $(shell python-config --includes)
 # Set common LLDB build flags.
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLDB_LEVEL)/include 
 CPP.Flags += -I$(PROJ_OBJ_DIR)/$(LLDB_LEVEL)/include
 CPP.Flags += -I$(LLVM_SRC_ROOT)/tools/clang/include
 CPP.Flags += -I$(LLVM_OBJ_ROOT)/tools/clang/include
-CPP.Flags +=   $(PYTHON_INC_DIR)
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLDB_LEVEL)/source
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLDB_LEVEL)/source/Utility
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLDB_LEVEL)/source/Plugins/Process/Utility
 CPP.Flags += -I$(PROJ_SRC_DIR)/$(LLDB_LEVEL)/source/Plugins/Process/POSIX
+
+ifeq (,$(findstring -DLLDB_DISABLE_PYTHON,$(CXXFLAGS)))
+# Set Python include directory
+PYTHON_INC_DIR = $(shell python-config --includes)
+CPP.Flags +=   $(PYTHON_INC_DIR)
+endif
+
 ifeq ($(HOST_OS),Darwin)
 CPP.Flags += -F/System/Library/Frameworks -F/System/Library/PrivateFrameworks
 CPP.Flags += -I/usr/include/libxml2

lldb/include/lldb/API/SBHostOS.h

@@ -30,7 +30,7 @@ class SBHostOS
 
     static lldb::thread_t
     ThreadCreate (const char *name,
-                  void *(*thread_function)(void *),
+                  thread_func_t thread_function,
                   void *thread_arg,
                   lldb::SBError *err);
 
@@ -43,7 +43,7 @@ class SBHostOS
                   lldb::SBError *err);
     static bool
     ThreadJoin (lldb::thread_t thread,
-                void **result,
+                thread_result_t *result,
                 lldb::SBError *err);
 
 

lldb/include/lldb/Core/ConnectionFileDescriptor.h

@@ -11,9 +11,13 @@
 #define liblldb_ConnectionFileDescriptor_h_
 
 // C Includes
+#ifdef _WIN32
+typedef unsigned short in_port_t;
+#else
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <netinet/in.h>
+#endif
 
 // C++ Includes
 // Other libraries and framework includes

lldb/include/lldb/Core/RegularExpression.h

@@ -11,7 +11,36 @@
 #define liblldb_DBRegex_h_
 #if defined(__cplusplus)
 
+#ifdef _WIN32
+#include "../lib/Support/regex_impl.h"
+
+typedef llvm_regmatch_t regmatch_t;
+typedef llvm_regex_t regex_t;
+
+inline int regcomp(llvm_regex_t * a, const char *b, int c)
+{
+    return llvm_regcomp(a, b, c);
+}
+
+inline size_t regerror(int a, const llvm_regex_t *b, char *c, size_t d)
+{
+    return llvm_regerror(a, b, c, d);
+}
+
+inline int regexec(const llvm_regex_t * a, const char * b, size_t c,
+    llvm_regmatch_t d [], int e)
+{
+    return llvm_regexec(a, b, c, d, e);
+}
+
+inline void regfree(llvm_regex_t * a)
+{
+    llvm_regfree(a);
+}
+
+#else
 #include <regex.h>
+#endif
 #include <stdint.h>
 
 #include <string>

lldb/include/lldb/Core/Value.h

@@ -114,7 +114,7 @@ class Value
 #if defined (ENABLE_128_BIT_SUPPORT)
                 else if (length >= 16) scalar = *(const __uint128_t *)bytes;
 #else
-                else if (length >= 16) scalar = *(const __uint64_t *)bytes;
+                else if (length >= 16) scalar = *(const uint64_t *)bytes;
 #endif
             }
             return scalar;

lldb/include/lldb/Host/Condition.h

@@ -12,7 +12,7 @@
 #if defined(__cplusplus)
 
 
-#include <pthread.h>
+#include "lldb/lldb-types.h"
 #include "lldb/Host/Mutex.h"
 
 namespace lldb_private {
@@ -105,15 +105,15 @@ class Condition
     //------------------------------------------------------------------
     // Member variables
     //------------------------------------------------------------------
-    pthread_cond_t m_condition; ///< The condition variable.
+    lldb::condition_t m_condition; ///< The condition variable.
 
     //------------------------------------------------------------------
     /// Get accessor to the pthread condition object.
     ///
     /// @return
     ///     A pointer to the condition variable owned by this object.
     //------------------------------------------------------------------
-    pthread_cond_t *
+    lldb::condition_t *
     GetCondition ();
 };
 

lldb/include/lldb/Host/Host.h

@@ -209,6 +209,9 @@ class Host
     static lldb::pid_t
     GetCurrentProcessID ();
 
+    static void
+    Kill(lldb::pid_t pid, int signo);
+
     //------------------------------------------------------------------
     /// Get the thread ID for the calling thread in the current process.
     ///
@@ -264,6 +267,17 @@ class Host
                 lldb::thread_result_t *thread_result_ptr,
                 Error *error);
 
+    typedef void (*ThreadLocalStorageCleanupCallback) (void *p);
+
+    static lldb::thread_key_t
+    ThreadLocalStorageCreate(ThreadLocalStorageCleanupCallback callback);
+
+    static void*
+    ThreadLocalStorageGet(lldb::thread_key_t key);
+
+    static void
+    ThreadLocalStorageSet(lldb::thread_key_t key, void *value);
+
     //------------------------------------------------------------------
     /// Gets the name of a thread in a process.
     ///

lldb/include/lldb/Host/Mutex.h

@@ -11,7 +11,7 @@
 #define liblldb_Mutex_h_
 #if defined(__cplusplus)
 
-#include <pthread.h>
+#include "lldb/lldb-types.h"
 #include <assert.h>
 
 #ifdef LLDB_CONFIGURATION_DEBUG
@@ -238,7 +238,7 @@ class Mutex
     //------------------------------------------------------------------
     // TODO: Hide the mutex in the implementation file in case we ever need to port to an
     // architecture that doesn't have pthread mutexes.
-    pthread_mutex_t m_mutex; ///< The pthread mutex object.
+    lldb::mutex_t m_mutex; ///< The OS mutex object.
 
 private:
     //------------------------------------------------------------------
@@ -247,7 +247,7 @@ class Mutex
     /// @return
     ///     A pointer to the pthread mutex object owned by this object.
     //------------------------------------------------------------------
-    pthread_mutex_t *
+    lldb::mutex_t *
     GetMutex();
 
     Mutex(const Mutex&);

lldb/include/lldb/Host/ProcessRunLock.h

@@ -11,9 +11,9 @@
 #define liblldb_ProcessRunLock_h_
 #if defined(__cplusplus)
 
+#include "lldb/lldb-defines.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Host/Condition.h"
-#include <pthread.h>
 #include <stdint.h>
 #include <time.h>
 
@@ -32,75 +32,14 @@ namespace lldb_private {
 class ProcessRunLock
 {
 public:
-    ProcessRunLock () :
-        m_rwlock(),
-        m_running(false)
-    {
-        int err = ::pthread_rwlock_init(&m_rwlock, NULL); (void)err;
-//#if LLDB_CONFIGURATION_DEBUG
-//        assert(err == 0);
-//#endif
-    }
-
-    ~ProcessRunLock ()
-    {
-        int err = ::pthread_rwlock_destroy (&m_rwlock); (void)err;
-//#if LLDB_CONFIGURATION_DEBUG
-//        assert(err == 0);
-//#endif
-    }
-
-    bool
-    ReadTryLock ()
-    {
-        ::pthread_rwlock_rdlock (&m_rwlock);
-        if (m_running == false)
-        {
-            return true;
-        }
-        ::pthread_rwlock_unlock (&m_rwlock);
-        return false;
-    }
-
-    bool
-    ReadUnlock ()
-    {
-        return ::pthread_rwlock_unlock (&m_rwlock) == 0;
-    }
-    
-    bool
-    SetRunning()
-    {
-        ::pthread_rwlock_wrlock (&m_rwlock);
-        m_running = true;
-        ::pthread_rwlock_unlock (&m_rwlock);
-        return true;
-    }
-    
-    bool
-    TrySetRunning()
-    {
-        bool r;
-
-        if (::pthread_rwlock_trywrlock (&m_rwlock) == 0)
-        {
-            r = !m_running;
-            m_running = true;
-            ::pthread_rwlock_unlock (&m_rwlock);
-            return r;
-        }
-        return false;
-    }
-    
-    bool
-    SetStopped ()
-    {
-        ::pthread_rwlock_wrlock (&m_rwlock);
-        m_running = false;
-        ::pthread_rwlock_unlock (&m_rwlock);
-        return true;
-    }
-
+    ProcessRunLock();
+    ~ProcessRunLock();
+    bool ReadTryLock ();
+    bool ReadUnlock ();
+    bool SetRunning ();
+    bool TrySetRunning ();
+    bool SetStopped ();
+public:
     class ProcessRunLocker
     {
     public:
@@ -153,7 +92,7 @@ class ProcessRunLock
     };
 
 protected:
-    pthread_rwlock_t m_rwlock;
+    lldb::rwlock_t m_rwlock;
     bool m_running;
 private:
     DISALLOW_COPY_AND_ASSIGN(ProcessRunLock);