external/gpl3/gcc/lib/libstdc++-v3/arch/earmv7/gthr-posix.h

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