* config/elfos.h, config/spu/spu.c, tree-ssa-operands.h,

[pf3gnuchains/gcc-fork.git] / gcc / gthr-posix.h

diff --git a/gcc/gthr-posix.h b/gcc/gthr-posix.h
index 38fc381..837bc1a 100644 (file)
--- 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, 2004, 2005
+/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    Free Software Foundation, Inc.
 
 This file is part of GCC.
@@ -36,7 +36,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #define __GTHREADS 1
 
 /* Some implementations of <pthread.h> require this to be defined.  */
-#ifndef _REENTRANT
+#if !defined(_REENTRANT) && defined(__osf__)
 #define _REENTRANT 1
 #endif
 
@@ -59,33 +59,62 @@ typedef pthread_mutex_t __gthread_recursive_mutex_t;
 #endif
 
 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
-# define __gthrw(name) \
-  static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name)));
+# define __gthrw2(name,name2,type) \
+  static __typeof(type) name __attribute__ ((__weakref__(#name2)));
 # define __gthrw_(name) __gthrw_ ## name
 #else
-# define __gthrw(name)
+# define __gthrw2(name,name2,type)
 # define __gthrw_(name) name
 #endif
 
+/* 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)
+#else
 __gthrw(pthread_once)
-__gthrw(pthread_key_create)
-__gthrw(pthread_key_delete)
 __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)
+#endif
+
+__gthrw(pthread_key_create)
+__gthrw(pthread_key_delete)
 __gthrw(pthread_mutexattr_init)
 __gthrw(pthread_mutexattr_settype)
 __gthrw(pthread_mutexattr_destroy)
 
-__gthrw(pthread_mutex_init)
 
 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
 /* Objective-C.  */
+#if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
+__gthrw3(pthread_cond_broadcast)
+__gthrw3(pthread_cond_destroy)
+__gthrw3(pthread_cond_init)
+__gthrw3(pthread_cond_signal)
+__gthrw3(pthread_cond_wait)
+__gthrw3(pthread_exit)
+__gthrw3(pthread_mutex_destroy)
+__gthrw3(pthread_self)
+#else
 __gthrw(pthread_cond_broadcast)
 __gthrw(pthread_cond_destroy)
 __gthrw(pthread_cond_init)
@@ -94,6 +123,7 @@ __gthrw(pthread_cond_wait)
 __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
 __gthrw(sched_get_priority_max)
@@ -112,6 +142,59 @@ __gthrw(pthread_setschedparam)
 
 #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 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)
 {
@@ -120,6 +203,8 @@ __gthread_active_p (void)
   return __gthread_active_ptr != 0;
 }
 
+#endif /* Solaris */
+
 #else /* not SUPPORTS_WEAK */
 
 static inline int