libgcc/config/pa/gthr-dce.h

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