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