gcc/gthr-win32.h

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