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