From a75150aea65b32e4d376a3e13b88d2db7bc04ab0 Mon Sep 17 00:00:00 2001
From: Chris Fairles <chris.fairles@gmail.com>
Date: Thu, 28 Aug 2008 09:20:57 +0000
Subject: [PATCH] gthr-posix.h (__gthread_create, [...]): New functions.
2008-08-28 Chris Fairles <chris.fairles@gmail.com>
* gthr-posix.h (__gthread_create, __gthread_join, __gthread_detach,
__gthread_mutex_timed_lock, __gthread_recursive_mutex_timed_lock,
__gthread_cond_signal, __gthread_cond_timedwait,
__gthread_cond_timedwait_recursive): New functions.
* gthr-posix.c (pthread_mutex_timedlock, pthread_cond_timedwait):
Likewise.
* gthr.h: Comment on defining __GTHREADS_CXX0X macro in conforming
thread interfaces.
From-SVN: r139704
---
gcc/ChangeLog | 11 +++++
gcc/gthr-posix.c | 35 +++++++++++++-
gcc/gthr-posix.h | 123 ++++++++++++++++++++++++++++++++++++++++++++---
gcc/gthr.h | 31 ++++++++++++
4 files changed, 191 insertions(+), 9 deletions(-)
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 6e943654e637..6430e4f8fd0e 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2008-08-28 Chris Fairles <chris.fairles@gmail.com>
+
+ * gthr-posix.h (__gthread_create, __gthread_join, __gthread_detach,
+ __gthread_mutex_timed_lock, __gthread_recursive_mutex_timed_lock,
+ __gthread_cond_signal, __gthread_cond_timedwait,
+ __gthread_cond_timedwait_recursive): New functions.
+ * gthr-posix.c (pthread_mutex_timedlock, pthread_cond_timedwait):
+ Likewise.
+ * gthr.h: Comment on defining __GTHREADS_CXX0X macro in conforming
+ thread interfaces.
+
2008-08-28 Richard Guenther <rguenther@suse.de>
PR middle-end/37005
diff --git a/gcc/gthr-posix.c b/gcc/gthr-posix.c
index e2d731ae4077..bfcd316de306 100644
--- a/gcc/gthr-posix.c
+++ b/gcc/gthr-posix.c
@@ -75,6 +75,24 @@ pthread_create (pthread_t *thread ATTRIBUTE_UNUSED,
return 0;
}
+int
+pthread_join (pthread_t thread ATTRIBUTE_UNUSED,
+ void **value_ptr ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
+void
+pthread_exit (void *value_ptr ATTRIBUTE_UNUSED)
+{
+}
+
+int
+pthread_detach (pthread_t thread ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
int
pthread_cancel (pthread_t thread ATTRIBUTE_UNUSED)
{
@@ -93,6 +111,15 @@ pthread_mutex_trylock (pthread_mutex_t *mutex ATTRIBUTE_UNUSED)
return 0;
}
+#ifdef _POSIX_TIMEOUTS
+int
+pthread_mutex_timedlock (pthread_mutex_t *mutex ATTRIBUTE_UNUSED,
+ const struct timespec *abs_timeout ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+#endif /* _POSIX_TIMEOUTS */
+
int
pthread_mutex_unlock (pthread_mutex_t *mutex ATTRIBUTE_UNUSED)
{
@@ -150,9 +177,12 @@ pthread_cond_wait (pthread_cond_t *cond ATTRIBUTE_UNUSED,
return 0;
}
-void
-pthread_exit (void *value_ptr ATTRIBUTE_UNUSED)
+int
+pthread_cond_timedwait (pthread_cond_t *cond ATTRIBUTE_UNUSED,
+ pthread_mutex_t *mutex ATTRIBUTE_UNUSED,
+ const struct timespec *abstime ATTRIBUTE_UNUSED)
{
+ return 0;
}
int
@@ -173,6 +203,7 @@ pthread_self (void)
{
return (pthread_t) 0;
}
+
#ifdef _POSIX_PRIORITY_SCHEDULING
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
int
diff --git a/gcc/gthr-posix.h b/gcc/gthr-posix.h
index b16f9b31fe8d..e9612995cced 100644
--- a/gcc/gthr-posix.h
+++ b/gcc/gthr-posix.h
@@ -34,6 +34,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
Easy, since the interface is just one-to-one mapping. */
#define __GTHREADS 1
+#define __GTHREADS_CXX0X 1
/* Some implementations of <pthread.h> require this to be defined. */
#if !defined(_REENTRANT) && defined(__osf__)
@@ -43,11 +44,13 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
#include <pthread.h>
#include <unistd.h>
+typedef pthread_t __gthread_t;
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;
+typedef struct timespec __gthread_time_t;
/* POSIX like conditional variables are supported. Please look at comments
in gthr.h for details. */
@@ -63,6 +66,7 @@ typedef pthread_cond_t __gthread_cond_t;
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
#endif
#define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
+#define __GTHREAD_TIME_INIT {0,0}
#if SUPPORTS_WEAK && GTHREAD_USE_WEAK
# ifndef __gthrw_pragma
@@ -88,28 +92,56 @@ typedef pthread_cond_t __gthread_cond_t;
__gthrw3(pthread_once)
__gthrw3(pthread_getspecific)
__gthrw3(pthread_setspecific)
+
__gthrw3(pthread_create)
+__gthrw3(pthread_join)
+__gthrw3(pthread_detach)
+__gthrw3(pthread_equal)
+__gthrw3(pthread_self)
__gthrw3(pthread_cancel)
+__gthrw3(sched_yield)
+
__gthrw3(pthread_mutex_lock)
__gthrw3(pthread_mutex_trylock)
+#ifdef _POSIX_TIMEOUTS
+__gthrw3(pthread_mutex_timedlock)
+#endif /* _POSIX_TIMEOUTS */
__gthrw3(pthread_mutex_unlock)
__gthrw3(pthread_mutex_init)
__gthrw3(pthread_mutex_destroy)
+
__gthrw3(pthread_cond_broadcast)
+__gthrw3(pthread_cond_signal)
__gthrw3(pthread_cond_wait)
+__gthrw3(pthread_cond_timedwait)
+__gthrw3(pthread_cond_destroy)
#else
__gthrw(pthread_once)
__gthrw(pthread_getspecific)
__gthrw(pthread_setspecific)
+
__gthrw(pthread_create)
+__gthrw(pthread_join)
+__gthrw(pthread_equal)
+__gthrw(pthread_self)
+__gthrw(pthread_detach)
__gthrw(pthread_cancel)
+__gthrw(sched_yield)
+
__gthrw(pthread_mutex_lock)
__gthrw(pthread_mutex_trylock)
+#ifdef _POSIX_TIMEOUTS
+__gthrw(pthread_mutex_timedlock)
+#endif /* _POSIX_TIMEOUTS */
__gthrw(pthread_mutex_unlock)
__gthrw(pthread_mutex_init)
__gthrw(pthread_mutex_destroy)
+
__gthrw(pthread_cond_broadcast)
+__gthrw(pthread_cond_signal)
__gthrw(pthread_cond_wait)
+__gthrw(pthread_cond_timedwait)
+__gthrw(pthread_cond_destroy)
#endif
__gthrw(pthread_key_create)
@@ -122,17 +154,11 @@ __gthrw(pthread_mutexattr_destroy)
#if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
/* Objective-C. */
#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_self)
#else
-__gthrw(pthread_cond_destroy)
__gthrw(pthread_cond_init)
-__gthrw(pthread_cond_signal)
__gthrw(pthread_exit)
-__gthrw(pthread_self)
#endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */
#ifdef _POSIX_PRIORITY_SCHEDULING
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
@@ -140,7 +166,6 @@ __gthrw(sched_get_priority_max)
__gthrw(sched_get_priority_min)
#endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
#endif /* _POSIX_PRIORITY_SCHEDULING */
-__gthrw(sched_yield)
__gthrw(pthread_attr_destroy)
__gthrw(pthread_attr_init)
__gthrw(pthread_attr_setdetachstate)
@@ -646,6 +671,42 @@ __gthread_objc_condition_signal (objc_condition_t condition)
#else /* _LIBOBJC */
+static inline int
+__gthread_create (__gthread_t *thread, void *(*func) (void*), void *args)
+{
+ return __gthrw_(pthread_create) (thread, NULL, func, args);
+}
+
+static inline int
+__gthread_join (__gthread_t thread, void **value_ptr)
+{
+ return __gthrw_(pthread_join) (thread, value_ptr);
+}
+
+static inline int
+__gthread_detach (__gthread_t thread)
+{
+ return __gthrw_(pthread_detach) (thread);
+}
+
+static inline int
+__gthread_equal (__gthread_t t1, __gthread_t t2)
+{
+ return __gthrw_(pthread_equal) (t1, t2);
+}
+
+static inline __gthread_t
+__gthread_self (void)
+{
+ return __gthrw_(pthread_self) ();
+}
+
+static inline int
+__gthread_yield (void)
+{
+ return __gthrw_(sched_yield) ();
+}
+
static inline int
__gthread_once (__gthread_once_t *once, void (*func) (void))
{
@@ -706,6 +767,18 @@ __gthread_mutex_trylock (__gthread_mutex_t *mutex)
return 0;
}
+#ifdef _POSIX_TIMEOUTS
+static inline int
+__gthread_mutex_timedlock (__gthread_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ if (__gthread_active_p ())
+ return __gthrw_(pthread_mutex_timedlock) (mutex, abs_timeout);
+ else
+ return 0;
+}
+#endif
+
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *mutex)
{
@@ -749,6 +822,15 @@ __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
return __gthread_mutex_trylock (mutex);
}
+#ifdef _POSIX_TIMEOUTS
+static inline int
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ return __gthread_mutex_timedlock (mutex, abs_timeout);
+}
+#endif
+
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
{
@@ -761,12 +843,25 @@ __gthread_cond_broadcast (__gthread_cond_t *cond)
return __gthrw_(pthread_cond_broadcast) (cond);
}
+static inline int
+__gthread_cond_signal (__gthread_cond_t *cond)
+{
+ return __gthrw_(pthread_cond_signal) (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_timedwait (__gthread_cond_t *cond, __gthread_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ return __gthrw_(pthread_cond_timedwait) (cond, mutex, abs_timeout);
+}
+
static inline int
__gthread_cond_wait_recursive (__gthread_cond_t *cond,
__gthread_recursive_mutex_t *mutex)
@@ -774,6 +869,20 @@ __gthread_cond_wait_recursive (__gthread_cond_t *cond,
return __gthread_cond_wait (cond, mutex);
}
+static inline int
+__gthread_cond_timedwait_recursive (__gthread_cond_t *cond,
+ __gthread_recursive_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout)
+{
+ return __gthread_cond_timedwait (cond, mutex, abs_timeout);
+}
+
+static inline int
+__gthread_cond_destroy (__gthread_cond_t* cond)
+{
+ return __gthrw_(pthread_cond_destroy) (cond);
+}
+
#endif /* _LIBOBJC */
#endif /* ! GCC_GTHR_POSIX_H */
diff --git a/gcc/gthr.h b/gcc/gthr.h
index a145ef1a9deb..d318256429a5 100644
--- a/gcc/gthr.h
+++ b/gcc/gthr.h
@@ -104,12 +104,43 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
All functions returning int should return zero on success or the error
number. If the operation is not supported, -1 is returned.
+ If the following are also defined, you should
+ #define __GTHREADS_CXX0X 1
+ to enable the c++0x thread library.
+
+ Types:
+ __gthread_t
+ __gthread_time_t
+
+ Interface:
+ int __gthread_create (__gthread_t *thread, void *(*func) (void*),
+ void *args);
+ int __gthread_join (__gthread_t thread, void **value_ptr);
+ int __gthread_detach (__gthread_t thread);
+ int __gthread_equal (__gthread_t t1, __gthread_t t2);
+ __gthread_t __gthread_self (void);
+ int __gthread_yield (void);
+
+ int __gthread_mutex_timedlock (__gthread_mutex_t *m,
+ const __gthread_time_t *abs_timeout);
+ int __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *m,
+ const __gthread_time_t *abs_time);
+
+ int __gthread_cond_signal (__gthread_cond_t *cond);
+ int __gthread_cond_timedwait (__gthread_cond_t *cond,
+ __gthread_mutex_t *mutex,
+ const __gthread_time_t *abs_timeout);
+ int __gthread_cond_timedwait_recursive (__gthread_cond_t *cond,
+ __gthread_recursive_mutex_t *mutex,
+ const __gthread_time_t *abs_time)
+
Currently supported threads packages are
TPF threads with -D__tpf__
POSIX/Unix98 threads with -D_PTHREADS
POSIX/Unix95 threads with -D_PTHREADS95
DCE threads with -D_DCE_THREADS
Solaris/UI threads with -D_SOLARIS_THREADS
+
*/
/* Check first for thread specific defines. */
--
GitLab