gcc/gthr-win32.h

   1 /* Threads compatibility routines for libgcc2 and libobjc.  */
   2 /* Compile this one with gcc.  */
   3
   4 /* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005
   5    Free Software Foundation, Inc.
   6    Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 2, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING.  If not, write to the Free
  22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  23 02110-1301, USA.  */
  24
  25 /* As a special exception, if you link this library with other files,
  26    some of which are compiled with GCC, to produce an executable,
  27    this library does not by itself cause the resulting executable
  28    to be covered by the GNU General Public License.
  29    This exception does not however invalidate any other reasons why
  30    the executable file might be covered by the GNU General Public License.  */
  31
  32 #ifndef GCC_GTHR_WIN32_H
  33 #define GCC_GTHR_WIN32_H
  34
  35 /* Windows32 threads specific definitions. The windows32 threading model
  36    does not map well into pthread-inspired gcc's threading model, and so
  37    there are caveats one needs to be aware of.
  38
  39    1. The destructor supplied to __gthread_key_create is ignored for
  40       generic x86-win32 ports. This will certainly cause memory leaks
  41       due to unreclaimed eh contexts (sizeof (eh_context) is at least
  42       24 bytes for x86 currently).
  43
  44       This memory leak may be significant for long-running applications
  45       that make heavy use of C++ EH.
  46
  47       However, Mingw runtime (version 0.3 or newer) provides a mechanism
  48       to emulate pthreads key dtors; the runtime provides a special DLL,
  49       linked in if -mthreads option is specified, that runs the dtors in
  50       the reverse order of registration when each thread exits. If
  51       -mthreads option is not given, a stub is linked in instead of the
  52       DLL, which results in memory leak. Other x86-win32 ports can use
  53       the same technique of course to avoid the leak.
  54
  55    2. The error codes returned are non-POSIX like, and cast into ints.
  56       This may cause incorrect error return due to truncation values on
  57       hw where sizeof (DWORD) > sizeof (int).
  58
  59    3. We are currently using a special mutex instead of the Critical
  60       Sections, since Win9x does not support TryEnterCriticalSection
  61       (while NT does).
  62
  63    The basic framework should work well enough. In the long term, GCC
  64    needs to use Structured Exception Handling on Windows32.  */
  65
  66 #define __GTHREADS 1
  67
  68 #include <errno.h>
  69 #ifdef __MINGW32__
  70 #include <_mingw.h>
  71 #endif
  72
  73 #ifdef _LIBOBJC
  74
  75 /* This is necessary to prevent windef.h (included from windows.h) from
  76    defining its own BOOL as a typedef.  */
  77 #ifndef __OBJC__
  78 #define __OBJC__
  79 #endif
  80 #include <windows.h>
  81 /* Now undef the windows BOOL.  */
  82 #undef BOOL
  83
  84 /* Key structure for maintaining thread specific storage */
  85 static DWORD    __gthread_objc_data_tls = (DWORD) -1;
  86
  87 /* Backend initialization functions */
  88
  89 /* Initialize the threads subsystem.  */
  90 int
  91 __gthread_objc_init_thread_system (void)
  92 {
  93   /* Initialize the thread storage key.  */
  94   if ((__gthread_objc_data_tls = TlsAlloc ()) != (DWORD) -1)
  95     return 0;
  96   else
  97     return -1;
  98 }
  99
 100 /* Close the threads subsystem.  */
 101 int
 102 __gthread_objc_close_thread_system (void)
 103 {
 104   if (__gthread_objc_data_tls != (DWORD) -1)
 105     TlsFree (__gthread_objc_data_tls);
 106   return 0;
 107 }
 108
 109 /* Backend thread functions */
 110
 111 /* Create a new thread of execution.  */
 112 objc_thread_t
 113 __gthread_objc_thread_detach (void (*func)(void *arg), void *arg)
 114 {
 115   DWORD thread_id = 0;
 116   HANDLE win32_handle;
 117
 118   if (!(win32_handle = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE) func,
 119                                      arg, 0, &thread_id)))
 120     thread_id = 0;
 121
 122   return (objc_thread_t) thread_id;
 123 }
 124
 125 /* Set the current thread's priority.  */
 126 int
 127 __gthread_objc_thread_set_priority (int priority)
 128 {
 129   int sys_priority = 0;
 130
 131   switch (priority)
 132     {
 133     case OBJC_THREAD_INTERACTIVE_PRIORITY:
 134       sys_priority = THREAD_PRIORITY_NORMAL;
 135       break;
 136     default:
 137     case OBJC_THREAD_BACKGROUND_PRIORITY:
 138       sys_priority = THREAD_PRIORITY_BELOW_NORMAL;
 139       break;
 140     case OBJC_THREAD_LOW_PRIORITY:
 141       sys_priority = THREAD_PRIORITY_LOWEST;
 142       break;
 143     }
 144
 145   /* Change priority */
 146   if (SetThreadPriority (GetCurrentThread (), sys_priority))
 147     return 0;
 148   else
 149     return -1;
 150 }
 151
 152 /* Return the current thread's priority.  */
 153 int
 154 __gthread_objc_thread_get_priority (void)
 155 {
 156   int sys_priority;
 157
 158   sys_priority = GetThreadPriority (GetCurrentThread ());
 159
 160   switch (sys_priority)
 161     {
 162     case THREAD_PRIORITY_HIGHEST:
 163     case THREAD_PRIORITY_TIME_CRITICAL:
 164     case THREAD_PRIORITY_ABOVE_NORMAL:
 165     case THREAD_PRIORITY_NORMAL:
 166       return OBJC_THREAD_INTERACTIVE_PRIORITY;
 167
 168     default:
 169     case THREAD_PRIORITY_BELOW_NORMAL:
 170       return OBJC_THREAD_BACKGROUND_PRIORITY;
 171
 172     case THREAD_PRIORITY_IDLE:
 173     case THREAD_PRIORITY_LOWEST:
 174       return OBJC_THREAD_LOW_PRIORITY;
 175     }
 176
 177   /* Couldn't get priority.  */
 178   return -1;
 179 }
 180
 181 /* Yield our process time to another thread.  */
 182 void
 183 __gthread_objc_thread_yield (void)
 184 {
 185   Sleep (0);
 186 }
 187
 188 /* Terminate the current thread.  */
 189 int
 190 __gthread_objc_thread_exit (void)
 191 {
 192   /* exit the thread */
 193   ExitThread (__objc_thread_exit_status);
 194
 195   /* Failed if we reached here */
 196   return -1;
 197 }
 198
 199 /* Returns an integer value which uniquely describes a thread.  */
 200 objc_thread_t
 201 __gthread_objc_thread_id (void)
 202 {
 203   return (objc_thread_t) GetCurrentThreadId ();
 204 }
 205
 206 /* Sets the thread's local storage pointer.  */
 207 int
 208 __gthread_objc_thread_set_data (void *value)
 209 {
 210   if (TlsSetValue (__gthread_objc_data_tls, value))
 211     return 0;
 212   else
 213     return -1;
 214 }
 215
 216 /* Returns the thread's local storage pointer.  */
 217 void *
 218 __gthread_objc_thread_get_data (void)
 219 {
 220   DWORD lasterror;
 221   void *ptr;
 222
 223   lasterror = GetLastError ();
 224
 225   ptr = TlsGetValue (__gthread_objc_data_tls);          /* Return thread data.  */
 226
 227   SetLastError (lasterror);
 228
 229   return ptr;
 230 }
 231
 232 /* Backend mutex functions */
 233
 234 /* Allocate a mutex.  */
 235 int
 236 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
 237 {
 238   if ((mutex->backend = (void *) CreateMutex (NULL, 0, NULL)) == NULL)
 239     return -1;
 240   else
 241     return 0;
 242 }
 243
 244 /* Deallocate a mutex.  */
 245 int
 246 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
 247 {
 248   CloseHandle ((HANDLE) (mutex->backend));
 249   return 0;
 250 }
 251
 252 /* Grab a lock on a mutex.  */
 253 int
 254 __gthread_objc_mutex_lock (objc_mutex_t mutex)
 255 {
 256   int status;
 257
 258   status = WaitForSingleObject ((HANDLE) (mutex->backend), INFINITE);
 259   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
 260     return -1;
 261   else
 262     return 0;
 263 }
 264
 265 /* Try to grab a lock on a mutex.  */
 266 int
 267 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
 268 {
 269   int status;
 270
 271   status = WaitForSingleObject ((HANDLE) (mutex->backend), 0);
 272   if (status != WAIT_OBJECT_0 && status != WAIT_ABANDONED)
 273     return -1;
 274   else
 275     return 0;
 276 }
 277
 278 /* Unlock the mutex */
 279 int
 280 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
 281 {
 282   if (ReleaseMutex ((HANDLE) (mutex->backend)) == 0)
 283     return -1;
 284   else
 285     return 0;
 286 }
 287
 288 /* Backend condition mutex functions */
 289
 290 /* Allocate a condition.  */
 291 int
 292 __gthread_objc_condition_allocate (objc_condition_t condition)
 293 {
 294   /* Unimplemented.  */
 295   return -1;
 296 }
 297
 298 /* Deallocate a condition.  */
 299 int
 300 __gthread_objc_condition_deallocate (objc_condition_t condition)
 301 {
 302   /* Unimplemented.  */
 303   return -1;
 304 }
 305
 306 /* Wait on the condition */
 307 int
 308 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 309 {
 310   /* Unimplemented.  */
 311   return -1;
 312 }
 313
 314 /* Wake up all threads waiting on this condition.  */
 315 int
 316 __gthread_objc_condition_broadcast (objc_condition_t condition)
 317 {
 318   /* Unimplemented.  */
 319   return -1;
 320 }
 321
 322 /* Wake up one thread waiting on this condition.  */
 323 int
 324 __gthread_objc_condition_signal (objc_condition_t condition)
 325 {
 326   /* Unimplemented.  */
 327   return -1;
 328 }
 329
 330 #else /* _LIBOBJC */
 331
 332 #ifdef __cplusplus
 333 extern "C" {
 334 #endif
 335
 336 typedef unsigned long __gthread_key_t;
 337
 338 typedef struct {
 339   int done;
 340   long started;
 341 } __gthread_once_t;
 342
 343 typedef struct {
 344   long counter;
 345   void *sema;
 346 } __gthread_mutex_t;
 347
 348 typedef struct {
 349   long counter;
 350   long depth;
 351   unsigned long owner;
 352   void *sema;
 353 } __gthread_recursive_mutex_t;
 354
 355 #define __GTHREAD_ONCE_INIT {0, -1}
 356 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
 357 #define __GTHREAD_MUTEX_INIT_DEFAULT {-1, 0}
 358 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION \
 359   __gthread_recursive_mutex_init_function
 360 #define __GTHREAD_RECURSIVE_MUTEX_INIT_DEFAULT {-1, 0, 0, 0}
 361
 362 #if __MINGW32_MAJOR_VERSION >= 1 || \
 363   (__MINGW32_MAJOR_VERSION == 0 && __MINGW32_MINOR_VERSION > 2)
 364 #define MINGW32_SUPPORTS_MT_EH 1
 365 /* Mingw runtime >= v0.3 provides a magic variable that is set to nonzero
 366    if -mthreads option was specified, or 0 otherwise. This is to get around
 367    the lack of weak symbols in PE-COFF.  */
 368 extern int _CRT_MT;
 369 extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
 370 #endif /* __MINGW32__ version */
 371
 372 /* The Windows95 kernel does not export InterlockedCompareExchange.
 373    This provides a substitute.   When building apps that reference
 374    gthread_mutex_try_lock, the  __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
 375    macro  must be defined if Windows95 is a target.  Currently
 376    gthread_mutex_try_lock is not referenced by libgcc or libstdc++.  */
 377 #ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
 378 static inline long
 379 __gthr_i486_lock_cmp_xchg(long *dest, long xchg, long comperand)
 380 {
 381   long result;
 382   __asm__ __volatile__ ("\n\
 383         lock\n\
 384         cmpxchg{l} {%4, %1|%1, %4}\n"
 385         : "=a" (result), "=m" (*dest)
 386         : "0" (comperand), "m" (*dest), "r" (xchg)
 387         : "cc");
 388   return result;
 389 }
 390 #define __GTHR_W32_InterlockedCompareExchange __gthr_i486_lock_cmp_xchg
 391 #else  /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
 392 #define __GTHR_W32_InterlockedCompareExchange InterlockedCompareExchange
 393 #endif /* __GTHREAD_I486_INLINE_LOCK_PRIMITIVES */
 394
 395 static inline int
 396 __gthread_active_p (void)
 397 {
 398 #ifdef MINGW32_SUPPORTS_MT_EH
 399   return _CRT_MT;
 400 #else
 401   return 1;
 402 #endif
 403 }
 404
 405 #if __GTHREAD_HIDE_WIN32API
 406
 407 /* The implementations are in config/i386/gthr-win32.c in libgcc.a.
 408    Only stubs are exposed to avoid polluting the C++ namespace with
 409    windows api definitions.  */
 410
 411 extern int __gthr_win32_once (__gthread_once_t *, void (*) (void));
 412 extern int __gthr_win32_key_create (__gthread_key_t *, void (*) (void*));
 413 extern int __gthr_win32_key_delete (__gthread_key_t);
 414 extern void * __gthr_win32_getspecific (__gthread_key_t);
 415 extern int __gthr_win32_setspecific (__gthread_key_t, const void *);
 416 extern void __gthr_win32_mutex_init_function (__gthread_mutex_t *);
 417 extern int __gthr_win32_mutex_lock (__gthread_mutex_t *);
 418 extern int __gthr_win32_mutex_trylock (__gthread_mutex_t *);
 419 extern int __gthr_win32_mutex_unlock (__gthread_mutex_t *);
 420 extern void
 421   __gthr_win32_recursive_mutex_init_function (__gthread_recursive_mutex_t *);
 422 extern int __gthr_win32_recursive_mutex_lock (__gthread_recursive_mutex_t *);
 423 extern int
 424   __gthr_win32_recursive_mutex_trylock (__gthread_recursive_mutex_t *);
 425 extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
 426 extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
 427
 428 static inline int
 429 __gthread_once (__gthread_once_t *once, void (*func) (void))
 430 {
 431   if (__gthread_active_p ())
 432     return __gthr_win32_once (once, func);
 433   else
 434     return -1;
 435 }
 436
 437 static inline int
 438 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
 439 {
 440   return __gthr_win32_key_create (key, dtor);
 441 }
 442
 443 static inline int
 444 __gthread_key_delete (__gthread_key_t key)
 445 {
 446   return __gthr_win32_key_delete (key);
 447 }
 448
 449 static inline void *
 450 __gthread_getspecific (__gthread_key_t key)
 451 {
 452   return __gthr_win32_getspecific (key);
 453 }
 454
 455 static inline int
 456 __gthread_setspecific (__gthread_key_t key, const void *ptr)
 457 {
 458   return __gthr_win32_setspecific (key, ptr);
 459 }
 460
 461 static inline void
 462 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
 463 {
 464   __gthr_win32_mutex_init_function (mutex);
 465 }
 466
 467 static inline void
 468 __gthread_mutex_destroy (__gthread_mutex_t *mutex)
 469 {
 470   __gthr_win32_mutex_destroy (mutex);
 471 }
 472
 473 static inline int
 474 __gthread_mutex_lock (__gthread_mutex_t *mutex)
 475 {
 476   if (__gthread_active_p ())
 477     return __gthr_win32_mutex_lock (mutex);
 478   else
 479     return 0;
 480 }
 481
 482 static inline int
 483 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
 484 {
 485   if (__gthread_active_p ())
 486     return __gthr_win32_mutex_trylock (mutex);
 487   else
 488     return 0;
 489 }
 490
 491 static inline int
 492 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
 493 {
 494   if (__gthread_active_p ())
 495     return __gthr_win32_mutex_unlock (mutex);
 496   else
 497     return 0;
 498 }
 499
 500 static inline void
 501 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
 502 {
 503    __gthr_win32_recursive_mutex_init_function (mutex);
 504 }
 505
 506 static inline int
 507 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 508 {
 509   if (__gthread_active_p ())
 510     return __gthr_win32_recursive_mutex_lock (mutex);
 511   else
 512     return 0;
 513 }
 514
 515 static inline int
 516 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
 517 {
 518   if (__gthread_active_p ())
 519     return __gthr_win32_recursive_mutex_trylock (mutex);
 520   else
 521     return 0;
 522 }
 523
 524 static inline int
 525 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
 526 {
 527   if (__gthread_active_p ())
 528     return __gthr_win32_recursive_mutex_unlock (mutex);
 529   else
 530     return 0;
 531 }
 532
 533 #else /* ! __GTHREAD_HIDE_WIN32API */
 534
 535 #include <windows.h>
 536 #include <errno.h>
 537
 538 static inline int
 539 __gthread_once (__gthread_once_t *once, void (*func) (void))
 540 {
 541   if (! __gthread_active_p ())
 542     return -1;
 543   else if (once == NULL || func == NULL)
 544     return EINVAL;
 545
 546   if (! once->done)
 547     {
 548       if (InterlockedIncrement (&(once->started)) == 0)
 549         {
 550           (*func) ();
 551           once->done = TRUE;
 552         }
 553       else
 554         {
 555           /* Another thread is currently executing the code, so wait for it
 556              to finish; yield the CPU in the meantime.  If performance
 557              does become an issue, the solution is to use an Event that
 558              we wait on here (and set above), but that implies a place to
 559              create the event before this routine is called.  */
 560           while (! once->done)
 561             Sleep (0);
 562         }
 563     }
 564
 565   return 0;
 566 }
 567
 568 /* Windows32 thread local keys don't support destructors; this leads to
 569    leaks, especially in threaded applications making extensive use of
 570    C++ EH. Mingw uses a thread-support DLL to work-around this problem.  */
 571 static inline int
 572 __gthread_key_create (__gthread_key_t *key,
 573                       void (*dtor) (void *) __attribute__((unused)))
 574 {
 575   int status = 0;
 576   DWORD tls_index = TlsAlloc ();
 577   if (tls_index != 0xFFFFFFFF)
 578     {
 579       *key = tls_index;
 580 #ifdef MINGW32_SUPPORTS_MT_EH
 581       /* Mingw runtime will run the dtors in reverse order for each thread
 582          when the thread exits.  */
 583       status = __mingwthr_key_dtor (*key, dtor);
 584 #endif
 585     }
 586   else
 587     status = (int) GetLastError ();
 588   return status;
 589 }
 590
 591 static inline int
 592 __gthread_key_delete (__gthread_key_t key)
 593 {
 594   return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
 595 }
 596
 597 static inline void *
 598 __gthread_getspecific (__gthread_key_t key)
 599 {
 600   DWORD lasterror;
 601   void *ptr;
 602
 603   lasterror = GetLastError ();
 604
 605   ptr = TlsGetValue (key);
 606
 607   SetLastError (lasterror);
 608
 609   return ptr;
 610 }
 611
 612 static inline int
 613 __gthread_setspecific (__gthread_key_t key, const void *ptr)
 614 {
 615   return (TlsSetValue (key, (void*) ptr) != 0) ? 0 : (int) GetLastError ();
 616 }
 617
 618 static inline void
 619 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
 620 {
 621   mutex->counter = -1;
 622   mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
 623 }
 624
 625 static inline void
 626 __gthread_mutex_destroy (__gthread_mutex_t *mutex)
 627 {
 628   CloseHandle ((HANDLE) mutex->sema);
 629 }
 630
 631 static inline int
 632 __gthread_mutex_lock (__gthread_mutex_t *mutex)
 633 {
 634   int status = 0;
 635
 636   if (__gthread_active_p ())
 637     {
 638       if (InterlockedIncrement (&mutex->counter) == 0 ||
 639           WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
 640         status = 0;
 641       else
 642         {
 643           /* WaitForSingleObject returns WAIT_FAILED, and we can only do
 644              some best-effort cleanup here.  */
 645           InterlockedDecrement (&mutex->counter);
 646           status = 1;
 647         }
 648     }
 649   return status;
 650 }
 651
 652 static inline int
 653 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
 654 {
 655   int status = 0;
 656
 657   if (__gthread_active_p ())
 658     {
 659       if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
 660         status = 0;
 661       else
 662         status = 1;
 663     }
 664   return status;
 665 }
 666
 667 static inline int
 668 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
 669 {
 670   if (__gthread_active_p ())
 671     {
 672       if (InterlockedDecrement (&mutex->counter) >= 0)
 673         return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
 674     }
 675   return 0;
 676 }
 677
 678 static inline void
 679 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
 680 {
 681   mutex->counter = -1;
 682   mutex->depth = 0;
 683   mutex->owner = 0;
 684   mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
 685 }
 686
 687 static inline int
 688 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 689 {
 690   if (__gthread_active_p ())
 691     {
 692       DWORD me = GetCurrentThreadId();
 693       if (InterlockedIncrement (&mutex->counter) == 0)
 694         {
 695           mutex->depth = 1;
 696           mutex->owner = me;
 697         }
 698       else if (mutex->owner == me)
 699         {
 700           InterlockedDecrement (&mutex->counter);
 701           ++(mutex->depth);
 702         }
 703       else if (WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
 704         {
 705           mutex->depth = 1;
 706           mutex->owner = me;
 707         }
 708       else
 709         {
 710           /* WaitForSingleObject returns WAIT_FAILED, and we can only do
 711              some best-effort cleanup here.  */
 712           InterlockedDecrement (&mutex->counter);
 713           return 1;
 714         }
 715     }
 716   return 0;
 717 }
 718
 719 static inline int
 720 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
 721 {
 722   if (__gthread_active_p ())
 723     {
 724       DWORD me = GetCurrentThreadId();
 725       if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
 726         {
 727           mutex->depth = 1;
 728           mutex->owner = me;
 729         }
 730       else if (mutex->owner == me)
 731         ++(mutex->depth);
 732       else
 733         return 1;
 734     }
 735   return 0;
 736 }
 737
 738 static inline int
 739 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
 740 {
 741   if (__gthread_active_p ())
 742     {
 743       --(mutex->depth);
 744       if (mutex->depth == 0)
 745         {
 746           mutex->owner = 0;
 747
 748           if (InterlockedDecrement (&mutex->counter) >= 0)
 749             return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
 750         }
 751     }
 752   return 0;
 753 }
 754
 755 #endif /*  __GTHREAD_HIDE_WIN32API */
 756
 757 #ifdef __cplusplus
 758 }
 759 #endif
 760
 761 #endif /* _LIBOBJC */
 762
 763 #endif /* ! GCC_GTHR_WIN32_H */