1 /* Routines required for instrumenting a program.  */
2 /* Compile this one with gcc.  */
3 /* Copyright (C) 1989-2018 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
__gcov_flush(void)32 void __gcov_flush (void) {}
33 #endif
34 
35 #ifdef L_gcov_reset
__gcov_reset(void)36 void __gcov_reset (void) {}
37 #endif
38 
39 #ifdef L_gcov_dump
__gcov_dump(void)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
init_mx(void)65 init_mx (void)
66 {
67   __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx);
68 }
69 
70 static void
init_mx_once(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
__gcov_flush(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
gcov_clear(const struct gcov_info * list)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
__gcov_reset_int(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
__gcov_dump_int(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
__gcov_fork(void)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
__gcov_execl(const char * path,char * arg,...)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
__gcov_execlp(const char * path,char * arg,...)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
__gcov_execle(const char * path,char * arg,...)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
__gcov_execv(const char * path,char * const argv[])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
__gcov_execvp(const char * path,char * const argv[])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
__gcov_execve(const char * path,char * const argv[],char * const envp[])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 */
318