X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgthr-posix.h;h=ad6822e26ade652f0ce2620f9d2406a9a181e6d8;hb=5bad702ffba44112598b9583b48782c7c6fedba7;hp=91204104658c3c5ab764cf3cee7a9094387f90ce;hpb=4813f5af50dada66ece22c495d18a5cd6393f53b;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/gthr-posix.h b/gcc/gthr-posix.h index 91204104658..ad6822e26ad 100644 --- a/gcc/gthr-posix.h +++ b/gcc/gthr-posix.h @@ -1,6 +1,6 @@ /* Threads compatibility routines for libgcc2 and libobjc. */ /* Compile this one with gcc. */ -/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003 +/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc. This file is part of GCC. @@ -17,8 +17,8 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ /* As a special exception, if you link this library with other files, some of which are compiled with GCC, to produce an executable, @@ -36,7 +36,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define __GTHREADS 1 /* Some implementations of require this to be defined. */ -#ifndef _REENTRANT +#if !defined(_REENTRANT) && defined(__osf__) #define _REENTRANT 1 #endif @@ -47,6 +47,11 @@ typedef pthread_key_t __gthread_key_t; typedef pthread_once_t __gthread_once_t; typedef pthread_mutex_t __gthread_mutex_t; typedef pthread_mutex_t __gthread_recursive_mutex_t; +typedef pthread_cond_t __gthread_cond_t; + +/* POSIX like conditional variables are supported. Please look at comments + in gthr.h for details. */ +#define __GTHREAD_HAS_COND 1 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT @@ -57,62 +62,236 @@ typedef pthread_mutex_t __gthread_recursive_mutex_t; #else #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function #endif +#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER #if SUPPORTS_WEAK && GTHREAD_USE_WEAK +# ifndef __gthrw_pragma +# define __gthrw_pragma(pragma) +# endif +# define __gthrw2(name,name2,type) \ + static __typeof(type) name __attribute__ ((__weakref__(#name2))); \ + __gthrw_pragma(weak type) +# define __gthrw_(name) __gthrw_ ## name +#else +# define __gthrw2(name,name2,type) +# define __gthrw_(name) name +#endif -#pragma weak pthread_once -#pragma weak pthread_key_create -#pragma weak pthread_key_delete -#pragma weak pthread_getspecific -#pragma weak pthread_setspecific -#pragma weak pthread_create +/* Typically, __gthrw_foo is a weak reference to symbol foo. */ +#define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name) + +/* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to + map a subset of the POSIX pthread API to mangled versions of their + names. */ +#if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_) +#define __gthrw3(name) __gthrw2(__gthrw_ ## name, __ ## name, name) +__gthrw3(pthread_once) +__gthrw3(pthread_getspecific) +__gthrw3(pthread_setspecific) +__gthrw3(pthread_create) +__gthrw3(pthread_cancel) +__gthrw3(pthread_mutex_lock) +__gthrw3(pthread_mutex_trylock) +__gthrw3(pthread_mutex_unlock) +__gthrw3(pthread_mutex_init) +__gthrw3(pthread_cond_broadcast) +__gthrw3(pthread_cond_wait) +#else +__gthrw(pthread_once) +__gthrw(pthread_getspecific) +__gthrw(pthread_setspecific) +__gthrw(pthread_create) +__gthrw(pthread_cancel) +__gthrw(pthread_mutex_lock) +__gthrw(pthread_mutex_trylock) +__gthrw(pthread_mutex_unlock) +__gthrw(pthread_mutex_init) +__gthrw(pthread_cond_broadcast) +__gthrw(pthread_cond_wait) +#endif + +__gthrw(pthread_key_create) +__gthrw(pthread_key_delete) +__gthrw(pthread_mutexattr_init) +__gthrw(pthread_mutexattr_settype) +__gthrw(pthread_mutexattr_destroy) -#pragma weak pthread_mutex_lock -#pragma weak pthread_mutex_trylock -#pragma weak pthread_mutex_unlock #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK) /* Objective-C. */ -#pragma weak pthread_cond_broadcast -#pragma weak pthread_cond_destroy -#pragma weak pthread_cond_init -#pragma weak pthread_cond_signal -#pragma weak pthread_cond_wait -#pragma weak pthread_exit -#pragma weak pthread_mutex_init -#pragma weak pthread_mutex_destroy -#pragma weak pthread_self +#if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_) +__gthrw3(pthread_cond_destroy) +__gthrw3(pthread_cond_init) +__gthrw3(pthread_cond_signal) +__gthrw3(pthread_exit) +__gthrw3(pthread_mutex_destroy) +__gthrw3(pthread_self) +#else +__gthrw(pthread_cond_destroy) +__gthrw(pthread_cond_init) +__gthrw(pthread_cond_signal) +__gthrw(pthread_exit) +__gthrw(pthread_mutex_destroy) +__gthrw(pthread_self) +#endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */ #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING -#pragma weak sched_get_priority_max -#pragma weak sched_get_priority_min +__gthrw(sched_get_priority_max) +__gthrw(sched_get_priority_min) #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ #endif /* _POSIX_PRIORITY_SCHEDULING */ -#pragma weak sched_yield -#pragma weak pthread_attr_destroy -#pragma weak pthread_attr_init -#pragma weak pthread_attr_setdetachstate +__gthrw(sched_yield) +__gthrw(pthread_attr_destroy) +__gthrw(pthread_attr_init) +__gthrw(pthread_attr_setdetachstate) #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING -#pragma weak pthread_getschedparam -#pragma weak pthread_setschedparam +__gthrw(pthread_getschedparam) +__gthrw(pthread_setschedparam) #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ #endif /* _LIBOBJC || _LIBOBJC_WEAK */ +#if SUPPORTS_WEAK && GTHREAD_USE_WEAK + +/* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if + -pthreads is not specified. The functions are dummies and most return an + error value. However pthread_once returns 0 without invoking the routine + it is passed so we cannot pretend that the interface is active if -pthreads + is not specified. On Solaris 2.5.1, the interface is not exposed at all so + we need to play the usual game with weak symbols. On Solaris 10 and up, a + working interface is always exposed. */ + +#if defined(__sun) && defined(__svr4__) + +static volatile int __gthread_active = -1; + +static void +__gthread_trigger (void) +{ + __gthread_active = 1; +} + static inline int __gthread_active_p (void) { - static void *const __gthread_active_ptr = (void *) &pthread_create; + static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; + static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT; + + /* Avoid reading __gthread_active twice on the main code path. */ + int __gthread_active_latest_value = __gthread_active; + + /* This test is not protected to avoid taking a lock on the main code + path so every update of __gthread_active in a threaded program must + be atomic with regard to the result of the test. */ + if (__builtin_expect (__gthread_active_latest_value < 0, 0)) + { + if (__gthrw_(pthread_once)) + { + /* If this really is a threaded program, then we must ensure that + __gthread_active has been set to 1 before exiting this block. */ + __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); + __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger); + __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); + } + + /* Make sure we'll never enter this block again. */ + if (__gthread_active < 0) + __gthread_active = 0; + + __gthread_active_latest_value = __gthread_active; + } + + return __gthread_active_latest_value != 0; +} + +#else /* not Solaris */ + +static inline int +__gthread_active_p (void) +{ + static void *const __gthread_active_ptr + = __extension__ (void *) &__gthrw_(pthread_cancel); return __gthread_active_ptr != 0; } +#endif /* Solaris */ + #else /* not SUPPORTS_WEAK */ +/* Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread + calls in shared flavors of the HP-UX C library. Most of the stubs + have no functionality. The details are described in the "libc cumulative + patch" for each subversion of HP-UX 11. There are two special interfaces + provided for checking whether an application is linked to a pthread + library or not. However, these interfaces aren't available in early + libc versions. We also can't use pthread_once as some libc versions + call the init function. So, we use pthread_create to check whether it + is possible to create a thread or not. The stub implementation returns + the error number ENOSYS. */ + +#if defined(__hppa__) && defined(__hpux__) + +#include + +static volatile int __gthread_active = -1; + +static void * +__gthread_start (void *arg __attribute__((unused))) +{ + return NULL; +} + +static void __gthread_active_init (void) __attribute__((noinline)); +static void +__gthread_active_init (void) +{ + static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; + pthread_t t; + pthread_attr_t a; + int result; + + __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); + if (__gthread_active < 0) + { + __gthrw_(pthread_attr_init) (&a); + __gthrw_(pthread_attr_setdetachstate) (&a, PTHREAD_CREATE_DETACHED); + result = __gthrw_(pthread_create) (&t, &a, __gthread_start, NULL); + if (result != ENOSYS) + __gthread_active = 1; + else + __gthread_active = 0; + __gthrw_(pthread_attr_destroy) (&a); + } + __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); +} + +static inline int +__gthread_active_p (void) +{ + /* Avoid reading __gthread_active twice on the main code path. */ + int __gthread_active_latest_value = __gthread_active; + + /* This test is not protected to avoid taking a lock on the main code + path so every update of __gthread_active in a threaded program must + be atomic with regard to the result of the test. */ + if (__builtin_expect (__gthread_active_latest_value < 0, 0)) + { + __gthread_active_init (); + __gthread_active_latest_value = __gthread_active; + } + + return __gthread_active_latest_value != 0; +} + +#else /* not hppa-hpux */ + static inline int __gthread_active_p (void) { return 1; } +#endif /* hppa-hpux */ + #endif /* SUPPORTS_WEAK */ #ifdef _LIBOBJC @@ -139,14 +318,14 @@ __gthread_objc_init_thread_system (void) { if (__gthread_active_p ()) { - /* Initialize the thread storage key */ - if (pthread_key_create (&_objc_thread_storage, NULL) == 0) + /* Initialize the thread storage key. */ + if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0) { /* The normal default detach state for threads is * PTHREAD_CREATE_JOINABLE which causes threads to not die * when you think they should. */ - if (pthread_attr_init (&_objc_thread_attribs) == 0 - && pthread_attr_setdetachstate (&_objc_thread_attribs, + if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0 + && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs, PTHREAD_CREATE_DETACHED) == 0) return 0; } @@ -160,8 +339,8 @@ static inline int __gthread_objc_close_thread_system (void) { if (__gthread_active_p () - && pthread_key_delete (_objc_thread_storage) == 0 - && pthread_attr_destroy (&_objc_thread_attribs) == 0) + && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0 + && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0) return 0; return -1; @@ -179,7 +358,7 @@ __gthread_objc_thread_detach (void (*func)(void *), void *arg) if (!__gthread_active_p ()) return NULL; - if (!(pthread_create (&new_thread_handle, NULL, (void *) func, arg))) + if (!(__gthrw_(pthread_create) (&new_thread_handle, NULL, (void *) func, arg))) thread_id = (objc_thread_t) new_thread_handle; else thread_id = NULL; @@ -197,17 +376,17 @@ __gthread_objc_thread_set_priority (int priority) { #ifdef _POSIX_PRIORITY_SCHEDULING #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING - pthread_t thread_id = pthread_self (); + pthread_t thread_id = __gthrw_(pthread_self) (); int policy; struct sched_param params; int priority_min, priority_max; - if (pthread_getschedparam (thread_id, &policy, ¶ms) == 0) + if (__gthrw_(pthread_getschedparam) (thread_id, &policy, ¶ms) == 0) { - if ((priority_max = sched_get_priority_max (policy)) == -1) + if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1) return -1; - if ((priority_min = sched_get_priority_min (policy)) == -1) + if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1) return -1; if (priority > priority_max) @@ -221,7 +400,7 @@ __gthread_objc_thread_set_priority (int priority) * this should be a pointer to policy but pthread.h is universally * at odds with this. */ - if (pthread_setschedparam (thread_id, policy, ¶ms) == 0) + if (__gthrw_(pthread_setschedparam) (thread_id, policy, ¶ms) == 0) return 0; } #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ @@ -241,7 +420,7 @@ __gthread_objc_thread_get_priority (void) int policy; struct sched_param params; - if (pthread_getschedparam (pthread_self (), &policy, ¶ms) == 0) + if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, ¶ms) == 0) return params.sched_priority; else return -1; @@ -257,7 +436,7 @@ static inline void __gthread_objc_thread_yield (void) { if (__gthread_active_p ()) - sched_yield (); + __gthrw_(sched_yield) (); } /* Terminate the current thread. */ @@ -266,7 +445,7 @@ __gthread_objc_thread_exit (void) { if (__gthread_active_p ()) /* exit the thread */ - pthread_exit (&__objc_thread_exit_status); + __gthrw_(pthread_exit) (&__objc_thread_exit_status); /* Failed if we reached here */ return -1; @@ -277,7 +456,7 @@ static inline objc_thread_t __gthread_objc_thread_id (void) { if (__gthread_active_p ()) - return (objc_thread_t) pthread_self (); + return (objc_thread_t) __gthrw_(pthread_self) (); else return (objc_thread_t) 1; } @@ -287,7 +466,7 @@ static inline int __gthread_objc_thread_set_data (void *value) { if (__gthread_active_p ()) - return pthread_setspecific (_objc_thread_storage, value); + return __gthrw_(pthread_setspecific) (_objc_thread_storage, value); else { thread_local_storage = value; @@ -300,7 +479,7 @@ static inline void * __gthread_objc_thread_get_data (void) { if (__gthread_active_p ()) - return pthread_getspecific (_objc_thread_storage); + return __gthrw_(pthread_getspecific) (_objc_thread_storage); else return thread_local_storage; } @@ -315,7 +494,7 @@ __gthread_objc_mutex_allocate (objc_mutex_t mutex) { mutex->backend = objc_malloc (sizeof (pthread_mutex_t)); - if (pthread_mutex_init ((pthread_mutex_t *) mutex->backend, NULL)) + if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL)) { objc_free (mutex->backend); mutex->backend = NULL; @@ -336,18 +515,18 @@ __gthread_objc_mutex_deallocate (objc_mutex_t mutex) /* * Posix Threads specifically require that the thread be unlocked - * for pthread_mutex_destroy to work. + * for __gthrw_(pthread_mutex_destroy) to work. */ do { - count = pthread_mutex_unlock ((pthread_mutex_t *) mutex->backend); + count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend); if (count < 0) return -1; } while (count); - if (pthread_mutex_destroy ((pthread_mutex_t *) mutex->backend)) + if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend)) return -1; objc_free (mutex->backend); @@ -361,7 +540,7 @@ static inline int __gthread_objc_mutex_lock (objc_mutex_t mutex) { if (__gthread_active_p () - && pthread_mutex_lock ((pthread_mutex_t *) mutex->backend) != 0) + && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0) { return -1; } @@ -374,7 +553,7 @@ static inline int __gthread_objc_mutex_trylock (objc_mutex_t mutex) { if (__gthread_active_p () - && pthread_mutex_trylock ((pthread_mutex_t *) mutex->backend) != 0) + && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0) { return -1; } @@ -387,7 +566,7 @@ static inline int __gthread_objc_mutex_unlock (objc_mutex_t mutex) { if (__gthread_active_p () - && pthread_mutex_unlock ((pthread_mutex_t *) mutex->backend) != 0) + && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0) { return -1; } @@ -405,7 +584,7 @@ __gthread_objc_condition_allocate (objc_condition_t condition) { condition->backend = objc_malloc (sizeof (pthread_cond_t)); - if (pthread_cond_init ((pthread_cond_t *) condition->backend, NULL)) + if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL)) { objc_free (condition->backend); condition->backend = NULL; @@ -422,7 +601,7 @@ __gthread_objc_condition_deallocate (objc_condition_t condition) { if (__gthread_active_p ()) { - if (pthread_cond_destroy ((pthread_cond_t *) condition->backend)) + if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend)) return -1; objc_free (condition->backend); @@ -436,7 +615,7 @@ static inline int __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex) { if (__gthread_active_p ()) - return pthread_cond_wait ((pthread_cond_t *) condition->backend, + return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend, (pthread_mutex_t *) mutex->backend); else return 0; @@ -447,7 +626,7 @@ static inline int __gthread_objc_condition_broadcast (objc_condition_t condition) { if (__gthread_active_p ()) - return pthread_cond_broadcast ((pthread_cond_t *) condition->backend); + return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend); else return 0; } @@ -457,7 +636,7 @@ static inline int __gthread_objc_condition_signal (objc_condition_t condition) { if (__gthread_active_p ()) - return pthread_cond_signal ((pthread_cond_t *) condition->backend); + return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend); else return 0; } @@ -468,7 +647,7 @@ static inline int __gthread_once (__gthread_once_t *once, void (*func) (void)) { if (__gthread_active_p ()) - return pthread_once (once, func); + return __gthrw_(pthread_once) (once, func); else return -1; } @@ -476,32 +655,32 @@ __gthread_once (__gthread_once_t *once, void (*func) (void)) static inline int __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *)) { - return pthread_key_create (key, dtor); + return __gthrw_(pthread_key_create) (key, dtor); } static inline int __gthread_key_delete (__gthread_key_t key) { - return pthread_key_delete (key); + return __gthrw_(pthread_key_delete) (key); } static inline void * __gthread_getspecific (__gthread_key_t key) { - return pthread_getspecific (key); + return __gthrw_(pthread_getspecific) (key); } static inline int __gthread_setspecific (__gthread_key_t key, const void *ptr) { - return pthread_setspecific (key, ptr); + return __gthrw_(pthread_setspecific) (key, ptr); } static inline int __gthread_mutex_lock (__gthread_mutex_t *mutex) { if (__gthread_active_p ()) - return pthread_mutex_lock (mutex); + return __gthrw_(pthread_mutex_lock) (mutex); else return 0; } @@ -510,7 +689,7 @@ static inline int __gthread_mutex_trylock (__gthread_mutex_t *mutex) { if (__gthread_active_p ()) - return pthread_mutex_trylock (mutex); + return __gthrw_(pthread_mutex_trylock) (mutex); else return 0; } @@ -519,7 +698,7 @@ static inline int __gthread_mutex_unlock (__gthread_mutex_t *mutex) { if (__gthread_active_p ()) - return pthread_mutex_unlock (mutex); + return __gthrw_(pthread_mutex_unlock) (mutex); else return 0; } @@ -533,15 +712,16 @@ __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex) pthread_mutexattr_t attr; int r; - r = pthread_mutexattr_init (&attr); + r = __gthrw_(pthread_mutexattr_init) (&attr); if (!r) - r = pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE); + r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE); if (!r) - r = pthread_mutex_init (mutex, &attr); + r = __gthrw_(pthread_mutex_init) (mutex, &attr); if (!r) - r = pthread_mutexattr_destroy (&attr); + r = __gthrw_(pthread_mutexattr_destroy) (&attr); return r; } + return 0; } #endif @@ -563,6 +743,25 @@ __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex) return __gthread_mutex_unlock (mutex); } +static inline int +__gthread_cond_broadcast (__gthread_cond_t *cond) +{ + return __gthrw_(pthread_cond_broadcast) (cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex) +{ + return __gthrw_(pthread_cond_wait) (cond, mutex); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *cond, + __gthread_recursive_mutex_t *mutex) +{ + return __gthread_cond_wait (cond, mutex); +} + #endif /* _LIBOBJC */ #endif /* ! GCC_GTHR_POSIX_H */