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