1/* Threads compatibility routines for libgcc2 and libobjc. */
2/* Compile this one with gcc. */
3/* Copyright (C) 1997-2024 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
47typedef pthread_t __gthread_t;
48typedef pthread_key_t __gthread_key_t;
49typedef pthread_once_t __gthread_once_t;
50typedef pthread_mutex_t __gthread_mutex_t;
51#ifndef __cplusplus
52typedef pthread_rwlock_t __gthread_rwlock_t;
53#endif
54typedef pthread_mutex_t __gthread_recursive_mutex_t;
55typedef pthread_cond_t __gthread_cond_t;
56typedef 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 __GXX_WEAK__ && _GLIBCXX_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 __GXX_WEAK__ && _GLIBCXX_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
185static volatile int __gthread_active = -1;
186
187static void
188__gthread_trigger (void)
189{
190 __gthread_active = 1;
191}
192
193static 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
260static 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 __GXX_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
291static volatile int __gthread_active = -1;
292
293static 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
312static inline int
313__gthread_active_p (void)
314{
315 return 1;
316}
317
318#endif /* hppa-hpux */
319
320#endif /* __GXX_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 */
332static pthread_key_t _objc_thread_storage;
333static pthread_attr_t _objc_thread_attribs;
334
335/* Thread local storage for a single thread */
336static void *thread_local_storage = NULL;
337
338/* Backend initialization functions */
339
340/* Initialize the threads subsystem. */
341static 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. */
363static 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. */
377static 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. */
396static 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. */
439static 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. */
461static 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. */
469static 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. */
481static 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. */
491static 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. */
504static 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. */
516static 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. */
535static 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. */
565static 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. */
578static 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 */
591static 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. */
606static 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. */
625static 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 */
640static 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. */
651static 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. */
661static 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
672static inline int
673__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
674 void *__args)
675{
676 return __gthrw_(pthread_create) (newthread: __threadid, NULL, start_routine: __func, arg: __args);
677}
678
679static inline int
680__gthread_join (__gthread_t __threadid, void **__value_ptr)
681{
682 return __gthrw_(pthread_join) (th: __threadid, thread_return: __value_ptr);
683}
684
685static inline int
686__gthread_detach (__gthread_t __threadid)
687{
688 return __gthrw_(pthread_detach) (th: __threadid);
689}
690
691static inline int
692__gthread_equal (__gthread_t __t1, __gthread_t __t2)
693{
694 return __gthrw_(pthread_equal) (thread1: __t1, thread2: __t2);
695}
696
697static inline __gthread_t
698__gthread_self (void)
699{
700 return __gthrw_(pthread_self) ();
701}
702
703static inline int
704__gthread_yield (void)
705{
706 return __gthrw_(sched_yield) ();
707}
708
709static inline int
710__gthread_once (__gthread_once_t *__once, void (*__func) (void))
711{
712 if (__gthread_active_p ())
713 return __gthrw_(pthread_once) (once_control: __once, init_routine: __func);
714 else
715 return -1;
716}
717
718static inline int
719__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
720{
721 return __gthrw_(pthread_key_create) (__key, destr_function: __dtor);
722}
723
724static inline int
725__gthread_key_delete (__gthread_key_t __key)
726{
727 return __gthrw_(pthread_key_delete) (__key);
728}
729
730static inline void *
731__gthread_getspecific (__gthread_key_t __key)
732{
733 return __gthrw_(pthread_getspecific) (__key);
734}
735
736static inline int
737__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
738{
739 return __gthrw_(pthread_setspecific) (__key, pointer: __ptr);
740}
741
742static 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
749static 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
758static 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
767static 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
777static 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, abstime: __abs_timeout);
783 else
784 return 0;
785}
786#endif
787
788static 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)
799static 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
821static inline int
822__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
823{
824 return __gthread_mutex_lock (__mutex);
825}
826
827static 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
834static 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
842static inline int
843__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
844{
845 return __gthread_mutex_unlock (__mutex);
846}
847
848static 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
855static 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
863static inline int
864__gthread_cond_broadcast (__gthread_cond_t *__cond)
865{
866 return __gthrw_(pthread_cond_broadcast) (__cond);
867}
868
869static inline int
870__gthread_cond_signal (__gthread_cond_t *__cond)
871{
872 return __gthrw_(pthread_cond_signal) (__cond);
873}
874
875static 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
881static 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, abstime: __abs_timeout);
886}
887
888static 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
895static inline int
896__gthread_cond_destroy (__gthread_cond_t* __cond)
897{
898 return __gthrw_(pthread_cond_destroy) (__cond);
899}
900
901#ifndef __cplusplus
902static 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
911static 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
920static 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
929static 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
938static 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 /* ! _GLIBCXX_GCC_GTHR_POSIX_H */
951