* config/xtensa/lib1funcs.asm (__umulsidi3): Restore a12-a15 on exit.
[official-gcc.git] / gcc / gthr-posix.h
blobfb58be94ea6ab15425f5a643a50e7c4084028411
1 /* Threads compatibility routines for libgcc2 and libobjc. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
4 Free Software Foundation, Inc.
6 This file is part of GCC.
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 2, or (at your option) any later
11 version.
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.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* As a special exception, if you link this library with other files,
24 some of which are compiled with GCC, to produce an executable,
25 this library does not by itself cause the resulting executable
26 to be covered by the GNU General Public License.
27 This exception does not however invalidate any other reasons why
28 the executable file might be covered by the GNU General Public License. */
30 #ifndef GCC_GTHR_POSIX_H
31 #define GCC_GTHR_POSIX_H
33 /* POSIX threads specific definitions.
34 Easy, since the interface is just one-to-one mapping. */
36 #define __GTHREADS 1
38 /* Some implementations of <pthread.h> require this to be defined. */
39 #ifndef _REENTRANT
40 #define _REENTRANT 1
41 #endif
43 #include <pthread.h>
44 #include <unistd.h>
46 typedef pthread_key_t __gthread_key_t;
47 typedef pthread_once_t __gthread_once_t;
48 typedef pthread_mutex_t __gthread_mutex_t;
49 typedef pthread_mutex_t __gthread_recursive_mutex_t;
51 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
52 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
53 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
54 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER
55 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
56 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
57 #else
58 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
59 #endif
61 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
62 # define __gthrw2(name,name2,type) \
63 static __typeof(type) name __attribute__ ((__weakref__(#name2)));
64 # define __gthrw_(name) __gthrw_ ## name
65 #else
66 # define __gthrw2(name,name2,type)
67 # define __gthrw_(name) name
68 #endif
70 /* Typically, __gthrw_foo is a weak reference to symbol foo. */
71 #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
73 /* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to
74 map a subset of the POSIX pthread API to mangled versions of their
75 names. */
76 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
77 #define __gthrw3(name) __gthrw2(__gthrw_ ## name, __ ## name, name)
78 __gthrw3(pthread_once)
79 __gthrw3(pthread_getspecific)
80 __gthrw3(pthread_setspecific)
81 __gthrw3(pthread_create)
82 __gthrw3(pthread_cancel)
83 __gthrw3(pthread_mutex_lock)
84 __gthrw3(pthread_mutex_trylock)
85 __gthrw3(pthread_mutex_unlock)
86 __gthrw3(pthread_mutex_init)
87 #else
88 __gthrw(pthread_once)
89 __gthrw(pthread_getspecific)
90 __gthrw(pthread_setspecific)
91 __gthrw(pthread_create)
92 __gthrw(pthread_cancel)
93 __gthrw(pthread_mutex_lock)
94 __gthrw(pthread_mutex_trylock)
95 __gthrw(pthread_mutex_unlock)
96 __gthrw(pthread_mutex_init)
97 #endif
99 __gthrw(pthread_key_create)
100 __gthrw(pthread_key_delete)
101 __gthrw(pthread_mutexattr_init)
102 __gthrw(pthread_mutexattr_settype)
103 __gthrw(pthread_mutexattr_destroy)
106 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
107 /* Objective-C. */
108 #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
109 __gthrw3(pthread_cond_broadcast)
110 __gthrw3(pthread_cond_destroy)
111 __gthrw3(pthread_cond_init)
112 __gthrw3(pthread_cond_signal)
113 __gthrw3(pthread_cond_wait)
114 __gthrw3(pthread_exit)
115 __gthrw3(pthread_mutex_destroy)
116 __gthrw3(pthread_self)
117 #else
118 __gthrw(pthread_cond_broadcast)
119 __gthrw(pthread_cond_destroy)
120 __gthrw(pthread_cond_init)
121 __gthrw(pthread_cond_signal)
122 __gthrw(pthread_cond_wait)
123 __gthrw(pthread_exit)
124 __gthrw(pthread_mutex_destroy)
125 __gthrw(pthread_self)
126 #endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */
127 #ifdef _POSIX_PRIORITY_SCHEDULING
128 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
129 __gthrw(sched_get_priority_max)
130 __gthrw(sched_get_priority_min)
131 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
132 #endif /* _POSIX_PRIORITY_SCHEDULING */
133 __gthrw(sched_yield)
134 __gthrw(pthread_attr_destroy)
135 __gthrw(pthread_attr_init)
136 __gthrw(pthread_attr_setdetachstate)
137 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
138 __gthrw(pthread_getschedparam)
139 __gthrw(pthread_setschedparam)
140 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
141 #endif /* _LIBOBJC || _LIBOBJC_WEAK */
143 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
145 /* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if
146 -pthreads is not specified. The functions are dummies and most return an
147 error value. However pthread_once returns 0 without invoking the routine
148 it is passed so we cannot pretend that the interface is active if -pthreads
149 is not specified. On Solaris 2.5.1, the interface is not exposed at all so
150 we need to play the usual game with weak symbols. On Solaris 10 and up, a
151 working interface is always exposed. */
153 #if defined(__sun) && defined(__svr4__)
155 static volatile int __gthread_active = -1;
157 static void
158 __gthread_trigger (void)
160 __gthread_active = 1;
163 static inline int
164 __gthread_active_p (void)
166 static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER;
167 static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT;
169 /* Avoid reading __gthread_active twice on the main code path. */
170 int __gthread_active_latest_value = __gthread_active;
172 /* This test is not protected to avoid taking a lock on the main code
173 path so every update of __gthread_active in a threaded program must
174 be atomic with regard to the result of the test. */
175 if (__builtin_expect (__gthread_active_latest_value < 0, 0))
177 if (__gthrw_(pthread_once))
179 /* If this really is a threaded program, then we must ensure that
180 __gthread_active has been set to 1 before exiting this block. */
181 __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex);
182 __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger);
183 __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
186 /* Make sure we'll never enter this block again. */
187 if (__gthread_active < 0)
188 __gthread_active = 0;
190 __gthread_active_latest_value = __gthread_active;
193 return __gthread_active_latest_value != 0;
196 #else /* not Solaris */
198 static inline int
199 __gthread_active_p (void)
201 static void *const __gthread_active_ptr
202 = __extension__ (void *) &__gthrw_(pthread_cancel);
203 return __gthread_active_ptr != 0;
206 #endif /* Solaris */
208 #else /* not SUPPORTS_WEAK */
210 static inline int
211 __gthread_active_p (void)
213 return 1;
216 #endif /* SUPPORTS_WEAK */
218 #ifdef _LIBOBJC
220 /* This is the config.h file in libobjc/ */
221 #include <config.h>
223 #ifdef HAVE_SCHED_H
224 # include <sched.h>
225 #endif
227 /* Key structure for maintaining thread specific storage */
228 static pthread_key_t _objc_thread_storage;
229 static pthread_attr_t _objc_thread_attribs;
231 /* Thread local storage for a single thread */
232 static void *thread_local_storage = NULL;
234 /* Backend initialization functions */
236 /* Initialize the threads subsystem. */
237 static inline int
238 __gthread_objc_init_thread_system (void)
240 if (__gthread_active_p ())
242 /* Initialize the thread storage key. */
243 if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0)
245 /* The normal default detach state for threads is
246 * PTHREAD_CREATE_JOINABLE which causes threads to not die
247 * when you think they should. */
248 if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0
249 && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs,
250 PTHREAD_CREATE_DETACHED) == 0)
251 return 0;
255 return -1;
258 /* Close the threads subsystem. */
259 static inline int
260 __gthread_objc_close_thread_system (void)
262 if (__gthread_active_p ()
263 && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0
264 && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0)
265 return 0;
267 return -1;
270 /* Backend thread functions */
272 /* Create a new thread of execution. */
273 static inline objc_thread_t
274 __gthread_objc_thread_detach (void (*func)(void *), void *arg)
276 objc_thread_t thread_id;
277 pthread_t new_thread_handle;
279 if (!__gthread_active_p ())
280 return NULL;
282 if (!(__gthrw_(pthread_create) (&new_thread_handle, NULL, (void *) func, arg)))
283 thread_id = (objc_thread_t) new_thread_handle;
284 else
285 thread_id = NULL;
287 return thread_id;
290 /* Set the current thread's priority. */
291 static inline int
292 __gthread_objc_thread_set_priority (int priority)
294 if (!__gthread_active_p ())
295 return -1;
296 else
298 #ifdef _POSIX_PRIORITY_SCHEDULING
299 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
300 pthread_t thread_id = __gthrw_(pthread_self) ();
301 int policy;
302 struct sched_param params;
303 int priority_min, priority_max;
305 if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0)
307 if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1)
308 return -1;
310 if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1)
311 return -1;
313 if (priority > priority_max)
314 priority = priority_max;
315 else if (priority < priority_min)
316 priority = priority_min;
317 params.sched_priority = priority;
320 * The solaris 7 and several other man pages incorrectly state that
321 * this should be a pointer to policy but pthread.h is universally
322 * at odds with this.
324 if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0)
325 return 0;
327 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
328 #endif /* _POSIX_PRIORITY_SCHEDULING */
329 return -1;
333 /* Return the current thread's priority. */
334 static inline int
335 __gthread_objc_thread_get_priority (void)
337 #ifdef _POSIX_PRIORITY_SCHEDULING
338 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
339 if (__gthread_active_p ())
341 int policy;
342 struct sched_param params;
344 if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, &params) == 0)
345 return params.sched_priority;
346 else
347 return -1;
349 else
350 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
351 #endif /* _POSIX_PRIORITY_SCHEDULING */
352 return OBJC_THREAD_INTERACTIVE_PRIORITY;
355 /* Yield our process time to another thread. */
356 static inline void
357 __gthread_objc_thread_yield (void)
359 if (__gthread_active_p ())
360 __gthrw_(sched_yield) ();
363 /* Terminate the current thread. */
364 static inline int
365 __gthread_objc_thread_exit (void)
367 if (__gthread_active_p ())
368 /* exit the thread */
369 __gthrw_(pthread_exit) (&__objc_thread_exit_status);
371 /* Failed if we reached here */
372 return -1;
375 /* Returns an integer value which uniquely describes a thread. */
376 static inline objc_thread_t
377 __gthread_objc_thread_id (void)
379 if (__gthread_active_p ())
380 return (objc_thread_t) __gthrw_(pthread_self) ();
381 else
382 return (objc_thread_t) 1;
385 /* Sets the thread's local storage pointer. */
386 static inline int
387 __gthread_objc_thread_set_data (void *value)
389 if (__gthread_active_p ())
390 return __gthrw_(pthread_setspecific) (_objc_thread_storage, value);
391 else
393 thread_local_storage = value;
394 return 0;
398 /* Returns the thread's local storage pointer. */
399 static inline void *
400 __gthread_objc_thread_get_data (void)
402 if (__gthread_active_p ())
403 return __gthrw_(pthread_getspecific) (_objc_thread_storage);
404 else
405 return thread_local_storage;
408 /* Backend mutex functions */
410 /* Allocate a mutex. */
411 static inline int
412 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
414 if (__gthread_active_p ())
416 mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
418 if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL))
420 objc_free (mutex->backend);
421 mutex->backend = NULL;
422 return -1;
426 return 0;
429 /* Deallocate a mutex. */
430 static inline int
431 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
433 if (__gthread_active_p ())
435 int count;
438 * Posix Threads specifically require that the thread be unlocked
439 * for __gthrw_(pthread_mutex_destroy) to work.
444 count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend);
445 if (count < 0)
446 return -1;
448 while (count);
450 if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend))
451 return -1;
453 objc_free (mutex->backend);
454 mutex->backend = NULL;
456 return 0;
459 /* Grab a lock on a mutex. */
460 static inline int
461 __gthread_objc_mutex_lock (objc_mutex_t mutex)
463 if (__gthread_active_p ()
464 && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0)
466 return -1;
469 return 0;
472 /* Try to grab a lock on a mutex. */
473 static inline int
474 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
476 if (__gthread_active_p ()
477 && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0)
479 return -1;
482 return 0;
485 /* Unlock the mutex */
486 static inline int
487 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
489 if (__gthread_active_p ()
490 && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0)
492 return -1;
495 return 0;
498 /* Backend condition mutex functions */
500 /* Allocate a condition. */
501 static inline int
502 __gthread_objc_condition_allocate (objc_condition_t condition)
504 if (__gthread_active_p ())
506 condition->backend = objc_malloc (sizeof (pthread_cond_t));
508 if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL))
510 objc_free (condition->backend);
511 condition->backend = NULL;
512 return -1;
516 return 0;
519 /* Deallocate a condition. */
520 static inline int
521 __gthread_objc_condition_deallocate (objc_condition_t condition)
523 if (__gthread_active_p ())
525 if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend))
526 return -1;
528 objc_free (condition->backend);
529 condition->backend = NULL;
531 return 0;
534 /* Wait on the condition */
535 static inline int
536 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
538 if (__gthread_active_p ())
539 return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend,
540 (pthread_mutex_t *) mutex->backend);
541 else
542 return 0;
545 /* Wake up all threads waiting on this condition. */
546 static inline int
547 __gthread_objc_condition_broadcast (objc_condition_t condition)
549 if (__gthread_active_p ())
550 return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend);
551 else
552 return 0;
555 /* Wake up one thread waiting on this condition. */
556 static inline int
557 __gthread_objc_condition_signal (objc_condition_t condition)
559 if (__gthread_active_p ())
560 return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend);
561 else
562 return 0;
565 #else /* _LIBOBJC */
567 static inline int
568 __gthread_once (__gthread_once_t *once, void (*func) (void))
570 if (__gthread_active_p ())
571 return __gthrw_(pthread_once) (once, func);
572 else
573 return -1;
576 static inline int
577 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
579 return __gthrw_(pthread_key_create) (key, dtor);
582 static inline int
583 __gthread_key_delete (__gthread_key_t key)
585 return __gthrw_(pthread_key_delete) (key);
588 static inline void *
589 __gthread_getspecific (__gthread_key_t key)
591 return __gthrw_(pthread_getspecific) (key);
594 static inline int
595 __gthread_setspecific (__gthread_key_t key, const void *ptr)
597 return __gthrw_(pthread_setspecific) (key, ptr);
600 static inline int
601 __gthread_mutex_lock (__gthread_mutex_t *mutex)
603 if (__gthread_active_p ())
604 return __gthrw_(pthread_mutex_lock) (mutex);
605 else
606 return 0;
609 static inline int
610 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
612 if (__gthread_active_p ())
613 return __gthrw_(pthread_mutex_trylock) (mutex);
614 else
615 return 0;
618 static inline int
619 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
621 if (__gthread_active_p ())
622 return __gthrw_(pthread_mutex_unlock) (mutex);
623 else
624 return 0;
627 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
628 static inline int
629 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
631 if (__gthread_active_p ())
633 pthread_mutexattr_t attr;
634 int r;
636 r = __gthrw_(pthread_mutexattr_init) (&attr);
637 if (!r)
638 r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE);
639 if (!r)
640 r = __gthrw_(pthread_mutex_init) (mutex, &attr);
641 if (!r)
642 r = __gthrw_(pthread_mutexattr_destroy) (&attr);
643 return r;
645 return 0;
647 #endif
649 static inline int
650 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
652 return __gthread_mutex_lock (mutex);
655 static inline int
656 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
658 return __gthread_mutex_trylock (mutex);
661 static inline int
662 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
664 return __gthread_mutex_unlock (mutex);
667 #endif /* _LIBOBJC */
669 #endif /* ! GCC_GTHR_POSIX_H */