1 /* Threads compatibility routines for libgcc2 and libobjc. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1997, 1999, 2000, 2001, 2004, 2005
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 2, 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 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. */
22
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. */
29
30 #ifndef GCC_GTHR_DCE_H
31 #define GCC_GTHR_DCE_H
32
33 /* If _DCE_THREADS is not defined, then we're building the single
34 threaded version of the libraries and do not want to reference
35 anything related to pthreads or dce. */
36 #ifndef _DCE_THREADS
37 #include "gthr-single.h"
38 #else
39 /* DCE threads interface.
40 DCE threads are based on POSIX threads draft 4, and many things
41 have changed since then. */
42
43 #define __GTHREADS 1
44
45 #include <pthread.h>
46
47 typedef pthread_key_t __gthread_key_t;
48 typedef pthread_once_t __gthread_once_t;
49 typedef pthread_mutex_t __gthread_mutex_t;
50 typedef pthread_mutex_t __gthread_recursive_mutex_t;
51
52 #define __GTHREAD_ONCE_INIT pthread_once_init
53
54 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function
55 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
56
57 #define __GTHREAD_MUTEX_INIT_DEFAULT pthread_once_init
58
59 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
60 # define __gthrw(name) \
61 static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name)));
62 # define __gthrw_(name) __gthrw_ ## name
63 #else
64 # define __gthrw(name)
65 # define __gthrw_(name) name
66 #endif
67
68 __gthrw(pthread_once)
__gthrw(pthread_keycreate)69 __gthrw(pthread_keycreate)
70 __gthrw(pthread_getspecific)
71 __gthrw(pthread_setspecific)
72 __gthrw(pthread_create)
73 __gthrw(pthread_mutex_init)
74 __gthrw(pthread_mutex_lock)
75 __gthrw(pthread_mutex_trylock)
76 __gthrw(pthread_mutex_unlock)
77 __gthrw(pthread_mutexattr_create)
78 __gthrw(pthread_mutexattr_setkind_np)
79 __gthrw(pthread_mutexattr_delete)
80
81 #ifdef _LIBOBJC
82 /* Objective-C. */
83 __gthrw(pthread_cond_broadcast)
84 __gthrw(pthread_cond_destroy)
85 __gthrw(pthread_cond_init)
86 __gthrw(pthread_cond_signal)
87 __gthrw(pthread_cond_wait)
88 __gthrw(pthread_exit)
89
90 #ifdef pthread_getunique_np
91 # define __gthrw_pthread_getunique_np pthread_getunique_np
92 #else
93 __gthrw(pthread_getunique_np)
94 # define __gthrw_pthread_getunique_np __gthrw_(pthread_getunique_np)
95 #endif
96
97 __gthrw(pthread_mutex_destroy)
98 __gthrw(pthread_self)
99 __gthrw(pthread_yield)
100 #endif
101
102 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
103
104 static inline int
105 __gthread_active_p (void)
106 {
107 static void *const __gthread_active_ptr = (void *) &__gthrw_(pthread_create);
108 return __gthread_active_ptr != 0;
109 }
110
111 #else /* not SUPPORTS_WEAK */
112
113 static inline int
114 __gthread_active_p (void)
115 {
116 return 1;
117 }
118
119 #endif /* SUPPORTS_WEAK */
120
121 #ifdef _LIBOBJC
122
123 /* Key structure for maintaining thread specific storage */
124 static pthread_key_t _objc_thread_storage;
125
126 /* Thread local storage for a single thread */
127 static void *thread_local_storage = NULL;
128
129 /* Backend initialization functions */
130
131 /* Initialize the threads subsystem. */
132 static inline int
__gthread_objc_init_thread_system(void)133 __gthread_objc_init_thread_system (void)
134 {
135 if (__gthread_active_p ())
136 /* Initialize the thread storage key. */
137 return __gthrw_(pthread_keycreate) (&_objc_thread_storage, NULL);
138 else
139 return -1;
140 }
141
142 /* Close the threads subsystem. */
143 static inline int
__gthread_objc_close_thread_system(void)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
__gthread_objc_thread_detach(void (* func)(void *),void * arg)156 __gthread_objc_thread_detach (void (*func)(void *), void *arg)
157 {
158 objc_thread_t thread_id;
159 pthread_t new_thread_handle;
160
161 if (!__gthread_active_p ())
162 return NULL;
163
164 if (!(__gthrw_(pthread_create) (&new_thread_handle, pthread_attr_default,
165 (void *) func, arg)))
166 {
167 /* ??? May not work! (64bit) */
168 thread_id = *(objc_thread_t *) &new_thread_handle;
169 pthread_detach (&new_thread_handle); /* Fully detach thread. */
170 }
171 else
172 thread_id = NULL;
173
174 return thread_id;
175 }
176
177 /* Set the current thread's priority. */
178 static inline int
__gthread_objc_thread_set_priority(int priority)179 __gthread_objc_thread_set_priority (int priority)
180 {
181 int sys_priority = 0;
182
183 if (!__gthread_active_p ())
184 return -1;
185
186 switch (priority)
187 {
188 case OBJC_THREAD_INTERACTIVE_PRIORITY:
189 sys_priority = (PRI_FG_MIN_NP + PRI_FG_MAX_NP) / 2;
190 break;
191 default:
192 case OBJC_THREAD_BACKGROUND_PRIORITY:
193 sys_priority = (PRI_BG_MIN_NP + PRI_BG_MAX_NP) / 2;
194 break;
195 case OBJC_THREAD_LOW_PRIORITY:
196 sys_priority = (PRI_BG_MIN_NP + PRI_BG_MAX_NP) / 2;
197 break;
198 }
199
200 /* Change the priority. */
201 if (pthread_setprio (__gthrw_(pthread_self) (), sys_priority) >= 0)
202 return 0;
203 else
204 /* Failed */
205 return -1;
206 }
207
208 /* Return the current thread's priority. */
209 static inline int
__gthread_objc_thread_get_priority(void)210 __gthread_objc_thread_get_priority (void)
211 {
212 int sys_priority;
213
214 if (__gthread_active_p ())
215 {
216 if ((sys_priority = pthread_getprio (__gthrw_(pthread_self) ())) >= 0)
217 {
218 if (sys_priority >= PRI_FG_MIN_NP
219 && sys_priority <= PRI_FG_MAX_NP)
220 return OBJC_THREAD_INTERACTIVE_PRIORITY;
221 if (sys_priority >= PRI_BG_MIN_NP
222 && sys_priority <= PRI_BG_MAX_NP)
223 return OBJC_THREAD_BACKGROUND_PRIORITY;
224 return OBJC_THREAD_LOW_PRIORITY;
225 }
226
227 /* Failed */
228 return -1;
229 }
230 else
231 return OBJC_THREAD_INTERACTIVE_PRIORITY;
232 }
233
234 /* Yield our process time to another thread. */
235 static inline void
__gthread_objc_thread_yield(void)236 __gthread_objc_thread_yield (void)
237 {
238 if (__gthread_active_p ())
239 __gthrw_(pthread_yield) ();
240 }
241
242 /* Terminate the current thread. */
243 static inline int
__gthread_objc_thread_exit(void)244 __gthread_objc_thread_exit (void)
245 {
246 if (__gthread_active_p ())
247 /* exit the thread */
248 __gthrw_(pthread_exit) (&__objc_thread_exit_status);
249
250 /* Failed if we reached here */
251 return -1;
252 }
253
254 /* Returns an integer value which uniquely describes a thread. */
255 static inline objc_thread_t
__gthread_objc_thread_id(void)256 __gthread_objc_thread_id (void)
257 {
258 if (__gthread_active_p ())
259 {
260 pthread_t self = __gthrw_(pthread_self) ();
261
262 return (objc_thread_t) __gthrw_pthread_getunique_np (&self);
263 }
264 else
265 return (objc_thread_t) 1;
266 }
267
268 /* Sets the thread's local storage pointer. */
269 static inline int
__gthread_objc_thread_set_data(void * value)270 __gthread_objc_thread_set_data (void *value)
271 {
272 if (__gthread_active_p ())
273 return __gthrw_(pthread_setspecific) (_objc_thread_storage, value);
274 else
275 {
276 thread_local_storage = value;
277 return 0;
278 }
279 }
280
281 /* Returns the thread's local storage pointer. */
282 static inline void *
__gthread_objc_thread_get_data(void)283 __gthread_objc_thread_get_data (void)
284 {
285 void *value = NULL;
286
287 if (__gthread_active_p ())
288 {
289 if (!(__gthrw_(pthread_getspecific) (_objc_thread_storage, &value)))
290 return value;
291
292 return NULL;
293 }
294 else
295 return thread_local_storage;
296 }
297
298 /* Backend mutex functions */
299
300 /* Allocate a mutex. */
301 static inline int
__gthread_objc_mutex_allocate(objc_mutex_t mutex)302 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
303 {
304 if (__gthread_active_p ())
305 {
306 mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
307
308 if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend,
309 pthread_mutexattr_default))
310 {
311 objc_free (mutex->backend);
312 mutex->backend = NULL;
313 return -1;
314 }
315 }
316
317 return 0;
318 }
319
320 /* Deallocate a mutex. */
321 static inline int
__gthread_objc_mutex_deallocate(objc_mutex_t mutex)322 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
323 {
324 if (__gthread_active_p ())
325 {
326 if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend))
327 return -1;
328
329 objc_free (mutex->backend);
330 mutex->backend = NULL;
331 }
332
333 return 0;
334 }
335
336 /* Grab a lock on a mutex. */
337 static inline int
__gthread_objc_mutex_lock(objc_mutex_t mutex)338 __gthread_objc_mutex_lock (objc_mutex_t mutex)
339 {
340 if (__gthread_active_p ())
341 return __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend);
342 else
343 return 0;
344 }
345
346 /* Try to grab a lock on a mutex. */
347 static inline int
__gthread_objc_mutex_trylock(objc_mutex_t mutex)348 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
349 {
350 if (__gthread_active_p ()
351 && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 1)
352 return -1;
353
354 return 0;
355 }
356
357 /* Unlock the mutex */
358 static inline int
__gthread_objc_mutex_unlock(objc_mutex_t mutex)359 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
360 {
361 if (__gthread_active_p ())
362 return __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend);
363 else
364 return 0;
365 }
366
367 /* Backend condition mutex functions */
368
369 /* Allocate a condition. */
370 static inline int
__gthread_objc_condition_allocate(objc_condition_t condition)371 __gthread_objc_condition_allocate (objc_condition_t condition
372 __attribute__ ((__unused__)))
373 {
374 if (__gthread_active_p ())
375 /* Unimplemented. */
376 return -1;
377 else
378 return 0;
379 }
380
381 /* Deallocate a condition. */
382 static inline int
__gthread_objc_condition_deallocate(objc_condition_t condition)383 __gthread_objc_condition_deallocate (objc_condition_t condition
384 __attribute__ ((__unused__)))
385 {
386 if (__gthread_active_p ())
387 /* Unimplemented. */
388 return -1;
389 else
390 return 0;
391 }
392
393 /* Wait on the condition */
394 static inline int
__gthread_objc_condition_wait(objc_condition_t condition,objc_mutex_t mutex)395 __gthread_objc_condition_wait (objc_condition_t condition
396 __attribute__ ((__unused__)),
397 objc_mutex_t mutex __attribute__ ((__unused__)))
398 {
399 if (__gthread_active_p ())
400 /* Unimplemented. */
401 return -1;
402 else
403 return 0;
404 }
405
406 /* Wake up all threads waiting on this condition. */
407 static inline int
__gthread_objc_condition_broadcast(objc_condition_t condition)408 __gthread_objc_condition_broadcast (objc_condition_t condition
409 __attribute__ ((__unused__)))
410 {
411 if (__gthread_active_p ())
412 /* Unimplemented. */
413 return -1;
414 else
415 return 0;
416 }
417
418 /* Wake up one thread waiting on this condition. */
419 static inline int
__gthread_objc_condition_signal(objc_condition_t condition)420 __gthread_objc_condition_signal (objc_condition_t condition
421 __attribute__ ((__unused__)))
422 {
423 if (__gthread_active_p ())
424 /* Unimplemented. */
425 return -1;
426 else
427 return 0;
428 }
429
430 #else /* _LIBOBJC */
431
432 static inline int
__gthread_once(__gthread_once_t * once,void (* func)(void))433 __gthread_once (__gthread_once_t *once, void (*func) (void))
434 {
435 if (__gthread_active_p ())
436 return __gthrw_(pthread_once) (once, func);
437 else
438 return -1;
439 }
440
441 static inline int
__gthread_key_create(__gthread_key_t * key,void (* dtor)(void *))442 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
443 {
444 return __gthrw_(pthread_keycreate) (key, dtor);
445 }
446
447 static inline int
__gthread_key_delete(__gthread_key_t key)448 __gthread_key_delete (__gthread_key_t key __attribute__ ((__unused__)))
449 {
450 /* Operation is not supported. */
451 return -1;
452 }
453
454 static inline void *
__gthread_getspecific(__gthread_key_t key)455 __gthread_getspecific (__gthread_key_t key)
456 {
457 void *ptr;
458 if (__gthrw_(pthread_getspecific) (key, &ptr) == 0)
459 return ptr;
460 else
461 return 0;
462 }
463
464 static inline int
__gthread_setspecific(__gthread_key_t key,const void * ptr)465 __gthread_setspecific (__gthread_key_t key, const void *ptr)
466 {
467 return __gthrw_(pthread_setspecific) (key, (void *) ptr);
468 }
469
470 static inline void
__gthread_mutex_init_function(__gthread_mutex_t * mutex)471 __gthread_mutex_init_function (__gthread_mutex_t *mutex)
472 {
473 if (__gthread_active_p ())
474 __gthrw_(pthread_mutex_init) (mutex, pthread_mutexattr_default);
475 }
476
477 static inline int
__gthread_mutex_lock(__gthread_mutex_t * mutex)478 __gthread_mutex_lock (__gthread_mutex_t *mutex)
479 {
480 if (__gthread_active_p ())
481 return __gthrw_(pthread_mutex_lock) (mutex);
482 else
483 return 0;
484 }
485
486 static inline int
__gthread_mutex_trylock(__gthread_mutex_t * mutex)487 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
488 {
489 if (__gthread_active_p ())
490 return __gthrw_(pthread_mutex_trylock) (mutex);
491 else
492 return 0;
493 }
494
495 static inline int
__gthread_mutex_unlock(__gthread_mutex_t * mutex)496 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
497 {
498 if (__gthread_active_p ())
499 return __gthrw_(pthread_mutex_unlock) (mutex);
500 else
501 return 0;
502 }
503
504 static inline int
__gthread_recursive_mutex_init_function(__gthread_recursive_mutex_t * mutex)505 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
506 {
507 if (__gthread_active_p ())
508 {
509 pthread_mutexattr_t attr;
510 int r;
511
512 r = __gthrw_(pthread_mutexattr_create) (&attr);
513 if (!r)
514 r = __gthrw_(pthread_mutexattr_setkind_np) (&attr, MUTEX_RECURSIVE_NP);
515 if (!r)
516 r = __gthrw_(pthread_mutex_init) (mutex, attr);
517 if (!r)
518 r = __gthrw_(pthread_mutexattr_delete) (&attr);
519 return r;
520 }
521 return 0;
522 }
523
524 static inline int
__gthread_recursive_mutex_lock(__gthread_recursive_mutex_t * mutex)525 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
526 {
527 return __gthread_mutex_lock (mutex);
528 }
529
530 static inline int
__gthread_recursive_mutex_trylock(__gthread_recursive_mutex_t * mutex)531 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
532 {
533 return __gthread_mutex_trylock (mutex);
534 }
535
536 static inline int
__gthread_recursive_mutex_unlock(__gthread_recursive_mutex_t * mutex)537 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
538 {
539 return __gthread_mutex_unlock (mutex);
540 }
541
542 #endif /* _LIBOBJC */
543
544 #endif
545 #endif /* ! GCC_GTHR_DCE_H */
546