1/* Threads compatibility routines for libgcc2 and libobjc. */
2/* Compile this one with gcc. */
3/* Copyright (C) 1997-2025 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 3, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17Under Section 7 of GPL version 3, you are granted additional
18permissions described in the GCC Runtime Library Exception, version
193.1, as published by the Free Software Foundation.
20
21You should have received a copy of the GNU General Public License and
22a copy of the GCC Runtime Library Exception along with this program;
23see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24<http://www.gnu.org/licenses/>. */
25
26#ifndef _GLIBCXX_GCC_GTHR_POSIX_H
27#define _GLIBCXX_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
62typedef pthread_t __gthread_t;
63typedef pthread_key_t __gthread_key_t;
64typedef pthread_once_t __gthread_once_t;
65typedef pthread_mutex_t __gthread_mutex_t;
66#ifndef __cplusplus
67typedef pthread_rwlock_t __gthread_rwlock_t;
68#endif
69typedef pthread_mutex_t __gthread_recursive_mutex_t;
70typedef pthread_cond_t __gthread_cond_t;
71typedef 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 __GXX_WEAK__ && _GLIBCXX_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 __GXX_WEAK__ && _GLIBCXX_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 __GXX_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 /* __GXX_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 */
365static pthread_key_t _objc_thread_storage;
366static pthread_attr_t _objc_thread_attribs;
367
368/* Thread local storage for a single thread */
369static void *thread_local_storage = NULL;
370
371/* Backend initialization functions */
372
373/* Initialize the threads subsystem. */
374static 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. */
396static 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. */
410static 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. */
429static 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. */
472static 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. */
494static 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. */
502static 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. */
514static 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. */
524static 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. */
537static 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. */
549static 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. */
568static 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. */
598static 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. */
611static 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 */
624static 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. */
639static 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. */
658static 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 */
673static 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. */
684static 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. */
694static 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) (newthread: __threadid, NULL, start_routine: __func, arg: __args);
710}
711
712__GTHREAD_INLINE int
713__gthread_join (__gthread_t __threadid, void **__value_ptr)
714{
715 return __gthrw_(pthread_join) (th: __threadid, thread_return: __value_ptr);
716}
717
718__GTHREAD_INLINE int
719__gthread_detach (__gthread_t __threadid)
720{
721 return __gthrw_(pthread_detach) (th: __threadid);
722}
723
724__GTHREAD_INLINE int
725__gthread_equal (__gthread_t __t1, __gthread_t __t2)
726{
727 return __gthrw_(pthread_equal) (thread1: __t1, thread2: __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_control: __once, init_routine: __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, destr_function: __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, pointer: __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, abstime: __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, abstime: __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 /* ! _GLIBCXX_GCC_GTHR_POSIX_H */
987