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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [gthr-dce.h] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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)
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
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
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
  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
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
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
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
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
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
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 *
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
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
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
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
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
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
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
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
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
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
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
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
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
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 *
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
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
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
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
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
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
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
525
__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
526
{
527
  return __gthread_mutex_lock (mutex);
528
}
529
 
530
static inline int
531
__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
532
{
533
  return __gthread_mutex_trylock (mutex);
534
}
535
 
536
static inline int
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 */

powered by: WebSVN 2.1.0

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