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