From fb21a4dfe2c81640379f64855509fb7613530887 Mon Sep 17 00:00:00 2001 From: Enrico Zini Date: Wed, 9 Sep 2015 22:43:35 +0200 Subject: Removed wrongly added coverage report --- .../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 deletions(-) delete mode 100644 rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html delete 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') 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 deleted file mode 100644 index 5529fc3..0000000 --- a/rep/usr/include/c++/4.3/i486-linux-gnu/bits/gthr-default.h.gcov.html +++ /dev/null @@ -1,837 +0,0 @@ - - - - - - - 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 deleted file mode 100644 index 14ebc63..0000000 --- a/rep/usr/include/c++/4.3/i486-linux-gnu/bits/index.html +++ /dev/null @@ -1,83 +0,0 @@ - - - - - - - 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