Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h
1 /* Threads compatibility routines for libgcc2 and libobjc. */ 2 /* Compile this one with gcc. */ 3 /* Copyright (C) 1997-2025 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 _GLIBCXX_GCC_GTHR_POSIX_H 27 #define _GLIBCXX_GCC_GTHR_POSIX_H 28 29 /* POSIX threads specific definitions. 30 Easy, since the interface is just one-to-one mapping. */ 31 32 #define __GTHREADS 1 33 #define __GTHREADS_CXX0X 1 34 35 #include <pthread.h> 36 37 #if ((defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)) \ 38 || !defined(_GTHREAD_USE_MUTEX_TIMEDLOCK)) 39 # include <unistd.h> 40 # if defined(_POSIX_TIMEOUTS) && _POSIX_TIMEOUTS >= 0 41 # define _GTHREAD_USE_MUTEX_TIMEDLOCK 1 42 # else 43 # define _GTHREAD_USE_MUTEX_TIMEDLOCK 0 44 # endif 45 #endif 46 47 #ifdef __has_attribute 48 # if __has_attribute(__always_inline__) 49 # define __GTHREAD_ALWAYS_INLINE __attribute__((__always_inline__)) 50 # endif 51 #endif 52 #ifndef __GTHREAD_ALWAYS_INLINE 53 # define __GTHREAD_ALWAYS_INLINE 54 #endif 55 56 #ifdef __cplusplus 57 # define __GTHREAD_INLINE inline __GTHREAD_ALWAYS_INLINE 58 #else 59 # define __GTHREAD_INLINE static inline 60 #endif 61 62 typedef pthread_t __gthread_t; 63 typedef pthread_key_t __gthread_key_t; 64 typedef pthread_once_t __gthread_once_t; 65 typedef pthread_mutex_t __gthread_mutex_t; 66 #ifndef __cplusplus 67 typedef pthread_rwlock_t __gthread_rwlock_t; 68 #endif 69 typedef pthread_mutex_t __gthread_recursive_mutex_t; 70 typedef pthread_cond_t __gthread_cond_t; 71 typedef struct timespec __gthread_time_t; 72 73 /* POSIX like conditional variables are supported. Please look at comments 74 in gthr.h for details. */ 75 #define __GTHREAD_HAS_COND 1 76 77 #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER 78 #define __GTHREAD_MUTEX_INIT_FUNCTION __gthread_mutex_init_function 79 #ifndef __cplusplus 80 #define __GTHREAD_RWLOCK_INIT PTHREAD_RWLOCK_INITIALIZER 81 #endif 82 #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT 83 #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER) 84 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER 85 #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) 86 #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP 87 #else 88 #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function 89 #endif 90 #define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER 91 #define __GTHREAD_TIME_INIT {0,0} 92 93 #ifdef _GTHREAD_USE_MUTEX_INIT_FUNC 94 # undef __GTHREAD_MUTEX_INIT 95 #endif 96 #ifdef _GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC 97 # undef __GTHREAD_RECURSIVE_MUTEX_INIT 98 # undef __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION 99 # define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function 100 #endif 101 #ifdef _GTHREAD_USE_COND_INIT_FUNC 102 # undef __GTHREAD_COND_INIT 103 # define __GTHREAD_COND_INIT_FUNCTION __gthread_cond_init_function 104 #endif 105 106 #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK 107 # ifndef __gthrw_pragma 108 # define __gthrw_pragma(pragma) 109 # endif 110 # define __gthrw2(name,name2,type) \ 111 static __typeof(type) name \ 112 __attribute__ ((__weakref__(#name2), __copy__ (type))); \ 113 __gthrw_pragma(weak type) 114 # define __gthrw_(name) __gthrw_ ## name 115 #else 116 # define __gthrw2(name,name2,type) 117 # define __gthrw_(name) name 118 #endif 119 120 /* Typically, __gthrw_foo is a weak reference to symbol foo. */ 121 #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name) 122 123 __gthrw(pthread_once) 124 __gthrw(pthread_getspecific) 125 __gthrw(pthread_setspecific) 126 127 __gthrw(pthread_create) 128 __gthrw(pthread_join) 129 __gthrw(pthread_equal) 130 __gthrw(pthread_self) 131 __gthrw(pthread_detach) 132 #ifndef __BIONIC__ 133 __gthrw(pthread_cancel) 134 #endif 135 __gthrw(sched_yield) 136 137 __gthrw(pthread_mutex_lock) 138 __gthrw(pthread_mutex_trylock) 139 #if _GTHREAD_USE_MUTEX_TIMEDLOCK 140 __gthrw(pthread_mutex_timedlock) 141 #endif 142 __gthrw(pthread_mutex_unlock) 143 __gthrw(pthread_mutex_init) 144 __gthrw(pthread_mutex_destroy) 145 146 __gthrw(pthread_cond_init) 147 __gthrw(pthread_cond_broadcast) 148 __gthrw(pthread_cond_signal) 149 __gthrw(pthread_cond_wait) 150 __gthrw(pthread_cond_timedwait) 151 __gthrw(pthread_cond_destroy) 152 153 __gthrw(pthread_key_create) 154 __gthrw(pthread_key_delete) 155 __gthrw(pthread_mutexattr_init) 156 __gthrw(pthread_mutexattr_settype) 157 __gthrw(pthread_mutexattr_destroy) 158 159 #ifndef __cplusplus 160 __gthrw(pthread_rwlock_rdlock) 161 __gthrw(pthread_rwlock_tryrdlock) 162 __gthrw(pthread_rwlock_wrlock) 163 __gthrw(pthread_rwlock_trywrlock) 164 __gthrw(pthread_rwlock_unlock) 165 #endif 166 167 #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK) 168 /* Objective-C. */ 169 __gthrw(pthread_exit) 170 #ifdef _POSIX_PRIORITY_SCHEDULING 171 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING 172 __gthrw(sched_get_priority_max) 173 __gthrw(sched_get_priority_min) 174 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ 175 #endif /* _POSIX_PRIORITY_SCHEDULING */ 176 __gthrw(pthread_attr_destroy) 177 __gthrw(pthread_attr_init) 178 __gthrw(pthread_attr_setdetachstate) 179 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING 180 __gthrw(pthread_getschedparam) 181 __gthrw(pthread_setschedparam) 182 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ 183 #endif /* _LIBOBJC || _LIBOBJC_WEAK */ 184 185 #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK 186 187 /* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if 188 -pthreads is not specified. The functions are dummies and most return an 189 error value. However pthread_once returns 0 without invoking the routine 190 it is passed so we cannot pretend that the interface is active if -pthreads 191 is not specified. On Solaris 2.5.1, the interface is not exposed at all so 192 we need to play the usual game with weak symbols. On Solaris 10 and up, a 193 working interface is always exposed. On FreeBSD 6 and later, libc also 194 exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up 195 to 9 does. FreeBSD >= 700014 even provides a pthread_cancel stub in libc, 196 which means the alternate __gthread_active_p below cannot be used there. */ 197 198 #if defined(__FreeBSD__) || (defined(__sun) && defined(__svr4__)) 199 200 #pragma GCC visibility push(hidden) 201 __GTHREAD_INLINE volatile int * 202 __gthread_active (void) 203 { 204 static volatile int __gthread_active_var = -1; 205 return &__gthread_active_var; 206 } 207 #pragma GCC visibility pop 208 209 __GTHREAD_INLINE void 210 __gthread_trigger (void) 211 { 212 *__gthread_active () = 1; 213 } 214 215 #pragma GCC visibility push(hidden) 216 __GTHREAD_INLINE int 217 __gthread_active_p (void) 218 { 219 static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER; 220 static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT; 221 222 /* Avoid reading __gthread_active twice on the main code path. */ 223 int __gthread_active_latest_value = *__gthread_active (); 224 225 /* This test is not protected to avoid taking a lock on the main code 226 path so every update of __gthread_active in a threaded program must 227 be atomic with regard to the result of the test. */ 228 if (__builtin_expect (__gthread_active_latest_value < 0, 0)) 229 { 230 if (__gthrw_(pthread_once)) 231 { 232 /* If this really is a threaded program, then we must ensure that 233 __gthread_active has been set to 1 before exiting this block. */ 234 __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex); 235 __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger); 236 __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex); 237 } 238 239 /* Make sure we'll never enter this block again. */ 240 if (*__gthread_active () < 0) 241 *__gthread_active () = 0; 242 243 __gthread_active_latest_value = *__gthread_active (); 244 } 245 246 return __gthread_active_latest_value != 0; 247 } 248 #pragma GCC visibility pop 249 250 #else /* neither FreeBSD nor Solaris */ 251 252 /* For a program to be multi-threaded the only thing that it certainly must 253 be using is pthread_create. However, there may be other libraries that 254 intercept pthread_create with their own definitions to wrap pthreads 255 functionality for some purpose. In those cases, pthread_create being 256 defined might not necessarily mean that libpthread is actually linked 257 in. 258 259 For the GNU C library, we can use a known internal name. This is always 260 available in the ABI, but no other library would define it. That is 261 ideal, since any public pthread function might be intercepted just as 262 pthread_create might be. __pthread_key_create is an "internal" 263 implementation symbol, but it is part of the public exported ABI. Also, 264 it's among the symbols that the static libpthread.a always links in 265 whenever pthread_create is used, so there is no danger of a false 266 negative result in any statically-linked, multi-threaded program. 267 268 For others, we choose pthread_cancel as a function that seems unlikely 269 to be redefined by an interceptor library. The bionic (Android) C 270 library does not provide pthread_cancel, so we do use pthread_create 271 there (and interceptor libraries lose). */ 272 273 #ifdef __GLIBC__ 274 __gthrw2(__gthrw_(__pthread_key_create), 275 __pthread_key_create, 276 pthread_key_create) 277 # define GTHR_ACTIVE_PROXY __gthrw_(__pthread_key_create) 278 #elif defined (__BIONIC__) 279 # define GTHR_ACTIVE_PROXY __gthrw_(pthread_create) 280 #else 281 # define GTHR_ACTIVE_PROXY __gthrw_(pthread_cancel) 282 #endif 283 284 #pragma GCC visibility push(hidden) 285 __GTHREAD_INLINE int 286 __gthread_active_p (void) 287 { 288 static void *const __gthread_active_ptr 289 = __extension__ (void *) >HR_ACTIVE_PROXY; 290 return __gthread_active_ptr != 0; 291 } 292 #pragma GCC visibility pop 293 294 #endif /* FreeBSD or Solaris */ 295 296 #else /* not __GXX_WEAK__ */ 297 298 /* Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread 299 calls in shared flavors of the HP-UX C library. Most of the stubs 300 have no functionality. The details are described in the "libc cumulative 301 patch" for each subversion of HP-UX 11. There are two special interfaces 302 provided for checking whether an application is linked to a shared pthread 303 library or not. However, these interfaces aren't available in early 304 libpthread libraries. We also need a test that works for archive 305 libraries. We can't use pthread_once as some libc versions call the 306 init function. We also can't use pthread_create or pthread_attr_init 307 as these create a thread and thereby prevent changing the default stack 308 size. The function pthread_default_stacksize_np is available in both 309 the archive and shared versions of libpthread. It can be used to 310 determine the default pthread stack size. There is a stub in some 311 shared libc versions which returns a zero size if pthreads are not 312 active. We provide an equivalent stub to handle cases where libc 313 doesn't provide one. */ 314 315 #if defined(__hppa__) && defined(__hpux__) 316 317 #pragma GCC visibility push(hidden) 318 __GTHREAD_INLINE volatile int * 319 __gthread_active (void) 320 { 321 static volatile int __gthread_active_var = -1; 322 return &__gthread_active_var; 323 } 324 #pragma GCC visibility pop 325 326 __GTHREAD_INLINE int 327 __gthread_active_p (void) 328 { 329 /* Avoid reading __gthread_active twice on the main code path. */ 330 int __gthread_active_latest_value = *__gthread_active (); 331 size_t __s; 332 333 if (__builtin_expect (__gthread_active_latest_value < 0, 0)) 334 { 335 pthread_default_stacksize_np (0, &__s); 336 *__gthread_active () = __s ? 1 : 0; 337 __gthread_active_latest_value = *__gthread_active (); 338 } 339 340 return __gthread_active_latest_value != 0; 341 } 342 343 #else /* not hppa-hpux */ 344 345 __GTHREAD_INLINE int 346 __gthread_active_p (void) 347 { 348 return 1; 349 } 350 351 #endif /* hppa-hpux */ 352 353 #endif /* __GXX_WEAK__ */ 354 355 #ifdef _LIBOBJC 356 357 /* This is the config.h file in libobjc/ */ 358 #include <config.h> 359 360 #ifdef HAVE_SCHED_H 361 # include <sched.h> 362 #endif 363 364 /* Key structure for maintaining thread specific storage */ 365 static pthread_key_t _objc_thread_storage; 366 static pthread_attr_t _objc_thread_attribs; 367 368 /* Thread local storage for a single thread */ 369 static void *thread_local_storage = NULL; 370 371 /* Backend initialization functions */ 372 373 /* Initialize the threads subsystem. */ 374 static inline int 375 __gthread_objc_init_thread_system (void) 376 { 377 if (__gthread_active_p ()) 378 { 379 /* Initialize the thread storage key. */ 380 if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0) 381 { 382 /* The normal default detach state for threads is 383 * PTHREAD_CREATE_JOINABLE which causes threads to not die 384 * when you think they should. */ 385 if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0 386 && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs, 387 PTHREAD_CREATE_DETACHED) == 0) 388 return 0; 389 } 390 } 391 392 return -1; 393 } 394 395 /* Close the threads subsystem. */ 396 static inline int 397 __gthread_objc_close_thread_system (void) 398 { 399 if (__gthread_active_p () 400 && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0 401 && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0) 402 return 0; 403 404 return -1; 405 } 406 407 /* Backend thread functions */ 408 409 /* Create a new thread of execution. */ 410 static inline objc_thread_t 411 __gthread_objc_thread_detach (void (*func)(void *), void *arg) 412 { 413 objc_thread_t thread_id; 414 pthread_t new_thread_handle; 415 416 if (!__gthread_active_p ()) 417 return NULL; 418 419 if (!(__gthrw_(pthread_create) (&new_thread_handle, &_objc_thread_attribs, 420 (void *) func, arg))) 421 thread_id = (objc_thread_t) new_thread_handle; 422 else 423 thread_id = NULL; 424 425 return thread_id; 426 } 427 428 /* Set the current thread's priority. */ 429 static inline int 430 __gthread_objc_thread_set_priority (int priority) 431 { 432 if (!__gthread_active_p ()) 433 return -1; 434 else 435 { 436 #ifdef _POSIX_PRIORITY_SCHEDULING 437 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING 438 pthread_t thread_id = __gthrw_(pthread_self) (); 439 int policy; 440 struct sched_param params; 441 int priority_min, priority_max; 442 443 if (__gthrw_(pthread_getschedparam) (thread_id, &policy, ¶ms) == 0) 444 { 445 if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1) 446 return -1; 447 448 if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1) 449 return -1; 450 451 if (priority > priority_max) 452 priority = priority_max; 453 else if (priority < priority_min) 454 priority = priority_min; 455 params.sched_priority = priority; 456 457 /* 458 * The solaris 7 and several other man pages incorrectly state that 459 * this should be a pointer to policy but pthread.h is universally 460 * at odds with this. 461 */ 462 if (__gthrw_(pthread_setschedparam) (thread_id, policy, ¶ms) == 0) 463 return 0; 464 } 465 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ 466 #endif /* _POSIX_PRIORITY_SCHEDULING */ 467 return -1; 468 } 469 } 470 471 /* Return the current thread's priority. */ 472 static inline int 473 __gthread_objc_thread_get_priority (void) 474 { 475 #ifdef _POSIX_PRIORITY_SCHEDULING 476 #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING 477 if (__gthread_active_p ()) 478 { 479 int policy; 480 struct sched_param params; 481 482 if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, ¶ms) == 0) 483 return params.sched_priority; 484 else 485 return -1; 486 } 487 else 488 #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */ 489 #endif /* _POSIX_PRIORITY_SCHEDULING */ 490 return OBJC_THREAD_INTERACTIVE_PRIORITY; 491 } 492 493 /* Yield our process time to another thread. */ 494 static inline void 495 __gthread_objc_thread_yield (void) 496 { 497 if (__gthread_active_p ()) 498 __gthrw_(sched_yield) (); 499 } 500 501 /* Terminate the current thread. */ 502 static inline int 503 __gthread_objc_thread_exit (void) 504 { 505 if (__gthread_active_p ()) 506 /* exit the thread */ 507 __gthrw_(pthread_exit) (&__objc_thread_exit_status); 508 509 /* Failed if we reached here */ 510 return -1; 511 } 512 513 /* Returns an integer value which uniquely describes a thread. */ 514 static inline objc_thread_t 515 __gthread_objc_thread_id (void) 516 { 517 if (__gthread_active_p ()) 518 return (objc_thread_t) __gthrw_(pthread_self) (); 519 else 520 return (objc_thread_t) 1; 521 } 522 523 /* Sets the thread's local storage pointer. */ 524 static inline int 525 __gthread_objc_thread_set_data (void *value) 526 { 527 if (__gthread_active_p ()) 528 return __gthrw_(pthread_setspecific) (_objc_thread_storage, value); 529 else 530 { 531 thread_local_storage = value; 532 return 0; 533 } 534 } 535 536 /* Returns the thread's local storage pointer. */ 537 static inline void * 538 __gthread_objc_thread_get_data (void) 539 { 540 if (__gthread_active_p ()) 541 return __gthrw_(pthread_getspecific) (_objc_thread_storage); 542 else 543 return thread_local_storage; 544 } 545 546 /* Backend mutex functions */ 547 548 /* Allocate a mutex. */ 549 static inline int 550 __gthread_objc_mutex_allocate (objc_mutex_t mutex) 551 { 552 if (__gthread_active_p ()) 553 { 554 mutex->backend = objc_malloc (sizeof (pthread_mutex_t)); 555 556 if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL)) 557 { 558 objc_free (mutex->backend); 559 mutex->backend = NULL; 560 return -1; 561 } 562 } 563 564 return 0; 565 } 566 567 /* Deallocate a mutex. */ 568 static inline int 569 __gthread_objc_mutex_deallocate (objc_mutex_t mutex) 570 { 571 if (__gthread_active_p ()) 572 { 573 int count; 574 575 /* 576 * Posix Threads specifically require that the thread be unlocked 577 * for __gthrw_(pthread_mutex_destroy) to work. 578 */ 579 580 do 581 { 582 count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend); 583 if (count < 0) 584 return -1; 585 } 586 while (count); 587 588 if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend)) 589 return -1; 590 591 objc_free (mutex->backend); 592 mutex->backend = NULL; 593 } 594 return 0; 595 } 596 597 /* Grab a lock on a mutex. */ 598 static inline int 599 __gthread_objc_mutex_lock (objc_mutex_t mutex) 600 { 601 if (__gthread_active_p () 602 && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0) 603 { 604 return -1; 605 } 606 607 return 0; 608 } 609 610 /* Try to grab a lock on a mutex. */ 611 static inline int 612 __gthread_objc_mutex_trylock (objc_mutex_t mutex) 613 { 614 if (__gthread_active_p () 615 && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0) 616 { 617 return -1; 618 } 619 620 return 0; 621 } 622 623 /* Unlock the mutex */ 624 static inline int 625 __gthread_objc_mutex_unlock (objc_mutex_t mutex) 626 { 627 if (__gthread_active_p () 628 && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0) 629 { 630 return -1; 631 } 632 633 return 0; 634 } 635 636 /* Backend condition mutex functions */ 637 638 /* Allocate a condition. */ 639 static inline int 640 __gthread_objc_condition_allocate (objc_condition_t condition) 641 { 642 if (__gthread_active_p ()) 643 { 644 condition->backend = objc_malloc (sizeof (pthread_cond_t)); 645 646 if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL)) 647 { 648 objc_free (condition->backend); 649 condition->backend = NULL; 650 return -1; 651 } 652 } 653 654 return 0; 655 } 656 657 /* Deallocate a condition. */ 658 static inline int 659 __gthread_objc_condition_deallocate (objc_condition_t condition) 660 { 661 if (__gthread_active_p ()) 662 { 663 if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend)) 664 return -1; 665 666 objc_free (condition->backend); 667 condition->backend = NULL; 668 } 669 return 0; 670 } 671 672 /* Wait on the condition */ 673 static inline int 674 __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex) 675 { 676 if (__gthread_active_p ()) 677 return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend, 678 (pthread_mutex_t *) mutex->backend); 679 else 680 return 0; 681 } 682 683 /* Wake up all threads waiting on this condition. */ 684 static inline int 685 __gthread_objc_condition_broadcast (objc_condition_t condition) 686 { 687 if (__gthread_active_p ()) 688 return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend); 689 else 690 return 0; 691 } 692 693 /* Wake up one thread waiting on this condition. */ 694 static inline int 695 __gthread_objc_condition_signal (objc_condition_t condition) 696 { 697 if (__gthread_active_p ()) 698 return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend); 699 else 700 return 0; 701 } 702 703 #else /* _LIBOBJC */ 704 705 __GTHREAD_INLINE int 706 __gthread_create (__gthread_t *__threadid, void *(*__func) (void*), 707 void *__args) 708 { 709 return __gthrw_(pthread_create) (__threadid, NULL, __func, __args); 710 } 711 712 __GTHREAD_INLINE int 713 __gthread_join (__gthread_t __threadid, void **__value_ptr) 714 { 715 return __gthrw_(pthread_join) (__threadid, __value_ptr); 716 } 717 718 __GTHREAD_INLINE int 719 __gthread_detach (__gthread_t __threadid) 720 { 721 return __gthrw_(pthread_detach) (__threadid); 722 } 723 724 __GTHREAD_INLINE int 725 __gthread_equal (__gthread_t __t1, __gthread_t __t2) 726 { 727 return __gthrw_(pthread_equal) (__t1, __t2); 728 } 729 730 __GTHREAD_INLINE __gthread_t 731 __gthread_self (void) 732 { 733 return __gthrw_(pthread_self) (); 734 } 735 736 __GTHREAD_INLINE int 737 __gthread_yield (void) 738 { 739 return __gthrw_(sched_yield) (); 740 } 741 742 __GTHREAD_INLINE int 743 __gthread_once (__gthread_once_t *__once, void (*__func) (void)) 744 { 745 if (__gthread_active_p ()) 746 return __gthrw_(pthread_once) (__once, __func); 747 else 748 return -1; 749 } 750 751 __GTHREAD_INLINE int 752 __gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) 753 { 754 return __gthrw_(pthread_key_create) (__key, __dtor); 755 } 756 757 __GTHREAD_INLINE int 758 __gthread_key_delete (__gthread_key_t __key) 759 { 760 return __gthrw_(pthread_key_delete) (__key); 761 } 762 763 __GTHREAD_INLINE void * 764 __gthread_getspecific (__gthread_key_t __key) 765 { 766 return __gthrw_(pthread_getspecific) (__key); 767 } 768 769 __GTHREAD_INLINE int 770 __gthread_setspecific (__gthread_key_t __key, const void *__ptr) 771 { 772 return __gthrw_(pthread_setspecific) (__key, __ptr); 773 } 774 775 __GTHREAD_INLINE void 776 __gthread_mutex_init_function (__gthread_mutex_t *__mutex) 777 { 778 if (__gthread_active_p ()) 779 __gthrw_(pthread_mutex_init) (__mutex, NULL); 780 } 781 782 __GTHREAD_INLINE int 783 __gthread_mutex_destroy (__gthread_mutex_t *__mutex) 784 { 785 if (__gthread_active_p ()) 786 return __gthrw_(pthread_mutex_destroy) (__mutex); 787 else 788 return 0; 789 } 790 791 __GTHREAD_INLINE int 792 __gthread_mutex_lock (__gthread_mutex_t *__mutex) 793 { 794 if (__gthread_active_p ()) 795 return __gthrw_(pthread_mutex_lock) (__mutex); 796 else 797 return 0; 798 } 799 800 __GTHREAD_INLINE int 801 __gthread_mutex_trylock (__gthread_mutex_t *__mutex) 802 { 803 if (__gthread_active_p ()) 804 return __gthrw_(pthread_mutex_trylock) (__mutex); 805 else 806 return 0; 807 } 808 809 #if _GTHREAD_USE_MUTEX_TIMEDLOCK 810 __GTHREAD_INLINE int 811 __gthread_mutex_timedlock (__gthread_mutex_t *__mutex, 812 const __gthread_time_t *__abs_timeout) 813 { 814 if (__gthread_active_p ()) 815 return __gthrw_(pthread_mutex_timedlock) (__mutex, __abs_timeout); 816 else 817 return 0; 818 } 819 #endif 820 821 __GTHREAD_INLINE int 822 __gthread_mutex_unlock (__gthread_mutex_t *__mutex) 823 { 824 if (__gthread_active_p ()) 825 return __gthrw_(pthread_mutex_unlock) (__mutex); 826 else 827 return 0; 828 } 829 830 #if !defined( PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP) \ 831 || defined(_GTHREAD_USE_RECURSIVE_MUTEX_INIT_FUNC) 832 __GTHREAD_INLINE int 833 __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *__mutex) 834 { 835 if (__gthread_active_p ()) 836 { 837 pthread_mutexattr_t __attr; 838 int __r; 839 840 __r = __gthrw_(pthread_mutexattr_init) (&__attr); 841 if (!__r) 842 __r = __gthrw_(pthread_mutexattr_settype) (&__attr, 843 PTHREAD_MUTEX_RECURSIVE); 844 if (!__r) 845 __r = __gthrw_(pthread_mutex_init) (__mutex, &__attr); 846 if (!__r) 847 __r = __gthrw_(pthread_mutexattr_destroy) (&__attr); 848 return __r; 849 } 850 return 0; 851 } 852 #endif 853 854 __GTHREAD_INLINE int 855 __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) 856 { 857 return __gthread_mutex_lock (__mutex); 858 } 859 860 __GTHREAD_INLINE int 861 __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) 862 { 863 return __gthread_mutex_trylock (__mutex); 864 } 865 866 #if _GTHREAD_USE_MUTEX_TIMEDLOCK 867 __GTHREAD_INLINE int 868 __gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, 869 const __gthread_time_t *__abs_timeout) 870 { 871 return __gthread_mutex_timedlock (__mutex, __abs_timeout); 872 } 873 #endif 874 875 __GTHREAD_INLINE int 876 __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) 877 { 878 return __gthread_mutex_unlock (__mutex); 879 } 880 881 __GTHREAD_INLINE int 882 __gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) 883 { 884 return __gthread_mutex_destroy (__mutex); 885 } 886 887 #ifdef _GTHREAD_USE_COND_INIT_FUNC 888 __GTHREAD_INLINE void 889 __gthread_cond_init_function (__gthread_cond_t *__cond) 890 { 891 if (__gthread_active_p ()) 892 __gthrw_(pthread_cond_init) (__cond, NULL); 893 } 894 #endif 895 896 __GTHREAD_INLINE int 897 __gthread_cond_broadcast (__gthread_cond_t *__cond) 898 { 899 return __gthrw_(pthread_cond_broadcast) (__cond); 900 } 901 902 __GTHREAD_INLINE int 903 __gthread_cond_signal (__gthread_cond_t *__cond) 904 { 905 return __gthrw_(pthread_cond_signal) (__cond); 906 } 907 908 __GTHREAD_INLINE int 909 __gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) 910 { 911 return __gthrw_(pthread_cond_wait) (__cond, __mutex); 912 } 913 914 __GTHREAD_INLINE int 915 __gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, 916 const __gthread_time_t *__abs_timeout) 917 { 918 return __gthrw_(pthread_cond_timedwait) (__cond, __mutex, __abs_timeout); 919 } 920 921 __GTHREAD_INLINE int 922 __gthread_cond_wait_recursive (__gthread_cond_t *__cond, 923 __gthread_recursive_mutex_t *__mutex) 924 { 925 return __gthread_cond_wait (__cond, __mutex); 926 } 927 928 __GTHREAD_INLINE int 929 __gthread_cond_destroy (__gthread_cond_t* __cond) 930 { 931 return __gthrw_(pthread_cond_destroy) (__cond); 932 } 933 934 #ifndef __cplusplus 935 __GTHREAD_INLINE int 936 __gthread_rwlock_rdlock (__gthread_rwlock_t *__rwlock) 937 { 938 if (__gthread_active_p ()) 939 return __gthrw_(pthread_rwlock_rdlock) (__rwlock); 940 else 941 return 0; 942 } 943 944 __GTHREAD_INLINE int 945 __gthread_rwlock_tryrdlock (__gthread_rwlock_t *__rwlock) 946 { 947 if (__gthread_active_p ()) 948 return __gthrw_(pthread_rwlock_tryrdlock) (__rwlock); 949 else 950 return 0; 951 } 952 953 __GTHREAD_INLINE int 954 __gthread_rwlock_wrlock (__gthread_rwlock_t *__rwlock) 955 { 956 if (__gthread_active_p ()) 957 return __gthrw_(pthread_rwlock_wrlock) (__rwlock); 958 else 959 return 0; 960 } 961 962 __GTHREAD_INLINE int 963 __gthread_rwlock_trywrlock (__gthread_rwlock_t *__rwlock) 964 { 965 if (__gthread_active_p ()) 966 return __gthrw_(pthread_rwlock_trywrlock) (__rwlock); 967 else 968 return 0; 969 } 970 971 __GTHREAD_INLINE int 972 __gthread_rwlock_unlock (__gthread_rwlock_t *__rwlock) 973 { 974 if (__gthread_active_p ()) 975 return __gthrw_(pthread_rwlock_unlock) (__rwlock); 976 else 977 return 0; 978 } 979 #endif 980 981 #endif /* _LIBOBJC */ 982 983 #undef __GTHREAD_INLINE 984 #undef __GTHREAD_ALWAYS_INLINE 985 986 #endif /* ! _GLIBCXX_GCC_GTHR_POSIX_H */
