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 Free Software Foundation, Inc.
6 This file is part of GCC.
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 2, or (at your option) any later
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
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 /* As a special exception, if you link this library with other files,
24 some of which are compiled with GCC, to produce an executable,
25 this library does not by itself cause the resulting executable
26 to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
30 #ifndef GCC_GTHR_POSIX_H
31 #define GCC_GTHR_POSIX_H
33 /* POSIX threads specific definitions.
34 Easy, since the interface is just one-to-one mapping. */
38 /* Some implementations of <pthread.h> require this to be defined. */
39 #if !defined(_REENTRANT) && defined(__osf__)
46 typedef pthread_key_t __gthread_key_t;
47 typedef pthread_once_t __gthread_once_t;
48 typedef pthread_mutex_t __gthread_mutex_t;
49 typedef pthread_mutex_t __gthread_recursive_mutex_t;
51 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
52 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
53 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
54 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER
55 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
56 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
58 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
61 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
62 # ifndef __gthrw_pragma
63 # define __gthrw_pragma(pragma)
65 # define __gthrw2(name,name2,type) \
66 static __typeof(type) name __attribute__ ((__weakref__(#name2))); \
67 __gthrw_pragma(weak type)
68 # define __gthrw_(name) __gthrw_ ## name
70 # define __gthrw2(name,name2,type)
71 # define __gthrw_(name) name
74 /* Typically, __gthrw_foo is a weak reference to symbol foo. */
75 #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
77 /* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to
78 map a subset of the POSIX pthread API to mangled versions of their
80 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
81 #define __gthrw3(name) __gthrw2(__gthrw_ ## name, __ ## name, name)
82 __gthrw3(pthread_once)
83 __gthrw3(pthread_getspecific)
84 __gthrw3(pthread_setspecific)
85 __gthrw3(pthread_create)
86 __gthrw3(pthread_cancel)
87 __gthrw3(pthread_mutex_lock)
88 __gthrw3(pthread_mutex_trylock)
89 __gthrw3(pthread_mutex_unlock)
90 __gthrw3(pthread_mutex_init)
93 __gthrw(pthread_getspecific)
94 __gthrw(pthread_setspecific)
95 __gthrw(pthread_create)
96 __gthrw(pthread_cancel)
97 __gthrw(pthread_mutex_lock)
98 __gthrw(pthread_mutex_trylock)
99 __gthrw(pthread_mutex_unlock)
100 __gthrw(pthread_mutex_init)
103 __gthrw(pthread_key_create)
104 __gthrw(pthread_key_delete)
105 __gthrw(pthread_mutexattr_init)
106 __gthrw(pthread_mutexattr_settype)
107 __gthrw(pthread_mutexattr_destroy)
110 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
112 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
113 __gthrw3(pthread_cond_broadcast)
114 __gthrw3(pthread_cond_destroy)
115 __gthrw3(pthread_cond_init)
116 __gthrw3(pthread_cond_signal)
117 __gthrw3(pthread_cond_wait)
118 __gthrw3(pthread_exit)
119 __gthrw3(pthread_mutex_destroy)
120 __gthrw3(pthread_self)
122 __gthrw(pthread_cond_broadcast)
123 __gthrw(pthread_cond_destroy)
124 __gthrw(pthread_cond_init)
125 __gthrw(pthread_cond_signal)
126 __gthrw(pthread_cond_wait)
127 __gthrw(pthread_exit)
128 __gthrw(pthread_mutex_destroy)
129 __gthrw(pthread_self)
130 #endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */
131 #ifdef _POSIX_PRIORITY_SCHEDULING
132 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
133 __gthrw(sched_get_priority_max)
134 __gthrw(sched_get_priority_min)
135 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
136 #endif /* _POSIX_PRIORITY_SCHEDULING */
138 __gthrw(pthread_attr_destroy)
139 __gthrw(pthread_attr_init)
140 __gthrw(pthread_attr_setdetachstate)
141 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
142 __gthrw(pthread_getschedparam)
143 __gthrw(pthread_setschedparam)
144 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
145 #endif /* _LIBOBJC || _LIBOBJC_WEAK */
147 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
149 /* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if
150 -pthreads is not specified. The functions are dummies and most return an
151 error value. However pthread_once returns 0 without invoking the routine
152 it is passed so we cannot pretend that the interface is active if -pthreads
153 is not specified. On Solaris 2.5.1, the interface is not exposed at all so
154 we need to play the usual game with weak symbols. On Solaris 10 and up, a
155 working interface is always exposed. On FreeBSD 6 and later, libc also
156 exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up
157 to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc,
158 which means the alternate __gthread_active_p below cannot be used there. */
160 #if defined(__FreeBSD__) || (defined(__sun) && defined(__svr4__))
162 static volatile int __gthread_active = -1;
165 __gthread_trigger (void)
167 __gthread_active = 1;
171 __gthread_active_p (void)
173 static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER;
174 static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT;
176 /* Avoid reading __gthread_active twice on the main code path. */
177 int __gthread_active_latest_value = __gthread_active;
179 /* This test is not protected to avoid taking a lock on the main code
180 path so every update of __gthread_active in a threaded program must
181 be atomic with regard to the result of the test. */
182 if (__builtin_expect (__gthread_active_latest_value < 0, 0))
184 if (__gthrw_(pthread_once))
186 /* If this really is a threaded program, then we must ensure that
187 __gthread_active has been set to 1 before exiting this block. */
188 __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex);
189 __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger);
190 __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
193 /* Make sure we'll never enter this block again. */
194 if (__gthread_active < 0)
195 __gthread_active = 0;
197 __gthread_active_latest_value = __gthread_active;
200 return __gthread_active_latest_value != 0;
203 #else /* neither FreeBSD nor Solaris */
206 __gthread_active_p (void)
208 static void *const __gthread_active_ptr
209 = __extension__ (void *) &__gthrw_(pthread_cancel);
210 return __gthread_active_ptr != 0;
213 #endif /* FreeBSD or Solaris */
215 #else /* not SUPPORTS_WEAK */
218 __gthread_active_p (void)
223 #endif /* SUPPORTS_WEAK */
227 /* This is the config.h file in libobjc/ */
234 /* Key structure for maintaining thread specific storage */
235 static pthread_key_t _objc_thread_storage;
236 static pthread_attr_t _objc_thread_attribs;
238 /* Thread local storage for a single thread */
239 static void *thread_local_storage = NULL;
241 /* Backend initialization functions */
243 /* Initialize the threads subsystem. */
245 __gthread_objc_init_thread_system (void)
247 if (__gthread_active_p ())
249 /* Initialize the thread storage key. */
250 if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0)
252 /* The normal default detach state for threads is
253 * PTHREAD_CREATE_JOINABLE which causes threads to not die
254 * when you think they should. */
255 if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0
256 && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs,
257 PTHREAD_CREATE_DETACHED) == 0)
265 /* Close the threads subsystem. */
267 __gthread_objc_close_thread_system (void)
269 if (__gthread_active_p ()
270 && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0
271 && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0)
277 /* Backend thread functions */
279 /* Create a new thread of execution. */
280 static inline objc_thread_t
281 __gthread_objc_thread_detach (void (*func)(void *), void *arg)
283 objc_thread_t thread_id;
284 pthread_t new_thread_handle;
286 if (!__gthread_active_p ())
289 if (!(__gthrw_(pthread_create) (&new_thread_handle, NULL, (void *) func, arg)))
290 thread_id = (objc_thread_t) new_thread_handle;
297 /* Set the current thread's priority. */
299 __gthread_objc_thread_set_priority (int priority)
301 if (!__gthread_active_p ())
305 #ifdef _POSIX_PRIORITY_SCHEDULING
306 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
307 pthread_t thread_id = __gthrw_(pthread_self) ();
309 struct sched_param params;
310 int priority_min, priority_max;
312 if (__gthrw_(pthread_getschedparam) (thread_id, &policy, ¶ms) == 0)
314 if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1)
317 if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1)
320 if (priority > priority_max)
321 priority = priority_max;
322 else if (priority < priority_min)
323 priority = priority_min;
324 params.sched_priority = priority;
327 * The solaris 7 and several other man pages incorrectly state that
328 * this should be a pointer to policy but pthread.h is universally
331 if (__gthrw_(pthread_setschedparam) (thread_id, policy, ¶ms) == 0)
334 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
335 #endif /* _POSIX_PRIORITY_SCHEDULING */
340 /* Return the current thread's priority. */
342 __gthread_objc_thread_get_priority (void)
344 #ifdef _POSIX_PRIORITY_SCHEDULING
345 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
346 if (__gthread_active_p ())
349 struct sched_param params;
351 if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, ¶ms) == 0)
352 return params.sched_priority;
357 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
358 #endif /* _POSIX_PRIORITY_SCHEDULING */
359 return OBJC_THREAD_INTERACTIVE_PRIORITY;
362 /* Yield our process time to another thread. */
364 __gthread_objc_thread_yield (void)
366 if (__gthread_active_p ())
367 __gthrw_(sched_yield) ();
370 /* Terminate the current thread. */
372 __gthread_objc_thread_exit (void)
374 if (__gthread_active_p ())
375 /* exit the thread */
376 __gthrw_(pthread_exit) (&__objc_thread_exit_status);
378 /* Failed if we reached here */
382 /* Returns an integer value which uniquely describes a thread. */
383 static inline objc_thread_t
384 __gthread_objc_thread_id (void)
386 if (__gthread_active_p ())
387 return (objc_thread_t) __gthrw_(pthread_self) ();
389 return (objc_thread_t) 1;
392 /* Sets the thread's local storage pointer. */
394 __gthread_objc_thread_set_data (void *value)
396 if (__gthread_active_p ())
397 return __gthrw_(pthread_setspecific) (_objc_thread_storage, value);
400 thread_local_storage = value;
405 /* Returns the thread's local storage pointer. */
407 __gthread_objc_thread_get_data (void)
409 if (__gthread_active_p ())
410 return __gthrw_(pthread_getspecific) (_objc_thread_storage);
412 return thread_local_storage;
415 /* Backend mutex functions */
417 /* Allocate a mutex. */
419 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
421 if (__gthread_active_p ())
423 mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
425 if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL))
427 objc_free (mutex->backend);
428 mutex->backend = NULL;
436 /* Deallocate a mutex. */
438 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
440 if (__gthread_active_p ())
445 * Posix Threads specifically require that the thread be unlocked
446 * for __gthrw_(pthread_mutex_destroy) to work.
451 count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend);
457 if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend))
460 objc_free (mutex->backend);
461 mutex->backend = NULL;
466 /* Grab a lock on a mutex. */
468 __gthread_objc_mutex_lock (objc_mutex_t mutex)
470 if (__gthread_active_p ()
471 && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0)
479 /* Try to grab a lock on a mutex. */
481 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
483 if (__gthread_active_p ()
484 && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0)
492 /* Unlock the mutex */
494 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
496 if (__gthread_active_p ()
497 && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0)
505 /* Backend condition mutex functions */
507 /* Allocate a condition. */
509 __gthread_objc_condition_allocate (objc_condition_t condition)
511 if (__gthread_active_p ())
513 condition->backend = objc_malloc (sizeof (pthread_cond_t));
515 if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL))
517 objc_free (condition->backend);
518 condition->backend = NULL;
526 /* Deallocate a condition. */
528 __gthread_objc_condition_deallocate (objc_condition_t condition)
530 if (__gthread_active_p ())
532 if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend))
535 objc_free (condition->backend);
536 condition->backend = NULL;
541 /* Wait on the condition */
543 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
545 if (__gthread_active_p ())
546 return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend,
547 (pthread_mutex_t *) mutex->backend);
552 /* Wake up all threads waiting on this condition. */
554 __gthread_objc_condition_broadcast (objc_condition_t condition)
556 if (__gthread_active_p ())
557 return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend);
562 /* Wake up one thread waiting on this condition. */
564 __gthread_objc_condition_signal (objc_condition_t condition)
566 if (__gthread_active_p ())
567 return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend);
575 __gthread_once (__gthread_once_t *once, void (*func) (void))
577 if (__gthread_active_p ())
578 return __gthrw_(pthread_once) (once, func);
584 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
586 return __gthrw_(pthread_key_create) (key, dtor);
590 __gthread_key_delete (__gthread_key_t key)
592 return __gthrw_(pthread_key_delete) (key);
596 __gthread_getspecific (__gthread_key_t key)
598 return __gthrw_(pthread_getspecific) (key);
602 __gthread_setspecific (__gthread_key_t key, const void *ptr)
604 return __gthrw_(pthread_setspecific) (key, ptr);
608 __gthread_mutex_lock (__gthread_mutex_t *mutex)
610 if (__gthread_active_p ())
611 return __gthrw_(pthread_mutex_lock) (mutex);
617 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
619 if (__gthread_active_p ())
620 return __gthrw_(pthread_mutex_trylock) (mutex);
626 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
628 if (__gthread_active_p ())
629 return __gthrw_(pthread_mutex_unlock) (mutex);
634 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
636 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
638 if (__gthread_active_p ())
640 pthread_mutexattr_t attr;
643 r = __gthrw_(pthread_mutexattr_init) (&attr);
645 r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE);
647 r = __gthrw_(pthread_mutex_init) (mutex, &attr);
649 r = __gthrw_(pthread_mutexattr_destroy) (&attr);
657 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
659 return __gthread_mutex_lock (mutex);
663 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
665 return __gthread_mutex_trylock (mutex);
669 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
671 return __gthread_mutex_unlock (mutex);
674 #endif /* _LIBOBJC */
676 #endif /* ! GCC_GTHR_POSIX_H */