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