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