1 /* Header file for libgcov-*.c.
2 Copyright (C) 1996-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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.
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/>. */
28 /* work around the poisoned malloc/calloc in system.h. */
30 #define xmalloc malloc
33 #define xcalloc calloc
37 /* About the target. */
38 /* This path will be used by libgcov runtime. */
41 #include "auto-target.h"
43 #include "coretypes.h"
45 #include "libgcc_tm.h"
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
)));
55 typedef signed gcov_type
__attribute__ ((mode (SI
)));
56 typedef unsigned gcov_type_unsigned
__attribute__ ((mode (SI
)));
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
)));
66 typedef signed gcov_type
__attribute__ ((mode (HI
)));
67 typedef unsigned gcov_type_unsigned
__attribute__ ((mode (HI
)));
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
)));
76 typedef signed gcov_type
__attribute__ ((mode (QI
)));
77 typedef unsigned gcov_type_unsigned
__attribute__ ((mode (QI
)));
82 #if defined (TARGET_POSIX_IO)
88 #ifndef GCOV_SUPPORTS_ATOMIC
89 /* Detect whether target can support atomic update of profilers. */
90 #if __SIZEOF_LONG_LONG__ == 4 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
91 #define GCOV_SUPPORTS_ATOMIC 1
93 #if __SIZEOF_LONG_LONG__ == 8 && __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
94 #define GCOV_SUPPORTS_ATOMIC 1
96 #define GCOV_SUPPORTS_ATOMIC 0
101 /* In libgcov we need these functions to be extern, so prefix them with
102 __gcov. In libgcov they must also be hidden so that the instance in
103 the executable is not also used in a DSO. */
104 #define gcov_var __gcov_var
105 #define gcov_open __gcov_open
106 #define gcov_close __gcov_close
107 #define gcov_write_tag_length __gcov_write_tag_length
108 #define gcov_position __gcov_position
109 #define gcov_seek __gcov_seek
110 #define gcov_rewrite __gcov_rewrite
111 #define gcov_is_error __gcov_is_error
112 #define gcov_write_unsigned __gcov_write_unsigned
113 #define gcov_write_counter __gcov_write_counter
114 #define gcov_write_summary __gcov_write_summary
115 #define gcov_read_unsigned __gcov_read_unsigned
116 #define gcov_read_counter __gcov_read_counter
117 #define gcov_read_summary __gcov_read_summary
119 #else /* IN_GCOV_TOOL */
120 /* About the host. */
121 /* This path will be compiled for the host and linked into
126 #include "coretypes.h"
129 typedef unsigned gcov_unsigned_t
;
130 typedef unsigned gcov_position_t
;
131 /* gcov_type is typedef'd elsewhere for the compiler */
132 #if defined (HOST_HAS_F_SETLKW)
133 #define GCOV_LOCKED 1
135 #define GCOV_LOCKED 0
138 /* Some Macros specific to gcov-tool. */
141 #define L_gcov_merge_add 1
142 #define L_gcov_merge_topn 1
143 #define L_gcov_merge_ior 1
144 #define L_gcov_merge_time_profile 1
146 extern gcov_type
gcov_read_counter_mem ();
147 extern unsigned gcov_get_merge_weight ();
148 extern struct gcov_info
*gcov_list
;
150 #endif /* !IN_GCOV_TOOL */
152 #if defined(inhibit_libc)
153 #define IN_LIBGCOV (-1)
157 #define GCOV_LINKAGE /* nothing */
161 /* Poison these, so they don't accidentally slip in. */
162 #pragma GCC poison gcov_write_string gcov_write_tag gcov_write_length
163 #pragma GCC poison gcov_time
165 #ifdef HAVE_GAS_HIDDEN
166 #define ATTRIBUTE_HIDDEN __attribute__ ((__visibility__ ("hidden")))
168 #define ATTRIBUTE_HIDDEN
173 /* Structures embedded in coveraged program. The structures generated
174 by write_profile must match these. */
176 /* Information about counters for a single function. */
179 gcov_unsigned_t num
; /* number of counters. */
180 gcov_type
*values
; /* their values. */
183 /* Information about a single function. This uses the trailing array
184 idiom. The number of counters is determined from the merge pointer
185 array in gcov_info. The key is used to detect which of a set of
186 comdat functions was selected -- it points to the gcov_info object
187 of the object file containing the selected comdat function. */
191 const struct gcov_info
*key
; /* comdat key */
192 gcov_unsigned_t ident
; /* unique ident of function */
193 gcov_unsigned_t lineno_checksum
; /* function lineo_checksum */
194 gcov_unsigned_t cfg_checksum
; /* function cfg checksum */
195 struct gcov_ctr_info ctrs
[1]; /* instrumented counters */
198 /* Type of function used to merge counters. */
199 typedef void (*gcov_merge_fn
) (gcov_type
*, gcov_unsigned_t
);
201 /* Information about a single object file. */
204 gcov_unsigned_t version
; /* expected version number */
205 struct gcov_info
*next
; /* link to next, used by libgcov */
207 gcov_unsigned_t stamp
; /* uniquifying time stamp */
208 const char *filename
; /* output file name */
210 gcov_merge_fn merge
[GCOV_COUNTERS
]; /* merge functions (null for
213 unsigned n_functions
; /* number of functions */
216 const struct gcov_fn_info
*const *functions
; /* pointer to pointers
217 to function information */
219 struct gcov_fn_info
**functions
;
220 struct gcov_summary summary
;
221 #endif /* !IN_GCOV_TOOL */
224 /* Root of a program/shared-object state */
227 struct gcov_info
*list
;
228 unsigned dumped
: 1; /* counts have been dumped. */
229 unsigned run_counted
: 1; /* run has been accounted for. */
230 struct gcov_root
*next
;
231 struct gcov_root
*prev
;
234 extern struct gcov_root __gcov_root ATTRIBUTE_HIDDEN
;
238 gcov_unsigned_t version
;
239 struct gcov_root
*root
;
242 struct indirect_call_tuple
244 /* Callee function. */
247 /* Pointer to counters. */
251 /* Exactly one of these will be active in the process. */
252 extern struct gcov_master __gcov_master
;
253 extern struct gcov_kvp __gcov_kvp_pool
[GCOV_PREALLOCATED_KVP
];
254 extern unsigned __gcov_kvp_pool_index
;
256 /* Dump a set of gcov objects. */
257 extern void __gcov_dump_one (struct gcov_root
*) ATTRIBUTE_HIDDEN
;
259 /* Register a new object file module. */
260 extern void __gcov_init (struct gcov_info
*) ATTRIBUTE_HIDDEN
;
262 /* GCOV exit function registered via a static destructor. */
263 extern void __gcov_exit (void) ATTRIBUTE_HIDDEN
;
265 /* Function to reset all counters to 0. Both externally visible (and
266 overridable) and internal version. */
267 extern void __gcov_reset_int (void) ATTRIBUTE_HIDDEN
;
269 /* User function to enable early write of profile information so far. */
270 extern void __gcov_dump_int (void) ATTRIBUTE_HIDDEN
;
272 /* Lock critical section for __gcov_dump and __gcov_reset functions. */
273 extern void __gcov_lock (void) ATTRIBUTE_HIDDEN
;
275 /* Unlock critical section for __gcov_dump and __gcov_reset functions. */
276 extern void __gcov_unlock (void) ATTRIBUTE_HIDDEN
;
278 /* The merge function that just sums the counters. */
279 extern void __gcov_merge_add (gcov_type
*, unsigned) ATTRIBUTE_HIDDEN
;
281 /* The merge function to select the minimum valid counter value. */
282 extern void __gcov_merge_time_profile (gcov_type
*, unsigned) ATTRIBUTE_HIDDEN
;
284 /* The merge function to choose the most common N values. */
285 extern void __gcov_merge_topn (gcov_type
*, unsigned) ATTRIBUTE_HIDDEN
;
287 /* The merge function that just ors the counters together. */
288 extern void __gcov_merge_ior (gcov_type
*, unsigned) ATTRIBUTE_HIDDEN
;
290 /* The profiler functions. */
291 extern void __gcov_interval_profiler (gcov_type
*, gcov_type
, int, unsigned);
292 extern void __gcov_interval_profiler_atomic (gcov_type
*, gcov_type
, int,
294 extern void __gcov_pow2_profiler (gcov_type
*, gcov_type
);
295 extern void __gcov_pow2_profiler_atomic (gcov_type
*, gcov_type
);
296 extern void __gcov_topn_values_profiler (gcov_type
*, gcov_type
);
297 extern void __gcov_topn_values_profiler_atomic (gcov_type
*, gcov_type
);
298 extern void __gcov_indirect_call_profiler_v4 (gcov_type
, void *);
299 extern void __gcov_indirect_call_profiler_v4_atomic (gcov_type
, void *);
300 extern void __gcov_time_profiler (gcov_type
*);
301 extern void __gcov_time_profiler_atomic (gcov_type
*);
302 extern void __gcov_average_profiler (gcov_type
*, gcov_type
);
303 extern void __gcov_average_profiler_atomic (gcov_type
*, gcov_type
);
304 extern void __gcov_ior_profiler (gcov_type
*, gcov_type
);
305 extern void __gcov_ior_profiler_atomic (gcov_type
*, gcov_type
);
308 /* The wrappers around some library functions.. */
309 extern pid_t
__gcov_fork (void) ATTRIBUTE_HIDDEN
;
310 extern int __gcov_execl (const char *, char *, ...) ATTRIBUTE_HIDDEN
;
311 extern int __gcov_execlp (const char *, char *, ...) ATTRIBUTE_HIDDEN
;
312 extern int __gcov_execle (const char *, char *, ...) ATTRIBUTE_HIDDEN
;
313 extern int __gcov_execv (const char *, char *const []) ATTRIBUTE_HIDDEN
;
314 extern int __gcov_execvp (const char *, char *const []) ATTRIBUTE_HIDDEN
;
315 extern int __gcov_execve (const char *, char *const [], char *const [])
318 /* Functions that only available in libgcov. */
319 GCOV_LINKAGE
int gcov_open (const char */
*name*/
) ATTRIBUTE_HIDDEN
;
320 GCOV_LINKAGE
void gcov_write_counter (gcov_type
) ATTRIBUTE_HIDDEN
;
321 GCOV_LINKAGE
void gcov_write_tag_length (gcov_unsigned_t
, gcov_unsigned_t
)
323 GCOV_LINKAGE
void gcov_write_summary (gcov_unsigned_t
/*tag*/,
324 const struct gcov_summary
*)
326 GCOV_LINKAGE
void gcov_seek (gcov_position_t
/*position*/) ATTRIBUTE_HIDDEN
;
327 GCOV_LINKAGE
void gcov_rewrite (void) ATTRIBUTE_HIDDEN
;
329 /* "Counts" stored in gcda files can be a real counter value, or
330 an target address. When differentiate these two types because
331 when manipulating counts, we should only change real counter values,
332 rather target addresses. */
334 static inline gcov_type
335 gcov_get_counter (void)
338 /* This version is for reading count values in libgcov runtime:
339 we read from gcda files. */
341 return gcov_read_counter ();
343 /* This version is for gcov-tool. We read the value from memory and
344 multiply it by the merge weight. */
346 return gcov_read_counter_mem () * gcov_get_merge_weight ();
350 /* Similar function as gcov_get_counter(), but do not scale
351 when read value is equal to IGNORE_SCALING. */
353 static inline gcov_type
354 gcov_get_counter_ignore_scaling (gcov_type ignore_scaling ATTRIBUTE_UNUSED
)
357 /* This version is for reading count values in libgcov runtime:
358 we read from gcda files. */
360 return gcov_read_counter ();
362 /* This version is for gcov-tool. We read the value from memory and
363 multiply it by the merge weight. */
365 gcov_type v
= gcov_read_counter_mem ();
366 if (v
!= ignore_scaling
)
367 v
*= gcov_get_merge_weight ();
373 /* Similar function as gcov_get_counter(), but handles target address
376 static inline gcov_type
377 gcov_get_counter_target (void)
380 /* This version is for reading count target values in libgcov runtime:
381 we read from gcda files. */
383 return gcov_read_counter ();
385 /* This version is for gcov-tool. We read the value from memory and we do NOT
386 multiply it by the merge weight. */
388 return gcov_read_counter_mem ();
392 /* Add VALUE to *COUNTER and make it with atomic operation
393 if USE_ATOMIC is true. */
396 gcov_counter_add (gcov_type
*counter
, gcov_type value
,
397 int use_atomic ATTRIBUTE_UNUSED
)
399 #if GCOV_SUPPORTS_ATOMIC
401 __atomic_fetch_add (counter
, value
, __ATOMIC_RELAXED
);
407 /* Allocate gcov_kvp from heap. If we are recursively called, then allocate
408 it from a list of pre-allocated pool. */
410 static inline struct gcov_kvp
*
411 allocate_gcov_kvp (void)
413 struct gcov_kvp
*new_node
= NULL
;
416 #if defined(HAVE_CC_TLS)
419 volatile unsigned in_recursion ATTRIBUTE_UNUSED
= 0;
421 #if !defined(IN_GCOV_TOOL) && !defined(L_gcov_merge_topn)
422 if (__builtin_expect (in_recursion
, 0))
425 #if GCOV_SUPPORTS_ATOMIC
427 = __atomic_fetch_add (&__gcov_kvp_pool_index
, 1, __ATOMIC_RELAXED
);
429 index
= __gcov_kvp_pool_index
++;
431 if (index
< GCOV_PREALLOCATED_KVP
)
432 new_node
= &__gcov_kvp_pool
[index
];
434 /* Do not crash in the situation. */
441 new_node
= (struct gcov_kvp
*)xcalloc (1, sizeof (struct gcov_kvp
));
448 /* Add key value pair VALUE:COUNT to a top N COUNTERS. When INCREMENT_TOTAL
449 is true, add COUNT to total of the TOP counter. If USE_ATOMIC is true,
450 do it in atomic way. */
453 gcov_topn_add_value (gcov_type
*counters
, gcov_type value
, gcov_type count
,
454 int use_atomic
, int increment_total
)
457 gcov_counter_add (&counters
[0], 1, use_atomic
);
459 struct gcov_kvp
*prev_node
= NULL
;
460 struct gcov_kvp
*minimal_node
= NULL
;
461 struct gcov_kvp
*current_node
= (struct gcov_kvp
*)(intptr_t)counters
[2];
465 if (current_node
->value
== value
)
467 gcov_counter_add (¤t_node
->count
, count
, use_atomic
);
471 if (minimal_node
== NULL
472 || current_node
->count
< minimal_node
->count
)
473 minimal_node
= current_node
;
475 prev_node
= current_node
;
476 current_node
= current_node
->next
;
479 if (counters
[1] == GCOV_TOPN_MAXIMUM_TRACKED_VALUES
)
481 if (--minimal_node
->count
< count
)
483 minimal_node
->value
= value
;
484 minimal_node
->count
= count
;
489 struct gcov_kvp
*new_node
= allocate_gcov_kvp ();
490 if (new_node
== NULL
)
493 new_node
->value
= value
;
494 new_node
->count
= count
;
499 #if GCOV_SUPPORTS_ATOMIC
502 struct gcov_kvp
**ptr
= (struct gcov_kvp
**)(intptr_t)&counters
[2];
503 success
= !__sync_val_compare_and_swap (ptr
, 0, new_node
);
508 counters
[2] = (intptr_t)new_node
;
512 else if (prev_node
&& !prev_node
->next
)
514 #if GCOV_SUPPORTS_ATOMIC
516 success
= !__sync_val_compare_and_swap (&prev_node
->next
, 0,
521 prev_node
->next
= new_node
;
526 /* Increment number of nodes. */
528 gcov_counter_add (&counters
[1], 1, use_atomic
);
532 #endif /* !inhibit_libc */
534 #endif /* GCC_LIBGCOV_H */