From 006621455482edd8abf46a05292120745f99f7ec Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Tue, 29 Sep 2009 15:08:02 +0100 Subject: Initial import --- .../i486-linux-gnu/bits/gthr-default.h.gcov.html | 837 +++++++++++++++++++++ .../include/c++/4.3/i486-linux-gnu/bits/index.html | 83 ++ 2 files changed, 920 insertions(+) create mode 100644 rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html create mode 100644 rep/usr/include/c++/4.3/i486-linux-gnu/bits/index.html (limited to 'rep/usr/include/c++/4.3/i486-linux-gnu/bits') diff --git a/rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html b/rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html new file mode 100644 index 0000000..5529fc3 --- /dev/null +++ b/rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html @@ -0,0 +1,837 @@ + + + + + + + LCOV - lcov.info - /usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h + + + + + + + + + + + + + +
LTP GCOV extension - code coverage report
+ + + + + + + + + + + + + + + + + + + + + + + +
Current view:directory - usr/include/c++/4.3/i486-linux-gnu/bits - gthr-default.h
Test:lcov.info
Date:2008-08-14Instrumented lines:2
Code covered:0.0 %Executed lines:0
+
+ + + + + + + + + 

+       1                 : /* Threads compatibility routines for libgcc2 and libobjc.  */
+       2                 : /* Compile this one with gcc.  */
+       3                 : /* Copyright (C) 1997, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+       4                 :    Free Software Foundation, Inc.
+       5                 : 
+       6                 : This file is part of GCC.
+       7                 : 
+       8                 : GCC is free software; you can redistribute it and/or modify it under
+       9                 : the terms of the GNU General Public License as published by the Free
+      10                 : Software Foundation; either version 2, or (at your option) any later
+      11                 : version.
+      12                 : 
+      13                 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+      14                 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
+      15                 : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+      16                 : for more details.
+      17                 : 
+      18                 : You should have received a copy of the GNU General Public License
+      19                 : along with GCC; see the file COPYING.  If not, write to the Free
+      20                 : Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
+      21                 : 02110-1301, USA.  */
+      22                 : 
+      23                 : /* As a special exception, if you link this library with other files,
+      24                 :    some of which are compiled with GCC, to produce an executable,
+      25                 :    this library does not by itself cause the resulting executable
+      26                 :    to be covered by the GNU General Public License.
+      27                 :    This exception does not however invalidate any other reasons why
+      28                 :    the executable file might be covered by the GNU General Public License.  */
+      29                 : 
+      30                 : #ifndef _GLIBCXX_GCC_GTHR_POSIX_H
+      31                 : #define _GLIBCXX_GCC_GTHR_POSIX_H
+      32                 : 
+      33                 : /* POSIX threads specific definitions.
+      34                 :    Easy, since the interface is just one-to-one mapping.  */
+      35                 : 
+      36                 : #define __GTHREADS 1
+      37                 : 
+      38                 : /* Some implementations of <pthread.h> require this to be defined.  */
+      39                 : #if !defined(_REENTRANT) && defined(__osf__)
+      40                 : #define _REENTRANT 1
+      41                 : #endif
+      42                 : 
+      43                 : #include <pthread.h>
+      44                 : #include <unistd.h>
+      45                 : 
+      46                 : typedef pthread_key_t __gthread_key_t;
+      47                 : typedef pthread_once_t __gthread_once_t;
+      48                 : typedef pthread_mutex_t __gthread_mutex_t;
+      49                 : typedef pthread_mutex_t __gthread_recursive_mutex_t;
+      50                 : typedef pthread_cond_t __gthread_cond_t;
+      51                 : 
+      52                 : /* POSIX like conditional variables are supported.  Please look at comments
+      53                 :    in gthr.h for details. */
+      54                 : #define __GTHREAD_HAS_COND      1       
+      55                 : 
+      56                 : #define __GTHREAD_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
+      57                 : #define __GTHREAD_ONCE_INIT PTHREAD_ONCE_INIT
+      58                 : #if defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER)
+      59                 : #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER
+      60                 : #elif defined(PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP)
+      61                 : #define __GTHREAD_RECURSIVE_MUTEX_INIT PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+      62                 : #else
+      63                 : #define __GTHREAD_RECURSIVE_MUTEX_INIT_FUNCTION __gthread_recursive_mutex_init_function
+      64                 : #endif
+      65                 : #define __GTHREAD_COND_INIT PTHREAD_COND_INITIALIZER
+      66                 : 
+      67                 : #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK
+      68                 : # ifndef __gthrw_pragma
+      69                 : #  define __gthrw_pragma(pragma)
+      70                 : # endif
+      71                 : # define __gthrw2(name,name2,type) \
+      72                 :   static __typeof(type) name __attribute__ ((__weakref__(#name2))); \
+      73                 :   __gthrw_pragma(weak type)
+      74                 : # define __gthrw_(name) __gthrw_ ## name
+      75                 : #else
+      76                 : # define __gthrw2(name,name2,type)
+      77                 : # define __gthrw_(name) name
+      78                 : #endif
+      79                 : 
+      80                 : /* Typically, __gthrw_foo is a weak reference to symbol foo.  */
+      81                 : #define __gthrw(name) __gthrw2(__gthrw_ ## name,name,name)
+      82                 : 
+      83                 : /* On Tru64, /usr/include/pthread.h uses #pragma extern_prefix "__" to
+      84                 :    map a subset of the POSIX pthread API to mangled versions of their
+      85                 :    names.  */
+      86                 : #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
+      87                 : #define __gthrw3(name) __gthrw2(__gthrw_ ## name, __ ## name, name)
+      88                 : __gthrw3(pthread_once)
+      89                 : __gthrw3(pthread_getspecific)
+      90                 : __gthrw3(pthread_setspecific)
+      91                 : __gthrw3(pthread_create)
+      92                 : __gthrw3(pthread_cancel)
+      93                 : __gthrw3(pthread_mutex_lock)
+      94                 : __gthrw3(pthread_mutex_trylock)
+      95                 : __gthrw3(pthread_mutex_unlock)
+      96                 : __gthrw3(pthread_mutex_init)
+      97                 : __gthrw3(pthread_cond_broadcast)
+      98                 : __gthrw3(pthread_cond_wait)
+      99                 : #else
+     100                 : __gthrw(pthread_once)
+     101                 : __gthrw(pthread_getspecific)
+     102                 : __gthrw(pthread_setspecific)
+     103                 : __gthrw(pthread_create)
+     104                 : __gthrw(pthread_cancel)
+     105                 : __gthrw(pthread_mutex_lock)
+     106                 : __gthrw(pthread_mutex_trylock)
+     107                 : __gthrw(pthread_mutex_unlock)
+     108                 : __gthrw(pthread_mutex_init)
+     109                 : __gthrw(pthread_cond_broadcast)
+     110                 : __gthrw(pthread_cond_wait)
+     111                 : #endif
+     112                 : 
+     113                 : __gthrw(pthread_key_create)
+     114                 : __gthrw(pthread_key_delete)
+     115                 : __gthrw(pthread_mutexattr_init)
+     116                 : __gthrw(pthread_mutexattr_settype)
+     117                 : __gthrw(pthread_mutexattr_destroy)
+     118                 : 
+     119                 : 
+     120                 : #if defined(_LIBOBJC) || defined(_LIBOBJC_WEAK)
+     121                 : /* Objective-C.  */
+     122                 : #if defined(__osf__) && defined(_PTHREAD_USE_MANGLED_NAMES_)
+     123                 : __gthrw3(pthread_cond_destroy)
+     124                 : __gthrw3(pthread_cond_init)
+     125                 : __gthrw3(pthread_cond_signal)
+     126                 : __gthrw3(pthread_exit)
+     127                 : __gthrw3(pthread_mutex_destroy)
+     128                 : __gthrw3(pthread_self)
+     129                 : #else
+     130                 : __gthrw(pthread_cond_destroy)
+     131                 : __gthrw(pthread_cond_init)
+     132                 : __gthrw(pthread_cond_signal)
+     133                 : __gthrw(pthread_exit)
+     134                 : __gthrw(pthread_mutex_destroy)
+     135                 : __gthrw(pthread_self)
+     136                 : #endif /* __osf__ && _PTHREAD_USE_MANGLED_NAMES_ */
+     137                 : #ifdef _POSIX_PRIORITY_SCHEDULING
+     138                 : #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
+     139                 : __gthrw(sched_get_priority_max)
+     140                 : __gthrw(sched_get_priority_min)
+     141                 : #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+     142                 : #endif /* _POSIX_PRIORITY_SCHEDULING */
+     143                 : __gthrw(sched_yield)
+     144                 : __gthrw(pthread_attr_destroy)
+     145                 : __gthrw(pthread_attr_init)
+     146                 : __gthrw(pthread_attr_setdetachstate)
+     147                 : #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
+     148                 : __gthrw(pthread_getschedparam)
+     149                 : __gthrw(pthread_setschedparam)
+     150                 : #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+     151                 : #endif /* _LIBOBJC || _LIBOBJC_WEAK */
+     152                 : 
+     153                 : #if __GXX_WEAK__ && _GLIBCXX_GTHREAD_USE_WEAK
+     154                 : 
+     155                 : /* On Solaris 2.6 up to 9, the libc exposes a POSIX threads interface even if
+     156                 :    -pthreads is not specified.  The functions are dummies and most return an
+     157                 :    error value.  However pthread_once returns 0 without invoking the routine
+     158                 :    it is passed so we cannot pretend that the interface is active if -pthreads
+     159                 :    is not specified.  On Solaris 2.5.1, the interface is not exposed at all so
+     160                 :    we need to play the usual game with weak symbols.  On Solaris 10 and up, a
+     161                 :    working interface is always exposed.  On FreeBSD 6 and later, libc also
+     162                 :    exposes a dummy POSIX threads interface, similar to what Solaris 2.6 up
+     163                 :    to 9 does.  FreeBSD >= 700014 even provides a pthread_cancel stub in libc,
+     164                 :    which means the alternate __gthread_active_p below cannot be used there.  */
+     165                 : 
+     166                 : #if defined(__FreeBSD__) || (defined(__sun) && defined(__svr4__))
+     167                 : 
+     168                 : static volatile int __gthread_active = -1;
+     169                 : 
+     170                 : static void
+     171                 : __gthread_trigger (void)
+     172                 : {
+     173                 :   __gthread_active = 1;
+     174                 : }
+     175                 : 
+     176                 : static inline int
+     177                 : __gthread_active_p (void)
+     178                 : {
+     179                 :   static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER;
+     180                 :   static pthread_once_t __gthread_active_once = PTHREAD_ONCE_INIT;
+     181                 : 
+     182                 :   /* Avoid reading __gthread_active twice on the main code path.  */
+     183                 :   int __gthread_active_latest_value = __gthread_active;
+     184                 : 
+     185                 :   /* This test is not protected to avoid taking a lock on the main code
+     186                 :      path so every update of __gthread_active in a threaded program must
+     187                 :      be atomic with regard to the result of the test.  */
+     188                 :   if (__builtin_expect (__gthread_active_latest_value < 0, 0))
+     189                 :     {
+     190                 :       if (__gthrw_(pthread_once))
+     191                 :         {
+     192                 :           /* If this really is a threaded program, then we must ensure that
+     193                 :              __gthread_active has been set to 1 before exiting this block.  */
+     194                 :           __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex);
+     195                 :           __gthrw_(pthread_once) (&__gthread_active_once, __gthread_trigger);
+     196                 :           __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
+     197                 :         }
+     198                 : 
+     199                 :       /* Make sure we'll never enter this block again.  */
+     200                 :       if (__gthread_active < 0)
+     201                 :         __gthread_active = 0;
+     202                 : 
+     203                 :       __gthread_active_latest_value = __gthread_active;
+     204                 :     }
+     205                 : 
+     206                 :   return __gthread_active_latest_value != 0;
+     207                 : }
+     208                 : 
+     209                 : #else /* neither FreeBSD nor Solaris */
+     210                 : 
+     211                 : static inline int
+     212               0 : __gthread_active_p (void)
+     213                 : {
+     214                 :   static void *const __gthread_active_ptr 
+     215                 :     = __extension__ (void *) &__gthrw_(pthread_cancel);
+     216               0 :   return __gthread_active_ptr != 0;
+     217                 : }
+     218                 : 
+     219                 : #endif /* FreeBSD or Solaris */
+     220                 : 
+     221                 : #else /* not __GXX_WEAK__ */
+     222                 : 
+     223                 : /* Similar to Solaris, HP-UX 11 for PA-RISC provides stubs for pthread
+     224                 :    calls in shared flavors of the HP-UX C library.  Most of the stubs
+     225                 :    have no functionality.  The details are described in the "libc cumulative
+     226                 :    patch" for each subversion of HP-UX 11.  There are two special interfaces
+     227                 :    provided for checking whether an application is linked to a pthread
+     228                 :    library or not.  However, these interfaces aren't available in early
+     229                 :    libc versions.  We also can't use pthread_once as some libc versions
+     230                 :    call the init function.  So, we use pthread_create to check whether it
+     231                 :    is possible to create a thread or not.  The stub implementation returns
+     232                 :    the error number ENOSYS.  */
+     233                 : 
+     234                 : #if defined(__hppa__) && defined(__hpux__)
+     235                 : 
+     236                 : #include <errno.h>
+     237                 : 
+     238                 : static volatile int __gthread_active = -1;
+     239                 : 
+     240                 : static void *
+     241                 : __gthread_start (void *arg __attribute__((unused)))
+     242                 : {
+     243                 :   return NULL;
+     244                 : }
+     245                 : 
+     246                 : static void __gthread_active_init (void) __attribute__((noinline));
+     247                 : static void
+     248                 : __gthread_active_init (void)
+     249                 : {
+     250                 :   static pthread_mutex_t __gthread_active_mutex = PTHREAD_MUTEX_INITIALIZER;
+     251                 :   pthread_t t;
+     252                 :   pthread_attr_t a;
+     253                 :   int result;
+     254                 : 
+     255                 :   __gthrw_(pthread_mutex_lock) (&__gthread_active_mutex);
+     256                 :   if (__gthread_active < 0)
+     257                 :     {
+     258                 :       __gthrw_(pthread_attr_init) (&a);
+     259                 :       __gthrw_(pthread_attr_setdetachstate) (&a, PTHREAD_CREATE_DETACHED);
+     260                 :       result = __gthrw_(pthread_create) (&t, &a, __gthread_start, NULL);
+     261                 :       if (result != ENOSYS)
+     262                 :         __gthread_active = 1;
+     263                 :       else
+     264                 :         __gthread_active = 0;
+     265                 :       __gthrw_(pthread_attr_destroy) (&a);
+     266                 :     }
+     267                 :   __gthrw_(pthread_mutex_unlock) (&__gthread_active_mutex);
+     268                 : }
+     269                 : 
+     270                 : static inline int
+     271                 : __gthread_active_p (void)
+     272                 : {
+     273                 :   /* Avoid reading __gthread_active twice on the main code path.  */
+     274                 :   int __gthread_active_latest_value = __gthread_active;
+     275                 : 
+     276                 :   /* This test is not protected to avoid taking a lock on the main code
+     277                 :      path so every update of __gthread_active in a threaded program must
+     278                 :      be atomic with regard to the result of the test.  */
+     279                 :   if (__builtin_expect (__gthread_active_latest_value < 0, 0))
+     280                 :     {
+     281                 :       __gthread_active_init ();
+     282                 :       __gthread_active_latest_value = __gthread_active;
+     283                 :     }
+     284                 : 
+     285                 :   return __gthread_active_latest_value != 0;
+     286                 : }
+     287                 : 
+     288                 : #else /* not hppa-hpux */
+     289                 : 
+     290                 : static inline int
+     291                 : __gthread_active_p (void)
+     292                 : {
+     293                 :   return 1;
+     294                 : }
+     295                 : 
+     296                 : #endif /* hppa-hpux */
+     297                 : 
+     298                 : #endif /* __GXX_WEAK__ */
+     299                 : 
+     300                 : #ifdef _LIBOBJC
+     301                 : 
+     302                 : /* This is the config.h file in libobjc/ */
+     303                 : #include <config.h>
+     304                 : 
+     305                 : #ifdef HAVE_SCHED_H
+     306                 : # include <sched.h>
+     307                 : #endif
+     308                 : 
+     309                 : /* Key structure for maintaining thread specific storage */
+     310                 : static pthread_key_t _objc_thread_storage;
+     311                 : static pthread_attr_t _objc_thread_attribs;
+     312                 : 
+     313                 : /* Thread local storage for a single thread */
+     314                 : static void *thread_local_storage = NULL;
+     315                 : 
+     316                 : /* Backend initialization functions */
+     317                 : 
+     318                 : /* Initialize the threads subsystem.  */
+     319                 : static inline int
+     320                 : __gthread_objc_init_thread_system (void)
+     321                 : {
+     322                 :   if (__gthread_active_p ())
+     323                 :     {
+     324                 :       /* Initialize the thread storage key.  */
+     325                 :       if (__gthrw_(pthread_key_create) (&_objc_thread_storage, NULL) == 0)
+     326                 :         {
+     327                 :           /* The normal default detach state for threads is
+     328                 :            * PTHREAD_CREATE_JOINABLE which causes threads to not die
+     329                 :            * when you think they should.  */
+     330                 :           if (__gthrw_(pthread_attr_init) (&_objc_thread_attribs) == 0
+     331                 :               && __gthrw_(pthread_attr_setdetachstate) (&_objc_thread_attribs,
+     332                 :                                               PTHREAD_CREATE_DETACHED) == 0)
+     333                 :             return 0;
+     334                 :         }
+     335                 :     }
+     336                 : 
+     337                 :   return -1;
+     338                 : }
+     339                 : 
+     340                 : /* Close the threads subsystem.  */
+     341                 : static inline int
+     342                 : __gthread_objc_close_thread_system (void)
+     343                 : {
+     344                 :   if (__gthread_active_p ()
+     345                 :       && __gthrw_(pthread_key_delete) (_objc_thread_storage) == 0
+     346                 :       && __gthrw_(pthread_attr_destroy) (&_objc_thread_attribs) == 0)
+     347                 :     return 0;
+     348                 : 
+     349                 :   return -1;
+     350                 : }
+     351                 : 
+     352                 : /* Backend thread functions */
+     353                 : 
+     354                 : /* Create a new thread of execution.  */
+     355                 : static inline objc_thread_t
+     356                 : __gthread_objc_thread_detach (void (*func)(void *), void *arg)
+     357                 : {
+     358                 :   objc_thread_t thread_id;
+     359                 :   pthread_t new_thread_handle;
+     360                 : 
+     361                 :   if (!__gthread_active_p ())
+     362                 :     return NULL;
+     363                 : 
+     364                 :   if (!(__gthrw_(pthread_create) (&new_thread_handle, NULL, (void *) func, arg)))
+     365                 :     thread_id = (objc_thread_t) new_thread_handle;
+     366                 :   else
+     367                 :     thread_id = NULL;
+     368                 : 
+     369                 :   return thread_id;
+     370                 : }
+     371                 : 
+     372                 : /* Set the current thread's priority.  */
+     373                 : static inline int
+     374                 : __gthread_objc_thread_set_priority (int priority)
+     375                 : {
+     376                 :   if (!__gthread_active_p ())
+     377                 :     return -1;
+     378                 :   else
+     379                 :     {
+     380                 : #ifdef _POSIX_PRIORITY_SCHEDULING
+     381                 : #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
+     382                 :       pthread_t thread_id = __gthrw_(pthread_self) ();
+     383                 :       int policy;
+     384                 :       struct sched_param params;
+     385                 :       int priority_min, priority_max;
+     386                 : 
+     387                 :       if (__gthrw_(pthread_getschedparam) (thread_id, &policy, &params) == 0)
+     388                 :         {
+     389                 :           if ((priority_max = __gthrw_(sched_get_priority_max) (policy)) == -1)
+     390                 :             return -1;
+     391                 : 
+     392                 :           if ((priority_min = __gthrw_(sched_get_priority_min) (policy)) == -1)
+     393                 :             return -1;
+     394                 : 
+     395                 :           if (priority > priority_max)
+     396                 :             priority = priority_max;
+     397                 :           else if (priority < priority_min)
+     398                 :             priority = priority_min;
+     399                 :           params.sched_priority = priority;
+     400                 : 
+     401                 :           /*
+     402                 :            * The solaris 7 and several other man pages incorrectly state that
+     403                 :            * this should be a pointer to policy but pthread.h is universally
+     404                 :            * at odds with this.
+     405                 :            */
+     406                 :           if (__gthrw_(pthread_setschedparam) (thread_id, policy, &params) == 0)
+     407                 :             return 0;
+     408                 :         }
+     409                 : #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+     410                 : #endif /* _POSIX_PRIORITY_SCHEDULING */
+     411                 :       return -1;
+     412                 :     }
+     413                 : }
+     414                 : 
+     415                 : /* Return the current thread's priority.  */
+     416                 : static inline int
+     417                 : __gthread_objc_thread_get_priority (void)
+     418                 : {
+     419                 : #ifdef _POSIX_PRIORITY_SCHEDULING
+     420                 : #ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
+     421                 :   if (__gthread_active_p ())
+     422                 :     {
+     423                 :       int policy;
+     424                 :       struct sched_param params;
+     425                 : 
+     426                 :       if (__gthrw_(pthread_getschedparam) (__gthrw_(pthread_self) (), &policy, &params) == 0)
+     427                 :         return params.sched_priority;
+     428                 :       else
+     429                 :         return -1;
+     430                 :     }
+     431                 :   else
+     432                 : #endif /* _POSIX_THREAD_PRIORITY_SCHEDULING */
+     433                 : #endif /* _POSIX_PRIORITY_SCHEDULING */
+     434                 :     return OBJC_THREAD_INTERACTIVE_PRIORITY;
+     435                 : }
+     436                 : 
+     437                 : /* Yield our process time to another thread.  */
+     438                 : static inline void
+     439                 : __gthread_objc_thread_yield (void)
+     440                 : {
+     441                 :   if (__gthread_active_p ())
+     442                 :     __gthrw_(sched_yield) ();
+     443                 : }
+     444                 : 
+     445                 : /* Terminate the current thread.  */
+     446                 : static inline int
+     447                 : __gthread_objc_thread_exit (void)
+     448                 : {
+     449                 :   if (__gthread_active_p ())
+     450                 :     /* exit the thread */
+     451                 :     __gthrw_(pthread_exit) (&__objc_thread_exit_status);
+     452                 : 
+     453                 :   /* Failed if we reached here */
+     454                 :   return -1;
+     455                 : }
+     456                 : 
+     457                 : /* Returns an integer value which uniquely describes a thread.  */
+     458                 : static inline objc_thread_t
+     459                 : __gthread_objc_thread_id (void)
+     460                 : {
+     461                 :   if (__gthread_active_p ())
+     462                 :     return (objc_thread_t) __gthrw_(pthread_self) ();
+     463                 :   else
+     464                 :     return (objc_thread_t) 1;
+     465                 : }
+     466                 : 
+     467                 : /* Sets the thread's local storage pointer.  */
+     468                 : static inline int
+     469                 : __gthread_objc_thread_set_data (void *value)
+     470                 : {
+     471                 :   if (__gthread_active_p ())
+     472                 :     return __gthrw_(pthread_setspecific) (_objc_thread_storage, value);
+     473                 :   else
+     474                 :     {
+     475                 :       thread_local_storage = value;
+     476                 :       return 0;
+     477                 :     }
+     478                 : }
+     479                 : 
+     480                 : /* Returns the thread's local storage pointer.  */
+     481                 : static inline void *
+     482                 : __gthread_objc_thread_get_data (void)
+     483                 : {
+     484                 :   if (__gthread_active_p ())
+     485                 :     return __gthrw_(pthread_getspecific) (_objc_thread_storage);
+     486                 :   else
+     487                 :     return thread_local_storage;
+     488                 : }
+     489                 : 
+     490                 : /* Backend mutex functions */
+     491                 : 
+     492                 : /* Allocate a mutex.  */
+     493                 : static inline int
+     494                 : __gthread_objc_mutex_allocate (objc_mutex_t mutex)
+     495                 : {
+     496                 :   if (__gthread_active_p ())
+     497                 :     {
+     498                 :       mutex->backend = objc_malloc (sizeof (pthread_mutex_t));
+     499                 : 
+     500                 :       if (__gthrw_(pthread_mutex_init) ((pthread_mutex_t *) mutex->backend, NULL))
+     501                 :         {
+     502                 :           objc_free (mutex->backend);
+     503                 :           mutex->backend = NULL;
+     504                 :           return -1;
+     505                 :         }
+     506                 :     }
+     507                 : 
+     508                 :   return 0;
+     509                 : }
+     510                 : 
+     511                 : /* Deallocate a mutex.  */
+     512                 : static inline int
+     513                 : __gthread_objc_mutex_deallocate (objc_mutex_t mutex)
+     514                 : {
+     515                 :   if (__gthread_active_p ())
+     516                 :     {
+     517                 :       int count;
+     518                 : 
+     519                 :       /*
+     520                 :        * Posix Threads specifically require that the thread be unlocked
+     521                 :        * for __gthrw_(pthread_mutex_destroy) to work.
+     522                 :        */
+     523                 : 
+     524                 :       do
+     525                 :         {
+     526                 :           count = __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend);
+     527                 :           if (count < 0)
+     528                 :             return -1;
+     529                 :         }
+     530                 :       while (count);
+     531                 : 
+     532                 :       if (__gthrw_(pthread_mutex_destroy) ((pthread_mutex_t *) mutex->backend))
+     533                 :         return -1;
+     534                 : 
+     535                 :       objc_free (mutex->backend);
+     536                 :       mutex->backend = NULL;
+     537                 :     }
+     538                 :   return 0;
+     539                 : }
+     540                 : 
+     541                 : /* Grab a lock on a mutex.  */
+     542                 : static inline int
+     543                 : __gthread_objc_mutex_lock (objc_mutex_t mutex)
+     544                 : {
+     545                 :   if (__gthread_active_p ()
+     546                 :       && __gthrw_(pthread_mutex_lock) ((pthread_mutex_t *) mutex->backend) != 0)
+     547                 :     {
+     548                 :       return -1;
+     549                 :     }
+     550                 : 
+     551                 :   return 0;
+     552                 : }
+     553                 : 
+     554                 : /* Try to grab a lock on a mutex.  */
+     555                 : static inline int
+     556                 : __gthread_objc_mutex_trylock (objc_mutex_t mutex)
+     557                 : {
+     558                 :   if (__gthread_active_p ()
+     559                 :       && __gthrw_(pthread_mutex_trylock) ((pthread_mutex_t *) mutex->backend) != 0)
+     560                 :     {
+     561                 :       return -1;
+     562                 :     }
+     563                 : 
+     564                 :   return 0;
+     565                 : }
+     566                 : 
+     567                 : /* Unlock the mutex */
+     568                 : static inline int
+     569                 : __gthread_objc_mutex_unlock (objc_mutex_t mutex)
+     570                 : {
+     571                 :   if (__gthread_active_p ()
+     572                 :       && __gthrw_(pthread_mutex_unlock) ((pthread_mutex_t *) mutex->backend) != 0)
+     573                 :     {
+     574                 :       return -1;
+     575                 :     }
+     576                 : 
+     577                 :   return 0;
+     578                 : }
+     579                 : 
+     580                 : /* Backend condition mutex functions */
+     581                 : 
+     582                 : /* Allocate a condition.  */
+     583                 : static inline int
+     584                 : __gthread_objc_condition_allocate (objc_condition_t condition)
+     585                 : {
+     586                 :   if (__gthread_active_p ())
+     587                 :     {
+     588                 :       condition->backend = objc_malloc (sizeof (pthread_cond_t));
+     589                 : 
+     590                 :       if (__gthrw_(pthread_cond_init) ((pthread_cond_t *) condition->backend, NULL))
+     591                 :         {
+     592                 :           objc_free (condition->backend);
+     593                 :           condition->backend = NULL;
+     594                 :           return -1;
+     595                 :         }
+     596                 :     }
+     597                 : 
+     598                 :   return 0;
+     599                 : }
+     600                 : 
+     601                 : /* Deallocate a condition.  */
+     602                 : static inline int
+     603                 : __gthread_objc_condition_deallocate (objc_condition_t condition)
+     604                 : {
+     605                 :   if (__gthread_active_p ())
+     606                 :     {
+     607                 :       if (__gthrw_(pthread_cond_destroy) ((pthread_cond_t *) condition->backend))
+     608                 :         return -1;
+     609                 : 
+     610                 :       objc_free (condition->backend);
+     611                 :       condition->backend = NULL;
+     612                 :     }
+     613                 :   return 0;
+     614                 : }
+     615                 : 
+     616                 : /* Wait on the condition */
+     617                 : static inline int
+     618                 : __gthread_objc_condition_wait (objc_condition_t condition, objc_mutex_t mutex)
+     619                 : {
+     620                 :   if (__gthread_active_p ())
+     621                 :     return __gthrw_(pthread_cond_wait) ((pthread_cond_t *) condition->backend,
+     622                 :                               (pthread_mutex_t *) mutex->backend);
+     623                 :   else
+     624                 :     return 0;
+     625                 : }
+     626                 : 
+     627                 : /* Wake up all threads waiting on this condition.  */
+     628                 : static inline int
+     629                 : __gthread_objc_condition_broadcast (objc_condition_t condition)
+     630                 : {
+     631                 :   if (__gthread_active_p ())
+     632                 :     return __gthrw_(pthread_cond_broadcast) ((pthread_cond_t *) condition->backend);
+     633                 :   else
+     634                 :     return 0;
+     635                 : }
+     636                 : 
+     637                 : /* Wake up one thread waiting on this condition.  */
+     638                 : static inline int
+     639                 : __gthread_objc_condition_signal (objc_condition_t condition)
+     640                 : {
+     641                 :   if (__gthread_active_p ())
+     642                 :     return __gthrw_(pthread_cond_signal) ((pthread_cond_t *) condition->backend);
+     643                 :   else
+     644                 :     return 0;
+     645                 : }
+     646                 : 
+     647                 : #else /* _LIBOBJC */
+     648                 : 
+     649                 : static inline int
+     650                 : __gthread_once (__gthread_once_t *once, void (*func) (void))
+     651                 : {
+     652                 :   if (__gthread_active_p ())
+     653                 :     return __gthrw_(pthread_once) (once, func);
+     654                 :   else
+     655                 :     return -1;
+     656                 : }
+     657                 : 
+     658                 : static inline int
+     659                 : __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *))
+     660                 : {
+     661                 :   return __gthrw_(pthread_key_create) (key, dtor);
+     662                 : }
+     663                 : 
+     664                 : static inline int
+     665                 : __gthread_key_delete (__gthread_key_t key)
+     666                 : {
+     667                 :   return __gthrw_(pthread_key_delete) (key);
+     668                 : }
+     669                 : 
+     670                 : static inline void *
+     671                 : __gthread_getspecific (__gthread_key_t key)
+     672                 : {
+     673                 :   return __gthrw_(pthread_getspecific) (key);
+     674                 : }
+     675                 : 
+     676                 : static inline int
+     677                 : __gthread_setspecific (__gthread_key_t key, const void *ptr)
+     678                 : {
+     679                 :   return __gthrw_(pthread_setspecific) (key, ptr);
+     680                 : }
+     681                 : 
+     682                 : static inline int
+     683                 : __gthread_mutex_lock (__gthread_mutex_t *mutex)
+     684                 : {
+     685                 :   if (__gthread_active_p ())
+     686                 :     return __gthrw_(pthread_mutex_lock) (mutex);
+     687                 :   else
+     688                 :     return 0;
+     689                 : }
+     690                 : 
+     691                 : static inline int
+     692                 : __gthread_mutex_trylock (__gthread_mutex_t *mutex)
+     693                 : {
+     694                 :   if (__gthread_active_p ())
+     695                 :     return __gthrw_(pthread_mutex_trylock) (mutex);
+     696                 :   else
+     697                 :     return 0;
+     698                 : }
+     699                 : 
+     700                 : static inline int
+     701                 : __gthread_mutex_unlock (__gthread_mutex_t *mutex)
+     702                 : {
+     703                 :   if (__gthread_active_p ())
+     704                 :     return __gthrw_(pthread_mutex_unlock) (mutex);
+     705                 :   else
+     706                 :     return 0;
+     707                 : }
+     708                 : 
+     709                 : #ifndef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
+     710                 : static inline int
+     711                 : __gthread_recursive_mutex_init_function (__gthread_recursive_mutex_t *mutex)
+     712                 : {
+     713                 :   if (__gthread_active_p ())
+     714                 :     {
+     715                 :       pthread_mutexattr_t attr;
+     716                 :       int r;
+     717                 : 
+     718                 :       r = __gthrw_(pthread_mutexattr_init) (&attr);
+     719                 :       if (!r)
+     720                 :         r = __gthrw_(pthread_mutexattr_settype) (&attr, PTHREAD_MUTEX_RECURSIVE);
+     721                 :       if (!r)
+     722                 :         r = __gthrw_(pthread_mutex_init) (mutex, &attr);
+     723                 :       if (!r)
+     724                 :         r = __gthrw_(pthread_mutexattr_destroy) (&attr);
+     725                 :       return r;
+     726                 :     }
+     727                 :   return 0;
+     728                 : }
+     729                 : #endif
+     730                 : 
+     731                 : static inline int
+     732                 : __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex)
+     733                 : {
+     734                 :   return __gthread_mutex_lock (mutex);
+     735                 : }
+     736                 : 
+     737                 : static inline int
+     738                 : __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex)
+     739                 : {
+     740                 :   return __gthread_mutex_trylock (mutex);
+     741                 : }
+     742                 : 
+     743                 : static inline int
+     744                 : __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex)
+     745                 : {
+     746                 :   return __gthread_mutex_unlock (mutex);
+     747                 : }
+     748                 : 
+     749                 : static inline int
+     750                 : __gthread_cond_broadcast (__gthread_cond_t *cond)
+     751                 : {
+     752                 :   return __gthrw_(pthread_cond_broadcast) (cond);
+     753                 : }
+     754                 : 
+     755                 : static inline int
+     756                 : __gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex)
+     757                 : {
+     758                 :   return __gthrw_(pthread_cond_wait) (cond, mutex);
+     759                 : }
+     760                 : 
+     761                 : static inline int
+     762                 : __gthread_cond_wait_recursive (__gthread_cond_t *cond,
+     763                 :                                __gthread_recursive_mutex_t *mutex)
+     764                 : {
+     765                 :   return __gthread_cond_wait (cond, mutex);
+     766                 : }
+     767                 : 
+     768                 : #endif /* _LIBOBJC */
+     769                 : 
+     770                 : #endif /* ! _GLIBCXX_GCC_GTHR_POSIX_H */
+
+
+
+ + + + +
Generated by: LTP GCOV extension version 1.6
+
+ + + diff --git a/rep/usr/include/c++/4.3/i486-linux-gnu/bits/index.html b/rep/usr/include/c++/4.3/i486-linux-gnu/bits/index.html new file mode 100644 index 0000000..14ebc63 --- /dev/null +++ b/rep/usr/include/c++/4.3/i486-linux-gnu/bits/index.html @@ -0,0 +1,83 @@ + + + + + + + LCOV - lcov.info - /usr/include/c++/4.3/i486-linux-gnu/bits + + + + + + + + + + + + + +
LTP GCOV extension - code coverage report
+ + + + + + + + + + + + + + + + + + + + + + + +
Current view:directory - /usr/include/c++/4.3/i486-linux-gnu/bits
Test:lcov.info
Date:2008-08-14Instrumented lines:2
Code covered:0.0 %Executed lines:0
+
+ +
+ + + + + + + + + + + + + + + + + + + + + +

FilenameCoverage
gthr-default.h +
0.0%
+ 		0.0 %0 / 2 lines
+
+
+ + + + +
Generated by: LTP GCOV extension version 1.6
+
+ + + -- cgit v1.2.3