libgcc/libgcov-interface.c

   1 /* Routines required for instrumenting a program.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989-2014 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 #include "libgcov.h"
  27 #include "gthr.h"
  28
  29 #if defined(inhibit_libc)
  30
  31 #ifdef L_gcov_flush
  32 void __gcov_flush (void) {}
  33 #endif
  34
  35 #ifdef L_gcov_reset
  36 void __gcov_reset (void) {}
  37 #endif
  38
  39 #ifdef L_gcov_dump
  40 void __gcov_dump (void) {}
  41 #endif
  42
  43 #else
  44
  45 /* Some functions we want to bind in this dynamic object, but have an
  46    overridable global alias.  Unfortunately not all targets support
  47    aliases, so we just have a forwarding function.  That'll be tail
  48    called, so the cost is a single jump instruction.*/
  49
  50 #define ALIAS_void_fn(src,dst) \
  51   void dst (void)           \
  52   { src (); }
  53
  54 extern __gthread_mutex_t __gcov_flush_mx ATTRIBUTE_HIDDEN;
  55 extern __gthread_mutex_t __gcov_flush_mx ATTRIBUTE_HIDDEN;
  56
  57 #ifdef L_gcov_flush
  58 #ifdef __GTHREAD_MUTEX_INIT
  59 __gthread_mutex_t __gcov_flush_mx = __GTHREAD_MUTEX_INIT;
  60 #define init_mx_once()
  61 #else
  62 __gthread_mutex_t __gcov_flush_mx;
  63
  64 static void
  65 init_mx (void)
  66 {
  67   __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx);
  68 }
  69
  70 static void
  71 init_mx_once (void)
  72 {
  73   static __gthread_once_t once = __GTHREAD_ONCE_INIT;
  74   __gthread_once (&once, init_mx);
  75 }
  76 #endif
  77
  78 /* Called before fork or exec - write out profile information gathered so
  79    far and reset it to zero.  This avoids duplication or loss of the
  80    profile information gathered so far.  */
  81
  82 void
  83 __gcov_flush (void)
  84 {
  85   init_mx_once ();
  86   __gthread_mutex_lock (&__gcov_flush_mx);
  87
  88   __gcov_dump_int ();
  89   __gcov_reset_int ();
  90
  91   __gthread_mutex_unlock (&__gcov_flush_mx);
  92 }
  93
  94 #endif /* L_gcov_flush */
  95
  96 #ifdef L_gcov_reset
  97
  98 /* Reset all counters to zero.  */
  99
 100 static void
 101 gcov_clear (const struct gcov_info *list)
 102 {
 103   const struct gcov_info *gi_ptr;
 104
 105   for (gi_ptr = list; gi_ptr; gi_ptr = gi_ptr->next)
 106     {
 107       unsigned f_ix;
 108
 109       for (f_ix = 0; f_ix < gi_ptr->n_functions; f_ix++)
 110         {
 111           unsigned t_ix;
 112           const struct gcov_fn_info *gfi_ptr = gi_ptr->functions[f_ix];
 113
 114           if (!gfi_ptr || gfi_ptr->key != gi_ptr)
 115             continue;
 116           const struct gcov_ctr_info *ci_ptr = gfi_ptr->ctrs;
 117           for (t_ix = 0; t_ix != GCOV_COUNTERS; t_ix++)
 118             {
 119               if (!gi_ptr->merge[t_ix])
 120                 continue;
 121
 122               memset (ci_ptr->values, 0, sizeof (gcov_type) * ci_ptr->num);
 123               ci_ptr++;
 124             }
 125         }
 126     }
 127 }
 128
 129 /* Function that can be called from application to reset counters to zero,
 130    in order to collect profile in region of interest.  */
 131
 132 void
 133 __gcov_reset_int (void)
 134 {
 135   struct gcov_root *root;
 136
 137   /* If we're compatible with the master, iterate over everything,
 138      otherise just do us.  */
 139   for (root = __gcov_master.version == GCOV_VERSION
 140          ? __gcov_master.root : &__gcov_root; root; root = root->next)
 141     {
 142       gcov_clear (root->list);
 143       root->dumped = 0;
 144     }
 145 }
 146
 147 ALIAS_void_fn (__gcov_reset_int, __gcov_reset);
 148
 149 #endif /* L_gcov_reset */
 150
 151 #ifdef L_gcov_dump
 152 /* Function that can be called from application to write profile collected
 153    so far, in order to collect profile in region of interest.  */
 154
 155 void
 156 __gcov_dump_int (void)
 157 {
 158   struct gcov_root *root;
 159
 160   /* If we're compatible with the master, iterate over everything,
 161      otherise just do us.  */
 162   for (root = __gcov_master.version == GCOV_VERSION
 163          ? __gcov_master.root : &__gcov_root; root; root = root->next)
 164     __gcov_dump_one (root);
 165 }
 166
 167 ALIAS_void_fn (__gcov_dump_int, __gcov_dump);
 168
 169 #endif /* L_gcov_dump */
 170
 171 #ifdef L_gcov_fork
 172 /* A wrapper for the fork function.  Flushes the accumulated profiling data, so
 173    that they are not counted twice.  */
 174
 175 pid_t
 176 __gcov_fork (void)
 177 {
 178   pid_t pid;
 179   __gcov_flush ();
 180   pid = fork ();
 181   if (pid == 0)
 182     __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx);
 183   return pid;
 184 }
 185 #endif
 186
 187 #ifdef L_gcov_execl
 188 /* A wrapper for the execl function.  Flushes the accumulated
 189    profiling data, so that they are not lost.  */
 190
 191 int
 192 __gcov_execl (const char *path, char *arg, ...)
 193 {
 194   va_list ap, aq;
 195   unsigned i, length;
 196   char **args;
 197
 198   __gcov_flush ();
 199
 200   va_start (ap, arg);
 201   va_copy (aq, ap);
 202
 203   length = 2;
 204   while (va_arg (ap, char *))
 205     length++;
 206   va_end (ap);
 207
 208   args = (char **) alloca (length * sizeof (void *));
 209   args[0] = arg;
 210   for (i = 1; i < length; i++)
 211     args[i] = va_arg (aq, char *);
 212   va_end (aq);
 213
 214   return execv (path, args);
 215 }
 216 #endif
 217
 218 #ifdef L_gcov_execlp
 219 /* A wrapper for the execlp function.  Flushes the accumulated
 220    profiling data, so that they are not lost.  */
 221
 222 int
 223 __gcov_execlp (const char *path, char *arg, ...)
 224 {
 225   va_list ap, aq;
 226   unsigned i, length;
 227   char **args;
 228
 229   __gcov_flush ();
 230
 231   va_start (ap, arg);
 232   va_copy (aq, ap);
 233
 234   length = 2;
 235   while (va_arg (ap, char *))
 236     length++;
 237   va_end (ap);
 238
 239   args = (char **) alloca (length * sizeof (void *));
 240   args[0] = arg;
 241   for (i = 1; i < length; i++)
 242     args[i] = va_arg (aq, char *);
 243   va_end (aq);
 244
 245   return execvp (path, args);
 246 }
 247 #endif
 248
 249 #ifdef L_gcov_execle
 250 /* A wrapper for the execle function.  Flushes the accumulated
 251    profiling data, so that they are not lost.  */
 252
 253 int
 254 __gcov_execle (const char *path, char *arg, ...)
 255 {
 256   va_list ap, aq;
 257   unsigned i, length;
 258   char **args;
 259   char **envp;
 260
 261   __gcov_flush ();
 262
 263   va_start (ap, arg);
 264   va_copy (aq, ap);
 265
 266   length = 2;
 267   while (va_arg (ap, char *))
 268     length++;
 269   va_end (ap);
 270
 271   args = (char **) alloca (length * sizeof (void *));
 272   args[0] = arg;
 273   for (i = 1; i < length; i++)
 274     args[i] = va_arg (aq, char *);
 275   envp = va_arg (aq, char **);
 276   va_end (aq);
 277
 278   return execve (path, args, envp);
 279 }
 280 #endif
 281
 282 #ifdef L_gcov_execv
 283 /* A wrapper for the execv function.  Flushes the accumulated
 284    profiling data, so that they are not lost.  */
 285
 286 int
 287 __gcov_execv (const char *path, char *const argv[])
 288 {
 289   __gcov_flush ();
 290   return execv (path, argv);
 291 }
 292 #endif
 293
 294 #ifdef L_gcov_execvp
 295 /* A wrapper for the execvp function.  Flushes the accumulated
 296    profiling data, so that they are not lost.  */
 297
 298 int
 299 __gcov_execvp (const char *path, char *const argv[])
 300 {
 301   __gcov_flush ();
 302   return execvp (path, argv);
 303 }
 304 #endif
 305
 306 #ifdef L_gcov_execve
 307 /* A wrapper for the execve function.  Flushes the accumulated
 308    profiling data, so that they are not lost.  */
 309
 310 int
 311 __gcov_execve (const char *path, char *const argv[], char *const envp[])
 312 {
 313   __gcov_flush ();
 314   return execve (path, argv, envp);
 315 }
 316 #endif
 317 #endif /* inhibit_libc */