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