URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [gthr-solaris.h] - Blame information for rev 280

Details | Compare with Previous | View Log


/* Threads compatibility routines for libgcc2 and libobjc.  */
/* Compile this one with gcc.  */
/* Copyright (C) 1997, 1999, 2000, 2004, 2005, 2006, 2008, 2009
   Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
 
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
 
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */
 
#ifndef GCC_GTHR_SOLARIS_H
#define GCC_GTHR_SOLARIS_H
 
/* Solaris threads as found in Solaris 2.[456].
   Actually these are Unix International (UI) threads, but I don't
   know if anyone else implements these.  */
 
#define __GTHREADS 1
 
#include <thread.h>
#include <errno.h>
 
#ifdef __cplusplus
#define UNUSED(x)
#else
#define UNUSED(x) x __attribute__((unused))
#endif
 
typedef thread_key_t __gthread_key_t;
typedef struct {
  mutex_t mutex;
  int once;
} __gthread_once_t;
typedef mutex_t __gthread_mutex_t;
 
typedef struct {
  long depth;
  thread_t owner;
  mutex_t actual;
} __gthread_recursive_mutex_t;
 
#define __GTHREAD_ONCE_INIT { DEFAULTMUTEX, 0 }
#define __GTHREAD_MUTEX_INIT DEFAULTMUTEX
#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
 
#if SUPPORTS_WEAK && GTHREAD_USE_WEAK
# define __gthrw(name) \
  static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name)));
# define __gthrw_(name) __gthrw_ ## name
#else
# define __gthrw(name)
# define __gthrw_(name) name
#endif
 
__gthrw(thr_keycreate)
__gthrw(thr_getspecific)
__gthrw(thr_setspecific)
__gthrw(thr_create)
__gthrw(thr_self)
 
__gthrw(mutex_init)
__gthrw(mutex_destroy)
__gthrw(mutex_lock)
__gthrw(mutex_trylock)
__gthrw(mutex_unlock)
 
#ifdef _LIBOBJC
__gthrw(thr_exit)
__gthrw(thr_getprio)
__gthrw(thr_setprio)
__gthrw(thr_yield)
 
__gthrw(cond_init)
__gthrw(cond_destroy)
__gthrw(cond_wait)
__gthrw(cond_broadcast)
__gthrw(cond_signal)
 
#endif
 
#if SUPPORTS_WEAK && GTHREAD_USE_WEAK
 
/* This will not actually work in Solaris 2.5, since libc contains
   dummy symbols of all thr_* routines.  */
 
static inline int
__gthread_active_p (void)
{
  static void *const __gthread_active_ptr
    = __extension__ (void *) &__gthrw_(thr_create);
  return __gthread_active_ptr != 0;
}
 
#else /* not SUPPORTS_WEAK */
 
static inline int
__gthread_active_p (void)
{
  return 1;
}
 
#endif /* SUPPORTS_WEAK */
 
#ifdef _LIBOBJC
 
/* Key structure for maintaining thread specific storage */
static thread_key_t _objc_thread_storage;
 
/* Thread local storage for a single thread */
static void *thread_local_storage = NULL;
 
/* Backend initialization functions */
 
/* Initialize the threads subsystem.  */
static inline int
__gthread_objc_init_thread_system (void)
{
  /* Initialize the thread storage key.  */
  if (__gthread_active_p ()
      && __gthrw_(thr_keycreate) (&_objc_thread_storage, NULL) == 0)
    return 0;
 
  return -1;
}
 
/* Close the threads subsystem.  */
static inline int
__gthread_objc_close_thread_system (void)
{
  if (__gthread_active_p ())
    return 0;
  else
    return -1;
}
 
/* Backend thread functions */
 
/* Create a new thread of execution.  */
static inline objc_thread_t
__gthread_objc_thread_detach (void (*func)(void *), void *arg)
{
  objc_thread_t thread_id;
  thread_t new_thread_id = 0;
 
  if (!__gthread_active_p ())
    return NULL;
 
  if (__gthrw_(thr_create) (NULL, 0, (void *) func, arg,
                  THR_DETACHED | THR_NEW_LWP,
                  &new_thread_id) == 0)
    thread_id = *(objc_thread_t *) &new_thread_id;
  else
    thread_id = NULL;
 
  return thread_id;
}
 
/* Set the current thread's priority.  */
static inline int
__gthread_objc_thread_set_priority (int priority)
{
  int sys_priority = 0;
 
  if (!__gthread_active_p ())
    return -1;
 
  switch (priority)
    {
    case OBJC_THREAD_INTERACTIVE_PRIORITY:
      sys_priority = 300;
      break;
    default:
    case OBJC_THREAD_BACKGROUND_PRIORITY:
      sys_priority = 200;
      break;
    case OBJC_THREAD_LOW_PRIORITY:
      sys_priority = 1000;
      break;
    }
 
  /* Change priority */
  if (__gthrw_(thr_setprio) (__gthrw_(thr_self) (), sys_priority) == 0)
    return 0;
  else
    return -1;
}
 
/* Return the current thread's priority.  */
static inline int
__gthread_objc_thread_get_priority (void)
{
  int sys_priority;
 
  if (!__gthread_active_p ())
    return OBJC_THREAD_INTERACTIVE_PRIORITY;
 
  if (__gthrw_(thr_getprio) (__gthrw_(thr_self) (), &sys_priority) == 0)
    {
      if (sys_priority >= 250)
        return OBJC_THREAD_INTERACTIVE_PRIORITY;
      else if (sys_priority >= 150)
        return OBJC_THREAD_BACKGROUND_PRIORITY;
      return OBJC_THREAD_LOW_PRIORITY;
    }
 
  /* Couldn't get priority.  */
  return -1;
}
 
/* Yield our process time to another thread.  */
static inline void
__gthread_objc_thread_yield (void)
{
  if (__gthread_active_p ())
    __gthrw_(thr_yield) ();
}
 
/* Terminate the current thread.  */
static inline int
__gthread_objc_thread_exit (void)
{
  if (__gthread_active_p ())
    /* exit the thread */
    __gthrw_(thr_exit) (&__objc_thread_exit_status);
 
  /* Failed if we reached here */
  return -1;
}
 
/* Returns an integer value which uniquely describes a thread.  */
static inline objc_thread_t
__gthread_objc_thread_id (void)
{
  if (__gthread_active_p ())
    return (objc_thread_t) __gthrw_(thr_self) ();
  else
    return (objc_thread_t) 1;
}
 
/* Sets the thread's local storage pointer.  */
static inline int
__gthread_objc_thread_set_data (void *value)
{
  if (__gthread_active_p ())
    {
      if (__gthrw_(thr_setspecific) (_objc_thread_storage, value) == 0)
        return 0;
      else
        return -1;
    }
  else
    {
      thread_local_storage = value;
      return 0;
    }
}
 
/* Returns the thread's local storage pointer.  */
static inline void *
__gthread_objc_thread_get_data (void)
{
  void *value = NULL;
 
  if (__gthread_active_p ())
    {
      if (__gthrw_(thr_getspecific) (_objc_thread_storage, &value) == 0)
        return value;
      else
        return NULL;
    }
  else
    return thread_local_storage;
}
 
/* Backend mutex functions */
 
/* Allocate a mutex.  */
static inline int
__gthread_objc_mutex_allocate (objc_mutex_t mutex)
{
  if (__gthread_active_p ()
      && __gthrw_(mutex_init) ((mutex_t *) (&(mutex->backend)), USYNC_THREAD, 0))
    return -1;
 
  return 0;
}
 
/* Deallocate a mutex.  */
static inline int
__gthread_objc_mutex_deallocate (objc_mutex_t mutex)
{
  if (__gthread_active_p ())
    __gthrw_(mutex_destroy) ((mutex_t *) (&(mutex->backend)));
 
  return 0;
}
 
/* Grab a lock on a mutex.  */
static inline int
__gthread_objc_mutex_lock (objc_mutex_t mutex)
{
  if (__gthread_active_p ()
      && __gthrw_(mutex_lock) ((mutex_t *) (&(mutex->backend))) != 0)
    return -1;
 
  return 0;
}
 
/* Try to grab a lock on a mutex.  */
static inline int
__gthread_objc_mutex_trylock (objc_mutex_t mutex)
{
  if (__gthread_active_p ()
      && __gthrw_(mutex_trylock) ((mutex_t *) (&(mutex->backend))) != 0)
    return -1;
 
  return 0;
}
 
/* Unlock the mutex */
static inline int
__gthread_objc_mutex_unlock (objc_mutex_t mutex)
{
  if (__gthread_active_p ()
      && __gthrw_(mutex_unlock) ((mutex_t *) (&(mutex->backend))) != 0)
    return -1;
 
  return 0;
}
 
/* Backend condition mutex functions */
 
/* Allocate a condition.  */
static inline int
__gthread_objc_condition_allocate (objc_condition_t condition)
{
  if (__gthread_active_p ())
    return __gthrw_(cond_init) ((cond_t *) (&(condition->backend)), USYNC_THREAD,
                      NULL);
  else
    return 0;
}
 
/* Deallocate a condition.  */
static inline int
__gthread_objc_condition_deallocate (objc_condition_t condition)
{
  if (__gthread_active_p ())
    return __gthrw_(cond_destroy) ((cond_t *) (&(condition->backend)));
  else
    return 0;
}
 
/* Wait on the condition */
static inline int
__gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
{
  if (__gthread_active_p ())
    return __gthrw_(cond_wait) ((cond_t *) (&(condition->backend)),
                      (mutex_t *) (&(mutex->backend)));
  else
    return 0;
}
 
/* Wake up all threads waiting on this condition.  */
static inline int
__gthread_objc_condition_broadcast (objc_condition_t condition)
{
  if (__gthread_active_p ())
    return __gthrw_(cond_broadcast) ((cond_t *) (&(condition->backend)));
  else
    return 0;
}
 
/* Wake up one thread waiting on this condition.  */
static inline int
__gthread_objc_condition_signal (objc_condition_t condition)
{
  if (__gthread_active_p ())
    return __gthrw_(cond_signal) ((cond_t *) (&(condition->backend)));
  else
    return 0;
}
 
#else /* _LIBOBJC */
 
static inline int
__gthread_once (__gthread_once_t *__once, void (*__func) (void))
{
  if (! __gthread_active_p ())
    return -1;
 
  if (__once == 0 || __func == 0)
    return EINVAL;
 
  if (__once->once == 0)
    {
      int __status = __gthrw_(mutex_lock) (&__once->mutex);
      if (__status != 0)
        return __status;
      if (__once->once == 0)
        {
          (*__func) ();
          __once->once++;
        }
      __gthrw_(mutex_unlock) (&__once->mutex);
    }
  return 0;
}
 
static inline int
__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)
    return -1;
  else
    return 0;
}
 
static inline int
__gthread_key_delete (__gthread_key_t UNUSED (__key))
{
  /* Not possible.  */
  return -1;
}
 
static inline void *
__gthread_getspecific (__gthread_key_t __key)
{
  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)
{
  return __gthrw_(thr_setspecific) (__key, (void *) __ptr);
}
 
static inline int
__gthread_mutex_destroy (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_(mutex_destroy) (__mutex);
  else
    return 0;
}
 
static inline int
__gthread_mutex_lock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_(mutex_lock) (__mutex);
  else
    return 0;
}
 
static inline int
__gthread_mutex_trylock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_(mutex_trylock) (__mutex);
  else
    return 0;
}
 
static inline int
__gthread_mutex_unlock (__gthread_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    return __gthrw_(mutex_unlock) (__mutex);
  else
    return 0;
}
 
static inline int
__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);
}
 
static inline int
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      thread_t __me = __gthrw_(thr_self) ();
 
      if (__mutex->owner != __me)
        {
          __gthrw_(mutex_lock) (&__mutex->actual);
          __mutex->owner = __me;
        }
 
      __mutex->depth++;
    }
  return 0;
}
 
static inline int
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      thread_t __me = __gthrw_(thr_self) ();
 
      if (__mutex->owner != __me)
        {
          if (__gthrw_(mutex_trylock) (&__mutex->actual))
            return 1;
          __mutex->owner = __me;
        }
 
      __mutex->depth++;
    }
  return 0;
}
 
static inline int
__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
{
  if (__gthread_active_p ())
    {
      if (--__mutex->depth == 0)
        {
           __mutex->owner = (thread_t) 0;
           __gthrw_(mutex_unlock) (&__mutex->actual);
        }
    }
  return 0;
}
 
#endif /* _LIBOBJC */
 
#undef UNUSED
 
#endif /* ! GCC_GTHR_SOLARIS_H */

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [gthr-solaris.h] - Blame information for rev 280

Line No.	Rev	Author	Line
1	280	jeremybenn	`/* Threads compatibility routines for libgcc2 and libobjc. */`
2			`/* Compile this one with gcc. */`
3			`/* Copyright (C) 1997, 1999, 2000, 2004, 2005, 2006, 2008, 2009`
4			`Free Software Foundation, Inc.`
5
6			`This file is part of GCC.`
7
8			`GCC is free software; you can redistribute it and/or modify it under`
9			`the terms of the GNU General Public License as published by the Free`
10			`Software Foundation; either version 3, or (at your option) any later`
11			`version.`
12
13			`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`
14			`WARRANTY; without even the implied warranty of MERCHANTABILITY or`
15			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
16			`for more details.`
17
18			`Under Section 7 of GPL version 3, you are granted additional`
19			`permissions described in the GCC Runtime Library Exception, version`
20			`3.1, as published by the Free Software Foundation.`
21
22			`You should have received a copy of the GNU General Public License and`
23			`a copy of the GCC Runtime Library Exception along with this program;`
24			`see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
25			`<http://www.gnu.org/licenses/>. */`
26
27			`#ifndef GCC_GTHR_SOLARIS_H`
28			`#define GCC_GTHR_SOLARIS_H`
29
30			`/* Solaris threads as found in Solaris 2.[456].`
31			`Actually these are Unix International (UI) threads, but I don't`
32			`know if anyone else implements these. */`
33
34			`#define __GTHREADS 1`
35
36			`#include <thread.h>`
37			`#include <errno.h>`
38
39			`#ifdef __cplusplus`
40			`#define UNUSED(x)`
41			`#else`
42			`#define UNUSED(x) x __attribute__((unused))`
43			`#endif`
44
45			`typedef thread_key_t __gthread_key_t;`
46			`typedef struct {`
47			`mutex_t mutex;`
48			`int once;`
49			`} __gthread_once_t;`
50			`typedef mutex_t __gthread_mutex_t;`
51
52			`typedef struct {`
53			`long depth;`
54			`thread_t owner;`
55			`mutex_t actual;`
56			`} __gthread_recursive_mutex_t;`
57
58			`#define __GTHREAD_ONCE_INIT { DEFAULTMUTEX, 0 }`
59			`#define __GTHREAD_MUTEX_INIT DEFAULTMUTEX`
60			`#define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function`
61
62			`#if SUPPORTS_WEAK && GTHREAD_USE_WEAK`
63			`# define __gthrw(name) \`
64			`static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name)));`
65			`# define __gthrw_(name) __gthrw_ ## name`
66			`#else`
67			`# define __gthrw(name)`
68			`# define __gthrw_(name) name`
69			`#endif`
70
71			`__gthrw(thr_keycreate)`
72			`__gthrw(thr_getspecific)`
73			`__gthrw(thr_setspecific)`
74			`__gthrw(thr_create)`
75			`__gthrw(thr_self)`
76
77			`__gthrw(mutex_init)`
78			`__gthrw(mutex_destroy)`
79			`__gthrw(mutex_lock)`
80			`__gthrw(mutex_trylock)`
81			`__gthrw(mutex_unlock)`
82
83			`#ifdef _LIBOBJC`
84			`__gthrw(thr_exit)`
85			`__gthrw(thr_getprio)`
86			`__gthrw(thr_setprio)`
87			`__gthrw(thr_yield)`
88
89			`__gthrw(cond_init)`
90			`__gthrw(cond_destroy)`
91			`__gthrw(cond_wait)`
92			`__gthrw(cond_broadcast)`
93			`__gthrw(cond_signal)`
94
95			`#endif`
96
97			`#if SUPPORTS_WEAK && GTHREAD_USE_WEAK`
98
99			`/* This will not actually work in Solaris 2.5, since libc contains`
100			`dummy symbols of all thr_* routines. */`
101
102			`static inline int`
103			`__gthread_active_p (void)`
104			`{`
105			`static void *const __gthread_active_ptr`
106			`= __extension__ (void *) &__gthrw_(thr_create);`
107			`return __gthread_active_ptr != 0;`
108			`}`
109
110			`#else /* not SUPPORTS_WEAK */`
111
112			`static inline int`
113			`__gthread_active_p (void)`
114			`{`
115			`return 1;`
116			`}`
117
118			`#endif /* SUPPORTS_WEAK */`
119
120			`#ifdef _LIBOBJC`
121
122			`/* Key structure for maintaining thread specific storage */`
123			`static thread_key_t _objc_thread_storage;`
124
125			`/* Thread local storage for a single thread */`
126			`static void *thread_local_storage = NULL;`
127
128			`/* Backend initialization functions */`
129
130			`/* Initialize the threads subsystem. */`
131			`static inline int`
132			`__gthread_objc_init_thread_system (void)`
133			`{`
134			`/* Initialize the thread storage key. */`
135			`if (__gthread_active_p ()`
136			`&& __gthrw_(thr_keycreate) (&_objc_thread_storage, NULL) == 0)`
137			`return 0;`
138
139			`return -1;`
140			`}`
141
142			`/* Close the threads subsystem. */`
143			`static inline int`
144			`__gthread_objc_close_thread_system (void)`
145			`{`
146			`if (__gthread_active_p ())`
147			`return 0;`
148			`else`
149			`return -1;`
150			`}`
151
152			`/* Backend thread functions */`
153
154			`/* Create a new thread of execution. */`
155			`static inline objc_thread_t`
156			`__gthread_objc_thread_detach (void (func)(void ), void *arg)`
157			`{`
158			`objc_thread_t thread_id;`
159			`thread_t new_thread_id = 0;`
160
161			`if (!__gthread_active_p ())`
162			`return NULL;`
163
164			`if (__gthrw_(thr_create) (NULL, 0, (void *) func, arg,`
165			`THR_DETACHED \| THR_NEW_LWP,`
166			`&new_thread_id) == 0)`
167			`thread_id = (objc_thread_t ) &new_thread_id;`
168			`else`
169			`thread_id = NULL;`
170
171			`return thread_id;`
172			`}`
173
174			`/* Set the current thread's priority. */`
175			`static inline int`
176			`__gthread_objc_thread_set_priority (int priority)`
177			`{`
178			`int sys_priority = 0;`
179
180			`if (!__gthread_active_p ())`
181			`return -1;`
182
183			`switch (priority)`
184			`{`
185			`case OBJC_THREAD_INTERACTIVE_PRIORITY:`
186			`sys_priority = 300;`
187			`break;`
188			`default:`
189			`case OBJC_THREAD_BACKGROUND_PRIORITY:`
190			`sys_priority = 200;`
191			`break;`
192			`case OBJC_THREAD_LOW_PRIORITY:`
193			`sys_priority = 1000;`
194			`break;`
195			`}`
196
197			`/* Change priority */`
198			`if (__gthrw_(thr_setprio) (__gthrw_(thr_self) (), sys_priority) == 0)`
199			`return 0;`
200			`else`
201			`return -1;`
202			`}`
203
204			`/* Return the current thread's priority. */`
205			`static inline int`
206			`__gthread_objc_thread_get_priority (void)`
207			`{`
208			`int sys_priority;`
209
210			`if (!__gthread_active_p ())`
211			`return OBJC_THREAD_INTERACTIVE_PRIORITY;`
212
213			`if (__gthrw_(thr_getprio) (__gthrw_(thr_self) (), &sys_priority) == 0)`
214			`{`
215			`if (sys_priority >= 250)`
216			`return OBJC_THREAD_INTERACTIVE_PRIORITY;`
217			`else if (sys_priority >= 150)`
218			`return OBJC_THREAD_BACKGROUND_PRIORITY;`
219			`return OBJC_THREAD_LOW_PRIORITY;`
220			`}`
221
222			`/* Couldn't get priority. */`
223			`return -1;`
224			`}`
225
226			`/* Yield our process time to another thread. */`
227			`static inline void`
228			`__gthread_objc_thread_yield (void)`
229			`{`
230			`if (__gthread_active_p ())`
231			`__gthrw_(thr_yield) ();`
232			`}`
233
234			`/* Terminate the current thread. */`
235			`static inline int`
236			`__gthread_objc_thread_exit (void)`
237			`{`
238			`if (__gthread_active_p ())`
239			`/* exit the thread */`
240			`__gthrw_(thr_exit) (&__objc_thread_exit_status);`
241
242			`/* Failed if we reached here */`
243			`return -1;`
244			`}`
245
246			`/* Returns an integer value which uniquely describes a thread. */`
247			`static inline objc_thread_t`
248			`__gthread_objc_thread_id (void)`
249			`{`
250			`if (__gthread_active_p ())`
251			`return (objc_thread_t) __gthrw_(thr_self) ();`
252			`else`
253			`return (objc_thread_t) 1;`
254			`}`
255
256			`/* Sets the thread's local storage pointer. */`
257			`static inline int`
258			`__gthread_objc_thread_set_data (void *value)`
259			`{`
260			`if (__gthread_active_p ())`
261			`{`
262			`if (__gthrw_(thr_setspecific) (_objc_thread_storage, value) == 0)`
263			`return 0;`
264			`else`
265			`return -1;`
266			`}`
267			`else`
268			`{`
269			`thread_local_storage = value;`
270			`return 0;`
271			`}`
272			`}`
273
274			`/* Returns the thread's local storage pointer. */`
275			`static inline void *`
276			`__gthread_objc_thread_get_data (void)`
277			`{`
278			`void *value = NULL;`
279
280			`if (__gthread_active_p ())`
281			`{`
282			`if (__gthrw_(thr_getspecific) (_objc_thread_storage, &value) == 0)`
283			`return value;`
284			`else`
285			`return NULL;`
286			`}`
287			`else`
288			`return thread_local_storage;`
289			`}`
290
291			`/* Backend mutex functions */`
292
293			`/* Allocate a mutex. */`
294			`static inline int`
295			`__gthread_objc_mutex_allocate (objc_mutex_t mutex)`
296			`{`
297			`if (__gthread_active_p ()`
298			`&& __gthrw_(mutex_init) ((mutex_t *) (&(mutex->backend)), USYNC_THREAD, 0))`
299			`return -1;`
300
301			`return 0;`
302			`}`
303
304			`/* Deallocate a mutex. */`
305			`static inline int`
306			`__gthread_objc_mutex_deallocate (objc_mutex_t mutex)`
307			`{`
308			`if (__gthread_active_p ())`
309			`__gthrw_(mutex_destroy) ((mutex_t *) (&(mutex->backend)));`
310
311			`return 0;`
312			`}`
313
314			`/* Grab a lock on a mutex. */`
315			`static inline int`
316			`__gthread_objc_mutex_lock (objc_mutex_t mutex)`
317			`{`
318			`if (__gthread_active_p ()`
319			`&& __gthrw_(mutex_lock) ((mutex_t *) (&(mutex->backend))) != 0)`
320			`return -1;`
321
322			`return 0;`
323			`}`
324
325			`/* Try to grab a lock on a mutex. */`
326			`static inline int`
327			`__gthread_objc_mutex_trylock (objc_mutex_t mutex)`
328			`{`
329			`if (__gthread_active_p ()`
330			`&& __gthrw_(mutex_trylock) ((mutex_t *) (&(mutex->backend))) != 0)`
331			`return -1;`
332
333			`return 0;`
334			`}`
335
336			`/* Unlock the mutex */`
337			`static inline int`
338			`__gthread_objc_mutex_unlock (objc_mutex_t mutex)`
339			`{`
340			`if (__gthread_active_p ()`
341			`&& __gthrw_(mutex_unlock) ((mutex_t *) (&(mutex->backend))) != 0)`
342			`return -1;`
343
344			`return 0;`
345			`}`
346
347			`/* Backend condition mutex functions */`
348
349			`/* Allocate a condition. */`
350			`static inline int`
351			`__gthread_objc_condition_allocate (objc_condition_t condition)`
352			`{`
353			`if (__gthread_active_p ())`
354			`return __gthrw_(cond_init) ((cond_t *) (&(condition->backend)), USYNC_THREAD,`
355			`NULL);`
356			`else`
357			`return 0;`
358			`}`
359
360			`/* Deallocate a condition. */`
361			`static inline int`
362			`__gthread_objc_condition_deallocate (objc_condition_t condition)`
363			`{`
364			`if (__gthread_active_p ())`
365			`return __gthrw_(cond_destroy) ((cond_t *) (&(condition->backend)));`
366			`else`
367			`return 0;`
368			`}`
369
370			`/* Wait on the condition */`
371			`static inline int`
372			`__gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)`
373			`{`
374			`if (__gthread_active_p ())`
375			`return __gthrw_(cond_wait) ((cond_t *) (&(condition->backend)),`
376			`(mutex_t *) (&(mutex->backend)));`
377			`else`
378			`return 0;`
379			`}`
380
381			`/* Wake up all threads waiting on this condition. */`
382			`static inline int`
383			`__gthread_objc_condition_broadcast (objc_condition_t condition)`
384			`{`
385			`if (__gthread_active_p ())`
386			`return __gthrw_(cond_broadcast) ((cond_t *) (&(condition->backend)));`
387			`else`
388			`return 0;`
389			`}`
390
391			`/* Wake up one thread waiting on this condition. */`
392			`static inline int`
393			`__gthread_objc_condition_signal (objc_condition_t condition)`
394			`{`
395			`if (__gthread_active_p ())`
396			`return __gthrw_(cond_signal) ((cond_t *) (&(condition->backend)));`
397			`else`
398			`return 0;`
399			`}`
400
401			`#else /* _LIBOBJC */`
402
403			`static inline int`
404			`__gthread_once (__gthread_once_t __once, void (__func) (void))`
405			`{`
406			`if (! __gthread_active_p ())`
407			`return -1;`
408
409			`if (__once == 0 \|\| __func == 0)`
410			`return EINVAL;`
411
412			`if (__once->once == 0)`
413			`{`
414			`int __status = __gthrw_(mutex_lock) (&__once->mutex);`
415			`if (__status != 0)`
416			`return __status;`
417			`if (__once->once == 0)`
418			`{`
419			`(*__func) ();`
420			`__once->once++;`
421			`}`
422			`__gthrw_(mutex_unlock) (&__once->mutex);`
423			`}`
424			`return 0;`
425			`}`
426
427			`static inline int`
428			`__gthread_key_create (__gthread_key_t __key, void (__dtor) (void *))`
429			`{`
430			`/* Solaris 2.5 contains thr_* routines no-op in libc, so test if we actually`
431			`got a reasonable key value, and if not, fail. */`
432			`*__key = (__gthread_key_t)-1;`
433			`if (__gthrw_(thr_keycreate) (__key, __dtor) != 0`
434			`\|\| *__key == (__gthread_key_t)-1)`
435			`return -1;`
436			`else`
437			`return 0;`
438			`}`
439
440			`static inline int`
441			`__gthread_key_delete (__gthread_key_t UNUSED (__key))`
442			`{`
443			`/* Not possible. */`
444			`return -1;`
445			`}`
446
447			`static inline void *`
448			`__gthread_getspecific (__gthread_key_t __key)`
449			`{`
450			`void *__ptr;`
451			`if (__gthrw_(thr_getspecific) (__key, &__ptr) == 0)`
452			`return __ptr;`
453			`else`
454			`return 0;`
455			`}`
456
457			`static inline int`
458			`__gthread_setspecific (__gthread_key_t __key, const void *__ptr)`
459			`{`
460			`return __gthrw_(thr_setspecific) (__key, (void *) __ptr);`
461			`}`
462
463			`static inline int`
464			`__gthread_mutex_destroy (__gthread_mutex_t *__mutex)`
465			`{`
466			`if (__gthread_active_p ())`
467			`return __gthrw_(mutex_destroy) (__mutex);`
468			`else`
469			`return 0;`
470			`}`
471
472			`static inline int`
473			`__gthread_mutex_lock (__gthread_mutex_t *__mutex)`
474			`{`
475			`if (__gthread_active_p ())`
476			`return __gthrw_(mutex_lock) (__mutex);`
477			`else`
478			`return 0;`
479			`}`
480
481			`static inline int`
482			`__gthread_mutex_trylock (__gthread_mutex_t *__mutex)`
483			`{`
484			`if (__gthread_active_p ())`
485			`return __gthrw_(mutex_trylock) (__mutex);`
486			`else`
487			`return 0;`
488			`}`
489
490			`static inline int`
491			`__gthread_mutex_unlock (__gthread_mutex_t *__mutex)`
492			`{`
493			`if (__gthread_active_p ())`
494			`return __gthrw_(mutex_unlock) (__mutex);`
495			`else`
496			`return 0;`
497			`}`
498
499			`static inline int`
500			`__gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)`
501			`{`
502			`__mutex->depth = 0;`
503			`__mutex->owner = (thread_t) 0;`
504			`return __gthrw_(mutex_init) (&__mutex->actual, USYNC_THREAD, 0);`
505			`}`
506
507			`static inline int`
508			`__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)`
509			`{`
510			`if (__gthread_active_p ())`
511			`{`
512			`thread_t __me = __gthrw_(thr_self) ();`
513
514			`if (__mutex->owner != __me)`
515			`{`
516			`__gthrw_(mutex_lock) (&__mutex->actual);`
517			`__mutex->owner = __me;`
518			`}`
519
520			`__mutex->depth++;`
521			`}`
522			`return 0;`
523			`}`
524
525			`static inline int`
526			`__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)`
527			`{`
528			`if (__gthread_active_p ())`
529			`{`
530			`thread_t __me = __gthrw_(thr_self) ();`
531
532			`if (__mutex->owner != __me)`
533			`{`
534			`if (__gthrw_(mutex_trylock) (&__mutex->actual))`
535			`return 1;`
536			`__mutex->owner = __me;`
537			`}`
538
539			`__mutex->depth++;`
540			`}`
541			`return 0;`
542			`}`
543
544			`static inline int`
545			`__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)`
546			`{`
547			`if (__gthread_active_p ())`
548			`{`
549			`if (--__mutex->depth == 0)`
550			`{`
551			`__mutex->owner = (thread_t) 0;`
552			`__gthrw_(mutex_unlock) (&__mutex->actual);`
553			`}`
554			`}`
555			`return 0;`
556			`}`
557
558			`#endif /* _LIBOBJC */`
559
560			`#undef UNUSED`
561
562			`#endif /* ! GCC_GTHR_SOLARIS_H */`