libgcc/gthr-posix.h

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