gcc/gthr-posix.h

   1 /* Threads compatibility routines for libgcc2 and libobjc.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 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, 59 Temple Place - Suite 330, Boston, MA
  21 02111-1307, 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_POSIX_H
  31 #define GCC_GTHR_POSIX_H
  32
  33 /* POSIX threads specific definitions.
  34    Easy, since the interface is just one-to-one mapping.  */
  35
  36 #define __GTHREADS 1
  37
  38 /* Some implementations of <pthread.h> require this to be defined.  */
  39 #ifndef _REENTRANT
  40 #define _REENTRANT 1
  41 #endif
  42
  43 #include <pthread.h>
  44 #include <unistd.h>
  45
  46 typedef pthread_key_t __gthread_key_t;
  47 typedef pthread_once_t __gthread_once_t;
  48 typedef pthread_mutex_t __gthread_mutex_t;
  49 typedef pthread_mutex_t __gthread_recursive_mutex_t;
  50
  51 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
  52 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
  53 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
  54 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER
  55 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
  56 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
  57 #else
  58 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
  59 #endif
  60
  61 #if SUPPORTS_WEAK && GTHREAD_USE_WEAK
  62
  63 #pragma weak pthread_once
  64 #pragma weak pthread_key_create
  65 #pragma weak pthread_key_delete
  66 #pragma weak pthread_getspecific
  67 #pragma weak pthread_setspecific
  68 #pragma weak pthread_create
  69 #pragma weak pthread_cancel
  70
  71 #pragma weak pthread_mutex_lock
  72 #pragma weak pthread_mutex_trylock
  73 #pragma weak pthread_mutex_unlock
  74 #pragma weak pthread_mutexattr_init
  75 #pragma weak pthread_mutexattr_settype
  76 #pragma weak pthread_mutexattr_destroy
  77
  78 #pragma weak pthread_mutex_init
  79
  80 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
  81 /* Objective-C.  */
  82 #pragma weak pthread_cond_broadcast
  83 #pragma weak pthread_cond_destroy
  84 #pragma weak pthread_cond_init
  85 #pragma weak pthread_cond_signal
  86 #pragma weak pthread_cond_wait
  87 #pragma weak pthread_exit
  88 #pragma weak pthread_mutex_destroy
  89 #pragma weak pthread_self
  90 #ifdef _POSIX_PRIORITY_SCHEDULING
  91 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
  92 #pragma weak sched_get_priority_max
  93 #pragma weak sched_get_priority_min
  94 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
  95 #endif /* _POSIX_PRIORITY_SCHEDULING */
  96 #pragma weak sched_yield
  97 #pragma weak pthread_attr_destroy
  98 #pragma weak pthread_attr_init
  99 #pragma weak pthread_attr_setdetachstate
 100 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 101 #pragma weak pthread_getschedparam
 102 #pragma weak pthread_setschedparam
 103 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 104 #endif /* _LIBOBJC || _LIBOBJC_WEAK */
 105
 106 static inline int
 107 __gthread_active_p (void)
 108 {
 109   static void *const __gthread_active_ptr
 110     = __extension__ (void *) &pthread_cancel;
 111   return __gthread_active_ptr != 0;
 112 }
 113
 114 #else /* not SUPPORTS_WEAK */
 115
 116 static inline int
 117 __gthread_active_p (void)
 118 {
 119   return 1;
 120 }
 121
 122 #endif /* SUPPORTS_WEAK */
 123
 124 #ifdef _LIBOBJC
 125
 126 /* This is the config.h file in libobjc/ */
 127 #include <config.h>
 128
 129 #ifdef HAVE_SCHED_H
 130 # include <sched.h>
 131 #endif
 132
 133 /* Key structure for maintaining thread specific storage */
 134 static pthread_key_t _objc_thread_storage;
 135 static pthread_attr_t _objc_thread_attribs;
 136
 137 /* Thread local storage for a single thread */
 138 static void *thread_local_storage = NULL;
 139
 140 /* Backend initialization functions */
 141
 142 /* Initialize the threads subsystem.  */
 143 static inline int
 144 __gthread_objc_init_thread_system (void)
 145 {
 146   if (__gthread_active_p ())
 147     {
 148       /* Initialize the thread storage key.  */
 149       if (pthread_key_create (&_objc_thread_storage, NULL) == 0)
 150         {
 151           /* The normal default detach state for threads is
 152            * PTHREAD_CREATE_JOINABLE which causes threads to not die
 153            * when you think they should.  */
 154           if (pthread_attr_init (&_objc_thread_attribs) == 0
 155               && pthread_attr_setdetachstate (&_objc_thread_attribs,
 156                                               PTHREAD_CREATE_DETACHED) == 0)
 157             return 0;
 158         }
 159     }
 160
 161   return -1;
 162 }
 163
 164 /* Close the threads subsystem.  */
 165 static inline int
 166 __gthread_objc_close_thread_system (void)
 167 {
 168   if (__gthread_active_p ()
 169       && pthread_key_delete (_objc_thread_storage) == 0
 170       && pthread_attr_destroy (&_objc_thread_attribs) == 0)
 171     return 0;
 172
 173   return -1;
 174 }
 175
 176 /* Backend thread functions */
 177
 178 /* Create a new thread of execution.  */
 179 static inline objc_thread_t
 180 __gthread_objc_thread_detach (void (*func)(void *), void *arg)
 181 {
 182   objc_thread_t thread_id;
 183   pthread_t new_thread_handle;
 184
 185   if (!__gthread_active_p ())
 186     return NULL;
 187
 188   if (!(pthread_create (&new_thread_handle, NULL, (void *) func, arg)))
 189     thread_id = (objc_thread_t) new_thread_handle;
 190   else
 191     thread_id = NULL;
 192
 193   return thread_id;
 194 }
 195
 196 /* Set the current thread's priority.  */
 197 static inline int
 198 __gthread_objc_thread_set_priority (int priority)
 199 {
 200   if (!__gthread_active_p ())
 201     return -1;
 202   else
 203     {
 204 #ifdef _POSIX_PRIORITY_SCHEDULING
 205 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 206       pthread_t thread_id = pthread_self ();
 207       int policy;
 208       struct sched_param params;
 209       int priority_min, priority_max;
 210
 211       if (pthread_getschedparam (thread_id, &policy, &params) == 0)
 212         {
 213           if ((priority_max = sched_get_priority_max (policy)) == -1)
 214             return -1;
 215
 216           if ((priority_min = sched_get_priority_min (policy)) == -1)
 217             return -1;
 218
 219           if (priority > priority_max)
 220             priority = priority_max;
 221           else if (priority < priority_min)
 222             priority = priority_min;
 223           params.sched_priority = priority;
 224
 225           /*
 226            * The solaris 7 and several other man pages incorrectly state that
 227            * this should be a pointer to policy but pthread.h is universally
 228            * at odds with this.
 229            */
 230           if (pthread_setschedparam (thread_id, policy, &params) == 0)
 231             return 0;
 232         }
 233 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 234 #endif /* _POSIX_PRIORITY_SCHEDULING */
 235       return -1;
 236     }
 237 }
 238
 239 /* Return the current thread's priority.  */
 240 static inline int
 241 __gthread_objc_thread_get_priority (void)
 242 {
 243 #ifdef _POSIX_PRIORITY_SCHEDULING
 244 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
 245   if (__gthread_active_p ())
 246     {
 247       int policy;
 248       struct sched_param params;
 249
 250       if (pthread_getschedparam (pthread_self (), &policy, &params) == 0)
 251         return params.sched_priority;
 252       else
 253         return -1;
 254     }
 255   else
 256 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
 257 #endif /* _POSIX_PRIORITY_SCHEDULING */
 258     return OBJC_THREAD_INTERACTIVE_PRIORITY;
 259 }
 260
 261 /* Yield our process time to another thread.  */
 262 static inline void
 263 __gthread_objc_thread_yield (void)
 264 {
 265   if (__gthread_active_p ())
 266     sched_yield ();
 267 }
 268
 269 /* Terminate the current thread.  */
 270 static inline int
 271 __gthread_objc_thread_exit (void)
 272 {
 273   if (__gthread_active_p ())
 274     /* exit the thread */
 275     pthread_exit (&__objc_thread_exit_status);
 276
 277   /* Failed if we reached here */
 278   return -1;
 279 }
 280
 281 /* Returns an integer value which uniquely describes a thread.  */
 282 static inline objc_thread_t
 283 __gthread_objc_thread_id (void)
 284 {
 285   if (__gthread_active_p ())
 286     return (objc_thread_t) pthread_self ();
 287   else
 288     return (objc_thread_t) 1;
 289 }
 290
 291 /* Sets the thread's local storage pointer.  */
 292 static inline int
 293 __gthread_objc_thread_set_data (void *value)
 294 {
 295   if (__gthread_active_p ())
 296     return pthread_setspecific (_objc_thread_storage, value);
 297   else
 298     {
 299       thread_local_storage = value;
 300       return 0;
 301     }
 302 }
 303
 304 /* Returns the thread's local storage pointer.  */
 305 static inline void *
 306 __gthread_objc_thread_get_data (void)
 307 {
 308   if (__gthread_active_p ())
 309     return pthread_getspecific (_objc_thread_storage);
 310   else
 311     return thread_local_storage;
 312 }
 313
 314 /* Backend mutex functions */
 315
 316 /* Allocate a mutex.  */
 317 static inline int
 318 __gthread_objc_mutex_allocate (objc_mutex_t mutex)
 319 {
 320   if (__gthread_active_p ())
 321     {
 322       mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
 323
 324       if (pthread_mutex_init ((pthread_mutex_t *) mutex->backend, NULL))
 325         {
 326           objc_free (mutex->backend);
 327           mutex->backend = NULL;
 328           return -1;
 329         }
 330     }
 331
 332   return 0;
 333 }
 334
 335 /* Deallocate a mutex.  */
 336 static inline int
 337 __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
 338 {
 339   if (__gthread_active_p ())
 340     {
 341       int count;
 342
 343       /*
 344        * Posix Threads specifically require that the thread be unlocked
 345        * for pthread_mutex_destroy to work.
 346        */
 347
 348       do
 349         {
 350           count = pthread_mutex_unlock ((pthread_mutex_t *) mutex->backend);
 351           if (count < 0)
 352             return -1;
 353         }
 354       while (count);
 355
 356       if (pthread_mutex_destroy ((pthread_mutex_t *) mutex->backend))
 357         return -1;
 358
 359       objc_free (mutex->backend);
 360       mutex->backend = NULL;
 361     }
 362   return 0;
 363 }
 364
 365 /* Grab a lock on a mutex.  */
 366 static inline int
 367 __gthread_objc_mutex_lock (objc_mutex_t mutex)
 368 {
 369   if (__gthread_active_p ()
 370       && pthread_mutex_lock ((pthread_mutex_t *) mutex->backend) != 0)
 371     {
 372       return -1;
 373     }
 374
 375   return 0;
 376 }
 377
 378 /* Try to grab a lock on a mutex.  */
 379 static inline int
 380 __gthread_objc_mutex_trylock (objc_mutex_t mutex)
 381 {
 382   if (__gthread_active_p ()
 383       && pthread_mutex_trylock ((pthread_mutex_t *) mutex->backend) != 0)
 384     {
 385       return -1;
 386     }
 387
 388   return 0;
 389 }
 390
 391 /* Unlock the mutex */
 392 static inline int
 393 __gthread_objc_mutex_unlock (objc_mutex_t mutex)
 394 {
 395   if (__gthread_active_p ()
 396       && pthread_mutex_unlock ((pthread_mutex_t *) mutex->backend) != 0)
 397     {
 398       return -1;
 399     }
 400
 401   return 0;
 402 }
 403
 404 /* Backend condition mutex functions */
 405
 406 /* Allocate a condition.  */
 407 static inline int
 408 __gthread_objc_condition_allocate (objc_condition_t condition)
 409 {
 410   if (__gthread_active_p ())
 411     {
 412       condition->backend = objc_malloc (sizeof (pthread_cond_t));
 413
 414       if (pthread_cond_init ((pthread_cond_t *) condition->backend, NULL))
 415         {
 416           objc_free (condition->backend);
 417           condition->backend = NULL;
 418           return -1;
 419         }
 420     }
 421
 422   return 0;
 423 }
 424
 425 /* Deallocate a condition.  */
 426 static inline int
 427 __gthread_objc_condition_deallocate (objc_condition_t condition)
 428 {
 429   if (__gthread_active_p ())
 430     {
 431       if (pthread_cond_destroy ((pthread_cond_t *) condition->backend))
 432         return -1;
 433
 434       objc_free (condition->backend);
 435       condition->backend = NULL;
 436     }
 437   return 0;
 438 }
 439
 440 /* Wait on the condition */
 441 static inline int
 442 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
 443 {
 444   if (__gthread_active_p ())
 445     return pthread_cond_wait ((pthread_cond_t *) condition->backend,
 446                               (pthread_mutex_t *) mutex->backend);
 447   else
 448     return 0;
 449 }
 450
 451 /* Wake up all threads waiting on this condition.  */
 452 static inline int
 453 __gthread_objc_condition_broadcast (objc_condition_t condition)
 454 {
 455   if (__gthread_active_p ())
 456     return pthread_cond_broadcast ((pthread_cond_t *) condition->backend);
 457   else
 458     return 0;
 459 }
 460
 461 /* Wake up one thread waiting on this condition.  */
 462 static inline int
 463 __gthread_objc_condition_signal (objc_condition_t condition)
 464 {
 465   if (__gthread_active_p ())
 466     return pthread_cond_signal ((pthread_cond_t *) condition->backend);
 467   else
 468     return 0;
 469 }
 470
 471 #else /* _LIBOBJC */
 472
 473 static inline int
 474 __gthread_once (__gthread_once_t *once, void (*func) (void))
 475 {
 476   if (__gthread_active_p ())
 477     return pthread_once (once, func);
 478   else
 479     return -1;
 480 }
 481
 482 static inline int
 483 __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
 484 {
 485   return pthread_key_create (key, dtor);
 486 }
 487
 488 static inline int
 489 __gthread_key_delete (__gthread_key_t key)
 490 {
 491   return pthread_key_delete (key);
 492 }
 493
 494 static inline void *
 495 __gthread_getspecific (__gthread_key_t key)
 496 {
 497   return pthread_getspecific (key);
 498 }
 499
 500 static inline int
 501 __gthread_setspecific (__gthread_key_t key, const void *ptr)
 502 {
 503   return pthread_setspecific (key, ptr);
 504 }
 505
 506 static inline int
 507 __gthread_mutex_lock (__gthread_mutex_t *mutex)
 508 {
 509   if (__gthread_active_p ())
 510     return pthread_mutex_lock (mutex);
 511   else
 512     return 0;
 513 }
 514
 515 static inline int
 516 __gthread_mutex_trylock (__gthread_mutex_t *mutex)
 517 {
 518   if (__gthread_active_p ())
 519     return pthread_mutex_trylock (mutex);
 520   else
 521     return 0;
 522 }
 523
 524 static inline int
 525 __gthread_mutex_unlock (__gthread_mutex_t *mutex)
 526 {
 527   if (__gthread_active_p ())
 528     return pthread_mutex_unlock (mutex);
 529   else
 530     return 0;
 531 }
 532
 533 #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
 534 static inline int
 535 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
 536 {
 537   if (__gthread_active_p ())
 538     {
 539       pthread_mutexattr_t attr;
 540       int r;
 541
 542       r = pthread_mutexattr_init (&attr);
 543       if (!r)
 544         r = pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 545       if (!r)
 546         r = pthread_mutex_init (mutex, &attr);
 547       if (!r)
 548         r = pthread_mutexattr_destroy (&attr);
 549       return r;
 550     }
 551 }
 552 #endif
 553
 554 static inline int
 555 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
 556 {
 557   return __gthread_mutex_lock (mutex);
 558 }
 559
 560 static inline int
 561 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
 562 {
 563   return __gthread_mutex_trylock (mutex);
 564 }
 565
 566 static inline int
 567 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
 568 {
 569   return __gthread_mutex_unlock (mutex);
 570 }
 571
 572 #endif /* _LIBOBJC */
 573
 574 #endif /* ! GCC_GTHR_POSIX_H */