contrib/gcc-4.4/gcc/gthr-posix.h

   1 /* Threads compatibility routines for libgcc2 and libobjc.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   4    2008, 2009 Free Software Foundation, Inc.
   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 3, 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 Under Section 7 of GPL version 3, you are granted additional
  19 permissions described in the GCC Runtime Library Exception, version
  20 3.1, as published by the Free Software Foundation.
  21
  22 You should have received a copy of the GNU General Public License and
  23 a copy of the GCC Runtime Library Exception along with this program;
  24 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 <http://www.gnu.org/licenses/>.  */
  26
  27 #ifndef GCC_GTHR_POSIX_H
  28 #define GCC_GTHR_POSIX_H
  29
  30 /* POSIX threads specific definitions.
  31    Easy, since the interface is just one-to-one mapping.  */
  32
  33 #define __GTHREADS 1
  34 #define __GTHREADS_CXX0X 1
  35
  36 /* Some implementations of <pthread.h> require this to be defined.  */
  37 #if !defined(_REENTRANT) && defined(__osf__)
  38 #define _REENTRANT 1
  39 #endif
  40
  41 #include <pthread.h>
  42 #include <unistd.h>
  43
  44 typedef pthread_t __gthread_t;
  45 typedef pthread_key_t __gthread_key_t;
  46 typedef pthread_once_t __gthread_once_t;
  47 typedef pthread_mutex_t __gthread_mutex_t;
  48 typedef pthread_mutex_t __gthread_recursive_mutex_t;
  49 typedef pthread_cond_t __gthread_cond_t;
  50 typedef struct timespec __gthread_time_t;
  51
  52 /* POSIX like conditional variables are supported.  Please look at comments
  53    in gthr.h for details. */
  54 #define __GTHREAD_HAS_COND      1
  55
  56 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
  57 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
  58 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
  59 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER
  60 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
  61 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
  62 #else
  63 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
  64 #endif
  65 #define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
  66 #define __GTHREAD_TIME_INIT {0,0}
  67
  68 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
  69 # ifndef __gthrw_pragma
  70 #  define __gthrw_pragma(pragma)
  71 # endif
  72 # define __gthrw2(name,name2,type) \
  73   static __typeof(type) name __attribute__ ((__weakref__(#name2))); \
  74   __gthrw_pragma(weak type)
  75 # define __gthrw_(name) __gthrw_ ## name
  76 #else
  77 # define __gthrw2(name,name2,type)
  78 # define __gthrw_(name) name
  79 #endif
  80
  81 /* Typically, __gthrw_foo is a weak reference to symbol foo.  */
  82 #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
  83
  84 /* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to
  85    map a subset of the POSIX pthread API to mangled versions of their
  86    names.  */
  87 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
  88 #define __gthrw3(name) __gthrw2(__gthrw_ ## name, __ ## name, name)
  89 __gthrw3(pthread_once)
  90 __gthrw3(pthread_getspecific)
  91 __gthrw3(pthread_setspecific)
  92
  93 __gthrw3(pthread_create)
  94 __gthrw3(pthread_join)
  95 __gthrw3(pthread_detach)
  96 __gthrw3(pthread_equal)
  97 __gthrw3(pthread_self)
  98 __gthrw3(pthread_cancel)
  99 __gthrw3(sched_yield)
 100
 101 __gthrw3(pthread_mutex_lock)
 102 __gthrw3(pthread_mutex_trylock)
 103 #ifdef _POSIX_TIMEOUTS
 104 #if _POSIX_TIMEOUTS >= 0
 105 __gthrw3(pthread_mutex_timedlock)
 106 #endif
 107 #endif /* _POSIX_TIMEOUTS */
 108 __gthrw3(pthread_mutex_unlock)
 109 __gthrw3(pthread_mutex_init)
 110 __gthrw3(pthread_mutex_destroy)
 111
 112 __gthrw3(pthread_cond_broadcast)
 113 __gthrw3(pthread_cond_signal)
 114 __gthrw3(pthread_cond_wait)
 115 __gthrw3(pthread_cond_timedwait)
 116 __gthrw3(pthread_cond_destroy)
 117 #else
 118 __gthrw(pthread_once)
 119 __gthrw(pthread_getspecific)
 120 __gthrw(pthread_setspecific)
 121
 122 __gthrw(pthread_create)
 123 __gthrw(pthread_join)
 124 __gthrw(pthread_equal)
 125 __gthrw(pthread_self)
 126 __gthrw(pthread_detach)
 127 __gthrw(pthread_cancel)
 128 __gthrw(sched_yield)
 129
 130 __gthrw(pthread_mutex_lock)
 131 __gthrw(pthread_mutex_trylock)
 132 #ifdef _POSIX_TIMEOUTS
 133 #if _POSIX_TIMEOUTS >= 0
 134 __gthrw(pthread_mutex_timedlock)
 135 #endif
 136 #endif /* _POSIX_TIMEOUTS */
 137 __gthrw(pthread_mutex_unlock)
 138 __gthrw(pthread_mutex_init)
 139 __gthrw(pthread_mutex_destroy)
 140
 141 __gthrw(pthread_cond_broadcast)
 142 __gthrw(pthread_cond_signal)
 143 __gthrw(pthread_cond_wait)
 144 __gthrw(pthread_cond_timedwait)
 145 __gthrw(pthread_cond_destroy)
 146 #endif
 147
 148 __gthrw(pthread_key_create)
 149 __gthrw(pthread_key_delete)
 150 __gthrw(pthread_mutexattr_init)
 151 __gthrw(pthread_mutexattr_settype)
 152 __gthrw(pthread_mutexattr_destroy)
 153
 154
 155 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
 156 /* Objective-C.  */
 157 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
 158 __gthrw3(pthread_cond_init)
 159 __gthrw3(pthread_exit)
 160 #else
 161 __gthrw(pthread_cond_init)
 162 __gthrw(pthread_exit)
 163 #endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */
 164 #ifdef _POSIX_PRIORITY_SCHEDULING
 165 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 166 __gthrw(sched_get_priority_max)
 167 __gthrw(sched_get_priority_min)
 168 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 169 #endif /* _POSIX_PRIORITY_SCHEDULING */
 170 __gthrw(pthread_attr_destroy)
 171 __gthrw(pthread_attr_init)
 172 __gthrw(pthread_attr_setdetachstate)
 173 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 174 __gthrw(pthread_getschedparam)
 175 __gthrw(pthread_setschedparam)
 176 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 177 #endif /* _LIBOBJC || _LIBOBJC_WEAK */
 178
 179 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
 180
 181 /* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if
 182    -pthreads is not specified.  The functions are dummies and most return an
 183    error value.  However pthread_once returns 0 without invoking the routine
 184    it is passed so we cannot pretend that the interface is active if -pthreads
 185    is not specified.  On Solaris 2.5.1, the interface is not exposed at all so
 186    we need to play the usual game with weak symbols.  On Solaris 10 and up, a
 187    working interface is always exposed.  On FreeBSD 6 and later, libc also
 188    exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up
 189    to 9 does.  FreeBSD >= 700014 even provides a pthread_cancel stub in libc,
 190    which means the alternate __gthread_active_p below cannot be used there.  */
 191
 192 #if defined(__FreeBSD__) || (defined(__sun) && defined(__svr4__))
 193
 194 static volatile int __gthread_active = -1;
 195
 196 static void
 197 __gthread_trigger (void)
 198 {
 199   __gthread_active = 1;
 200 }
 201
 202 static inline int
 203 __gthread_active_p (void)
 204 {
 205   static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER;
 206   static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT;
 207
 208   /* Avoid reading __gthread_active twice on the main code path.  */
 209   int __gthread_active_latest_value = __gthread_active;
 210
 211   /* This test is not protected to avoid taking a lock on the main code
 212      path so every update of __gthread_active in a threaded program must
 213      be atomic with regard to the result of the test.  */
 214   if (__builtin_expect (__gthread_active_latest_value < 0, 0))
 215     {
 216       if (__gthrw_(pthread_once))
 217         {
 218           /* If this really is a threaded program, then we must ensure that
 219              __gthread_active has been set to 1 before exiting this block.  */
 220           __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex);
 221           __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger);
 222           __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
 223         }
 224
 225       /* Make sure we'll never enter this block again.  */
 226       if (__gthread_active < 0)
 227         __gthread_active = 0;
 228
 229       __gthread_active_latest_value = __gthread_active;
 230     }
 231
 232   return __gthread_active_latest_value != 0;
 233 }
 234
 235 #else /* neither FreeBSD nor Solaris */
 236
 237 static inline int
 238 __gthread_active_p (void)
 239 {
 240   static void *const __gthread_active_ptr
 241     = __extension__ (void *) &__gthrw_(pthread_cancel);
 242   return __gthread_active_ptr != 0;
 243 }
 244
 245 #endif /* FreeBSD or Solaris */
 246
 247 #else /* not SUPPORTS_WEAK */
 248
 249 /* Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread
 250    calls in shared flavors of the HP-UX C library.  Most of the stubs
 251    have no functionality.  The details are described in the "libc cumulative
 252    patch" for each subversion of HP-UX 11.  There are two special interfaces
 253    provided for checking whether an application is linked to a shared pthread
 254    library or not.  However, these interfaces aren't available in early
 255    libpthread libraries.  We also need a test that works for archive
 256    libraries.  We can't use pthread_once as some libc versions call the
 257    init function.  We also can't use pthread_create or pthread_attr_init
 258    as these create a thread and thereby prevent changing the default stack
 259    size.  The function pthread_default_stacksize_np is available in both
 260    the archive and shared versions of libpthread.   It can be used to
 261    determine the default pthread stack size.  There is a stub in some
 262    shared libc versions which returns a zero size if pthreads are not
 263    active.  We provide an equivalent stub to handle cases where libc
 264    doesn't provide one.  */
 265
 266 #if defined(__hppa__) && defined(__hpux__)
 267
 268 static volatile int __gthread_active = -1;
 269
 270 static inline int
 271 __gthread_active_p (void)
 272 {
 273   /* Avoid reading __gthread_active twice on the main code path.  */
 274   int __gthread_active_latest_value = __gthread_active;
 275   size_t __s;
 276
 277   if (__builtin_expect (__gthread_active_latest_value < 0, 0))
 278     {
 279       pthread_default_stacksize_np (0, &__s);
 280       __gthread_active = __s ? 1 : 0;
 281       __gthread_active_latest_value = __gthread_active;
 282     }
 283
 284   return __gthread_active_latest_value != 0;
 285 }
 286
 287 #else /* not hppa-hpux */
 288
 289 static inline int
 290 __gthread_active_p (void)
 291 {
 292   return 1;
 293 }
 294
 295 #endif /* hppa-hpux */
 296
 297 #endif /* SUPPORTS_WEAK */
 298
 299 #ifdef _LIBOBJC
 300
 301 /* This is the config.h file in libobjc/ */
 302 #include <config.h>
 303
 304 #ifdef HAVE_SCHED_H
 305 # include <sched.h>
 306 #endif
 307
 308 /* Key structure for maintaining thread specific storage */
 309 static pthread_key_t _objc_thread_storage;
 310 static pthread_attr_t _objc_thread_attribs;
 311
 312 /* Thread local storage for a single thread */
 313 static void *thread_local_storage = NULL;
 314
 315 /* Backend initialization functions */
 316
 317 /* Initialize the threads subsystem.  */
 318 static inline int
 319 __gthread_objc_init_thread_system (void)
 320 {
 321   if (__gthread_active_p ())
 322     {
 323       /* Initialize the thread storage key.  */
 324       if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0)
 325         {
 326           /* The normal default detach state for threads is
 327            * PTHREAD_CREATE_JOINABLE which causes threads to not die
 328            * when you think they should.  */
 329           if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0
 330               && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs,
 331                                               PTHREAD_CREATE_DETACHED) == 0)
 332             return 0;
 333         }
 334     }
 335
 336   return -1;
 337 }
 338
 339 /* Close the threads subsystem.  */
 340 static inline int
 341 __gthread_objc_close_thread_system (void)
 342 {
 343   if (__gthread_active_p ()
 344       && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0
 345       && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0)
 346     return 0;
 347
 348   return -1;
 349 }
 350
 351 /* Backend thread functions */
 352
 353 /* Create a new thread of execution.  */
 354 static inline objc_thread_t
 355 __gthread_objc_thread_detach (void (*func)(void *), void *arg)
 356 {
 357   objc_thread_t thread_id;
 358   pthread_t new_thread_handle;
 359
 360   if (!__gthread_active_p ())
 361     return NULL;
 362
 363   if (!(__gthrw_(pthread_create) (&new_thread_handle, NULL, (void *) func, arg)))
 364     thread_id = (objc_thread_t) new_thread_handle;
 365   else
 366     thread_id = NULL;
 367
 368   return thread_id;
 369 }
 370
 371 /* Set the current thread's priority.  */
 372 static inline int
 373 __gthread_objc_thread_set_priority (int priority)
 374 {
 375   if (!__gthread_active_p ())
 376     return -1;
 377   else
 378     {
 379 #ifdef _POSIX_PRIORITY_SCHEDULING
 380 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 381       pthread_t thread_id = __gthrw_(pthread_self) ();
 382       int policy;
 383       struct sched_param params;
 384       int priority_min, priority_max;
 385
 386       if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0)
 387         {
 388           if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1)
 389             return -1;
 390
 391           if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1)
 392             return -1;
 393
 394           if (priority > priority_max)
 395             priority = priority_max;
 396           else if (priority < priority_min)
 397             priority = priority_min;
 398           params.sched_priority = priority;
 399
 400           /*
 401            * The solaris 7 and several other man pages incorrectly state that
 402            * this should be a pointer to policy but pthread.h is universally
 403            * at odds with this.
 404            */
 405           if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0)
 406             return 0;
 407         }
 408 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 409 #endif /* _POSIX_PRIORITY_SCHEDULING */
 410       return -1;
 411     }
 412 }
 413
 414 /* Return the current thread's priority.  */
 415 static inline int
 416 __gthread_objc_thread_get_priority (void)
 417 {
 418 #ifdef _POSIX_PRIORITY_SCHEDULING
 419 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 420   if (__gthread_active_p ())
 421     {
 422       int policy;
 423       struct sched_param params;
 424
 425       if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, &params) == 0)
 426         return params.sched_priority;
 427       else
 428         return -1;
 429     }
 430   else
 431 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 432 #endif /* _POSIX_PRIORITY_SCHEDULING */
 433     return OBJC_THREAD_INTERACTIVE_PRIORITY;
 434 }
 435
 436 /* Yield our process time to another thread.  */
 437 static inline void
 438 __gthread_objc_thread_yield (void)
 439 {
 440   if (__gthread_active_p ())
 441     __gthrw_(sched_yield) ();
 442 }
 443
 444 /* Terminate the current thread.  */
 445 static inline int
 446 __gthread_objc_thread_exit (void)
 447 {
 448   if (__gthread_active_p ())
 449     /* exit the thread */
 450     __gthrw_(pthread_exit) (&__objc_thread_exit_status);
 451
 452   /* Failed if we reached here */
 453   return -1;
 454 }
 455
 456 /* Returns an integer value which uniquely describes a thread.  */
 457 static inline objc_thread_t
 458 __gthread_objc_thread_id (void)
 459 {
 460   if (__gthread_active_p ())
 461     return (objc_thread_t) __gthrw_(pthread_self) ();
 462   else
 463     return (objc_thread_t) 1;
 464 }
 465
 466 /* Sets the thread's local storage pointer.  */
 467 static inline int
 468 __gthread_objc_thread_set_data (void *value)
 469 {
 470   if (__gthread_active_p ())
 471     return __gthrw_(pthread_setspecific) (_objc_thread_storage, value);
 472   else
 473     {
 474       thread_local_storage = value;
 475       return 0;
 476     }
 477 }
 478
 479 /* Returns the thread's local storage pointer.  */
 480 static inline void *
 481 __gthread_objc_thread_get_data (void)
 482 {
 483   if (__gthread_active_p ())
 484     return __gthrw_(pthread_getspecific) (_objc_thread_storage);
 485   else
 486     return thread_local_storage;
 487 }
 488
 489 /* Backend mutex functions */
 490
 491 /* Allocate a mutex.  */
 492 static inline int
 493 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
 494 {
 495   if (__gthread_active_p ())
 496     {
 497       mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
 498
 499       if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL))
 500         {
 501           objc_free (mutex->backend);
 502           mutex->backend = NULL;
 503           return -1;
 504         }
 505     }
 506
 507   return 0;
 508 }
 509
 510 /* Deallocate a mutex.  */
 511 static inline int
 512 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
 513 {
 514   if (__gthread_active_p ())
 515     {
 516       int count;
 517
 518       /*
 519        * Posix Threads specifically require that the thread be unlocked
 520        * for __gthrw_(pthread_mutex_destroy) to work.
 521        */
 522
 523       do
 524         {
 525           count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend);
 526           if (count < 0)
 527             return -1;
 528         }
 529       while (count);
 530
 531       if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend))
 532         return -1;
 533
 534       objc_free (mutex->backend);
 535       mutex->backend = NULL;
 536     }
 537   return 0;
 538 }
 539
 540 /* Grab a lock on a mutex.  */
 541 static inline int
 542 __gthread_objc_mutex_lock (objc_mutex_t mutex)
 543 {
 544   if (__gthread_active_p ()
 545       && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0)
 546     {
 547       return -1;
 548     }
 549
 550   return 0;
 551 }
 552
 553 /* Try to grab a lock on a mutex.  */
 554 static inline int
 555 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
 556 {
 557   if (__gthread_active_p ()
 558       && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0)
 559     {
 560       return -1;
 561     }
 562
 563   return 0;
 564 }
 565
 566 /* Unlock the mutex */
 567 static inline int
 568 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
 569 {
 570   if (__gthread_active_p ()
 571       && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0)
 572     {
 573       return -1;
 574     }
 575
 576   return 0;
 577 }
 578
 579 /* Backend condition mutex functions */
 580
 581 /* Allocate a condition.  */
 582 static inline int
 583 __gthread_objc_condition_allocate (objc_condition_t condition)
 584 {
 585   if (__gthread_active_p ())
 586     {
 587       condition->backend = objc_malloc (sizeof (pthread_cond_t));
 588
 589       if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL))
 590         {
 591           objc_free (condition->backend);
 592           condition->backend = NULL;
 593           return -1;
 594         }
 595     }
 596
 597   return 0;
 598 }
 599
 600 /* Deallocate a condition.  */
 601 static inline int
 602 __gthread_objc_condition_deallocate (objc_condition_t condition)
 603 {
 604   if (__gthread_active_p ())
 605     {
 606       if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend))
 607         return -1;
 608
 609       objc_free (condition->backend);
 610       condition->backend = NULL;
 611     }
 612   return 0;
 613 }
 614
 615 /* Wait on the condition */
 616 static inline int
 617 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 618 {
 619   if (__gthread_active_p ())
 620     return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend,
 621                               (pthread_mutex_t *) mutex->backend);
 622   else
 623     return 0;
 624 }
 625
 626 /* Wake up all threads waiting on this condition.  */
 627 static inline int
 628 __gthread_objc_condition_broadcast (objc_condition_t condition)
 629 {
 630   if (__gthread_active_p ())
 631     return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend);
 632   else
 633     return 0;
 634 }
 635
 636 /* Wake up one thread waiting on this condition.  */
 637 static inline int
 638 __gthread_objc_condition_signal (objc_condition_t condition)
 639 {
 640   if (__gthread_active_p ())
 641     return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend);
 642   else
 643     return 0;
 644 }
 645
 646 #else /* _LIBOBJC */
 647
 648 static inline int
 649 __gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
 650                   void *__args)
 651 {
 652   return __gthrw_(pthread_create) (__threadid, NULL, __func, __args);
 653 }
 654
 655 static inline int
 656 __gthread_join (__gthread_t __threadid, void **__value_ptr)
 657 {
 658   return __gthrw_(pthread_join) (__threadid, __value_ptr);
 659 }
 660
 661 static inline int
 662 __gthread_detach (__gthread_t __threadid)
 663 {
 664   return __gthrw_(pthread_detach) (__threadid);
 665 }
 666
 667 static inline int
 668 __gthread_equal (__gthread_t __t1, __gthread_t __t2)
 669 {
 670   return __gthrw_(pthread_equal) (__t1, __t2);
 671 }
 672
 673 static inline __gthread_t
 674 __gthread_self (void)
 675 {
 676   return __gthrw_(pthread_self) ();
 677 }
 678
 679 static inline int
 680 __gthread_yield (void)
 681 {
 682   return __gthrw_(sched_yield) ();
 683 }
 684
 685 static inline int
 686 __gthread_once (__gthread_once_t *__once, void (*__func) (void))
 687 {
 688   if (__gthread_active_p ())
 689     return __gthrw_(pthread_once) (__once, __func);
 690   else
 691     return -1;
 692 }
 693
 694 static inline int
 695 __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
 696 {
 697   return __gthrw_(pthread_key_create) (__key, __dtor);
 698 }
 699
 700 static inline int
 701 __gthread_key_delete (__gthread_key_t __key)
 702 {
 703   return __gthrw_(pthread_key_delete) (__key);
 704 }
 705
 706 static inline void *
 707 __gthread_getspecific (__gthread_key_t __key)
 708 {
 709   return __gthrw_(pthread_getspecific) (__key);
 710 }
 711
 712 static inline int
 713 __gthread_setspecific (__gthread_key_t __key, const void *__ptr)
 714 {
 715   return __gthrw_(pthread_setspecific) (__key, __ptr);
 716 }
 717
 718 static inline int
 719 __gthread_mutex_destroy (__gthread_mutex_t *__mutex)
 720 {
 721   if (__gthread_active_p ())
 722     return __gthrw_(pthread_mutex_destroy) (__mutex);
 723   else
 724     return 0;
 725 }
 726
 727 static inline int
 728 __gthread_mutex_lock (__gthread_mutex_t *__mutex)
 729 {
 730   if (__gthread_active_p ())
 731     return __gthrw_(pthread_mutex_lock) (__mutex);
 732   else
 733     return 0;
 734 }
 735
 736 static inline int
 737 __gthread_mutex_trylock (__gthread_mutex_t *__mutex)
 738 {
 739   if (__gthread_active_p ())
 740     return __gthrw_(pthread_mutex_trylock) (__mutex);
 741   else
 742     return 0;
 743 }
 744
 745 #ifdef _POSIX_TIMEOUTS
 746 #if _POSIX_TIMEOUTS >= 0
 747 static inline int
 748 __gthread_mutex_timedlock (__gthread_mutex_t *__mutex,
 749                            const __gthread_time_t *__abs_timeout)
 750 {
 751   if (__gthread_active_p ())
 752     return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout);
 753   else
 754     return 0;
 755 }
 756 #endif
 757 #endif
 758
 759 static inline int
 760 __gthread_mutex_unlock (__gthread_mutex_t *__mutex)
 761 {
 762   if (__gthread_active_p ())
 763     return __gthrw_(pthread_mutex_unlock) (__mutex);
 764   else
 765     return 0;
 766 }
 767
 768 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 769 static inline int
 770 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
 771 {
 772   if (__gthread_active_p ())
 773     {
 774       pthread_mutexattr_t __attr;
 775       int __r;
 776
 777       __r = __gthrw_(pthread_mutexattr_init) (&__attr);
 778       if (!__r)
 779         __r = __gthrw_(pthread_mutexattr_settype) (&__attr,
 780                                                    PTHREAD_MUTEX_RECURSIVE);
 781       if (!__r)
 782         __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr);
 783       if (!__r)
 784         __r = __gthrw_(pthread_mutexattr_destroy) (&__attr);
 785       return __r;
 786     }
 787   return 0;
 788 }
 789 #endif
 790
 791 static inline int
 792 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
 793 {
 794   return __gthread_mutex_lock (__mutex);
 795 }
 796
 797 static inline int
 798 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
 799 {
 800   return __gthread_mutex_trylock (__mutex);
 801 }
 802
 803 #ifdef _POSIX_TIMEOUTS
 804 #if _POSIX_TIMEOUTS >= 0
 805 static inline int
 806 __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
 807                                      const __gthread_time_t *__abs_timeout)
 808 {
 809   return __gthread_mutex_timedlock (__mutex, __abs_timeout);
 810 }
 811 #endif
 812 #endif
 813
 814 static inline int
 815 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
 816 {
 817   return __gthread_mutex_unlock (__mutex);
 818 }
 819
 820 static inline int
 821 __gthread_cond_broadcast (__gthread_cond_t *__cond)
 822 {
 823   return __gthrw_(pthread_cond_broadcast) (__cond);
 824 }
 825
 826 static inline int
 827 __gthread_cond_signal (__gthread_cond_t *__cond)
 828 {
 829   return __gthrw_(pthread_cond_signal) (__cond);
 830 }
 831
 832 static inline int
 833 __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
 834 {
 835   return __gthrw_(pthread_cond_wait) (__cond, __mutex);
 836 }
 837
 838 static inline int
 839 __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex,
 840                           const __gthread_time_t *__abs_timeout)
 841 {
 842   return __gthrw_(pthread_cond_timedwait) (__cond, __mutex, __abs_timeout);
 843 }
 844
 845 static inline int
 846 __gthread_cond_wait_recursive (__gthread_cond_t *__cond,
 847                                __gthread_recursive_mutex_t *__mutex)
 848 {
 849   return __gthread_cond_wait (__cond, __mutex);
 850 }
 851
 852 static inline int
 853 __gthread_cond_timedwait_recursive (__gthread_cond_t *__cond,
 854                                     __gthread_recursive_mutex_t *__mutex,
 855                                     const __gthread_time_t *__abs_timeout)
 856 {
 857   return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
 858 }
 859
 860 static inline int
 861 __gthread_cond_destroy (__gthread_cond_t* __cond)
 862 {
 863   return __gthrw_(pthread_cond_destroy) (__cond);
 864 }
 865
 866 #endif /* _LIBOBJC */
 867
 868 #endif /* ! GCC_GTHR_POSIX_H */