implement condition-variable to gthr-win32 needed for std::thread family. modify from gcc-4.7.0.

gthr-win32-gcc471.patch

diff --git a/libgcc/config/i386/gthr-win32.c b/libgcc/config/i386/gthr-win32.c
index ab1b69f..4b35582 100644
--- a/libgcc/config/i386/gthr-win32.c
+++ b/libgcc/config/i386/gthr-win32.c
@@ -1,11 +1,13 @@
 /* Implementation of W32-specific threads compatibility routines for
    libgcc2.  */
 
-/* Copyright (C) 1999, 2000, 2002, 2004, 2008, 2009, 2011
+/* Copyright (C) 1999, 2000, 2002, 2004, 2008, 2009, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
    Modified and moved to separate file by Danny Smith
    <dannysmith@users.sourceforge.net>.
+   Implemented Condition Variable by Tomohiro Kashiwada
+   <kikairoya@gmail.com>.
 
 This file is part of GCC.
 
@@ -29,6 +31,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include <windows.h>
+#include <process.h>
 #ifndef __GTHREAD_HIDE_WIN32API
 # define __GTHREAD_HIDE_WIN32API 1
 #endif
@@ -202,7 +205,7 @@ __gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
 int
 __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 {
-  DWORD me = GetCurrentThreadId();
+  DWORD me = GetCurrentThreadId ();
   if (InterlockedIncrement (&mutex->counter) == 0)
     {
       mutex->depth = 1;
@@ -231,7 +234,7 @@ __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 int
 __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
 {
-  DWORD me = GetCurrentThreadId();
+  DWORD me = GetCurrentThreadId ();
   if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
     {
       mutex->depth = 1;
@@ -259,3 +262,266 @@ __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
 
   return 0;
 }
+
+static DWORD
+gthread_calc_time_offset (const __gthread_time_t *abs_time)
+{
+  FILETIME ft;
+  LONGLONG ll;
+  LONGLONG ret;
+  GetSystemTimeAsFileTime (&ft);
+  ll = ((LONGLONG)ft.dwHighDateTime << 32) + ft.dwLowDateTime;
+  ret = (((LONGLONG)abs_time->tv_sec * 10000000 + abs_time->tv_nsec / 100)
+	 - (ll - 116444736000000000)) / 10000;
+  if (ret < 0)
+    return 0;
+  if (ret > 0x7FFFFFFF)
+    return 0x7FFFFFFF;
+  return ret;
+}
+
+int
+__gthr_win32_cond_init (__gthread_cond_t *cond,
+			void *attr __attribute__((unused)))
+{
+  cond->counter = -1;
+  cond->pcs = malloc (sizeof (CRITICAL_SECTION));
+  InitializeCriticalSection ((LPCRITICAL_SECTION)cond->pcs);
+  cond->sema = CreateSemaphore (NULL, 0, 65535, NULL);
+  return 0;
+}
+
+int
+__gthr_win32_cond_destroy (__gthread_cond_t *cond)
+{
+  __gthread_cond_broadcast (cond);
+  free (cond->pcs);
+  CloseHandle ((HANDLE)cond->sema);
+  return 0;
+}
+
+int
+__gthr_win32_cond_broadcast (__gthread_cond_t *cond)
+{
+  EnterCriticalSection (cond->pcs);
+  if (cond->counter >= 0)
+    ReleaseSemaphore (cond->sema, cond->counter+1, NULL);
+  cond->counter = -1;
+  LeaveCriticalSection (cond->pcs);
+  return 0;
+}
+
+static int
+cond_wait_impl (__gthread_cond_t *cond,
+		__gthread_mutex_t *mutex, DWORD timeout)
+{
+  EnterCriticalSection (cond->pcs);
+  ++cond->counter;
+  LeaveCriticalSection (cond->pcs);
+  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
+      != WAIT_OBJECT_0)
+    {
+      EnterCriticalSection (cond->pcs);
+      --cond->counter;
+      LeaveCriticalSection (cond->pcs);
+    }
+  WaitForSingleObject (mutex->sema, INFINITE);
+  return 0;
+}
+
+static int
+cond_wait_recursive_impl (__gthread_cond_t *cond,
+			  __gthread_recursive_mutex_t *mutex, DWORD timeout)
+{
+  EnterCriticalSection (cond->pcs);
+  ++cond->counter;
+  LeaveCriticalSection (cond->pcs);
+  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
+      != WAIT_OBJECT_0)
+    {
+      EnterCriticalSection (cond->pcs);
+      --cond->counter;
+      LeaveCriticalSection (cond->pcs);
+    }
+  WaitForSingleObject (mutex->sema, INFINITE);
+  return 0;
+}
+
+int
+__gthr_win32_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
+{
+  return cond_wait_impl (cond, mutex, INFINITE);
+}
+
+int
+__gthr_win32_cond_wait_recursive (__gthread_cond_t *cond,
+				  __gthread_recursive_mutex_t *mutex)
+{
+  return cond_wait_recursive_impl (cond, mutex, INFINITE);
+}
+
+static unsigned
+get_thread_id (__gthread_t thr)
+{
+  if (thr)
+    return thr->id;
+  return GetCurrentThreadId ();
+}
+
+static DWORD gthr_gthread_t_get_slot (void)
+{
+  static DWORD gthread_slot = 0xFFFFFFFF;
+  if (gthread_slot == 0xFFFFFFFF)
+    {
+      DWORD s = TlsAlloc ();
+      if (__GTHR_W32_InterlockedCompareExchange(&gthread_slot, s, 0xFFFFFFFF)
+	  != 0xFFFFFFFF)
+	{
+	  TlsFree (s);
+	  return gthread_slot;
+	}
+      else
+	{
+	  __gthread_t thr = (__gthread_t)malloc (sizeof (__gthread_solid_t));
+	  thr->func = NULL;
+	  thr->arg = NULL;
+	  thr->id = GetCurrentThreadId ();
+	  DuplicateHandle(GetCurrentProcess (), GetCurrentThread (),
+			  GetCurrentProcess (), (HANDLE *)&thr->id,
+			  0, FALSE, DUPLICATE_SAME_ACCESS);
+	  TlsSetValue(gthread_slot, thr);
+	}
+    }
+  return gthread_slot;
+}
+
+static unsigned __stdcall
+gthr_entry_stub (void *arg)
+{
+  __gthread_t p = (__gthread_t)arg;
+  TlsSetValue (gthr_gthread_t_get_slot (), arg);
+  return (unsigned)(*p->func) (p->arg);
+}
+
+
+int
+__gthr_win32_create (__gthread_t *thrp, void *(*func) (void *), void *arg)
+{
+  gthr_gthread_t_get_slot ();
+  *thrp = (__gthread_t)malloc (sizeof (__gthread_solid_t));
+  (*thrp)->func = func;
+  (*thrp)->arg = arg;
+  (*thrp)->handle = (void *)_beginthreadex (NULL, 0, &gthr_entry_stub, *thrp,
+					    CREATE_SUSPENDED, &(*thrp)->id);
+  ResumeThread((HANDLE)(*thrp)->handle);
+  return 0;
+}
+
+int
+__gthr_win32_join (__gthread_t thr, void **pv)
+{
+  DWORD r;
+  WaitForSingleObject ((HANDLE)thr->handle, INFINITE);
+  GetExitCodeThread ((HANDLE)thr->handle, &r);
+  __gthr_win32_detach (thr);
+  if (pv) *pv = (void *)r;
+  return 0;
+}
+
+int __gthr_win32_detach (__gthread_t thr)
+{
+  CloseHandle ((HANDLE)thr->handle);
+  free (thr);
+  return 0;
+}
+
+int __gthr_win32_equal (__gthread_t t1, __gthread_t t2)
+{
+  return get_thread_id (t1) == get_thread_id (t2);
+}
+
+__gthread_t
+__gthr_win32_self (void)
+{
+  return (__gthread_t)TlsGetValue (gthr_gthread_t_get_slot ());
+}
+
+int
+__gthr_win32_yield (void)
+{
+  Sleep(0);
+  return 0;
+}
+
+int
+__gthr_win32_mutex_timedlock (__gthread_mutex_t *mutex,
+			      const __gthread_time_t *abs_timeout)
+{
+  if (InterlockedIncrement (&mutex->counter) == 0 ||
+      WaitForSingleObject (mutex->sema, gthread_calc_time_offset (abs_timeout))
+      == WAIT_OBJECT_0)
+    return 0;
+  else
+    {
+      InterlockedDecrement (&mutex->counter);
+      return 0;
+    }
+}
+
+int
+__gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
+					const __gthread_time_t *abs_timeout)
+{
+  DWORD me = GetCurrentThreadId ();
+  if (InterlockedIncrement (&mutex->counter) == 0)
+    {
+      mutex->depth = 1;
+      mutex->owner = me;
+    }
+  else if (mutex->owner == me)
+    {
+      InterlockedDecrement (&mutex->counter);
+      ++(mutex->depth);
+    }
+  else if (WaitForSingleObject (mutex->sema,
+				gthread_calc_time_offset (abs_timeout))
+	   == WAIT_OBJECT_0)
+    {
+      mutex->depth = 1;
+      mutex->owner = me;
+    }
+  else
+    {
+      InterlockedDecrement (&mutex->counter);
+    }
+  return 0;
+}
+
+int
+__gthr_win32_cond_signal (__gthread_cond_t *cond)
+{
+  EnterCriticalSection (cond->pcs);
+  if (cond->counter >= 0)
+    {
+      --cond->counter;
+      ReleaseSemaphore (cond->sema, 1, NULL);
+    }
+  LeaveCriticalSection (cond->pcs);
+  return 0;
+}
+
+int
+__gthr_win32_cond_timedwait (__gthread_cond_t *cond, __gthread_mutex_t *mutex,
+			     const __gthread_time_t *abs_timeout)
+{
+  return cond_wait_impl (cond, mutex, gthread_calc_time_offset (abs_timeout));
+}
+
+int
+__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *cond,
+				       __gthread_recursive_mutex_t *mutex,
+				       const __gthread_time_t *abs_timeout)
+{
+  return cond_wait_recursive_impl (cond, mutex,
+				   gthread_calc_time_offset (abs_timeout));
+}
diff --git a/libgcc/config/i386/gthr-win32.h b/libgcc/config/i386/gthr-win32.h
index 53f8396..48658c1 100644
--- a/libgcc/config/i386/gthr-win32.h
+++ b/libgcc/config/i386/gthr-win32.h
@@ -1,9 +1,11 @@
 /* Threads compatibility routines for libgcc2 and libobjc.  */
 /* Compile this one with gcc.  */
 
-/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009
+/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009, 2012
    Free Software Foundation, Inc.
    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
+   Implemented Condition Variable by Tomohiro Kashiwada
+   <kikairoya@gmail.com>.
 
 This file is part of GCC.
 
@@ -66,6 +68,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    needs to use Structured Exception Handling on Windows32.  */
 
 #define __GTHREADS 1
+#define __GTHREADS_CXX0X 1
+#define __GTHREAD_HAS_COND 1
 
 #include <errno.h>
 #ifdef __MINGW32__
@@ -359,6 +363,25 @@ typedef struct {
   void *sema;
 } __gthread_recursive_mutex_t;
 
+typedef struct {
+  long counter;
+  void *pcs;
+  void *sema;
+} __gthread_cond_t;
+
+typedef struct {
+  void *handle;
+  unsigned id;
+  void *(*func) (void *);
+  void *arg;
+} __gthread_solid_t;
+typedef __gthread_solid_t *__gthread_t;
+
+typedef struct {
+  time_t tv_sec;
+  long tv_nsec;
+} __gthread_time_t;
+
 #define __GTHREAD_ONCE_INIT {0, -1}
 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 #define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
@@ -366,6 +389,8 @@ typedef struct {
   __gthread_recursive_mutex_init_function
 #define __GTHREAD_RECURSIVE_MUTEX_INIT_DEFAULT {-1, 0, 0, 0}
 
+#define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function
+
 #if defined (_WIN32) && !defined(__CYGWIN__)
 #define MINGW32_SUPPORTS_MT_EH 1
 /* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
@@ -430,6 +455,31 @@ extern int
   __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
 extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
 extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
+extern int __gthr_win32_cond_init (__gthread_cond_t *, void *);
+extern int __gthr_win32_cond_destroy (__gthread_cond_t *);
+extern int __gthr_win32_cond_broadcast (__gthread_cond_t *);
+extern int __gthr_win32_cond_wait (__gthread_cond_t *, __gthread_mutex_t *);
+extern int __gthr_win32_cond_wait_recursive (__gthread_cond_t *,
+					     __gthread_recursive_mutex_t *);
+extern int __gthr_win32_create (__gthread_t *, void *(*func) (void *), void *);
+extern int __gthr_win32_join (__gthread_t, void **);
+extern int __gthr_win32_detach (__gthread_t);
+extern int __gthr_win32_equal (__gthread_t, __gthread_t);
+extern __gthread_t __gthr_win32_self (void);
+extern int __gthr_win32_yield (void);
+extern int __gthr_win32_mutex_timedlock (__gthread_mutex_t *,
+					 const __gthread_time_t *);
+extern int
+  __gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *,
+					  const __gthread_time_t *);
+extern int __gthr_win32_cond_signal (__gthread_cond_t *);
+extern int __gthr_win32_cond_timedwait (__gthread_cond_t *,
+					__gthread_mutex_t *,
+					const __gthread_time_t *);
+extern int
+__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *,
+				       __gthread_recursive_mutex_t *,
+				       const __gthread_time_t *);
 
 static inline int
 __gthread_once (__gthread_once_t *__once, void (*__func) (void))
@@ -536,6 +586,154 @@ __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
     return 0;
 }
 
+static inline int
+__gthread_cond_init_function (__gthread_cond_t *__cond)
+{
+  return __gthr_win32_cond_init (__cond, NULL);
+}
+
+static inline int
+__gthread_cond_init (__gthread_cond_t *__cond, void *__attr)
+{
+  return __gthr_win32_cond_init (__cond, __attr);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t *__cond)
+{
+  return __gthr_win32_cond_destroy (__cond);
+}
+
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_broadcast (__cond);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_wait (__cond, __mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+			       __gthread_recursive_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_wait_recursive (__cond, __mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_create (__gthread_t *__pthr, void *(*__func) (void *), void *__args)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_create (__pthr, __func, __args);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_join (__gthread_t __thr, void **__value_ptr)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_join (__thr, __value_ptr);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_detach (__gthread_t __thr)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_detach (__thr);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_equal (__t1, __t2);
+  else
+    return 0;
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthr_win32_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_yield ();
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+			   const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+				     const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_recursive_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_signal (__cond);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+			  const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_timedwait (__cond, __mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
+				    __gthread_recursive_mutex_t *__mutex,
+				    const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_timedwait_recursive (__cond, __mutex,
+						  __abs_timeout);
+  else
+    return 0;
+}
+
 #else /* ! __GTHREAD_HIDE_WIN32API */
 
 #include <windows.h>

gthr-win32-gcc48head.patch

diff --git a/libgcc/config/i386/gthr-win32.c b/libgcc/config/i386/gthr-win32.c
index ab1b69f..4b35582 100644
--- a/libgcc/config/i386/gthr-win32.c
+++ b/libgcc/config/i386/gthr-win32.c
@@ -1,11 +1,13 @@
 /* Implementation of W32-specific threads compatibility routines for
    libgcc2.  */
 
-/* Copyright (C) 1999, 2000, 2002, 2004, 2008, 2009, 2011
+/* Copyright (C) 1999, 2000, 2002, 2004, 2008, 2009, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
    Modified and moved to separate file by Danny Smith
    <dannysmith@users.sourceforge.net>.
+   Implemented Condition Variable by Tomohiro Kashiwada
+   <kikairoya@gmail.com>.
 
 This file is part of GCC.
 
@@ -29,6 +31,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
 <http://www.gnu.org/licenses/>.  */
 
 #include <windows.h>
+#include <process.h>
 #ifndef __GTHREAD_HIDE_WIN32API
 # define __GTHREAD_HIDE_WIN32API 1
 #endif
@@ -202,7 +205,7 @@ __gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
 int
 __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 {
-  DWORD me = GetCurrentThreadId();
+  DWORD me = GetCurrentThreadId ();
   if (InterlockedIncrement (&mutex->counter) == 0)
     {
       mutex->depth = 1;
@@ -231,7 +234,7 @@ __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 int
 __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
 {
-  DWORD me = GetCurrentThreadId();
+  DWORD me = GetCurrentThreadId ();
   if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
     {
       mutex->depth = 1;
@@ -259,3 +262,266 @@ __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
 
   return 0;
 }
+
+static DWORD
+gthread_calc_time_offset (const __gthread_time_t *abs_time)
+{
+  FILETIME ft;
+  LONGLONG ll;
+  LONGLONG ret;
+  GetSystemTimeAsFileTime (&ft);
+  ll = ((LONGLONG)ft.dwHighDateTime << 32) + ft.dwLowDateTime;
+  ret = (((LONGLONG)abs_time->tv_sec * 10000000 + abs_time->tv_nsec / 100)
+	 - (ll - 116444736000000000)) / 10000;
+  if (ret < 0)
+    return 0;
+  if (ret > 0x7FFFFFFF)
+    return 0x7FFFFFFF;
+  return ret;
+}
+
+int
+__gthr_win32_cond_init (__gthread_cond_t *cond,
+			void *attr __attribute__((unused)))
+{
+  cond->counter = -1;
+  cond->pcs = malloc (sizeof (CRITICAL_SECTION));
+  InitializeCriticalSection ((LPCRITICAL_SECTION)cond->pcs);
+  cond->sema = CreateSemaphore (NULL, 0, 65535, NULL);
+  return 0;
+}
+
+int
+__gthr_win32_cond_destroy (__gthread_cond_t *cond)
+{
+  __gthread_cond_broadcast (cond);
+  free (cond->pcs);
+  CloseHandle ((HANDLE)cond->sema);
+  return 0;
+}
+
+int
+__gthr_win32_cond_broadcast (__gthread_cond_t *cond)
+{
+  EnterCriticalSection (cond->pcs);
+  if (cond->counter >= 0)
+    ReleaseSemaphore (cond->sema, cond->counter+1, NULL);
+  cond->counter = -1;
+  LeaveCriticalSection (cond->pcs);
+  return 0;
+}
+
+static int
+cond_wait_impl (__gthread_cond_t *cond,
+		__gthread_mutex_t *mutex, DWORD timeout)
+{
+  EnterCriticalSection (cond->pcs);
+  ++cond->counter;
+  LeaveCriticalSection (cond->pcs);
+  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
+      != WAIT_OBJECT_0)
+    {
+      EnterCriticalSection (cond->pcs);
+      --cond->counter;
+      LeaveCriticalSection (cond->pcs);
+    }
+  WaitForSingleObject (mutex->sema, INFINITE);
+  return 0;
+}
+
+static int
+cond_wait_recursive_impl (__gthread_cond_t *cond,
+			  __gthread_recursive_mutex_t *mutex, DWORD timeout)
+{
+  EnterCriticalSection (cond->pcs);
+  ++cond->counter;
+  LeaveCriticalSection (cond->pcs);
+  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
+      != WAIT_OBJECT_0)
+    {
+      EnterCriticalSection (cond->pcs);
+      --cond->counter;
+      LeaveCriticalSection (cond->pcs);
+    }
+  WaitForSingleObject (mutex->sema, INFINITE);
+  return 0;
+}
+
+int
+__gthr_win32_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
+{
+  return cond_wait_impl (cond, mutex, INFINITE);
+}
+
+int
+__gthr_win32_cond_wait_recursive (__gthread_cond_t *cond,
+				  __gthread_recursive_mutex_t *mutex)
+{
+  return cond_wait_recursive_impl (cond, mutex, INFINITE);
+}
+
+static unsigned
+get_thread_id (__gthread_t thr)
+{
+  if (thr)
+    return thr->id;
+  return GetCurrentThreadId ();
+}
+
+static DWORD gthr_gthread_t_get_slot (void)
+{
+  static DWORD gthread_slot = 0xFFFFFFFF;
+  if (gthread_slot == 0xFFFFFFFF)
+    {
+      DWORD s = TlsAlloc ();
+      if (__GTHR_W32_InterlockedCompareExchange(&gthread_slot, s, 0xFFFFFFFF)
+	  != 0xFFFFFFFF)
+	{
+	  TlsFree (s);
+	  return gthread_slot;
+	}
+      else
+	{
+	  __gthread_t thr = (__gthread_t)malloc (sizeof (__gthread_solid_t));
+	  thr->func = NULL;
+	  thr->arg = NULL;
+	  thr->id = GetCurrentThreadId ();
+	  DuplicateHandle(GetCurrentProcess (), GetCurrentThread (),
+			  GetCurrentProcess (), (HANDLE *)&thr->id,
+			  0, FALSE, DUPLICATE_SAME_ACCESS);
+	  TlsSetValue(gthread_slot, thr);
+	}
+    }
+  return gthread_slot;
+}
+
+static unsigned __stdcall
+gthr_entry_stub (void *arg)
+{
+  __gthread_t p = (__gthread_t)arg;
+  TlsSetValue (gthr_gthread_t_get_slot (), arg);
+  return (unsigned)(*p->func) (p->arg);
+}
+
+
+int
+__gthr_win32_create (__gthread_t *thrp, void *(*func) (void *), void *arg)
+{
+  gthr_gthread_t_get_slot ();
+  *thrp = (__gthread_t)malloc (sizeof (__gthread_solid_t));
+  (*thrp)->func = func;
+  (*thrp)->arg = arg;
+  (*thrp)->handle = (void *)_beginthreadex (NULL, 0, &gthr_entry_stub, *thrp,
+					    CREATE_SUSPENDED, &(*thrp)->id);
+  ResumeThread((HANDLE)(*thrp)->handle);
+  return 0;
+}
+
+int
+__gthr_win32_join (__gthread_t thr, void **pv)
+{
+  DWORD r;
+  WaitForSingleObject ((HANDLE)thr->handle, INFINITE);
+  GetExitCodeThread ((HANDLE)thr->handle, &r);
+  __gthr_win32_detach (thr);
+  if (pv) *pv = (void *)r;
+  return 0;
+}
+
+int __gthr_win32_detach (__gthread_t thr)
+{
+  CloseHandle ((HANDLE)thr->handle);
+  free (thr);
+  return 0;
+}
+
+int __gthr_win32_equal (__gthread_t t1, __gthread_t t2)
+{
+  return get_thread_id (t1) == get_thread_id (t2);
+}
+
+__gthread_t
+__gthr_win32_self (void)
+{
+  return (__gthread_t)TlsGetValue (gthr_gthread_t_get_slot ());
+}
+
+int
+__gthr_win32_yield (void)
+{
+  Sleep(0);
+  return 0;
+}
+
+int
+__gthr_win32_mutex_timedlock (__gthread_mutex_t *mutex,
+			      const __gthread_time_t *abs_timeout)
+{
+  if (InterlockedIncrement (&mutex->counter) == 0 ||
+      WaitForSingleObject (mutex->sema, gthread_calc_time_offset (abs_timeout))
+      == WAIT_OBJECT_0)
+    return 0;
+  else
+    {
+      InterlockedDecrement (&mutex->counter);
+      return 0;
+    }
+}
+
+int
+__gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
+					const __gthread_time_t *abs_timeout)
+{
+  DWORD me = GetCurrentThreadId ();
+  if (InterlockedIncrement (&mutex->counter) == 0)
+    {
+      mutex->depth = 1;
+      mutex->owner = me;
+    }
+  else if (mutex->owner == me)
+    {
+      InterlockedDecrement (&mutex->counter);
+      ++(mutex->depth);
+    }
+  else if (WaitForSingleObject (mutex->sema,
+				gthread_calc_time_offset (abs_timeout))
+	   == WAIT_OBJECT_0)
+    {
+      mutex->depth = 1;
+      mutex->owner = me;
+    }
+  else
+    {
+      InterlockedDecrement (&mutex->counter);
+    }
+  return 0;
+}
+
+int
+__gthr_win32_cond_signal (__gthread_cond_t *cond)
+{
+  EnterCriticalSection (cond->pcs);
+  if (cond->counter >= 0)
+    {
+      --cond->counter;
+      ReleaseSemaphore (cond->sema, 1, NULL);
+    }
+  LeaveCriticalSection (cond->pcs);
+  return 0;
+}
+
+int
+__gthr_win32_cond_timedwait (__gthread_cond_t *cond, __gthread_mutex_t *mutex,
+			     const __gthread_time_t *abs_timeout)
+{
+  return cond_wait_impl (cond, mutex, gthread_calc_time_offset (abs_timeout));
+}
+
+int
+__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *cond,
+				       __gthread_recursive_mutex_t *mutex,
+				       const __gthread_time_t *abs_timeout)
+{
+  return cond_wait_recursive_impl (cond, mutex,
+				   gthread_calc_time_offset (abs_timeout));
+}
diff --git a/libgcc/config/i386/gthr-win32.h b/libgcc/config/i386/gthr-win32.h
index 53f8396..48658c1 100644
--- a/libgcc/config/i386/gthr-win32.h
+++ b/libgcc/config/i386/gthr-win32.h
@@ -1,9 +1,11 @@
 /* Threads compatibility routines for libgcc2 and libobjc.  */
 /* Compile this one with gcc.  */
 
-/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009
+/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009, 2012
    Free Software Foundation, Inc.
    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
+   Implemented Condition Variable by Tomohiro Kashiwada
+   <kikairoya@gmail.com>.
 
 This file is part of GCC.
 
@@ -66,6 +68,8 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    needs to use Structured Exception Handling on Windows32.  */
 
 #define __GTHREADS 1
+#define __GTHREADS_CXX0X 1
+#define __GTHREAD_HAS_COND 1
 
 #include <errno.h>
 #ifdef __MINGW32__
@@ -359,6 +363,25 @@ typedef struct {
   void *sema;
 } __gthread_recursive_mutex_t;
 
+typedef struct {
+  long counter;
+  void *pcs;
+  void *sema;
+} __gthread_cond_t;
+
+typedef struct {
+  void *handle;
+  unsigned id;
+  void *(*func) (void *);
+  void *arg;
+} __gthread_solid_t;
+typedef __gthread_solid_t *__gthread_t;
+
+typedef struct {
+  time_t tv_sec;
+  long tv_nsec;
+} __gthread_time_t;
+
 #define __GTHREAD_ONCE_INIT {0, -1}
 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 #define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
@@ -366,6 +389,8 @@ typedef struct {
   __gthread_recursive_mutex_init_function
 #define __GTHREAD_RECURSIVE_MUTEX_INIT_DEFAULT {-1, 0, 0, 0}
 
+#define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function
+
 #if defined (_WIN32) && !defined(__CYGWIN__)
 #define MINGW32_SUPPORTS_MT_EH 1
 /* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
@@ -430,6 +455,31 @@ extern int
   __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
 extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
 extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
+extern int __gthr_win32_cond_init (__gthread_cond_t *, void *);
+extern int __gthr_win32_cond_destroy (__gthread_cond_t *);
+extern int __gthr_win32_cond_broadcast (__gthread_cond_t *);
+extern int __gthr_win32_cond_wait (__gthread_cond_t *, __gthread_mutex_t *);
+extern int __gthr_win32_cond_wait_recursive (__gthread_cond_t *,
+					     __gthread_recursive_mutex_t *);
+extern int __gthr_win32_create (__gthread_t *, void *(*func) (void *), void *);
+extern int __gthr_win32_join (__gthread_t, void **);
+extern int __gthr_win32_detach (__gthread_t);
+extern int __gthr_win32_equal (__gthread_t, __gthread_t);
+extern __gthread_t __gthr_win32_self (void);
+extern int __gthr_win32_yield (void);
+extern int __gthr_win32_mutex_timedlock (__gthread_mutex_t *,
+					 const __gthread_time_t *);
+extern int
+  __gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *,
+					  const __gthread_time_t *);
+extern int __gthr_win32_cond_signal (__gthread_cond_t *);
+extern int __gthr_win32_cond_timedwait (__gthread_cond_t *,
+					__gthread_mutex_t *,
+					const __gthread_time_t *);
+extern int
+__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *,
+				       __gthread_recursive_mutex_t *,
+				       const __gthread_time_t *);
 
 static inline int
 __gthread_once (__gthread_once_t *__once, void (*__func) (void))
@@ -536,6 +586,154 @@ __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
     return 0;
 }
 
+static inline int
+__gthread_cond_init_function (__gthread_cond_t *__cond)
+{
+  return __gthr_win32_cond_init (__cond, NULL);
+}
+
+static inline int
+__gthread_cond_init (__gthread_cond_t *__cond, void *__attr)
+{
+  return __gthr_win32_cond_init (__cond, __attr);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t *__cond)
+{
+  return __gthr_win32_cond_destroy (__cond);
+}
+
+static inline int
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_broadcast (__cond);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_wait (__cond, __mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+			       __gthread_recursive_mutex_t *__mutex)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_wait_recursive (__cond, __mutex);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_create (__gthread_t *__pthr, void *(*__func) (void *), void *__args)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_create (__pthr, __func, __args);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_join (__gthread_t __thr, void **__value_ptr)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_join (__thr, __value_ptr);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_detach (__gthread_t __thr)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_detach (__thr);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_equal (__t1, __t2);
+  else
+    return 0;
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+  return __gthr_win32_self ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_yield ();
+  else
+    return 0;
+}
+
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
+			   const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+				     const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_recursive_mutex_timedlock (__mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_signal (__gthread_cond_t *__cond)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_signal (__cond);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
+			  const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_timedwait (__cond, __mutex, __abs_timeout);
+  else
+    return 0;
+}
+
+static inline int
+__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
+				    __gthread_recursive_mutex_t *__mutex,
+				    const __gthread_time_t *__abs_timeout)
+{
+  if (__gthread_active_p ())
+    return __gthr_win32_cond_timedwait_recursive (__cond, __mutex,
+						  __abs_timeout);
+  else
+    return 0;
+}
+
 #else /* ! __GTHREAD_HIDE_WIN32API */
 
 #include <windows.h>

gthr-win32.c

/* Implementation of W32-specific threads compatibility routines for
   libgcc2.  */

/* Copyright (C) 1999, 2000, 2002, 2004, 2008, 2009, 2011, 2012
   Free Software Foundation, Inc.
   Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
   Modified and moved to separate file by Danny Smith
   <dannysmith@users.sourceforge.net>.
   Implemented Condition Variable by Tomohiro Kashiwada
   <kikairoya@gmail.com>.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#include <windows.h>
#include <process.h>
#ifndef __GTHREAD_HIDE_WIN32API
# define __GTHREAD_HIDE_WIN32API 1
#endif
#undef  __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
#define __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
#include "gthr-win32.h"

/* Windows32 threads specific definitions. The windows32 threading model
   does not map well into pthread-inspired gcc's threading model, and so 
   there are caveats one needs to be aware of.

   1. The destructor supplied to __gthread_key_create is ignored for
      generic x86-win32 ports. This will certainly cause memory leaks 
      due to unreclaimed eh contexts (sizeof (eh_context) is at least 
      24 bytes for x86 currently).

      This memory leak may be significant for long-running applications
      that make heavy use of C++ EH.

      However, Mingw runtime (version 0.3 or newer) provides a mechanism
      to emulate pthreads key dtors; the runtime provides a special DLL,
      linked in if -mthreads option is specified, that runs the dtors in
      the reverse order of registration when each thread exits. If
      -mthreads option is not given, a stub is linked in instead of the
      DLL, which results in memory leak. Other x86-win32 ports can use 
      the same technique of course to avoid the leak.

   2. The error codes returned are non-POSIX like, and cast into ints.
      This may cause incorrect error return due to truncation values on 
      hw where sizeof (DWORD) > sizeof (int).
   
   3. We are currently using a special mutex instead of the Critical
      Sections, since Win9x does not support TryEnterCriticalSection
      (while NT does).
  
   The basic framework should work well enough. In the long term, GCC
   needs to use Structured Exception Handling on Windows32.  */

int
__gthr_win32_once (__gthread_once_t *once, void (*func) (void))
{
  if (once == NULL || func == NULL)
    return EINVAL;

  if (! once->done)
    {
      if (InterlockedIncrement (&(once->started)) == 0)
        {
	  (*func) ();
	  once->done = TRUE;
	}
      else
	{
	  /* Another thread is currently executing the code, so wait for it 
	     to finish; yield the CPU in the meantime.  If performance 
	     does become an issue, the solution is to use an Event that 
	     we wait on here (and set above), but that implies a place to 
	     create the event before this routine is called.  */ 
	  while (! once->done)
	    Sleep (0);
	}
    }
  return 0;
}

/* Windows32 thread local keys don't support destructors; this leads to
   leaks, especially in threaded applications making extensive use of 
   C++ EH. Mingw uses a thread-support DLL to work-around this problem.  */

int
__gthr_win32_key_create (__gthread_key_t *key,
			 void (*dtor) (void *) __attribute__((unused)))
{
  int status = 0;
  DWORD tls_index = TlsAlloc ();
  if (tls_index != 0xFFFFFFFF)
    {
      *key = tls_index;
#ifdef MINGW32_SUPPORTS_MT_EH
      /* Mingw runtime will run the dtors in reverse order for each thread
         when the thread exits.  */
      status = __mingwthr_key_dtor (*key, dtor);
#endif
    }
  else
    status = (int) GetLastError ();
  return status;
}

int
__gthr_win32_key_delete (__gthread_key_t key)
{
  return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
}

void *
__gthr_win32_getspecific (__gthread_key_t key)
{
  DWORD lasterror;
  void *ptr;
  lasterror = GetLastError();
  ptr = TlsGetValue(key);
  SetLastError( lasterror );
  return ptr;
}

int
__gthr_win32_setspecific (__gthread_key_t key, const void *ptr)
{
  if (TlsSetValue (key, CONST_CAST2(void *, const void *, ptr)) != 0)
    return 0;
  else
    return GetLastError ();
}

void
__gthr_win32_mutex_init_function (__gthread_mutex_t *mutex)
{
  mutex->counter = -1;
  mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}

void
__gthr_win32_mutex_destroy (__gthread_mutex_t *mutex)
{
  CloseHandle ((HANDLE) mutex->sema);
}

int
__gthr_win32_mutex_lock (__gthread_mutex_t *mutex)
{
  if (InterlockedIncrement (&mutex->counter) == 0 ||
      WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
    return 0;
  else
    {
      /* WaitForSingleObject returns WAIT_FAILED, and we can only do
         some best-effort cleanup here.  */
      InterlockedDecrement (&mutex->counter);
      return 1;
    }
}

int
__gthr_win32_mutex_trylock (__gthread_mutex_t *mutex)
{
  if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
    return 0;
  else
    return 1;
}

int
__gthr_win32_mutex_unlock (__gthread_mutex_t *mutex)
{
  if (InterlockedDecrement (&mutex->counter) >= 0)
    return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
  else
    return 0;
}

void
__gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
{
  mutex->counter = -1;
  mutex->depth = 0;
  mutex->owner = 0;
  mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}

int
__gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
{
  DWORD me = GetCurrentThreadId ();
  if (InterlockedIncrement (&mutex->counter) == 0)
    {
      mutex->depth = 1;
      mutex->owner = me;
    }
  else if (mutex->owner == me)
    {
      InterlockedDecrement (&mutex->counter);
      ++(mutex->depth);
    }
  else if (WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
    {
      mutex->depth = 1;
      mutex->owner = me;
    }
  else
    {
      /* WaitForSingleObject returns WAIT_FAILED, and we can only do
         some best-effort cleanup here.  */
      InterlockedDecrement (&mutex->counter);
      return 1;
    }
  return 0;
}

int
__gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
{
  DWORD me = GetCurrentThreadId ();
  if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
    {
      mutex->depth = 1;
      mutex->owner = me;
    }
  else if (mutex->owner == me)
    ++(mutex->depth);
  else
    return 1;

  return 0;
}

int
__gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
{
  --(mutex->depth);
  if (mutex->depth == 0)
    {
      mutex->owner = 0;

      if (InterlockedDecrement (&mutex->counter) >= 0)
	return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
    }

  return 0;
}

static DWORD
gthread_calc_time_offset (const __gthread_time_t *abs_time)
{
  FILETIME ft;
  LONGLONG ll;
  LONGLONG ret;
  GetSystemTimeAsFileTime (&ft);
  ll = ((LONGLONG)ft.dwHighDateTime << 32) + ft.dwLowDateTime;
  ret = (((LONGLONG)abs_time->tv_sec * 10000000 + abs_time->tv_nsec / 100)
	 - (ll - 116444736000000000)) / 10000;
  if (ret < 0)
    return 0;
  if (ret > 0x7FFFFFFF)
    return 0x7FFFFFFF;
  return ret;
}

int
__gthr_win32_cond_init (__gthread_cond_t *cond,
			void *attr __attribute__((unused)))
{
  cond->counter = -1;
  cond->pcs = malloc (sizeof (CRITICAL_SECTION));
  InitializeCriticalSection ((LPCRITICAL_SECTION)cond->pcs);
  cond->sema = CreateSemaphore (NULL, 0, 65535, NULL);
  return 0;
}

int
__gthr_win32_cond_destroy (__gthread_cond_t *cond)
{
  __gthread_cond_broadcast (cond);
  free (cond->pcs);
  CloseHandle ((HANDLE)cond->sema);
  return 0;
}

int
__gthr_win32_cond_broadcast (__gthread_cond_t *cond)
{
  EnterCriticalSection (cond->pcs);
  if (cond->counter >= 0)
    ReleaseSemaphore (cond->sema, cond->counter+1, NULL);
  cond->counter = -1;
  LeaveCriticalSection (cond->pcs);
  return 0;
}

static int
cond_wait_impl (__gthread_cond_t *cond,
		__gthread_mutex_t *mutex, DWORD timeout)
{
  EnterCriticalSection (cond->pcs);
  ++cond->counter;
  LeaveCriticalSection (cond->pcs);
  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
      != WAIT_OBJECT_0)
    {
      EnterCriticalSection (cond->pcs);
      --cond->counter;
      LeaveCriticalSection (cond->pcs);
    }
  WaitForSingleObject (mutex->sema, INFINITE);
  return 0;
}

static int
cond_wait_recursive_impl (__gthread_cond_t *cond,
			  __gthread_recursive_mutex_t *mutex, DWORD timeout)
{
  EnterCriticalSection (cond->pcs);
  ++cond->counter;
  LeaveCriticalSection (cond->pcs);
  if (SignalObjectAndWait (mutex->sema, cond->sema, timeout, FALSE)
      != WAIT_OBJECT_0)
    {
      EnterCriticalSection (cond->pcs);
      --cond->counter;
      LeaveCriticalSection (cond->pcs);
    }
  WaitForSingleObject (mutex->sema, INFINITE);
  return 0;
}

int
__gthr_win32_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
{
  return cond_wait_impl (cond, mutex, INFINITE);
}

int
__gthr_win32_cond_wait_recursive (__gthread_cond_t *cond,
				  __gthread_recursive_mutex_t *mutex)
{
  return cond_wait_recursive_impl (cond, mutex, INFINITE);
}

static unsigned
get_thread_id (__gthread_t thr)
{
  if (thr)
    return thr->id;
  return GetCurrentThreadId ();
}

static DWORD gthr_gthread_t_get_slot (void)
{
  static DWORD gthread_slot = 0xFFFFFFFF;
  if (gthread_slot == 0xFFFFFFFF)
    {
      DWORD s = TlsAlloc ();
      if (__GTHR_W32_InterlockedCompareExchange(&gthread_slot, s, 0xFFFFFFFF)
	  != 0xFFFFFFFF)
	{
	  TlsFree (s);
	  return gthread_slot;
	}
      else
	{
	  __gthread_t thr = (__gthread_t)malloc (sizeof (__gthread_solid_t));
	  thr->func = NULL;
	  thr->arg = NULL;
	  thr->id = GetCurrentThreadId ();
	  DuplicateHandle(GetCurrentProcess (), GetCurrentThread (),
			  GetCurrentProcess (), (HANDLE *)&thr->id,
			  0, FALSE, DUPLICATE_SAME_ACCESS);
	  TlsSetValue(gthread_slot, thr);
	}
    }
  return gthread_slot;
}

static unsigned __stdcall
gthr_entry_stub (void *arg)
{
  __gthread_t p = (__gthread_t)arg;
  TlsSetValue (gthr_gthread_t_get_slot (), arg);
  return (unsigned)(*p->func) (p->arg);
}


int
__gthr_win32_create (__gthread_t *thrp, void *(*func) (void *), void *arg)
{
  gthr_gthread_t_get_slot ();
  *thrp = (__gthread_t)malloc (sizeof (__gthread_solid_t));
  (*thrp)->func = func;
  (*thrp)->arg = arg;
  (*thrp)->handle = (void *)_beginthreadex (NULL, 0, &gthr_entry_stub, *thrp,
					    CREATE_SUSPENDED, &(*thrp)->id);
  ResumeThread((HANDLE)(*thrp)->handle);
  return 0;
}

int
__gthr_win32_join (__gthread_t thr, void **pv)
{
  DWORD r;
  WaitForSingleObject ((HANDLE)thr->handle, INFINITE);
  GetExitCodeThread ((HANDLE)thr->handle, &r);
  __gthr_win32_detach (thr);
  if (pv) *pv = (void *)r;
  return 0;
}

int __gthr_win32_detach (__gthread_t thr)
{
  CloseHandle ((HANDLE)thr->handle);
  free (thr);
  return 0;
}

int __gthr_win32_equal (__gthread_t t1, __gthread_t t2)
{
  return get_thread_id (t1) == get_thread_id (t2);
}

__gthread_t
__gthr_win32_self (void)
{
  return (__gthread_t)TlsGetValue (gthr_gthread_t_get_slot ());
}

int
__gthr_win32_yield (void)
{
  Sleep(0);
  return 0;
}

int
__gthr_win32_mutex_timedlock (__gthread_mutex_t *mutex,
			      const __gthread_time_t *abs_timeout)
{
  if (InterlockedIncrement (&mutex->counter) == 0 ||
      WaitForSingleObject (mutex->sema, gthread_calc_time_offset (abs_timeout))
      == WAIT_OBJECT_0)
    return 0;
  else
    {
      InterlockedDecrement (&mutex->counter);
      return 0;
    }
}

int
__gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
					const __gthread_time_t *abs_timeout)
{
  DWORD me = GetCurrentThreadId ();
  if (InterlockedIncrement (&mutex->counter) == 0)
    {
      mutex->depth = 1;
      mutex->owner = me;
    }
  else if (mutex->owner == me)
    {
      InterlockedDecrement (&mutex->counter);
      ++(mutex->depth);
    }
  else if (WaitForSingleObject (mutex->sema,
				gthread_calc_time_offset (abs_timeout))
	   == WAIT_OBJECT_0)
    {
      mutex->depth = 1;
      mutex->owner = me;
    }
  else
    {
      InterlockedDecrement (&mutex->counter);
    }
  return 0;
}

int
__gthr_win32_cond_signal (__gthread_cond_t *cond)
{
  EnterCriticalSection (cond->pcs);
  if (cond->counter >= 0)
    {
      --cond->counter;
      ReleaseSemaphore (cond->sema, 1, NULL);
    }
  LeaveCriticalSection (cond->pcs);
  return 0;
}

int
__gthr_win32_cond_timedwait (__gthread_cond_t *cond, __gthread_mutex_t *mutex,
			     const __gthread_time_t *abs_timeout)
{
  return cond_wait_impl (cond, mutex, gthread_calc_time_offset (abs_timeout));
}

int
__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *cond,
				       __gthread_recursive_mutex_t *mutex,
				       const __gthread_time_t *abs_timeout)
{
  return cond_wait_recursive_impl (cond, mutex,
				   gthread_calc_time_offset (abs_timeout));
}

gthr-win32.h

/* Threads compatibility routines for libgcc2 and libobjc.  */
/* Compile this one with gcc.  */

/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009, 2012
   Free Software Foundation, Inc.
   Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
   Implemented Condition Variable by Tomohiro Kashiwada
   <kikairoya@gmail.com>.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.

You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */

#ifndef GCC_GTHR_WIN32_H
#define GCC_GTHR_WIN32_H

/* Make sure CONST_CAST2 (origin in system.h) is declared.  */
#ifndef CONST_CAST2
#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq)
#endif

/* Windows32 threads specific definitions. The windows32 threading model
   does not map well into pthread-inspired gcc's threading model, and so
   there are caveats one needs to be aware of.

   1. The destructor supplied to __gthread_key_create is ignored for
      generic x86-win32 ports. This will certainly cause memory leaks
      due to unreclaimed eh contexts (sizeof (eh_context) is at least
      24 bytes for x86 currently).

      This memory leak may be significant for long-running applications
      that make heavy use of C++ EH.

      However, Mingw runtime (version 0.3 or newer) provides a mechanism
      to emulate pthreads key dtors; the runtime provides a special DLL,
      linked in if -mthreads option is specified, that runs the dtors in
      the reverse order of registration when each thread exits. If
      -mthreads option is not given, a stub is linked in instead of the
      DLL, which results in memory leak. Other x86-win32 ports can use
      the same technique of course to avoid the leak.

   2. The error codes returned are non-POSIX like, and cast into ints.
      This may cause incorrect error return due to truncation values on
      hw where sizeof (DWORD) > sizeof (int).

   3. We are currently using a special mutex instead of the Critical
      Sections, since Win9x does not support TryEnterCriticalSection
      (while NT does).

   The basic framework should work well enough. In the long term, GCC
   needs to use Structured Exception Handling on Windows32.  */

#define __GTHREADS 1
#define __GTHREADS_CXX0X 1
#define __GTHREAD_HAS_COND 1

#include <errno.h>
#ifdef __MINGW32__
#include <_mingw.h>
#endif

#ifndef __UNUSED_PARAM
#define __UNUSED_PARAM(x) x
#endif

#ifdef _LIBOBJC

/* This is necessary to prevent windef.h (included from windows.h) from
   defining its own BOOL as a typedef.  */
#ifndef __OBJC__
#define __OBJC__
#endif
#include <windows.h>
/* Now undef the windows BOOL.  */
#undef BOOL

/* Key structure for maintaining thread specific storage */
static DWORD	__gthread_objc_data_tls = (DWORD) -1;

/* Backend initialization functions */

/* Initialize the threads subsystem.  */
int
__gthread_objc_init_thread_system (void)
{
  /* Initialize the thread storage key.  */
  if ((__gthread_objc_data_tls = TlsAlloc ()) != (DWORD) -1)
    return 0;
  else
    return -1;
}

/* Close the threads subsystem.  */
int
__gthread_objc_close_thread_system (void)
{
  if (__gthread_objc_data_tls != (DWORD) -1)
    TlsFree (__gthread_objc_data_tls);
  return 0;
}

/* Backend thread functions */

/* Create a new thread of execution.  */
objc_thread_t
__gthread_objc_thread_detach (void (*func)(void *arg), void *arg)
{
  DWORD	thread_id = 0;
  HANDLE win32_handle;

  if (!(win32_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) func,
				     arg, 0, &thread_id)))
    thread_id = 0;

  return (objc_thread_t) (INT_PTR) thread_id;
}

/* Set the current thread's priority.  */
int
__gthread_objc_thread_set_priority (int priority)
{
  int sys_priority = 0;

  switch (priority)
    {
    case OBJC_THREAD_INTERACTIVE_PRIORITY:
      sys_priority = THREAD_PRIORITY_NORMAL;
      break;
    default:
    case OBJC_THREAD_BACKGROUND_PRIORITY:
      sys_priority = THREAD_PRIORITY_BELOW_NORMAL;
      break;
    case OBJC_THREAD_LOW_PRIORITY:
      sys_priority = THREAD_PRIORITY_LOWEST;
      break;
    }

  /* Change priority */
  if (SetThreadPriority (GetCurrentThread (), sys_priority))
    return 0;
  else
    return -1;
}

/* Return the current thread's priority.  */
int
__gthread_objc_thread_get_priority (void)
{
  int sys_priority;

  sys_priority = GetThreadPriority (GetCurrentThread ());

  switch (sys_priority)
    {
    case THREAD_PRIORITY_HIGHEST:
    case THREAD_PRIORITY_TIME_CRITICAL:
    case THREAD_PRIORITY_ABOVE_NORMAL:
    case THREAD_PRIORITY_NORMAL:
      return OBJC_THREAD_INTERACTIVE_PRIORITY;

    default:
    case THREAD_PRIORITY_BELOW_NORMAL:
      return OBJC_THREAD_BACKGROUND_PRIORITY;

    case THREAD_PRIORITY_IDLE:
    case THREAD_PRIORITY_LOWEST:
      return OBJC_THREAD_LOW_PRIORITY;
    }

  /* Couldn't get priority.  */
  return -1;
}

/* Yield our process time to another thread.  */
void
__gthread_objc_thread_yield (void)
{
  Sleep (0);
}

/* Terminate the current thread.  */
int
__gthread_objc_thread_exit (void)
{
  /* exit the thread */
  ExitThread (__objc_thread_exit_status);

  /* Failed if we reached here */
  return -1;
}

/* Returns an integer value which uniquely describes a thread.  */
objc_thread_t
__gthread_objc_thread_id (void)
{
  return (objc_thread_t) (INT_PTR) GetCurrentThreadId ();
}

/* Sets the thread's local storage pointer.  */
int
__gthread_objc_thread_set_data (void *value)
{
  if (TlsSetValue (__gthread_objc_data_tls, value))
    return 0;
  else
    return -1;
}

/* Returns the thread's local storage pointer.  */
void *
__gthread_objc_thread_get_data (void)
{
  DWORD lasterror;
  void *ptr;

  lasterror = GetLastError ();

  ptr = TlsGetValue (__gthread_objc_data_tls);          /* Return thread data.  */

  SetLastError (lasterror);

  return ptr;
}

/* Backend mutex functions */

/* Allocate a mutex.  */
int
__gthread_objc_mutex_allocate (objc_mutex_t mutex)
{
  if ((mutex->backend = (void *) CreateMutex (NULL, 0, NULL)) == NULL)
    return -1;
  else
    return 0;
}

/* Deallocate a mutex.  */
int
__gthread_objc_mutex_deallocate (objc_mutex_t mutex)
{
  CloseHandle ((HANDLE) (mutex->backend));
  return 0;
}

/* Grab a lock on a mutex.  */
int
__gthread_objc_mutex_lock (objc_mutex_t mutex)
{
  int status;

  status = WaitForSingleObject ((HANDLE) (mutex->backend), INFINITE);
  if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
    return -1;
  else
    return 0;
}

/* Try to grab a lock on a mutex.  */
int
__gthread_objc_mutex_trylock (objc_mutex_t mutex)
{
  int status;

  status = WaitForSingleObject ((HANDLE) (mutex->backend), 0);
  if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
    return -1;
  else
    return 0;
}

/* Unlock the mutex */
int
__gthread_objc_mutex_unlock (objc_mutex_t mutex)
{
  if (ReleaseMutex ((HANDLE) (mutex->backend)) == 0)
    return -1;
  else
    return 0;
}

/* Backend condition mutex functions */

/* Allocate a condition.  */
int
__gthread_objc_condition_allocate (objc_condition_t __UNUSED_PARAM(condition))
{
  /* Unimplemented.  */
  return -1;
}

/* Deallocate a condition.  */
int
__gthread_objc_condition_deallocate (objc_condition_t __UNUSED_PARAM(condition))
{
  /* Unimplemented.  */
  return -1;
}

/* Wait on the condition */
int
__gthread_objc_condition_wait (objc_condition_t __UNUSED_PARAM(condition),
			       objc_mutex_t __UNUSED_PARAM(mutex))
{
  /* Unimplemented.  */
  return -1;
}

/* Wake up all threads waiting on this condition.  */
int
__gthread_objc_condition_broadcast (objc_condition_t __UNUSED_PARAM(condition))
{
  /* Unimplemented.  */
  return -1;
}

/* Wake up one thread waiting on this condition.  */
int
__gthread_objc_condition_signal (objc_condition_t __UNUSED_PARAM(condition))
{
  /* Unimplemented.  */
  return -1;
}

#else /* _LIBOBJC */

#ifdef __cplusplus
extern "C" {
#endif

typedef unsigned long __gthread_key_t;

typedef struct {
  int done;
  long started;
} __gthread_once_t;

typedef struct {
  long counter;
  void *sema;
} __gthread_mutex_t;

typedef struct {
  long counter;
  long depth;
  unsigned long owner;
  void *sema;
} __gthread_recursive_mutex_t;

typedef struct {
  long counter;
  void *pcs;
  void *sema;
} __gthread_cond_t;

typedef struct {
  void *handle;
  unsigned id;
  void *(*func) (void *);
  void *arg;
} __gthread_solid_t;
typedef __gthread_solid_t *__gthread_t;

typedef struct {
  time_t tv_sec;
  long tv_nsec;
} __gthread_time_t;

#define __GTHREAD_ONCE_INIT {0, -1}
#define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
#define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION \
  __gthread_recursive_mutex_init_function
#define __GTHREAD_RECURSIVE_MUTEX_INIT_DEFAULT {-1, 0, 0, 0}

#define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function

#if defined (_WIN32) && !defined(__CYGWIN__)
#define MINGW32_SUPPORTS_MT_EH 1
/* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
   if -mthreads option was specified, or 0 otherwise. This is to get around
   the lack of weak symbols in PE-COFF.  */
extern int _CRT_MT;
extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
#endif /* _WIN32 && !__CYGWIN__ */

/* The Windows95 kernel does not export InterlockedCompareExchange.
   This provides a substitute.   When building apps that reference
   gthread_mutex_try_lock, the  __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
   macro  must be defined if Windows95 is a target.  Currently
   gthread_mutex_try_lock is not referenced by libgcc or libstdc++.  */
#ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
static inline long
__gthr_i486_lock_cmp_xchg(long *__dest, long __xchg, long __comperand)
{
  long result;
  __asm__ __volatile__ ("\n\
	lock\n\
	cmpxchg{l} {%4, %1|%1, %4}\n"
	: "=a" (result), "=m" (*__dest)
	: "0" (__comperand), "m" (*__dest), "r" (__xchg)
	: "cc");
  return result;
}
#define __GTHR_W32_InterlockedCompareExchange __gthr_i486_lock_cmp_xchg
#else  /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
#define __GTHR_W32_InterlockedCompareExchange InterlockedCompareExchange
#endif /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */

static inline int
__gthread_active_p (void)
{
#ifdef MINGW32_SUPPORTS_MT_EH
  return _CRT_MT;
#else
  return 1;
#endif
}

#if __GTHREAD_HIDE_WIN32API

/* The implementations are in config/i386/gthr-win32.c in libgcc.a.
   Only stubs are exposed to avoid polluting the C++ namespace with
   windows api definitions.  */

extern int __gthr_win32_once (__gthread_once_t *, void (*) (void));
extern int __gthr_win32_key_create (__gthread_key_t *, void (*) (void*));
extern int __gthr_win32_key_delete (__gthread_key_t);
extern void * __gthr_win32_getspecific (__gthread_key_t);
extern int __gthr_win32_setspecific (__gthread_key_t, const void *);
extern void __gthr_win32_mutex_init_function (__gthread_mutex_t *);
extern int __gthr_win32_mutex_lock (__gthread_mutex_t *);
extern int __gthr_win32_mutex_trylock (__gthread_mutex_t *);
extern int __gthr_win32_mutex_unlock (__gthread_mutex_t *);
extern void
  __gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *);
extern int __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *);
extern int
  __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
extern int __gthr_win32_cond_init (__gthread_cond_t *, void *);
extern int __gthr_win32_cond_destroy (__gthread_cond_t *);
extern int __gthr_win32_cond_broadcast (__gthread_cond_t *);
extern int __gthr_win32_cond_wait (__gthread_cond_t *, __gthread_mutex_t *);
extern int __gthr_win32_cond_wait_recursive (__gthread_cond_t *,
					     __gthread_recursive_mutex_t *);
extern int __gthr_win32_create (__gthread_t *, void *(*func) (void *), void *);
extern int __gthr_win32_join (__gthread_t, void **);
extern int __gthr_win32_detach (__gthread_t);
extern int __gthr_win32_equal (__gthread_t, __gthread_t);
extern __gthread_t __gthr_win32_self (void);
extern int __gthr_win32_yield (void);
extern int __gthr_win32_mutex_timedlock (__gthread_mutex_t *,
					 const __gthread_time_t *);
extern int
  __gthr_win32_recursive_mutex_timedlock (__gthread_recursive_mutex_t *,
					  const __gthread_time_t *);
extern int __gthr_win32_cond_signal (__gthread_cond_t *);
extern int __gthr_win32_cond_timedwait (__gthread_cond_t *,
					__gthread_mutex_t *,
					const __gthread_time_t *);
extern int
__gthr_win32_cond_timedwait_recursive (__gthread_cond_t *,
				       __gthread_recursive_mutex_t *,
				       const __gthread_time_t *);

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (__gthread_active_p ())
    return __gthr_win32_once (__once, __func);
  else
    return -1;
}

static inline int
__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
  return __gthr_win32_key_create (__key, __dtor);
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return __gthr_win32_key_delete (__key);
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  return __gthr_win32_getspecific (__key);
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  return __gthr_win32_setspecific (__key, __ptr);
}

static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  __gthr_win32_mutex_init_function (__mutex);
}

static inline void
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  __gthr_win32_mutex_destroy (__mutex);
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_mutex_trylock (__mutex);
  else
    return 0;
}

static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_mutex_unlock (__mutex);
  else
    return 0;
}

static inline void
__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
   __gthr_win32_recursive_mutex_init_function (__mutex);
}

static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_recursive_mutex_lock (__mutex);
  else
    return 0;
}

static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_recursive_mutex_trylock (__mutex);
  else
    return 0;
}

static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_recursive_mutex_unlock (__mutex);
  else
    return 0;
}

static inline int
__gthread_cond_init_function (__gthread_cond_t *__cond)
{
  return __gthr_win32_cond_init (__cond, NULL);
}

static inline int
__gthread_cond_init (__gthread_cond_t *__cond, void *__attr)
{
  return __gthr_win32_cond_init (__cond, __attr);
}

static inline int
__gthread_cond_destroy (__gthread_cond_t *__cond)
{
  return __gthr_win32_cond_destroy (__cond);
}

static inline int
__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_broadcast (__cond);
  else
    return 0;
}

static inline int
__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_wait (__cond, __mutex);
  else
    return 0;
}

static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
			       __gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_wait_recursive (__cond, __mutex);
  else
    return 0;
}

static inline int
__gthread_create (__gthread_t *__pthr, void *(*__func) (void *), void *__args)
{
  if (__gthread_active_p ())
    return __gthr_win32_create (__pthr, __func, __args);
  else
    return 0;
}

static inline int
__gthread_join (__gthread_t __thr, void **__value_ptr)
{
  if (__gthread_active_p ())
    return __gthr_win32_join (__thr, __value_ptr);
  else
    return 0;
}

static inline int
__gthread_detach (__gthread_t __thr)
{
  if (__gthread_active_p ())
    return __gthr_win32_detach (__thr);
  else
    return 0;
}

static inline int
__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
  if (__gthread_active_p ())
    return __gthr_win32_equal (__t1, __t2);
  else
    return 0;
}

static inline __gthread_t
__gthread_self (void)
{
  return __gthr_win32_self ();
}

static inline int
__gthread_yield (void)
{
  if (__gthread_active_p ())
    return __gthr_win32_yield ();
  else
    return 0;
}

static inline int
__gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
			   const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthr_win32_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}

static inline int
__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
				     const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthr_win32_recursive_mutex_timedlock (__mutex, __abs_timeout);
  else
    return 0;
}

static inline int
__gthread_cond_signal (__gthread_cond_t *__cond)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_signal (__cond);
  else
    return 0;
}

static inline int
__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
			  const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_timedwait (__cond, __mutex, __abs_timeout);
  else
    return 0;
}

static inline int
__gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
				    __gthread_recursive_mutex_t *__mutex,
				    const __gthread_time_t *__abs_timeout)
{
  if (__gthread_active_p ())
    return __gthr_win32_cond_timedwait_recursive (__cond, __mutex,
						  __abs_timeout);
  else
    return 0;
}

#else /* ! __GTHREAD_HIDE_WIN32API */

#include <windows.h>
#include <errno.h>

static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (! __gthread_active_p ())
    return -1;
  else if (__once == NULL || __func == NULL)
    return EINVAL;

  if (! __once->done)
    {
      if (InterlockedIncrement (&(__once->started)) == 0)
	{
	  (*__func) ();
	  __once->done = TRUE;
	}
      else
	{
	  /* Another thread is currently executing the code, so wait for it
	     to finish; yield the CPU in the meantime.  If performance
	     does become an issue, the solution is to use an Event that
	     we wait on here (and set above), but that implies a place to
	     create the event before this routine is called.  */
	  while (! __once->done)
	    Sleep (0);
	}
    }

  return 0;
}

/* Windows32 thread local keys don't support destructors; this leads to
   leaks, especially in threaded applications making extensive use of
   C++ EH. Mingw uses a thread-support DLL to work-around this problem.  */
static inline int
__gthread_key_create (__gthread_key_t *__key,
		      void (*__dtor) (void *) __attribute__((unused)))
{
  int __status = 0;
  DWORD __tls_index = TlsAlloc ();
  if (__tls_index != 0xFFFFFFFF)
    {
      *__key = __tls_index;
#ifdef MINGW32_SUPPORTS_MT_EH
      /* Mingw runtime will run the dtors in reverse order for each thread
         when the thread exits.  */
      __status = __mingwthr_key_dtor (*__key, __dtor);
#endif
    }
  else
    __status = (int) GetLastError ();
  return __status;
}

static inline int
__gthread_key_delete (__gthread_key_t __key)
{
  return (TlsFree (__key) != 0) ? 0 : (int) GetLastError ();
}

static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  DWORD __lasterror;
  void *__ptr;

  __lasterror = GetLastError ();

  __ptr = TlsGetValue (__key);

  SetLastError (__lasterror);

  return __ptr;
}

static inline int
__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
  if (TlsSetValue (__key, CONST_CAST2(void *, const void *, __ptr)) != 0)
    return 0;
  else
    return GetLastError ();
}

static inline void
__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
  __mutex->counter = -1;
  __mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}

static inline void
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  CloseHandle ((HANDLE) __mutex->sema);
}

static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  int __status = 0;

  if (__gthread_active_p ())
    {
      if (InterlockedIncrement (&__mutex->counter) == 0 ||
	  WaitForSingleObject (__mutex->sema, INFINITE) == WAIT_OBJECT_0)
	__status = 0;
      else
	{
	  /* WaitForSingleObject returns WAIT_FAILED, and we can only do
	     some best-effort cleanup here.  */
	  InterlockedDecrement (&__mutex->counter);
	  __status = 1;
	}
    }
  return __status;
}

static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  int __status = 0;

  if (__gthread_active_p ())
    {
      if (__GTHR_W32_InterlockedCompareExchange (&__mutex->counter, 0, -1) < 0)
	__status = 0;
      else
	__status = 1;
    }
  return __status;
}

static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      if (InterlockedDecrement (&__mutex->counter) >= 0)
	return ReleaseSemaphore (__mutex->sema, 1, NULL) ? 0 : 1;
    }
  return 0;
}

static inline void
__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
  __mutex->counter = -1;
  __mutex->depth = 0;
  __mutex->owner = 0;
  __mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}

static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      DWORD __me = GetCurrentThreadId();
      if (InterlockedIncrement (&__mutex->counter) == 0)
	{
	  __mutex->depth = 1;
	  __mutex->owner = __me;
	}
      else if (__mutex->owner == __me)
	{
	  InterlockedDecrement (&__mutex->counter);
	  ++(__mutex->depth);
	}
      else if (WaitForSingleObject (__mutex->sema, INFINITE) == WAIT_OBJECT_0)
	{
	  __mutex->depth = 1;
	  __mutex->owner = __me;
	}
      else
	{
	  /* WaitForSingleObject returns WAIT_FAILED, and we can only do
	     some best-effort cleanup here.  */
	  InterlockedDecrement (&__mutex->counter);
	  return 1;
	}
    }
  return 0;
}

static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      DWORD __me = GetCurrentThreadId();
      if (__GTHR_W32_InterlockedCompareExchange (&__mutex->counter, 0, -1) < 0)
	{
	  __mutex->depth = 1;
	  __mutex->owner = __me;
	}
      else if (__mutex->owner == __me)
	++(__mutex->depth);
      else
	return 1;
    }
  return 0;
}

static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      --(__mutex->depth);
      if (__mutex->depth == 0)
	{
	  __mutex->owner = 0;

	  if (InterlockedDecrement (&__mutex->counter) >= 0)
	    return ReleaseSemaphore (__mutex->sema, 1, NULL) ? 0 : 1;
	}
    }
  return 0;
}

#endif /*  __GTHREAD_HIDE_WIN32API */

#ifdef __cplusplus
}
#endif

#endif /* _LIBOBJC */

#endif /* ! GCC_GTHR_WIN32_H */