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