gcc/gthr-solaris.h

   1 /* Threads compatibility routines for libgcc2 and libobjc.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1997, 1999, 2000, 2004, 2005, 2006, 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_SOLARIS_H
  28 #define GCC_GTHR_SOLARIS_H
  29
  30 /* Solaris threads as found in Solaris 2.[456].
  31    Actually these are Unix International (UI) threads, but I don't
  32    know if anyone else implements these.  */
  33
  34 #define __GTHREADS 1
  35
  36 #include <thread.h>
  37 #include <errno.h>
  38
  39 #ifdef __cplusplus
  40 #define UNUSED(x)
  41 #else
  42 #define UNUSED(x) x __attribute__((unused))
  43 #endif
  44
  45 typedef thread_key_t __gthread_key_t;
  46 typedef struct {
  47   mutex_t mutex;
  48   int once;
  49 } __gthread_once_t;
  50 typedef mutex_t __gthread_mutex_t;
  51
  52 typedef struct {
  53   long depth;
  54   thread_t owner;
  55   mutex_t actual;
  56 } __gthread_recursive_mutex_t;
  57
  58 #define __GTHREAD_ONCE_INIT { DEFAULTMUTEX, 0 }
  59 #define __GTHREAD_MUTEX_INIT DEFAULTMUTEX
  60 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
  61
  62 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
  63 # define __gthrw(name) \
  64   static __typeof(name) __gthrw_ ## name __attribute__ ((__weakref__(#name)));
  65 # define __gthrw_(name) __gthrw_ ## name
  66 #else
  67 # define __gthrw(name)
  68 # define __gthrw_(name) name
  69 #endif
  70
  71 __gthrw(thr_keycreate)
  72 __gthrw(thr_getspecific)
  73 __gthrw(thr_setspecific)
  74 __gthrw(thr_create)
  75 __gthrw(thr_self)
  76
  77 __gthrw(mutex_init)
  78 __gthrw(mutex_destroy)
  79 __gthrw(mutex_lock)
  80 __gthrw(mutex_trylock)
  81 __gthrw(mutex_unlock)
  82
  83 #ifdef _LIBOBJC
  84 __gthrw(thr_exit)
  85 __gthrw(thr_getprio)
  86 __gthrw(thr_setprio)
  87 __gthrw(thr_yield)
  88
  89 __gthrw(cond_init)
  90 __gthrw(cond_destroy)
  91 __gthrw(cond_wait)
  92 __gthrw(cond_broadcast)
  93 __gthrw(cond_signal)
  94
  95 #endif
  96
  97 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
  98
  99 /* This will not actually work in Solaris 2.5, since libc contains
 100    dummy symbols of all thr_* routines.  */
 101
 102 static inline int
 103 __gthread_active_p (void)
 104 {
 105   static void *const __gthread_active_ptr
 106     = __extension__ (void *) &__gthrw_(thr_create);
 107   return __gthread_active_ptr != 0;
 108 }
 109
 110 #else /* not SUPPORTS_WEAK */
 111
 112 static inline int
 113 __gthread_active_p (void)
 114 {
 115   return 1;
 116 }
 117
 118 #endif /* SUPPORTS_WEAK */
 119
 120 #ifdef _LIBOBJC
 121
 122 /* Key structure for maintaining thread specific storage */
 123 static thread_key_t _objc_thread_storage;
 124
 125 /* Thread local storage for a single thread */
 126 static void *thread_local_storage = NULL;
 127
 128 /* Backend initialization functions */
 129
 130 /* Initialize the threads subsystem.  */
 131 static inline int
 132 __gthread_objc_init_thread_system (void)
 133 {
 134   /* Initialize the thread storage key.  */
 135   if (__gthread_active_p ()
 136       && __gthrw_(thr_keycreate) (&_objc_thread_storage, NULL) == 0)
 137     return 0;
 138
 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   thread_t new_thread_id = 0;
 160
 161   if (!__gthread_active_p ())
 162     return NULL;
 163
 164   if (__gthrw_(thr_create) (NULL, 0, (void *) func, arg,
 165                   THR_DETACHED | THR_NEW_LWP,
 166                   &new_thread_id) == 0)
 167     thread_id = *(objc_thread_t *) &new_thread_id;
 168   else
 169     thread_id = NULL;
 170
 171   return thread_id;
 172 }
 173
 174 /* Set the current thread's priority.  */
 175 static inline int
 176 __gthread_objc_thread_set_priority (int priority)
 177 {
 178   int sys_priority = 0;
 179
 180   if (!__gthread_active_p ())
 181     return -1;
 182
 183   switch (priority)
 184     {
 185     case OBJC_THREAD_INTERACTIVE_PRIORITY:
 186       sys_priority = 300;
 187       break;
 188     default:
 189     case OBJC_THREAD_BACKGROUND_PRIORITY:
 190       sys_priority = 200;
 191       break;
 192     case OBJC_THREAD_LOW_PRIORITY:
 193       sys_priority = 1000;
 194       break;
 195     }
 196
 197   /* Change priority */
 198   if (__gthrw_(thr_setprio) (__gthrw_(thr_self) (), sys_priority) == 0)
 199     return 0;
 200   else
 201     return -1;
 202 }
 203
 204 /* Return the current thread's priority.  */
 205 static inline int
 206 __gthread_objc_thread_get_priority (void)
 207 {
 208   int sys_priority;
 209
 210   if (!__gthread_active_p ())
 211     return OBJC_THREAD_INTERACTIVE_PRIORITY;
 212
 213   if (__gthrw_(thr_getprio) (__gthrw_(thr_self) (), &sys_priority) == 0)
 214     {
 215       if (sys_priority >= 250)
 216         return OBJC_THREAD_INTERACTIVE_PRIORITY;
 217       else if (sys_priority >= 150)
 218         return OBJC_THREAD_BACKGROUND_PRIORITY;
 219       return OBJC_THREAD_LOW_PRIORITY;
 220     }
 221
 222   /* Couldn't get priority.  */
 223   return -1;
 224 }
 225
 226 /* Yield our process time to another thread.  */
 227 static inline void
 228 __gthread_objc_thread_yield (void)
 229 {
 230   if (__gthread_active_p ())
 231     __gthrw_(thr_yield) ();
 232 }
 233
 234 /* Terminate the current thread.  */
 235 static inline int
 236 __gthread_objc_thread_exit (void)
 237 {
 238   if (__gthread_active_p ())
 239     /* exit the thread */
 240     __gthrw_(thr_exit) (&__objc_thread_exit_status);
 241
 242   /* Failed if we reached here */
 243   return -1;
 244 }
 245
 246 /* Returns an integer value which uniquely describes a thread.  */
 247 static inline objc_thread_t
 248 __gthread_objc_thread_id (void)
 249 {
 250   if (__gthread_active_p ())
 251     return (objc_thread_t) __gthrw_(thr_self) ();
 252   else
 253     return (objc_thread_t) 1;
 254 }
 255
 256 /* Sets the thread's local storage pointer.  */
 257 static inline int
 258 __gthread_objc_thread_set_data (void *value)
 259 {
 260   if (__gthread_active_p ())
 261     {
 262       if (__gthrw_(thr_setspecific) (_objc_thread_storage, value) == 0)
 263         return 0;
 264       else
 265         return -1;
 266     }
 267   else
 268     {
 269       thread_local_storage = value;
 270       return 0;
 271     }
 272 }
 273
 274 /* Returns the thread's local storage pointer.  */
 275 static inline void *
 276 __gthread_objc_thread_get_data (void)
 277 {
 278   void *value = NULL;
 279
 280   if (__gthread_active_p ())
 281     {
 282       if (__gthrw_(thr_getspecific) (_objc_thread_storage, &value) == 0)
 283         return value;
 284       else
 285         return NULL;
 286     }
 287   else
 288     return thread_local_storage;
 289 }
 290
 291 /* Backend mutex functions */
 292
 293 /* Allocate a mutex.  */
 294 static inline int
 295 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
 296 {
 297   if (__gthread_active_p ()
 298       && __gthrw_(mutex_init) ((mutex_t *) (&(mutex->backend)), USYNC_THREAD, 0))
 299     return -1;
 300
 301   return 0;
 302 }
 303
 304 /* Deallocate a mutex.  */
 305 static inline int
 306 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
 307 {
 308   if (__gthread_active_p ())
 309     __gthrw_(mutex_destroy) ((mutex_t *) (&(mutex->backend)));
 310
 311   return 0;
 312 }
 313
 314 /* Grab a lock on a mutex.  */
 315 static inline int
 316 __gthread_objc_mutex_lock (objc_mutex_t mutex)
 317 {
 318   if (__gthread_active_p ()
 319       && __gthrw_(mutex_lock) ((mutex_t *) (&(mutex->backend))) != 0)
 320     return -1;
 321
 322   return 0;
 323 }
 324
 325 /* Try to grab a lock on a mutex.  */
 326 static inline int
 327 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
 328 {
 329   if (__gthread_active_p ()
 330       && __gthrw_(mutex_trylock) ((mutex_t *) (&(mutex->backend))) != 0)
 331     return -1;
 332
 333   return 0;
 334 }
 335
 336 /* Unlock the mutex */
 337 static inline int
 338 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
 339 {
 340   if (__gthread_active_p ()
 341       && __gthrw_(mutex_unlock) ((mutex_t *) (&(mutex->backend))) != 0)
 342     return -1;
 343
 344   return 0;
 345 }
 346
 347 /* Backend condition mutex functions */
 348
 349 /* Allocate a condition.  */
 350 static inline int
 351 __gthread_objc_condition_allocate (objc_condition_t condition)
 352 {
 353   if (__gthread_active_p ())
 354     return __gthrw_(cond_init) ((cond_t *) (&(condition->backend)), USYNC_THREAD,
 355                       NULL);
 356   else
 357     return 0;
 358 }
 359
 360 /* Deallocate a condition.  */
 361 static inline int
 362 __gthread_objc_condition_deallocate (objc_condition_t condition)
 363 {
 364   if (__gthread_active_p ())
 365     return __gthrw_(cond_destroy) ((cond_t *) (&(condition->backend)));
 366   else
 367     return 0;
 368 }
 369
 370 /* Wait on the condition */
 371 static inline int
 372 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 373 {
 374   if (__gthread_active_p ())
 375     return __gthrw_(cond_wait) ((cond_t *) (&(condition->backend)),
 376                       (mutex_t *) (&(mutex->backend)));
 377   else
 378     return 0;
 379 }
 380
 381 /* Wake up all threads waiting on this condition.  */
 382 static inline int
 383 __gthread_objc_condition_broadcast (objc_condition_t condition)
 384 {
 385   if (__gthread_active_p ())
 386     return __gthrw_(cond_broadcast) ((cond_t *) (&(condition->backend)));
 387   else
 388     return 0;
 389 }
 390
 391 /* Wake up one thread waiting on this condition.  */
 392 static inline int
 393 __gthread_objc_condition_signal (objc_condition_t condition)
 394 {
 395   if (__gthread_active_p ())
 396     return __gthrw_(cond_signal) ((cond_t *) (&(condition->backend)));
 397   else
 398     return 0;
 399 }
 400
 401 #else /* _LIBOBJC */
 402
 403 static inline int
 404 __gthread_once (__gthread_once_t *__once, void (*__func) (void))
 405 {
 406   if (! __gthread_active_p ())
 407     return -1;
 408
 409   if (__once == 0 || __func == 0)
 410     return EINVAL;
 411
 412   if (__once->once == 0)
 413     {
 414       int __status = __gthrw_(mutex_lock) (&__once->mutex);
 415       if (__status != 0)
 416         return __status;
 417       if (__once->once == 0)
 418         {
 419           (*__func) ();
 420           __once->once++;
 421         }
 422       __gthrw_(mutex_unlock) (&__once->mutex);
 423     }
 424   return 0;
 425 }
 426
 427 static inline int
 428 __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *))
 429 {
 430   /* Solaris 2.5 contains thr_* routines no-op in libc, so test if we actually
 431      got a reasonable key value, and if not, fail.  */
 432   *__key = (__gthread_key_t)-1;
 433   if (__gthrw_(thr_keycreate) (__key, __dtor) != 0
 434       || *__key == (__gthread_key_t)-1)
 435     return -1;
 436   else
 437     return 0;
 438 }
 439
 440 static inline int
 441 __gthread_key_delete (__gthread_key_t UNUSED (__key))
 442 {
 443   /* Not possible.  */
 444   return -1;
 445 }
 446
 447 static inline void *
 448 __gthread_getspecific (__gthread_key_t __key)
 449 {
 450   void *__ptr;
 451   if (__gthrw_(thr_getspecific) (__key, &__ptr) == 0)
 452     return __ptr;
 453   else
 454     return 0;
 455 }
 456
 457 static inline int
 458 __gthread_setspecific (__gthread_key_t __key, const void *__ptr)
 459 {
 460   return __gthrw_(thr_setspecific) (__key, (void *) __ptr);
 461 }
 462
 463 static inline int
 464 __gthread_mutex_destroy (__gthread_mutex_t *__mutex)
 465 {
 466   if (__gthread_active_p ())
 467     return __gthrw_(mutex_destroy) (__mutex);
 468   else
 469     return 0;
 470 }
 471
 472 static inline int
 473 __gthread_mutex_lock (__gthread_mutex_t *__mutex)
 474 {
 475   if (__gthread_active_p ())
 476     return __gthrw_(mutex_lock) (__mutex);
 477   else
 478     return 0;
 479 }
 480
 481 static inline int
 482 __gthread_mutex_trylock (__gthread_mutex_t *__mutex)
 483 {
 484   if (__gthread_active_p ())
 485     return __gthrw_(mutex_trylock) (__mutex);
 486   else
 487     return 0;
 488 }
 489
 490 static inline int
 491 __gthread_mutex_unlock (__gthread_mutex_t *__mutex)
 492 {
 493   if (__gthread_active_p ())
 494     return __gthrw_(mutex_unlock) (__mutex);
 495   else
 496     return 0;
 497 }
 498
 499 static inline int
 500 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex)
 501 {
 502   __mutex->depth = 0;
 503   __mutex->owner = (thread_t) 0;
 504   return __gthrw_(mutex_init) (&__mutex->actual, USYNC_THREAD, 0);
 505 }
 506
 507 static inline int
 508 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex)
 509 {
 510   if (__gthread_active_p ())
 511     {
 512       thread_t __me = __gthrw_(thr_self) ();
 513
 514       if (__mutex->owner != __me)
 515         {
 516           __gthrw_(mutex_lock) (&__mutex->actual);
 517           __mutex->owner = __me;
 518         }
 519
 520       __mutex->depth++;
 521     }
 522   return 0;
 523 }
 524
 525 static inline int
 526 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex)
 527 {
 528   if (__gthread_active_p ())
 529     {
 530       thread_t __me = __gthrw_(thr_self) ();
 531
 532       if (__mutex->owner != __me)
 533         {
 534           if (__gthrw_(mutex_trylock) (&__mutex->actual))
 535             return 1;
 536           __mutex->owner = __me;
 537         }
 538
 539       __mutex->depth++;
 540     }
 541   return 0;
 542 }
 543
 544 static inline int
 545 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex)
 546 {
 547   if (__gthread_active_p ())
 548     {
 549       if (--__mutex->depth == 0)
 550         {
 551            __mutex->owner = (thread_t) 0;
 552            __gthrw_(mutex_unlock) (&__mutex->actual);
 553         }
 554     }
 555   return 0;
 556 }
 557
 558 #endif /* _LIBOBJC */
 559
 560 #undef UNUSED
 561
 562 #endif /* ! GCC_GTHR_SOLARIS_H */