From 09e361bbde5b4f9c74e846ff49360a42d25ec2d5 Mon Sep 17 00:00:00 2001
From: Jakub Jelinek <jakub@redhat.com>
Date: Mon, 16 Feb 2009 13:19:34 +0100
Subject: [PATCH] gthr-dce.h: Uglify function parameter and local variable
names.
* gthr-dce.h: Uglify function parameter and local variable names.
* gthr-gnat.h: Likewise.
* gthr-mipssde.h: Likewise.
* gthr-nks.h: Likewise.
* gthr-posix95.h: Likewise.
* gthr-posix.h: Likewise.
* gthr-rtems.h: Likewise.
* gthr-single.h: Likewise.
* gthr-solaris.h: Likewise.
* gthr-tpf.h: Likewise.
* gthr-vxworks.h: Likewise.
* gthr-win32.h: Likewise.
From-SVN: r144201
---
gcc/ChangeLog | 15 +++
gcc/gthr-dce.h | 81 +++++++++--------
gcc/gthr-gnat.h | 4 +-
gcc/gthr-mipssde.h | 78 ++++++++--------
gcc/gthr-nks.h | 76 ++++++++--------
gcc/gthr-posix.h | 160 ++++++++++++++++----------------
gcc/gthr-posix95.h | 92 +++++++++----------
gcc/gthr-rtems.h | 78 ++++++++--------
gcc/gthr-single.h | 33 +++----
gcc/gthr-solaris.h | 99 ++++++++++----------
gcc/gthr-tpf.h | 75 +++++++--------
gcc/gthr-vxworks.h | 12 +--
gcc/gthr-win32.h | 222 ++++++++++++++++++++++-----------------------
13 files changed, 523 insertions(+), 502 deletions(-)
diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 0ab715f7eda4..d4b786006081 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,18 @@
+2009-02-16 Jakub Jelinek <jakub@redhat.com>
+
+ * gthr-dce.h: Uglify function parameter and local variable names.
+ * gthr-gnat.h: Likewise.
+ * gthr-mipssde.h: Likewise.
+ * gthr-nks.h: Likewise.
+ * gthr-posix95.h: Likewise.
+ * gthr-posix.h: Likewise.
+ * gthr-rtems.h: Likewise.
+ * gthr-single.h: Likewise.
+ * gthr-solaris.h: Likewise.
+ * gthr-tpf.h: Likewise.
+ * gthr-vxworks.h: Likewise.
+ * gthr-win32.h: Likewise.
+
2009-02-15 H.J. Lu <hongjiu.lu@intel.com>
PR target/39196
diff --git a/gcc/gthr-dce.h b/gcc/gthr-dce.h
index e95a4e5c87d3..50b6fdb51e69 100644
--- a/gcc/gthr-dce.h
+++ b/gcc/gthr-dce.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000, 2001, 2004, 2005
+/* Copyright (C) 1997, 1999, 2000, 2001, 2004, 2005, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
@@ -431,122 +431,123 @@ __gthread_objc_condition_signal (objc_condition_t condition
#else /* _LIBOBJC */
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
- return __gthrw_(pthread_once) (once, func);
+ return __gthrw_(pthread_once) (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return __gthrw_(pthread_keycreate) (key, dtor);
+ return __gthrw_(pthread_keycreate) (__key, __dtor);
}
static inline int
-__gthread_key_delete (__gthread_key_t key __attribute__ ((__unused__)))
+__gthread_key_delete (__gthread_key_t __key __attribute__ ((__unused__)))
{
/* Operation is not supported. */
return -1;
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- void *ptr;
- if (__gthrw_(pthread_getspecific) (key, &ptr) == 0)
- return ptr;
+ void *__ptr;
+ if (__gthrw_(pthread_getspecific) (__key, &__ptr) == 0)
+ return __ptr;
else
return 0;
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthrw_(pthread_setspecific) (key, (void *) ptr);
+ return __gthrw_(pthread_setspecific) (__key, (void *) __ptr);
}
static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *mutex)
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- __gthrw_(pthread_mutex_init) (mutex, pthread_mutexattr_default);
+ __gthrw_(pthread_mutex_init) (__mutex, pthread_mutexattr_default);
}
static inline int
-__gthread_mutx_destroy (__gthread_mutex_t *mutex)
+__gthread_mutx_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_destroy) (mutex);
+ return __gthrw_(pthread_mutex_destroy) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_lock) (mutex);
+ return __gthrw_(pthread_mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_trylock) (mutex);
+ return __gthrw_(pthread_mutex_trylock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_unlock) (mutex);
+ return __gthrw_(pthread_mutex_unlock) (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- pthread_mutexattr_t attr;
- int r;
-
- r = __gthrw_(pthread_mutexattr_create) (&attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_setkind_np) (&attr, MUTEX_RECURSIVE_NP);
- if (!r)
- r = __gthrw_(pthread_mutex_init) (mutex, attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_delete) (&attr);
- return r;
+ pthread_mutexattr_t __attr;
+ int __r;
+
+ __r = __gthrw_(pthread_mutexattr_create) (&__attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_setkind_np) (&__attr,
+ MUTEX_RECURSIVE_NP);
+ if (!__r)
+ __r = __gthrw_(pthread_mutex_init) (__mutex, __attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_delete) (&__attr);
+ return __r;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_lock (mutex);
+ return __gthread_mutex_lock (__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_trylock (mutex);
+ return __gthread_mutex_trylock (__mutex);
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_unlock (mutex);
+ return __gthread_mutex_unlock (__mutex);
}
#endif /* _LIBOBJC */
diff --git a/gcc/gthr-gnat.h b/gcc/gthr-gnat.h
index a7931c01858d..51066df47bd2 100644
--- a/gcc/gthr-gnat.h
+++ b/gcc/gthr-gnat.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2. */
/* Compile this one with gcc. */
-/* Copyright (C) 2003, 2004 Free Software Foundation, Inc.
+/* Copyright (C) 2003, 2004, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
@@ -38,7 +38,7 @@ typedef int __gthread_mutex_t;
#define __GTHREAD_MUTEX_INIT 0
-extern void __gnat_install_locks (void (*lock) (void), void (*unlock) (void));
+extern void __gnat_install_locks (void (*) (void), void (*) (void));
extern int __gthread_active_p (void);
extern int __gthread_mutex_lock (__gthread_mutex_t *);
extern int __gthread_mutex_unlock (__gthread_mutex_t *);
diff --git a/gcc/gthr-mipssde.h b/gcc/gthr-mipssde.h
index b8cf24ebc750..325bcc52e600 100644
--- a/gcc/gthr-mipssde.h
+++ b/gcc/gthr-mipssde.h
@@ -1,6 +1,6 @@
/* MIPS SDE threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 2006, 2007 Free Software Foundation, Inc.
+/* Copyright (C) 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
Contributed by Nigel Stephens <nigel@mips.com>
This file is part of GCC.
@@ -55,7 +55,7 @@ typedef struct {
#define __GTHREAD_MUTEX_INIT __SDETHREAD_MUTEX_INITIALIZER("gthr")
#define __GTHREAD_ONCE_INIT __SDETHREAD_ONCE_INIT
static inline int
-__gthread_recursive_mutex_init_function(__gthread_recursive_mutex_t *mutex);
+__gthread_recursive_mutex_init_function(__gthread_recursive_mutex_t *__mutex);
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
#if SUPPORTS_WEAK && GTHREAD_USE_WEAK
@@ -102,125 +102,125 @@ __gthread_active_p (void)
#endif /* SUPPORTS_WEAK */
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
- return __gthrw_(__sdethread_once) (once, func);
+ return __gthrw_(__sdethread_once) (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return __gthrw_(__sdethread_key_create) (key, dtor);
+ return __gthrw_(__sdethread_key_create) (__key, __dtor);
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return __gthrw_(__sdethread_key_delete) (key);
+ return __gthrw_(__sdethread_key_delete) (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- return __gthrw_(__sdethread_getspecific) (key);
+ return __gthrw_(__sdethread_getspecific) (__key);
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthrw_(__sdethread_setspecific) (key, ptr);
+ return __gthrw_(__sdethread_setspecific) (__key, __ptr);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(mutex))
+__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(__mutex))
{
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(__sdethread_mutex_lock) (mutex);
+ return __gthrw_(__sdethread_mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(__sdethread_mutex_trylock) (mutex);
+ return __gthrw_(__sdethread_mutex_trylock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(__sdethread_mutex_unlock) (mutex);
+ return __gthrw_(__sdethread_mutex_unlock) (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- mutex->depth = 0;
- mutex->owner = __gthrw_(__sdethread_self) ();
- return __gthrw_(__sdethread_mutex_init) (&mutex->actual, NULL);
+ __mutex->depth = 0;
+ __mutex->owner = __gthrw_(__sdethread_self) ();
+ return __gthrw_(__sdethread_mutex_init) (&__mutex->actual, NULL);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- __sdethread_t me = __gthrw_(__sdethread_self) ();
+ __sdethread_t __me = __gthrw_(__sdethread_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- __gthrw_(__sdethread_mutex_lock) (&mutex->actual);
- mutex->owner = me;
+ __gthrw_(__sdethread_mutex_lock) (&__mutex->actual);
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- __sdethread_t me = __gthrw_(__sdethread_self) ();
+ __sdethread_t __me = __gthrw_(__sdethread_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- if (__gthrw_(__sdethread_mutex_trylock) (&mutex->actual))
+ if (__gthrw_(__sdethread_mutex_trylock) (&__mutex->actual))
return 1;
- mutex->owner = me;
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- if (--mutex->depth == 0)
+ if (--__mutex->depth == 0)
{
- mutex->owner = (__sdethread_t) 0;
- __gthrw_(__sdethread_mutex_unlock) (&mutex->actual);
+ __mutex->owner = (__sdethread_t) 0;
+ __gthrw_(__sdethread_mutex_unlock) (&__mutex->actual);
}
}
return 0;
diff --git a/gcc/gthr-nks.h b/gcc/gthr-nks.h
index 14027e0871bf..1d0d1c2f1258 100644
--- a/gcc/gthr-nks.h
+++ b/gcc/gthr-nks.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2004, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
@@ -281,118 +281,118 @@ typedef volatile long __gthread_once_t;
#define __GTHREAD_ONCE_INIT 0
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
- if (__compare_and_swap (once, 0, 1))
+ if (__compare_and_swap (__once, 0, 1))
{
- func();
- *once |= 2;
+ __func ();
+ *__once |= 2;
}
else
{
- while (!(*once & 2))
+ while (!(*__once & 2))
NXThreadYield ();
}
return 0;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return NXKeyCreate (dtor, NULL, key);
+ return NXKeyCreate (__dtor, NULL, __key);
}
static inline int
-__gthread_key_dtor (__gthread_key_t key, void *ptr)
+__gthread_key_dtor (__gthread_key_t __key, void *__ptr)
{
/* Just reset the key value to zero. */
- if (ptr)
- return NXKeySetValue (key, NULL);
+ if (__ptr)
+ return NXKeySetValue (__key, NULL);
return 0;
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return NXKeyDelete (key);
+ return NXKeyDelete (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- void *value;
+ void *__value;
- if (NXKeyGetValue (key, &value) == 0)
- return value;
+ if (NXKeyGetValue (__key, &__value) == 0)
+ return __value;
return NULL;
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return NXKeySetValue (key, (void *)ptr);
+ return NXKeySetValue (__key, (void *)__ptr);
}
static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *mutex)
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
- static const NX_LOCK_INFO_ALLOC (info, "GTHREADS", 0);
+ static const NX_LOCK_INFO_ALLOC (__info, "GTHREADS", 0);
- *mutex = NXMutexAlloc (0, 0, &info);
+ *__mutex = NXMutexAlloc (0, 0, &__info);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(mutex))
+__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(__mutex))
{
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
- return NXLock (*mutex);
+ return NXLock (*__mutex);
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
- if (NXTryLock (*mutex))
+ if (NXTryLock (*__mutex))
return 0;
return -1;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
- return NXUnlock (*mutex);
+ return NXUnlock (*__mutex);
}
static inline void
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- static const NX_LOCK_INFO_ALLOC (info, "GTHREADS", 0);
+ static const NX_LOCK_INFO_ALLOC (__info, "GTHREADS", 0);
- *mutex = NXMutexAlloc (NX_MUTEX_RECURSIVE, 0, &info);
+ *__mutex = NXMutexAlloc (NX_MUTEX_RECURSIVE, 0, &__info);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
- return NXLock (*mutex);
+ return NXLock (*__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
- if (NXTryLock (*mutex))
+ if (NXTryLock (*__mutex))
return 0;
return -1;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
- return NXUnlock (*mutex);
+ return NXUnlock (*__mutex);
}
#endif /* _LIBOBJC */
diff --git a/gcc/gthr-posix.h b/gcc/gthr-posix.h
index 221833e0089e..e0d2bbff6117 100644
--- a/gcc/gthr-posix.h
+++ b/gcc/gthr-posix.h
@@ -1,7 +1,7 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
- Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+ 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
@@ -267,7 +267,7 @@ __gthread_active_p (void)
static volatile int __gthread_active = -1;
static void *
-__gthread_start (void *arg __attribute__((unused)))
+__gthread_start (void *__arg __attribute__((unused)))
{
return NULL;
}
@@ -277,21 +277,21 @@ 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;
+ 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)
+ __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_attr_destroy) (&__a);
}
__gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
}
@@ -676,27 +676,28 @@ __gthread_objc_condition_signal (objc_condition_t condition)
#else /* _LIBOBJC */
static inline int
-__gthread_create (__gthread_t *thread, void *(*func) (void*), void *args)
+__gthread_create (__gthread_t *__threadid, void *(*__func) (void*),
+ void *__args)
{
- return __gthrw_(pthread_create) (thread, NULL, func, args);
+ return __gthrw_(pthread_create) (__threadid, NULL, __func, __args);
}
static inline int
-__gthread_join (__gthread_t thread, void **value_ptr)
+__gthread_join (__gthread_t __threadid, void **__value_ptr)
{
- return __gthrw_(pthread_join) (thread, value_ptr);
+ return __gthrw_(pthread_join) (__threadid, __value_ptr);
}
static inline int
-__gthread_detach (__gthread_t thread)
+__gthread_detach (__gthread_t __threadid)
{
- return __gthrw_(pthread_detach) (thread);
+ return __gthrw_(pthread_detach) (__threadid);
}
static inline int
-__gthread_equal (__gthread_t t1, __gthread_t t2)
+__gthread_equal (__gthread_t __t1, __gthread_t __t2)
{
- return __gthrw_(pthread_equal) (t1, t2);
+ return __gthrw_(pthread_equal) (__t1, __t2);
}
static inline __gthread_t
@@ -712,61 +713,61 @@ __gthread_yield (void)
}
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
- return __gthrw_(pthread_once) (once, func);
+ return __gthrw_(pthread_once) (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return __gthrw_(pthread_key_create) (key, dtor);
+ return __gthrw_(pthread_key_create) (__key, __dtor);
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return __gthrw_(pthread_key_delete) (key);
+ return __gthrw_(pthread_key_delete) (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- return __gthrw_(pthread_getspecific) (key);
+ return __gthrw_(pthread_getspecific) (__key);
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthrw_(pthread_setspecific) (key, ptr);
+ return __gthrw_(pthread_setspecific) (__key, __ptr);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_destroy) (mutex);
+ return __gthrw_(pthread_mutex_destroy) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_lock) (mutex);
+ return __gthrw_(pthread_mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_trylock) (mutex);
+ return __gthrw_(pthread_mutex_trylock) (__mutex);
else
return 0;
}
@@ -774,11 +775,11 @@ __gthread_mutex_trylock (__gthread_mutex_t *mutex)
#ifdef _POSIX_TIMEOUTS
#if _POSIX_TIMEOUTS >= 0
static inline int
-__gthread_mutex_timedlock (__gthread_mutex_t *mutex,
- const __gthread_time_t *abs_timeout)
+__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);
+ return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout);
else
return 0;
}
@@ -786,109 +787,110 @@ __gthread_mutex_timedlock (__gthread_mutex_t *mutex,
#endif
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_unlock) (mutex);
+ return __gthrw_(pthread_mutex_unlock) (__mutex);
else
return 0;
}
#ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- pthread_mutexattr_t attr;
- int r;
-
- r = __gthrw_(pthread_mutexattr_init) (&attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE);
- if (!r)
- r = __gthrw_(pthread_mutex_init) (mutex, &attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_destroy) (&attr);
- return r;
+ pthread_mutexattr_t __attr;
+ int __r;
+
+ __r = __gthrw_(pthread_mutexattr_init) (&__attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_settype) (&__attr,
+ PTHREAD_MUTEX_RECURSIVE);
+ if (!__r)
+ __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_destroy) (&__attr);
+ return __r;
}
return 0;
}
#endif
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_lock (mutex);
+ return __gthread_mutex_lock (__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_trylock (mutex);
+ return __gthread_mutex_trylock (__mutex);
}
#ifdef _POSIX_TIMEOUTS
#if _POSIX_TIMEOUTS >= 0
static inline int
-__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *mutex,
- const __gthread_time_t *abs_timeout)
+__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex,
+ const __gthread_time_t *__abs_timeout)
{
- return __gthread_mutex_timedlock (mutex, abs_timeout);
+ return __gthread_mutex_timedlock (__mutex, __abs_timeout);
}
#endif
#endif
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_unlock (mutex);
+ return __gthread_mutex_unlock (__mutex);
}
static inline int
-__gthread_cond_broadcast (__gthread_cond_t *cond)
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
- return __gthrw_(pthread_cond_broadcast) (cond);
+ return __gthrw_(pthread_cond_broadcast) (__cond);
}
static inline int
-__gthread_cond_signal (__gthread_cond_t *cond)
+__gthread_cond_signal (__gthread_cond_t *__cond)
{
- return __gthrw_(pthread_cond_signal) (cond);
+ return __gthrw_(pthread_cond_signal) (__cond);
}
static inline int
-__gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
- return __gthrw_(pthread_cond_wait) (cond, 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)
+__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);
+ 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)
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+ __gthread_recursive_mutex_t *__mutex)
{
- return __gthread_cond_wait (cond, mutex);
+ 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)
+__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);
+ return __gthread_cond_timedwait (__cond, __mutex, __abs_timeout);
}
static inline int
-__gthread_cond_destroy (__gthread_cond_t* cond)
+__gthread_cond_destroy (__gthread_cond_t* __cond)
{
- return __gthrw_(pthread_cond_destroy) (cond);
+ return __gthrw_(pthread_cond_destroy) (__cond);
}
#endif /* _LIBOBJC */
diff --git a/gcc/gthr-posix95.h b/gcc/gthr-posix95.h
index 190b097d284d..9310a7e2dd0b 100644
--- a/gcc/gthr-posix95.h
+++ b/gcc/gthr-posix95.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 2004, 2005, 2007 Free Software Foundation, Inc.
+/* Copyright (C) 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
@@ -610,150 +610,150 @@ __gthread_objc_condition_signal (objc_condition_t condition)
#else /* _LIBOBJC */
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
- return __gthrw_(pthread_once) (once, func);
+ return __gthrw_(pthread_once) (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return __gthrw_(pthread_key_create) (key, dtor);
+ return __gthrw_(pthread_key_create) (__key, __dtor);
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return __gthrw_(pthread_key_delete) (key);
+ return __gthrw_(pthread_key_delete) (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- return __gthrw_(pthread_getspecific) (key);
+ return __gthrw_(pthread_getspecific) (__key);
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthrw_(pthread_setspecific) (key, ptr);
+ return __gthrw_(pthread_setspecific) (__key, __ptr);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_destroy) (mutex);
+ return __gthrw_(pthread_mutex_destroy) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_lock) (mutex);
+ return __gthrw_(pthread_mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_trylock) (mutex);
+ return __gthrw_(pthread_mutex_trylock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(pthread_mutex_unlock) (mutex);
+ return __gthrw_(pthread_mutex_unlock) (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- mutex->depth = 0;
- mutex->owner = (pthread_t) 0;
- return __gthrw_(pthread_mutex_init) (&mutex->actual, NULL);
+ __mutex->depth = 0;
+ __mutex->owner = (pthread_t) 0;
+ return __gthrw_(pthread_mutex_init) (&__mutex->actual, NULL);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- pthread_t me = __gthrw_(pthread_self) ();
+ pthread_t __me = __gthrw_(pthread_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- __gthrw_(pthread_mutex_lock) (&mutex->actual);
- mutex->owner = me;
+ __gthrw_(pthread_mutex_lock) (&__mutex->actual);
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- pthread_t me = __gthrw_(pthread_self) ();
+ pthread_t __me = __gthrw_(pthread_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- if (__gthrw_(pthread_mutex_trylock) (&mutex->actual))
+ if (__gthrw_(pthread_mutex_trylock) (&__mutex->actual))
return 1;
- mutex->owner = me;
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- if (--mutex->depth == 0)
+ if (--__mutex->depth == 0)
{
- mutex->owner = (pthread_t) 0;
- __gthrw_(pthread_mutex_unlock) (&mutex->actual);
+ __mutex->owner = (pthread_t) 0;
+ __gthrw_(pthread_mutex_unlock) (&__mutex->actual);
}
}
return 0;
}
static inline int
-__gthread_cond_broadcast (__gthread_cond_t *cond)
+__gthread_cond_broadcast (__gthread_cond_t *__cond)
{
- return __gthrw_(pthread_cond_broadcast) (cond);
+ return __gthrw_(pthread_cond_broadcast) (__cond);
}
static inline int
-__gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
+__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex)
{
- return __gthrw_(pthread_cond_wait) (cond, mutex);
+ return __gthrw_(pthread_cond_wait) (__cond, __mutex);
}
static inline int
-__gthread_cond_wait_recursive (__gthread_cond_t *cond,
- __gthread_recursive_mutex_t *mutex)
+__gthread_cond_wait_recursive (__gthread_cond_t *__cond,
+ __gthread_recursive_mutex_t *__mutex)
{
- return __gthrw_(pthread_cond_wait) (cond, &mutex->actual);
+ return __gthrw_(pthread_cond_wait) (__cond, &__mutex->actual);
}
#endif /* _LIBOBJC */
diff --git a/gcc/gthr-rtems.h b/gcc/gthr-rtems.h
index e926d534c5e9..d15ad5e1976f 100644
--- a/gcc/gthr-rtems.h
+++ b/gcc/gthr-rtems.h
@@ -1,7 +1,7 @@
/* RTEMS threads compatibility routines for libgcc2 and libobjc.
by: Rosimildo da Silva( rdasilva@connecttel.com ) */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000, 2002, 2003, 2005
+/* Copyright (C) 1997, 1999, 2000, 2002, 2003, 2005, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
@@ -54,24 +54,24 @@ typedef void *__gthread_recursive_mutex_t;
*/
/* generic per task variables */
-extern int rtems_gxx_once (__gthread_once_t *once, void (*func) (void));
-extern int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *));
-extern int rtems_gxx_key_delete (__gthread_key_t key);
-extern void *rtems_gxx_getspecific (__gthread_key_t key);
-extern int rtems_gxx_setspecific (__gthread_key_t key, const void *ptr);
+extern int rtems_gxx_once (__gthread_once_t *__once, void (*__func) (void));
+extern int rtems_gxx_key_create (__gthread_key_t *__key, void (*__dtor) (void *));
+extern int rtems_gxx_key_delete (__gthread_key_t __key);
+extern void *rtems_gxx_getspecific (__gthread_key_t __key);
+extern int rtems_gxx_setspecific (__gthread_key_t __key, const void *__ptr);
/* mutex support */
-extern void rtems_gxx_mutex_init (__gthread_mutex_t *mutex);
-extern int rtems_gxx_mutex_destroy (__gthread_mutex_t *mutex);
-extern int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex);
-extern int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex);
-extern int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex);
+extern void rtems_gxx_mutex_init (__gthread_mutex_t *__mutex);
+extern int rtems_gxx_mutex_destroy (__gthread_mutex_t *__mutex);
+extern int rtems_gxx_mutex_lock (__gthread_mutex_t *__mutex);
+extern int rtems_gxx_mutex_trylock (__gthread_mutex_t *__mutex);
+extern int rtems_gxx_mutex_unlock (__gthread_mutex_t *__mutex);
/* recursive mutex support */
-extern void rtems_gxx_recursive_mutex_init (__gthread_recursive_mutex_t *mutex);
-extern int rtems_gxx_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex);
-extern int rtems_gxx_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex);
-extern int rtems_gxx_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex);
+extern void rtems_gxx_recursive_mutex_init (__gthread_recursive_mutex_t *__mutex);
+extern int rtems_gxx_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex);
+extern int rtems_gxx_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex);
+extern int rtems_gxx_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex);
/* RTEMS threading is always active */
static inline int
@@ -82,75 +82,75 @@ __gthread_active_p (void)
/* Wrapper calls */
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
- return rtems_gxx_once( once, func );
+ return rtems_gxx_once( __once, __func );
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return rtems_gxx_key_create( key, dtor );
+ return rtems_gxx_key_create( __key, __dtor );
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return rtems_gxx_key_delete (key);
+ return rtems_gxx_key_delete (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- return rtems_gxx_getspecific (key);
+ return rtems_gxx_getspecific (__key);
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return rtems_gxx_setspecific (key, ptr);
+ return rtems_gxx_setspecific (__key, __ptr);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
- return rtems_gxx_mutex_destroy (mutex);
+ return rtems_gxx_mutex_destroy (__mutex);
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
- return rtems_gxx_mutex_lock (mutex);
+ return rtems_gxx_mutex_lock (__mutex);
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
- return rtems_gxx_mutex_trylock (mutex);
+ return rtems_gxx_mutex_trylock (__mutex);
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
- return rtems_gxx_mutex_unlock( mutex );
+ return rtems_gxx_mutex_unlock( __mutex );
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
- return rtems_gxx_recursive_mutex_lock (mutex);
+ return rtems_gxx_recursive_mutex_lock (__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
- return rtems_gxx_recursive_mutex_trylock (mutex);
+ return rtems_gxx_recursive_mutex_trylock (__mutex);
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
- return rtems_gxx_recursive_mutex_unlock( mutex );
+ return rtems_gxx_recursive_mutex_unlock( __mutex );
}
#ifdef __cplusplus
diff --git a/gcc/gthr-single.h b/gcc/gthr-single.h
index a0a45cb71067..56dd8bc89f94 100644
--- a/gcc/gthr-single.h
+++ b/gcc/gthr-single.h
@@ -1,6 +1,7 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000, 2004, 2008 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1999, 2000, 2004, 2008, 2009
+ Free Software Foundation, Inc.
This file is part of GCC.
@@ -216,75 +217,75 @@ __gthread_active_p (void)
}
static inline int
-__gthread_once (__gthread_once_t *once UNUSED, void (*func) (void) UNUSED)
+__gthread_once (__gthread_once_t *__once UNUSED, void (*__func) (void) UNUSED)
{
return 0;
}
static inline int UNUSED
-__gthread_key_create (__gthread_key_t *key UNUSED, void (*func) (void *) UNUSED)
+__gthread_key_create (__gthread_key_t *__key UNUSED, void (*__func) (void *) UNUSED)
{
return 0;
}
static int UNUSED
-__gthread_key_delete (__gthread_key_t key UNUSED)
+__gthread_key_delete (__gthread_key_t __key UNUSED)
{
return 0;
}
static inline void *
-__gthread_getspecific (__gthread_key_t key UNUSED)
+__gthread_getspecific (__gthread_key_t __key UNUSED)
{
return 0;
}
static inline int
-__gthread_setspecific (__gthread_key_t key UNUSED, const void *v UNUSED)
+__gthread_setspecific (__gthread_key_t __key UNUSED, const void *__v UNUSED)
{
return 0;
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex UNUSED)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex UNUSED)
{
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex UNUSED)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex UNUSED)
{
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex UNUSED)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex UNUSED)
{
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex UNUSED)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex UNUSED)
{
return 0;
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_lock (mutex);
+ return __gthread_mutex_lock (__mutex);
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_trylock (mutex);
+ return __gthread_mutex_trylock (__mutex);
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
- return __gthread_mutex_unlock (mutex);
+ return __gthread_mutex_unlock (__mutex);
}
#endif /* _LIBOBJC */
diff --git a/gcc/gthr-solaris.h b/gcc/gthr-solaris.h
index a726bfa1fd93..083a43346a46 100644
--- a/gcc/gthr-solaris.h
+++ b/gcc/gthr-solaris.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000, 2004, 2005, 2006
+/* Copyright (C) 1997, 1999, 2000, 2004, 2005, 2006, 2008, 2009
Free Software Foundation, Inc.
This file is part of GCC.
@@ -403,154 +403,155 @@ __gthread_objc_condition_signal (objc_condition_t condition)
#else /* _LIBOBJC */
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (! __gthread_active_p ())
return -1;
- if (once == 0 || func == 0)
+ if (__once == 0 || __func == 0)
return EINVAL;
- if (once->once == 0)
+ if (__once->once == 0)
{
- int status = __gthrw_(mutex_lock) (&once->mutex);
- if (status != 0)
- return status;
- if (once->once == 0)
+ int __status = __gthrw_(mutex_lock) (&__once->mutex);
+ if (__status != 0)
+ return __status;
+ if (__once->once == 0)
{
- (*func) ();
- once->once++;
+ (*__func) ();
+ __once->once++;
}
- __gthrw_(mutex_unlock) (&once->mutex);
+ __gthrw_(mutex_unlock) (&__once->mutex);
}
return 0;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
/* Solaris 2.5 contains thr_* routines no-op in libc, so test if we actually
got a reasonable key value, and if not, fail. */
- *key = (__gthread_key_t)-1;
- if (__gthrw_(thr_keycreate) (key, dtor) != 0 || *key == (__gthread_key_t)-1)
+ *__key = (__gthread_key_t)-1;
+ if (__gthrw_(thr_keycreate) (__key, __dtor) != 0
+ || *__key == (__gthread_key_t)-1)
return -1;
else
return 0;
}
static inline int
-__gthread_key_delete (__gthread_key_t UNUSED (key))
+__gthread_key_delete (__gthread_key_t UNUSED (__key))
{
/* Not possible. */
return -1;
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- void *ptr;
- if (__gthrw_(thr_getspecific) (key, &ptr) == 0)
- return ptr;
+ void *__ptr;
+ if (__gthrw_(thr_getspecific) (__key, &__ptr) == 0)
+ return __ptr;
else
return 0;
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthrw_(thr_setspecific) (key, (void *) ptr);
+ return __gthrw_(thr_setspecific) (__key, (void *) __ptr);
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(mutex))
+__gthread_mutex_destroy (__gthread_mutex_t * UNUSED(__mutex))
{
if (__gthread_active_p ())
- return __gthrw_(mutex_destroy) (mutex);
+ return __gthrw_(mutex_destroy) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(mutex_lock) (mutex);
+ return __gthrw_(mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(mutex_trylock) (mutex);
+ return __gthrw_(mutex_trylock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthrw_(mutex_unlock) (mutex);
+ return __gthrw_(mutex_unlock) (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- mutex->depth = 0;
- mutex->owner = (thread_t) 0;
- return __gthrw_(mutex_init) (&mutex->actual, USYNC_THREAD, 0);
+ __mutex->depth = 0;
+ __mutex->owner = (thread_t) 0;
+ return __gthrw_(mutex_init) (&__mutex->actual, USYNC_THREAD, 0);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- thread_t me = __gthrw_(thr_self) ();
+ thread_t __me = __gthrw_(thr_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- __gthrw_(mutex_lock) (&mutex->actual);
- mutex->owner = me;
+ __gthrw_(mutex_lock) (&__mutex->actual);
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- thread_t me = __gthrw_(thr_self) ();
+ thread_t __me = __gthrw_(thr_self) ();
- if (mutex->owner != me)
+ if (__mutex->owner != __me)
{
- if (__gthrw_(mutex_trylock) (&mutex->actual))
+ if (__gthrw_(mutex_trylock) (&__mutex->actual))
return 1;
- mutex->owner = me;
+ __mutex->owner = __me;
}
- mutex->depth++;
+ __mutex->depth++;
}
return 0;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- if (--mutex->depth == 0)
+ if (--__mutex->depth == 0)
{
- mutex->owner = (thread_t) 0;
- __gthrw_(mutex_unlock) (&mutex->actual);
+ __mutex->owner = (thread_t) 0;
+ __gthrw_(mutex_unlock) (&__mutex->actual);
}
}
return 0;
diff --git a/gcc/gthr-tpf.h b/gcc/gthr-tpf.h
index fd80bd49df37..c4b8f0b3805f 100644
--- a/gcc/gthr-tpf.h
+++ b/gcc/gthr-tpf.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc.
Compile this one with gcc.
- Copyright (C) 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2004, 2005, 2008, 2009 Free Software Foundation, Inc.
This file is part of GCC.
@@ -101,129 +101,130 @@ __gthread_active_p (void)
}
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_once) (once, func);
+ return __gthrw_(pthread_once) (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_key_create) (key, dtor);
+ return __gthrw_(pthread_key_create) (__key, __dtor);
else
return -1;
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_key_delete) (key);
+ return __gthrw_(pthread_key_delete) (__key);
else
return -1;
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_getspecific) (key);
+ return __gthrw_(pthread_getspecific) (__key);
else
return NULL;
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_setspecific) (key, ptr);
+ return __gthrw_(pthread_setspecific) (__key, __ptr);
else
return -1;
}
static inline int
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_mutex_destroy) (mutex);
+ return __gthrw_(pthread_mutex_destroy) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_mutex_lock) (mutex);
+ return __gthrw_(pthread_mutex_lock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_mutex_trylock) (mutex);
+ return __gthrw_(pthread_mutex_trylock) (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthrw_(pthread_mutex_unlock) (mutex);
+ return __gthrw_(pthread_mutex_unlock) (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthread_mutex_lock (mutex);
+ return __gthread_mutex_lock (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthread_mutex_trylock (mutex);
+ return __gthread_mutex_trylock (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
- return __gthread_mutex_unlock (mutex);
+ return __gthread_mutex_unlock (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
if (__tpf_pthread_active ())
{
- pthread_mutexattr_t attr;
- int r;
-
- r = __gthrw_(pthread_mutexattr_init) (&attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE);
- if (!r)
- r = __gthrw_(pthread_mutex_init) (mutex, &attr);
- if (!r)
- r = __gthrw_(pthread_mutexattr_destroy) (&attr);
- return r;
+ pthread_mutexattr_t __attr;
+ int __r;
+
+ __r = __gthrw_(pthread_mutexattr_init) (&__attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_settype) (&__attr,
+ PTHREAD_MUTEX_RECURSIVE);
+ if (!__r)
+ __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr);
+ if (!__r)
+ __r = __gthrw_(pthread_mutexattr_destroy) (&__attr);
+ return __r;
}
return 0;
}
diff --git a/gcc/gthr-vxworks.h b/gcc/gthr-vxworks.h
index 7a61a5a40f7c..e0ff957e4f45 100644
--- a/gcc/gthr-vxworks.h
+++ b/gcc/gthr-vxworks.h
@@ -1,6 +1,6 @@
/* Threads compatibility routines for libgcc2 and libobjc for VxWorks. */
/* Compile this one with gcc. */
-/* Copyright (C) 1997, 1999, 2000 Free Software Foundation, Inc.
+/* Copyright (C) 1997, 1999, 2000, 2008, 2009 Free Software Foundation, Inc.
Contributed by Mike Stump <mrs@wrs.com>.
This file is part of GCC.
@@ -131,7 +131,7 @@ __gthread_once_t;
# define __GTHREAD_ONCE_INIT { 0 }
#endif
-extern int __gthread_once (__gthread_once_t *once, void (*func)(void));
+extern int __gthread_once (__gthread_once_t *__once, void (*__func)(void));
/* Thread-specific data requires a great deal of effort, since VxWorks
is not really set up for it. See config/vxlib.c for the gory
@@ -140,11 +140,11 @@ extern int __gthread_once (__gthread_once_t *once, void (*func)(void));
typedef unsigned int __gthread_key_t;
-extern int __gthread_key_create (__gthread_key_t *keyp, void (*dtor)(void *));
-extern int __gthread_key_delete (__gthread_key_t key);
+extern int __gthread_key_create (__gthread_key_t *__keyp, void (*__dtor)(void *));
+extern int __gthread_key_delete (__gthread_key_t __key);
-extern void *__gthread_getspecific (__gthread_key_t key);
-extern int __gthread_setspecific (__gthread_key_t key, void *ptr);
+extern void *__gthread_getspecific (__gthread_key_t __key);
+extern int __gthread_setspecific (__gthread_key_t __key, void *__ptr);
#undef UNUSED
diff --git a/gcc/gthr-win32.h b/gcc/gthr-win32.h
index e9a6e8869c4e..6b97ed9ea5d7 100644
--- a/gcc/gthr-win32.h
+++ b/gcc/gthr-win32.h
@@ -1,7 +1,7 @@
/* Threads compatibility routines for libgcc2 and libobjc. */
/* Compile this one with gcc. */
-/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005
+/* Copyright (C) 1999, 2000, 2002, 2003, 2004, 2005, 2008, 2009
Free Software Foundation, Inc.
Contributed by Mumit Khan <khan@xraylith.wisc.edu>.
@@ -381,14 +381,14 @@ extern int __mingwthr_key_dtor (unsigned long, void (*) (void *));
gthread_mutex_try_lock is not referenced by libgcc or libstdc++. */
#ifdef __GTHREAD_I486_INLINE_LOCK_PRIMITIVES
static inline long
-__gthr_i486_lock_cmp_xchg(long *dest, long xchg, long comperand)
+__gthr_i486_lock_cmp_xchg(long *__dest, long __xchg, long __comperand)
{
long result;
__asm__ __volatile__ ("\n\
lock\n\
cmpxchg{l} {%4, %1|%1, %4}\n"
- : "=a" (result), "=m" (*dest)
- : "0" (comperand), "m" (*dest), "r" (xchg)
+ : "=a" (result), "=m" (*__dest)
+ : "0" (__comperand), "m" (*__dest), "r" (__xchg)
: "cc");
return result;
}
@@ -431,106 +431,106 @@ extern int __gthr_win32_recursive_mutex_unlock (__gthread_recursive_mutex_t *);
extern void __gthr_win32_mutex_destroy (__gthread_mutex_t *);
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (__gthread_active_p ())
- return __gthr_win32_once (once, func);
+ return __gthr_win32_once (__once, __func);
else
return -1;
}
static inline int
-__gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
{
- return __gthr_win32_key_create (key, dtor);
+ return __gthr_win32_key_create (__key, __dtor);
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return __gthr_win32_key_delete (key);
+ return __gthr_win32_key_delete (__key);
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- return __gthr_win32_getspecific (key);
+ return __gthr_win32_getspecific (__key);
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- return __gthr_win32_setspecific (key, ptr);
+ return __gthr_win32_setspecific (__key, __ptr);
}
static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *mutex)
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
- __gthr_win32_mutex_init_function (mutex);
+ __gthr_win32_mutex_init_function (__mutex);
}
static inline void
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
- __gthr_win32_mutex_destroy (mutex);
+ __gthr_win32_mutex_destroy (__mutex);
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_mutex_lock (mutex);
+ return __gthr_win32_mutex_lock (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_mutex_trylock (mutex);
+ return __gthr_win32_mutex_trylock (__mutex);
else
return 0;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_mutex_unlock (mutex);
+ return __gthr_win32_mutex_unlock (__mutex);
else
return 0;
}
static inline void
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- __gthr_win32_recursive_mutex_init_function (mutex);
+ __gthr_win32_recursive_mutex_init_function (__mutex);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_recursive_mutex_lock (mutex);
+ return __gthr_win32_recursive_mutex_lock (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_recursive_mutex_trylock (mutex);
+ return __gthr_win32_recursive_mutex_trylock (__mutex);
else
return 0;
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
- return __gthr_win32_recursive_mutex_unlock (mutex);
+ return __gthr_win32_recursive_mutex_unlock (__mutex);
else
return 0;
}
@@ -541,19 +541,19 @@ __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
#include <errno.h>
static inline int
-__gthread_once (__gthread_once_t *once, void (*func) (void))
+__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
if (! __gthread_active_p ())
return -1;
- else if (once == NULL || func == NULL)
+ else if (__once == NULL || __func == NULL)
return EINVAL;
- if (! once->done)
+ if (! __once->done)
{
- if (InterlockedIncrement (&(once->started)) == 0)
+ if (InterlockedIncrement (&(__once->started)) == 0)
{
- (*func) ();
- once->done = TRUE;
+ (*__func) ();
+ __once->done = TRUE;
}
else
{
@@ -562,7 +562,7 @@ __gthread_once (__gthread_once_t *once, void (*func) (void))
does become an issue, the solution is to use an Event that
we wait on here (and set above), but that implies a place to
create the event before this routine is called. */
- while (! once->done)
+ while (! __once->done)
Sleep (0);
}
}
@@ -574,150 +574,150 @@ __gthread_once (__gthread_once_t *once, void (*func) (void))
leaks, especially in threaded applications making extensive use of
C++ EH. Mingw uses a thread-support DLL to work-around this problem. */
static inline int
-__gthread_key_create (__gthread_key_t *key,
- void (*dtor) (void *) __attribute__((unused)))
+__gthread_key_create (__gthread_key_t *__key,
+ void (*__dtor) (void *) __attribute__((unused)))
{
- int status = 0;
- DWORD tls_index = TlsAlloc ();
- if (tls_index != 0xFFFFFFFF)
+ int __status = 0;
+ DWORD __tls_index = TlsAlloc ();
+ if (__tls_index != 0xFFFFFFFF)
{
- *key = tls_index;
+ *__key = __tls_index;
#ifdef MINGW32_SUPPORTS_MT_EH
/* Mingw runtime will run the dtors in reverse order for each thread
when the thread exits. */
- status = __mingwthr_key_dtor (*key, dtor);
+ __status = __mingwthr_key_dtor (*__key, __dtor);
#endif
}
else
- status = (int) GetLastError ();
- return status;
+ __status = (int) GetLastError ();
+ return __status;
}
static inline int
-__gthread_key_delete (__gthread_key_t key)
+__gthread_key_delete (__gthread_key_t __key)
{
- return (TlsFree (key) != 0) ? 0 : (int) GetLastError ();
+ return (TlsFree (__key) != 0) ? 0 : (int) GetLastError ();
}
static inline void *
-__gthread_getspecific (__gthread_key_t key)
+__gthread_getspecific (__gthread_key_t __key)
{
- DWORD lasterror;
- void *ptr;
+ DWORD __lasterror;
+ void *__ptr;
- lasterror = GetLastError ();
+ __lasterror = GetLastError ();
- ptr = TlsGetValue (key);
+ __ptr = TlsGetValue (__key);
- SetLastError (lasterror);
+ SetLastError (__lasterror);
- return ptr;
+ return __ptr;
}
static inline int
-__gthread_setspecific (__gthread_key_t key, const void *ptr)
+__gthread_setspecific (__gthread_key_t __key, const void *__ptr)
{
- if (TlsSetValue (key, CONST_CAST2(void *, const void *, ptr)) != 0)
+ if (TlsSetValue (__key, CONST_CAST2(void *, const void *, __ptr)) != 0)
return 0;
else
return GetLastError ();
}
static inline void
-__gthread_mutex_init_function (__gthread_mutex_t *mutex)
+__gthread_mutex_init_function (__gthread_mutex_t *__mutex)
{
- mutex->counter = -1;
- mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
+ __mutex->counter = -1;
+ __mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}
static inline void
-__gthread_mutex_destroy (__gthread_mutex_t *mutex)
+__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
- CloseHandle ((HANDLE) mutex->sema);
+ CloseHandle ((HANDLE) __mutex->sema);
}
static inline int
-__gthread_mutex_lock (__gthread_mutex_t *mutex)
+__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
- int status = 0;
+ int __status = 0;
if (__gthread_active_p ())
{
- if (InterlockedIncrement (&mutex->counter) == 0 ||
- WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
- status = 0;
+ if (InterlockedIncrement (&__mutex->counter) == 0 ||
+ WaitForSingleObject (__mutex->sema, INFINITE) == WAIT_OBJECT_0)
+ __status = 0;
else
{
/* WaitForSingleObject returns WAIT_FAILED, and we can only do
some best-effort cleanup here. */
- InterlockedDecrement (&mutex->counter);
- status = 1;
+ InterlockedDecrement (&__mutex->counter);
+ __status = 1;
}
}
- return status;
+ return __status;
}
static inline int
-__gthread_mutex_trylock (__gthread_mutex_t *mutex)
+__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
- int status = 0;
+ int __status = 0;
if (__gthread_active_p ())
{
- if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
- status = 0;
+ if (__GTHR_W32_InterlockedCompareExchange (&__mutex->counter, 0, -1) < 0)
+ __status = 0;
else
- status = 1;
+ __status = 1;
}
- return status;
+ return __status;
}
static inline int
-__gthread_mutex_unlock (__gthread_mutex_t *mutex)
+__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- if (InterlockedDecrement (&mutex->counter) >= 0)
- return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
+ if (InterlockedDecrement (&__mutex->counter) >= 0)
+ return ReleaseSemaphore (__mutex->sema, 1, NULL) ? 0 : 1;
}
return 0;
}
static inline void
-__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
{
- mutex->counter = -1;
- mutex->depth = 0;
- mutex->owner = 0;
- mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
+ __mutex->counter = -1;
+ __mutex->depth = 0;
+ __mutex->owner = 0;
+ __mutex->sema = CreateSemaphore (NULL, 0, 65535, NULL);
}
static inline int
-__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- DWORD me = GetCurrentThreadId();
- if (InterlockedIncrement (&mutex->counter) == 0)
+ DWORD __me = GetCurrentThreadId();
+ if (InterlockedIncrement (&__mutex->counter) == 0)
{
- mutex->depth = 1;
- mutex->owner = me;
+ __mutex->depth = 1;
+ __mutex->owner = __me;
}
- else if (mutex->owner == me)
+ else if (__mutex->owner == __me)
{
- InterlockedDecrement (&mutex->counter);
- ++(mutex->depth);
+ InterlockedDecrement (&__mutex->counter);
+ ++(__mutex->depth);
}
- else if (WaitForSingleObject (mutex->sema, INFINITE) == WAIT_OBJECT_0)
+ else if (WaitForSingleObject (__mutex->sema, INFINITE) == WAIT_OBJECT_0)
{
- mutex->depth = 1;
- mutex->owner = me;
+ __mutex->depth = 1;
+ __mutex->owner = __me;
}
else
{
/* WaitForSingleObject returns WAIT_FAILED, and we can only do
some best-effort cleanup here. */
- InterlockedDecrement (&mutex->counter);
+ InterlockedDecrement (&__mutex->counter);
return 1;
}
}
@@ -725,18 +725,18 @@ __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
}
static inline int
-__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- DWORD me = GetCurrentThreadId();
- if (__GTHR_W32_InterlockedCompareExchange (&mutex->counter, 0, -1) < 0)
+ DWORD __me = GetCurrentThreadId();
+ if (__GTHR_W32_InterlockedCompareExchange (&__mutex->counter, 0, -1) < 0)
{
- mutex->depth = 1;
- mutex->owner = me;
+ __mutex->depth = 1;
+ __mutex->owner = __me;
}
- else if (mutex->owner == me)
- ++(mutex->depth);
+ else if (__mutex->owner == __me)
+ ++(__mutex->depth);
else
return 1;
}
@@ -744,17 +744,17 @@ __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
}
static inline int
-__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
if (__gthread_active_p ())
{
- --(mutex->depth);
- if (mutex->depth == 0)
+ --(__mutex->depth);
+ if (__mutex->depth == 0)
{
- mutex->owner = 0;
+ __mutex->owner = 0;
- if (InterlockedDecrement (&mutex->counter) >= 0)
- return ReleaseSemaphore (mutex->sema, 1, NULL) ? 0 : 1;
+ if (InterlockedDecrement (&__mutex->counter) >= 0)
+ return ReleaseSemaphore (__mutex->sema, 1, NULL) ? 0 : 1;
}
}
return 0;
--
GitLab