libgcc/libgcov-interface.c

   1 /* Routines required for instrumenting a program.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1989-2013 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 "tconfig.h"
  27 #include "tsystem.h"
  28 #include "coretypes.h"
  29 #include "tm.h"
  30 #include "libgcc_tm.h"
  31 #include "gthr.h"
  32
  33 #if defined(inhibit_libc)
  34 #define IN_LIBGCOV (-1)
  35 #else
  36 #define IN_LIBGCOV 1
  37 #endif
  38 #include "gcov-io.h"
  39
  40 #if defined(inhibit_libc)
  41
  42 #ifdef L_gcov_flush
  43 void __gcov_flush (void) {}
  44 #endif
  45
  46 #ifdef L_gcov_reset
  47 void __gcov_reset (void) {}
  48 #endif
  49
  50 #ifdef L_gcov_dump
  51 void __gcov_dump (void) {}
  52 #endif
  53
  54 #else
  55
  56 extern void gcov_clear (void) ATTRIBUTE_HIDDEN;
  57 extern void gcov_exit (void) ATTRIBUTE_HIDDEN;
  58 extern void set_gcov_dump_complete (void) ATTRIBUTE_HIDDEN;
  59 extern void reset_gcov_dump_complete (void) ATTRIBUTE_HIDDEN;
  60
  61 #ifdef L_gcov_flush
  62
  63 #ifdef __GTHREAD_MUTEX_INIT
  64 ATTRIBUTE_HIDDEN __gthread_mutex_t __gcov_flush_mx = __GTHREAD_MUTEX_INIT;
  65 #define init_mx_once()
  66 #else
  67 __gthread_mutex_t __gcov_flush_mx ATTRIBUTE_HIDDEN;
  68
  69 static void
  70 init_mx (void)
  71 {
  72   __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx);
  73 }
  74 static void
  75 init_mx_once (void)
  76 {
  77   static __gthread_once_t once = __GTHREAD_ONCE_INIT;
  78   __gthread_once (&once, init_mx);
  79 }
  80 #endif
  81
  82 /* Called before fork or exec - write out profile information gathered so
  83    far and reset it to zero.  This avoids duplication or loss of the
  84    profile information gathered so far.  */
  85
  86 void
  87 __gcov_flush (void)
  88 {
  89   init_mx_once ();
  90   __gthread_mutex_lock (&__gcov_flush_mx);
  91
  92   gcov_exit ();
  93   gcov_clear ();
  94
  95   __gthread_mutex_unlock (&__gcov_flush_mx);
  96 }
  97
  98 #endif /* L_gcov_flush */
  99
 100 #ifdef L_gcov_reset
 101
 102 /* Function that can be called from application to reset counters to zero,
 103    in order to collect profile in region of interest.  */
 104
 105 void
 106 __gcov_reset (void)
 107 {
 108   gcov_clear ();
 109   /* Re-enable dumping to support collecting profile in multiple regions
 110      of interest.  */
 111   reset_gcov_dump_complete ();
 112 }
 113
 114 #endif /* L_gcov_reset */
 115
 116 #ifdef L_gcov_dump
 117
 118 /* Function that can be called from application to write profile collected
 119    so far, in order to collect profile in region of interest.  */
 120
 121 void
 122 __gcov_dump (void)
 123 {
 124   gcov_exit ();
 125   /* Prevent profile from being dumped a second time on application exit.  */
 126   set_gcov_dump_complete ();
 127 }
 128
 129 #endif /* L_gcov_dump */
 130
 131
 132 #ifdef L_gcov_fork
 133 /* A wrapper for the fork function.  Flushes the accumulated profiling data, so
 134    that they are not counted twice.  */
 135
 136 pid_t
 137 __gcov_fork (void)
 138 {
 139   pid_t pid;
 140   extern __gthread_mutex_t __gcov_flush_mx;
 141   __gcov_flush ();
 142   pid = fork ();
 143   if (pid == 0)
 144     __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx);
 145   return pid;
 146 }
 147 #endif
 148
 149 #ifdef L_gcov_execl
 150 /* A wrapper for the execl function.  Flushes the accumulated profiling data, so
 151    that they are not lost.  */
 152
 153 int
 154 __gcov_execl (const char *path, char *arg, ...)
 155 {
 156   va_list ap, aq;
 157   unsigned i, length;
 158   char **args;
 159
 160   __gcov_flush ();
 161
 162   va_start (ap, arg);
 163   va_copy (aq, ap);
 164
 165   length = 2;
 166   while (va_arg (ap, char *))
 167     length++;
 168   va_end (ap);
 169
 170   args = (char **) alloca (length * sizeof (void *));
 171   args[0] = arg;
 172   for (i = 1; i < length; i++)
 173     args[i] = va_arg (aq, char *);
 174   va_end (aq);
 175
 176   return execv (path, args);
 177 }
 178 #endif
 179
 180 #ifdef L_gcov_execlp
 181 /* A wrapper for the execlp function.  Flushes the accumulated profiling data, so
 182    that they are not lost.  */
 183
 184 int
 185 __gcov_execlp (const char *path, char *arg, ...)
 186 {
 187   va_list ap, aq;
 188   unsigned i, length;
 189   char **args;
 190
 191   __gcov_flush ();
 192
 193   va_start (ap, arg);
 194   va_copy (aq, ap);
 195
 196   length = 2;
 197   while (va_arg (ap, char *))
 198     length++;
 199   va_end (ap);
 200
 201   args = (char **) alloca (length * sizeof (void *));
 202   args[0] = arg;
 203   for (i = 1; i < length; i++)
 204     args[i] = va_arg (aq, char *);
 205   va_end (aq);
 206
 207   return execvp (path, args);
 208 }
 209 #endif
 210
 211 #ifdef L_gcov_execle
 212 /* A wrapper for the execle function.  Flushes the accumulated profiling data, so
 213    that they are not lost.  */
 214
 215 int
 216 __gcov_execle (const char *path, char *arg, ...)
 217 {
 218   va_list ap, aq;
 219   unsigned i, length;
 220   char **args;
 221   char **envp;
 222
 223   __gcov_flush ();
 224
 225   va_start (ap, arg);
 226   va_copy (aq, ap);
 227
 228   length = 2;
 229   while (va_arg (ap, char *))
 230     length++;
 231   va_end (ap);
 232
 233   args = (char **) alloca (length * sizeof (void *));
 234   args[0] = arg;
 235   for (i = 1; i < length; i++)
 236     args[i] = va_arg (aq, char *);
 237   envp = va_arg (aq, char **);
 238   va_end (aq);
 239
 240   return execve (path, args, envp);
 241 }
 242 #endif
 243
 244 #ifdef L_gcov_execv
 245 /* A wrapper for the execv function.  Flushes the accumulated profiling data, so
 246    that they are not lost.  */
 247
 248 int
 249 __gcov_execv (const char *path, char *const argv[])
 250 {
 251   __gcov_flush ();
 252   return execv (path, argv);
 253 }
 254 #endif
 255
 256 #ifdef L_gcov_execvp
 257 /* A wrapper for the execvp function.  Flushes the accumulated profiling data, so
 258    that they are not lost.  */
 259
 260 int
 261 __gcov_execvp (const char *path, char *const argv[])
 262 {
 263   __gcov_flush ();
 264   return execvp (path, argv);
 265 }
 266 #endif
 267
 268 #ifdef L_gcov_execve
 269 /* A wrapper for the execve function.  Flushes the accumulated profiling data, so
 270    that they are not lost.  */
 271
 272 int
 273 __gcov_execve (const char *path, char *const argv[], char *const envp[])
 274 {
 275   __gcov_flush ();
 276   return execve (path, argv, envp);
 277 }
 278 #endif
 279 #endif /* inhibit_libc */