LCOV - code coverage report
Current view: top level - usr/include/x86_64-linux-gnu/c++/6/bits - gthr-default.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2 2 100.0 %
Date: 2018-11-14 16:53:58 Functions: 1 1 100.0 %

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

Generated by: LCOV version 1.13