|
111
|
1 /* Header file for libgcov-*.c.
|
|
145
|
2 Copyright (C) 1996-2020 Free Software Foundation, Inc.
|
|
111
|
3
|
|
|
4 This file is part of GCC.
|
|
|
5
|
|
|
6 GCC is free software; you can redistribute it and/or modify it under
|
|
|
7 the terms of the GNU General Public License as published by the Free
|
|
|
8 Software Foundation; either version 3, or (at your option) any later
|
|
|
9 version.
|
|
|
10
|
|
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
|
14 for more details.
|
|
|
15
|
|
|
16 Under Section 7 of GPL version 3, you are granted additional
|
|
|
17 permissions described in the GCC Runtime Library Exception, version
|
|
|
18 3.1, as published by the Free Software Foundation.
|
|
|
19
|
|
|
20 You should have received a copy of the GNU General Public License and
|
|
|
21 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
22 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
23 <http://www.gnu.org/licenses/>. */
|
|
|
24
|
|
|
25 #ifndef GCC_LIBGCOV_H
|
|
|
26 #define GCC_LIBGCOV_H
|
|
|
27
|
|
|
28 /* work around the poisoned malloc/calloc in system.h. */
|
|
|
29 #ifndef xmalloc
|
|
|
30 #define xmalloc malloc
|
|
|
31 #endif
|
|
|
32 #ifndef xcalloc
|
|
|
33 #define xcalloc calloc
|
|
|
34 #endif
|
|
|
35
|
|
|
36 #ifndef IN_GCOV_TOOL
|
|
|
37 /* About the target. */
|
|
|
38 /* This path will be used by libgcov runtime. */
|
|
|
39
|
|
|
40 #include "tconfig.h"
|
|
|
41 #include "auto-target.h"
|
|
|
42 #include "tsystem.h"
|
|
|
43 #include "coretypes.h"
|
|
|
44 #include "tm.h"
|
|
|
45 #include "libgcc_tm.h"
|
|
|
46 #include "gcov.h"
|
|
|
47
|
|
|
48 #if __CHAR_BIT__ == 8
|
|
|
49 typedef unsigned gcov_unsigned_t __attribute__ ((mode (SI)));
|
|
|
50 typedef unsigned gcov_position_t __attribute__ ((mode (SI)));
|
|
|
51 #if LONG_LONG_TYPE_SIZE > 32
|
|
|
52 typedef signed gcov_type __attribute__ ((mode (DI)));
|
|
|
53 typedef unsigned gcov_type_unsigned __attribute__ ((mode (DI)));
|
|
|
54 #else
|
|
|
55 typedef signed gcov_type __attribute__ ((mode (SI)));
|
|
|
56 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
|
|
|
57 #endif
|
|
|
58 #else
|
|
|
59 #if __CHAR_BIT__ == 16
|
|
|
60 typedef unsigned gcov_unsigned_t __attribute__ ((mode (HI)));
|
|
|
61 typedef unsigned gcov_position_t __attribute__ ((mode (HI)));
|
|
|
62 #if LONG_LONG_TYPE_SIZE > 32
|
|
|
63 typedef signed gcov_type __attribute__ ((mode (SI)));
|
|
|
64 typedef unsigned gcov_type_unsigned __attribute__ ((mode (SI)));
|
|
|
65 #else
|
|
|
66 typedef signed gcov_type __attribute__ ((mode (HI)));
|
|
|
67 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
|
|
|
68 #endif
|
|
|
69 #else
|
|
|
70 typedef unsigned gcov_unsigned_t __attribute__ ((mode (QI)));
|
|
|
71 typedef unsigned gcov_position_t __attribute__ ((mode (QI)));
|
|
|
72 #if LONG_LONG_TYPE_SIZE > 32
|
|
|
73 typedef signed gcov_type __attribute__ ((mode (HI)));
|
|
|
74 typedef unsigned gcov_type_unsigned __attribute__ ((mode (HI)));
|
|
|
75 #else
|
|
|
76 typedef signed gcov_type __attribute__ ((mode (QI)));
|
|
|
77 typedef unsigned gcov_type_unsigned __attribute__ ((mode (QI)));
|
|
|
78 #endif
|
|
|
79 #endif
|
|
|
80 #endif
|
|
|
81
|
|
|
82 #if defined (TARGET_POSIX_IO)
|
|
|
83 #define GCOV_LOCKED 1
|
|
|
84 #else
|
|
|
85 #define GCOV_LOCKED 0
|
|
|
86 #endif
|
|
|
87
|
|
|
88 /* In libgcov we need these functions to be extern, so prefix them with
|
|
|
89 __gcov. In libgcov they must also be hidden so that the instance in
|
|
|
90 the executable is not also used in a DSO. */
|
|
|
91 #define gcov_var __gcov_var
|
|
|
92 #define gcov_open __gcov_open
|
|
|
93 #define gcov_close __gcov_close
|
|
|
94 #define gcov_write_tag_length __gcov_write_tag_length
|
|
|
95 #define gcov_position __gcov_position
|
|
|
96 #define gcov_seek __gcov_seek
|
|
|
97 #define gcov_rewrite __gcov_rewrite
|
|
|
98 #define gcov_is_error __gcov_is_error
|
|
|
99 #define gcov_write_unsigned __gcov_write_unsigned
|
|
|
100 #define gcov_write_counter __gcov_write_counter
|
|
|
101 #define gcov_write_summary __gcov_write_summary
|
|
|
102 #define gcov_read_unsigned __gcov_read_unsigned
|
|
|
103 #define gcov_read_counter __gcov_read_counter
|
|
|
104 #define gcov_read_summary __gcov_read_summary
|
|
|
105
|
|
|
106 #else /* IN_GCOV_TOOL */
|
|
|
107 /* About the host. */
|
|
|
108 /* This path will be compiled for the host and linked into
|
|
|
109 gcov-tool binary. */
|
|
|
110
|
|
|
111 #include "config.h"
|
|
|
112 #include "system.h"
|
|
|
113 #include "coretypes.h"
|
|
|
114 #include "tm.h"
|
|
|
115
|
|
|
116 typedef unsigned gcov_unsigned_t;
|
|
|
117 typedef unsigned gcov_position_t;
|
|
|
118 /* gcov_type is typedef'd elsewhere for the compiler */
|
|
|
119 #if defined (HOST_HAS_F_SETLKW)
|
|
|
120 #define GCOV_LOCKED 1
|
|
|
121 #else
|
|
|
122 #define GCOV_LOCKED 0
|
|
|
123 #endif
|
|
|
124
|
|
|
125 /* Some Macros specific to gcov-tool. */
|
|
|
126
|
|
|
127 #define L_gcov 1
|
|
|
128 #define L_gcov_merge_add 1
|
|
145
|
129 #define L_gcov_merge_topn 1
|
|
111
|
130 #define L_gcov_merge_ior 1
|
|
|
131 #define L_gcov_merge_time_profile 1
|
|
|
132
|
|
|
133 extern gcov_type gcov_read_counter_mem ();
|
|
|
134 extern unsigned gcov_get_merge_weight ();
|
|
|
135 extern struct gcov_info *gcov_list;
|
|
|
136
|
|
|
137 #endif /* !IN_GCOV_TOOL */
|
|
|
138
|
|
|
139 #if defined(inhibit_libc)
|
|
|
140 #define IN_LIBGCOV (-1)
|
|
|
141 #else
|
|
|
142 #define IN_LIBGCOV 1
|
|
|
143 #if defined(L_gcov)
|
|
|
144 #define GCOV_LINKAGE /* nothing */
|
|
|
145 #endif
|
|
|
146 #endif
|
|
|
147
|
|
|
148 /* Poison these, so they don't accidentally slip in. */
|
|
|
149 #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length
|
|
|
150 #pragma GCC poison gcov_time gcov_magic
|
|
|
151
|
|
|
152 #ifdef HAVE_GAS_HIDDEN
|
|
|
153 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
|
|
|
154 #else
|
|
|
155 #define ATTRIBUTE_HIDDEN
|
|
|
156 #endif
|
|
|
157
|
|
|
158 #include "gcov-io.h"
|
|
|
159
|
|
|
160 /* Structures embedded in coveraged program. The structures generated
|
|
|
161 by write_profile must match these. */
|
|
|
162
|
|
|
163 /* Information about counters for a single function. */
|
|
|
164 struct gcov_ctr_info
|
|
|
165 {
|
|
|
166 gcov_unsigned_t num; /* number of counters. */
|
|
|
167 gcov_type *values; /* their values. */
|
|
|
168 };
|
|
|
169
|
|
|
170 /* Information about a single function. This uses the trailing array
|
|
|
171 idiom. The number of counters is determined from the merge pointer
|
|
|
172 array in gcov_info. The key is used to detect which of a set of
|
|
|
173 comdat functions was selected -- it points to the gcov_info object
|
|
|
174 of the object file containing the selected comdat function. */
|
|
|
175
|
|
|
176 struct gcov_fn_info
|
|
|
177 {
|
|
|
178 const struct gcov_info *key; /* comdat key */
|
|
|
179 gcov_unsigned_t ident; /* unique ident of function */
|
|
|
180 gcov_unsigned_t lineno_checksum; /* function lineo_checksum */
|
|
|
181 gcov_unsigned_t cfg_checksum; /* function cfg checksum */
|
|
|
182 struct gcov_ctr_info ctrs[1]; /* instrumented counters */
|
|
|
183 };
|
|
|
184
|
|
|
185 /* Type of function used to merge counters. */
|
|
|
186 typedef void (*gcov_merge_fn) (gcov_type *, gcov_unsigned_t);
|
|
|
187
|
|
|
188 /* Information about a single object file. */
|
|
|
189 struct gcov_info
|
|
|
190 {
|
|
|
191 gcov_unsigned_t version; /* expected version number */
|
|
|
192 struct gcov_info *next; /* link to next, used by libgcov */
|
|
|
193
|
|
|
194 gcov_unsigned_t stamp; /* uniquifying time stamp */
|
|
|
195 const char *filename; /* output file name */
|
|
|
196
|
|
|
197 gcov_merge_fn merge[GCOV_COUNTERS]; /* merge functions (null for
|
|
|
198 unused) */
|
|
|
199
|
|
|
200 unsigned n_functions; /* number of functions */
|
|
|
201
|
|
|
202 #ifndef IN_GCOV_TOOL
|
|
|
203 const struct gcov_fn_info *const *functions; /* pointer to pointers
|
|
|
204 to function information */
|
|
|
205 #else
|
|
|
206 const struct gcov_fn_info **functions;
|
|
|
207 #endif /* !IN_GCOV_TOOL */
|
|
|
208 };
|
|
|
209
|
|
|
210 /* Root of a program/shared-object state */
|
|
|
211 struct gcov_root
|
|
|
212 {
|
|
|
213 struct gcov_info *list;
|
|
|
214 unsigned dumped : 1; /* counts have been dumped. */
|
|
|
215 unsigned run_counted : 1; /* run has been accounted for. */
|
|
|
216 struct gcov_root *next;
|
|
|
217 struct gcov_root *prev;
|
|
|
218 };
|
|
|
219
|
|
|
220 extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN;
|
|
|
221
|
|
|
222 struct gcov_master
|
|
|
223 {
|
|
|
224 gcov_unsigned_t version;
|
|
|
225 struct gcov_root *root;
|
|
|
226 };
|
|
131
|
227
|
|
|
228 struct indirect_call_tuple
|
|
|
229 {
|
|
|
230 /* Callee function. */
|
|
|
231 void *callee;
|
|
|
232
|
|
|
233 /* Pointer to counters. */
|
|
|
234 gcov_type *counters;
|
|
|
235 };
|
|
111
|
236
|
|
|
237 /* Exactly one of these will be active in the process. */
|
|
|
238 extern struct gcov_master __gcov_master;
|
|
|
239
|
|
|
240 /* Dump a set of gcov objects. */
|
|
|
241 extern void __gcov_dump_one (struct gcov_root *) ATTRIBUTE_HIDDEN;
|
|
|
242
|
|
|
243 /* Register a new object file module. */
|
|
|
244 extern void __gcov_init (struct gcov_info *) ATTRIBUTE_HIDDEN;
|
|
|
245
|
|
|
246 /* GCOV exit function registered via a static destructor. */
|
|
|
247 extern void __gcov_exit (void) ATTRIBUTE_HIDDEN;
|
|
|
248
|
|
|
249 /* Function to reset all counters to 0. Both externally visible (and
|
|
|
250 overridable) and internal version. */
|
|
|
251 extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN;
|
|
|
252
|
|
|
253 /* User function to enable early write of profile information so far. */
|
|
|
254 extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN;
|
|
|
255
|
|
|
256 /* The merge function that just sums the counters. */
|
|
|
257 extern void __gcov_merge_add (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
|
|
|
258
|
|
|
259 /* The merge function to select the minimum valid counter value. */
|
|
|
260 extern void __gcov_merge_time_profile (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
|
|
|
261
|
|
145
|
262 /* The merge function to choose the most common N values. */
|
|
|
263 extern void __gcov_merge_topn (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
|
|
111
|
264
|
|
|
265 /* The merge function that just ors the counters together. */
|
|
|
266 extern void __gcov_merge_ior (gcov_type *, unsigned) ATTRIBUTE_HIDDEN;
|
|
|
267
|
|
|
268 /* The profiler functions. */
|
|
|
269 extern void __gcov_interval_profiler (gcov_type *, gcov_type, int, unsigned);
|
|
|
270 extern void __gcov_interval_profiler_atomic (gcov_type *, gcov_type, int,
|
|
|
271 unsigned);
|
|
|
272 extern void __gcov_pow2_profiler (gcov_type *, gcov_type);
|
|
|
273 extern void __gcov_pow2_profiler_atomic (gcov_type *, gcov_type);
|
|
145
|
274 extern void __gcov_topn_values_profiler (gcov_type *, gcov_type);
|
|
|
275 extern void __gcov_topn_values_profiler_atomic (gcov_type *, gcov_type);
|
|
|
276 extern void __gcov_indirect_call_profiler_v4 (gcov_type, void *);
|
|
|
277 extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type, void *);
|
|
111
|
278 extern void __gcov_time_profiler (gcov_type *);
|
|
|
279 extern void __gcov_time_profiler_atomic (gcov_type *);
|
|
|
280 extern void __gcov_average_profiler (gcov_type *, gcov_type);
|
|
|
281 extern void __gcov_average_profiler_atomic (gcov_type *, gcov_type);
|
|
|
282 extern void __gcov_ior_profiler (gcov_type *, gcov_type);
|
|
|
283 extern void __gcov_ior_profiler_atomic (gcov_type *, gcov_type);
|
|
|
284
|
|
|
285 #ifndef inhibit_libc
|
|
|
286 /* The wrappers around some library functions.. */
|
|
|
287 extern pid_t __gcov_fork (void) ATTRIBUTE_HIDDEN;
|
|
|
288 extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN;
|
|
|
289 extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN;
|
|
|
290 extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN;
|
|
|
291 extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN;
|
|
|
292 extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN;
|
|
|
293 extern int __gcov_execve (const char *, char *const [], char *const [])
|
|
|
294 ATTRIBUTE_HIDDEN;
|
|
|
295
|
|
|
296 /* Functions that only available in libgcov. */
|
|
|
297 GCOV_LINKAGE int gcov_open (const char */*name*/) ATTRIBUTE_HIDDEN;
|
|
|
298 GCOV_LINKAGE void gcov_write_counter (gcov_type) ATTRIBUTE_HIDDEN;
|
|
|
299 GCOV_LINKAGE void gcov_write_tag_length (gcov_unsigned_t, gcov_unsigned_t)
|
|
|
300 ATTRIBUTE_HIDDEN;
|
|
|
301 GCOV_LINKAGE void gcov_write_summary (gcov_unsigned_t /*tag*/,
|
|
|
302 const struct gcov_summary *)
|
|
|
303 ATTRIBUTE_HIDDEN;
|
|
|
304 GCOV_LINKAGE void gcov_seek (gcov_position_t /*position*/) ATTRIBUTE_HIDDEN;
|
|
|
305 GCOV_LINKAGE void gcov_rewrite (void) ATTRIBUTE_HIDDEN;
|
|
|
306
|
|
|
307 /* "Counts" stored in gcda files can be a real counter value, or
|
|
|
308 an target address. When differentiate these two types because
|
|
|
309 when manipulating counts, we should only change real counter values,
|
|
|
310 rather target addresses. */
|
|
|
311
|
|
|
312 static inline gcov_type
|
|
|
313 gcov_get_counter (void)
|
|
|
314 {
|
|
|
315 #ifndef IN_GCOV_TOOL
|
|
|
316 /* This version is for reading count values in libgcov runtime:
|
|
|
317 we read from gcda files. */
|
|
|
318
|
|
|
319 return gcov_read_counter ();
|
|
|
320 #else
|
|
|
321 /* This version is for gcov-tool. We read the value from memory and
|
|
|
322 multiply it by the merge weight. */
|
|
|
323
|
|
|
324 return gcov_read_counter_mem () * gcov_get_merge_weight ();
|
|
|
325 #endif
|
|
|
326 }
|
|
|
327
|
|
145
|
328 /* Similar function as gcov_get_counter(), but do not scale
|
|
|
329 when read value is equal to IGNORE_SCALING. */
|
|
|
330
|
|
|
331 static inline gcov_type
|
|
|
332 gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED)
|
|
|
333 {
|
|
|
334 #ifndef IN_GCOV_TOOL
|
|
|
335 /* This version is for reading count values in libgcov runtime:
|
|
|
336 we read from gcda files. */
|
|
|
337
|
|
|
338 return gcov_read_counter ();
|
|
|
339 #else
|
|
|
340 /* This version is for gcov-tool. We read the value from memory and
|
|
|
341 multiply it by the merge weight. */
|
|
|
342
|
|
|
343 gcov_type v = gcov_read_counter_mem ();
|
|
|
344 if (v != ignore_scaling)
|
|
|
345 v *= gcov_get_merge_weight ();
|
|
|
346
|
|
|
347 return v;
|
|
|
348 #endif
|
|
|
349 }
|
|
|
350
|
|
111
|
351 /* Similar function as gcov_get_counter(), but handles target address
|
|
|
352 counters. */
|
|
|
353
|
|
|
354 static inline gcov_type
|
|
|
355 gcov_get_counter_target (void)
|
|
|
356 {
|
|
|
357 #ifndef IN_GCOV_TOOL
|
|
|
358 /* This version is for reading count target values in libgcov runtime:
|
|
|
359 we read from gcda files. */
|
|
|
360
|
|
|
361 return gcov_read_counter ();
|
|
|
362 #else
|
|
|
363 /* This version is for gcov-tool. We read the value from memory and we do NOT
|
|
|
364 multiply it by the merge weight. */
|
|
|
365
|
|
|
366 return gcov_read_counter_mem ();
|
|
|
367 #endif
|
|
|
368 }
|
|
|
369
|
|
|
370 #endif /* !inhibit_libc */
|
|
|
371
|
|
|
372 #endif /* GCC_LIBGCOV_H */
|
