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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.