gcc/gthr-dce.h

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