1 /* Routines required for instrumenting a program. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2021 Free Software Foundation, Inc.
5 This file is part of GCC.
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
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
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.
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/>. */
29 /* Return 1, if all counter values are zero, otherwise 0. */
32 are_all_counters_zero (const struct gcov_ctr_info
*ci_ptr
)
34 for (unsigned i
= 0; i
< ci_ptr
->num
; i
++)
35 if (ci_ptr
->values
[i
] != 0)
41 #if defined(inhibit_libc)
42 /* If libc and its header files are not available, provide dummy functions. */
45 void __gcov_init (struct gcov_info
*p
__attribute__ ((unused
))) {}
48 #else /* inhibit_libc */
54 #elif GCOV_LOCKED_WITH_LOCKING
56 #include <sys/locking.h>
64 #endif /* inhibit_libc */
66 #if defined(L_gcov) && !defined(inhibit_libc)
70 #if defined(L_gcov_info_to_gcda) && !IN_GCOV_TOOL
71 #define NEED_L_GCOV_INFO_TO_GCDA
75 /* A utility function for outputting errors. */
76 static int gcov_error (const char *, ...);
79 static void gcov_error_exit (void);
84 #define GCOV_PROF_PREFIX "libgcov profiling error:%s:"
88 struct gcov_fn_buffer
*next
;
90 struct gcov_fn_info info
;
91 /* note gcov_fn_info ends in a trailing array. */
94 struct gcov_summary_buffer
96 struct gcov_summary_buffer
*next
;
97 struct gcov_summary summary
;
100 /* A struct that bundles all the related information about the
105 char *filename
; /* filename buffer */
106 int strip
; /* leading chars to strip from filename */
107 char *prefix
; /* prefix string */
110 static struct gcov_fn_buffer
*
111 free_fn_data (const struct gcov_info
*gi_ptr
, struct gcov_fn_buffer
*buffer
,
114 struct gcov_fn_buffer
*next
;
115 unsigned ix
, n_ctr
= 0;
121 for (ix
= 0; ix
!= limit
; ix
++)
122 if (gi_ptr
->merge
[ix
])
123 free (buffer
->info
.ctrs
[n_ctr
++].values
);
128 static struct gcov_fn_buffer
**
129 buffer_fn_data (const char *filename
, const struct gcov_info
*gi_ptr
,
130 struct gcov_fn_buffer
**end_ptr
, unsigned fn_ix
)
132 unsigned n_ctrs
= 0, ix
= 0;
133 struct gcov_fn_buffer
*fn_buffer
;
136 for (ix
= GCOV_COUNTERS
; ix
--;)
137 if (gi_ptr
->merge
[ix
])
140 len
= sizeof (*fn_buffer
) + sizeof (fn_buffer
->info
.ctrs
[0]) * n_ctrs
;
141 fn_buffer
= (struct gcov_fn_buffer
*) xmalloc (len
);
147 fn_buffer
->fn_ix
= fn_ix
;
148 fn_buffer
->info
.ident
= gcov_read_unsigned ();
149 fn_buffer
->info
.lineno_checksum
= gcov_read_unsigned ();
150 fn_buffer
->info
.cfg_checksum
= gcov_read_unsigned ();
152 for (n_ctrs
= ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
154 gcov_unsigned_t length
;
157 if (!gi_ptr
->merge
[ix
])
160 if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix
))
166 length
= GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());
167 len
= length
* sizeof (gcov_type
);
168 values
= (gcov_type
*) xmalloc (len
);
172 fn_buffer
->info
.ctrs
[n_ctrs
].num
= length
;
173 fn_buffer
->info
.ctrs
[n_ctrs
].values
= values
;
176 *values
++ = gcov_read_counter ();
180 *end_ptr
= fn_buffer
;
181 return &fn_buffer
->next
;
184 gcov_error (GCOV_PROF_PREFIX
"Function %u %s %u \n", filename
, fn_ix
,
185 len
? "cannot allocate" : "counter mismatch", len
? len
: ix
);
187 return (struct gcov_fn_buffer
**)free_fn_data (gi_ptr
, fn_buffer
, ix
);
190 /* Convert VERSION into a string description and return the it.
191 BUFFER is used for storage of the string. The code should be
192 aligned wit gcov-iov.c. */
195 gcov_version_string (char *buffer
, char version
[4])
197 if (version
[0] < 'A' || version
[0] > 'Z'
198 || version
[1] < '0' || version
[1] > '9'
199 || version
[2] < '0' || version
[2] > '9')
200 sprintf (buffer
, "(unknown)");
203 unsigned major
= 10 * (version
[0] - 'A') + (version
[1] - '0');
204 unsigned minor
= version
[2] - '0';
205 sprintf (buffer
, "%u.%u (%s)", major
, minor
,
206 version
[3] == '*' ? "release" : "experimental");
211 /* Check if VERSION of the info block PTR matches libgcov one.
212 Return 1 on success, or zero in case of versions mismatch.
213 If FILENAME is not NULL, its value used for reporting purposes
214 instead of value from the info block. */
217 gcov_version (struct gcov_info
*ptr
, gcov_unsigned_t version
,
218 const char *filename
)
220 if (version
!= GCOV_VERSION
)
223 char ver_string
[128], expected_string
[128];
225 GCOV_UNSIGNED2STRING (v
, version
);
226 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
228 gcov_error (GCOV_PROF_PREFIX
"Version mismatch - expected %s (%.4s) "
230 filename
? filename
: ptr
->filename
,
231 gcov_version_string (expected_string
, e
), e
,
232 gcov_version_string (ver_string
, v
), v
);
238 /* buffer for the fn_data from another program. */
239 static struct gcov_fn_buffer
*fn_buffer
;
241 /* Including system dependent components. */
242 #include "libgcov-driver-system.c"
244 /* This function merges counters in GI_PTR to an existing gcda file.
246 Return -1 on error. In this case, caller will goto read_fatal. */
249 merge_one_data (const char *filename
,
250 struct gcov_info
*gi_ptr
,
251 struct gcov_summary
*summary
)
253 gcov_unsigned_t tag
, length
;
257 struct gcov_fn_buffer
**fn_tail
= &fn_buffer
;
259 length
= gcov_read_unsigned ();
260 if (!gcov_version (gi_ptr
, length
, filename
))
263 /* Skip timestamp. */
264 gcov_read_unsigned ();
266 length
= gcov_read_unsigned ();
267 if (length
!= gi_ptr
->checksum
)
269 /* Read from a different compilation. Overwrite the file. */
270 gcov_error (GCOV_PROF_PREFIX
"overwriting an existing profile data "
271 "with a different checksum\n", filename
);
275 tag
= gcov_read_unsigned ();
276 if (tag
!= GCOV_TAG_OBJECT_SUMMARY
)
278 length
= gcov_read_unsigned ();
279 gcc_assert (length
> 0);
280 gcov_read_summary (summary
);
282 tag
= gcov_read_unsigned ();
283 /* Merge execution counts for each function. */
284 for (f_ix
= 0; (unsigned)f_ix
!= gi_ptr
->n_functions
;
285 f_ix
++, tag
= gcov_read_unsigned ())
287 const struct gcov_ctr_info
*ci_ptr
;
288 const struct gcov_fn_info
*gfi_ptr
= gi_ptr
->functions
[f_ix
];
290 if (tag
!= GCOV_TAG_FUNCTION
)
293 length
= gcov_read_unsigned ();
295 /* This function did not appear in the other program.
296 We have nothing to merge. */
299 if (length
!= GCOV_TAG_FUNCTION_LENGTH
)
302 if (!gfi_ptr
|| gfi_ptr
->key
!= gi_ptr
)
304 /* This function appears in the other program. We
305 need to buffer the information in order to write
306 it back out -- we'll be inserting data before
307 this point, so cannot simply keep the data in the
309 fn_tail
= buffer_fn_data (filename
, gi_ptr
, fn_tail
, f_ix
);
315 length
= gcov_read_unsigned ();
316 if (length
!= gfi_ptr
->ident
)
319 length
= gcov_read_unsigned ();
320 if (length
!= gfi_ptr
->lineno_checksum
)
323 length
= gcov_read_unsigned ();
324 if (length
!= gfi_ptr
->cfg_checksum
)
327 ci_ptr
= gfi_ptr
->ctrs
;
328 for (t_ix
= 0; t_ix
< GCOV_COUNTERS
; t_ix
++)
330 gcov_merge_fn merge
= gi_ptr
->merge
[t_ix
];
335 tag
= gcov_read_unsigned ();
336 int read_length
= (int)gcov_read_unsigned ();
337 length
= abs (read_length
);
338 if (tag
!= GCOV_TAG_FOR_COUNTER (t_ix
)
339 || (length
!= GCOV_TAG_COUNTER_LENGTH (ci_ptr
->num
)
340 && t_ix
!= GCOV_COUNTER_V_TOPN
341 && t_ix
!= GCOV_COUNTER_V_INDIR
))
343 /* Merging with all zero counters does not make sense. */
345 (*merge
) (ci_ptr
->values
, ci_ptr
->num
);
348 if ((error
= gcov_is_error ()))
355 gcov_error (GCOV_PROF_PREFIX
"Merge mismatch for %s %u\n",
356 filename
, f_ix
>= 0 ? "function" : "summary",
357 f_ix
< 0 ? -1 - f_ix
: f_ix
);
363 gcov_error (GCOV_PROF_PREFIX
"%s merging\n", filename
,
364 error
< 0 ? "Overflow": "Error");
368 /* Write the DATA of LENGTH characters to the gcov file. */
371 gcov_dump_handler (const void *data
,
373 void *arg ATTRIBUTE_UNUSED
)
375 gcov_write (data
, length
);
378 /* Allocate SIZE characters and return the address of the allocated memory. */
381 gcov_allocate_handler (unsigned size
, void *arg ATTRIBUTE_UNUSED
)
383 return xmalloc (size
);
385 #endif /* NEED_L_GCOV */
387 #if defined(NEED_L_GCOV) || defined(NEED_L_GCOV_INFO_TO_GCDA)
388 /* Dump the WORD using the DUMP handler called with ARG. */
391 dump_unsigned (gcov_unsigned_t word
,
392 void (*dump_fn
) (const void *, unsigned, void *),
395 (*dump_fn
) (&word
, sizeof (word
), arg
);
398 /* Dump the COUNTER using the DUMP handler called with ARG. */
401 dump_counter (gcov_type counter
,
402 void (*dump_fn
) (const void *, unsigned, void *),
405 dump_unsigned ((gcov_unsigned_t
)counter
, dump_fn
, arg
);
407 if (sizeof (counter
) > sizeof (gcov_unsigned_t
))
408 dump_unsigned ((gcov_unsigned_t
)(counter
>> 32), dump_fn
, arg
);
410 dump_unsigned (0, dump_fn
, arg
);
413 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
415 /* Store all TOP N counters where each has a dynamic length. */
418 write_topn_counters (const struct gcov_ctr_info
*ci_ptr
,
420 gcov_unsigned_t n_counts
,
421 void (*dump_fn
) (const void *, unsigned, void *),
422 void *(*allocate_fn
)(unsigned, void *),
425 unsigned counters
= n_counts
/ GCOV_TOPN_MEM_COUNTERS
;
426 gcc_assert (n_counts
% GCOV_TOPN_MEM_COUNTERS
== 0);
428 /* It can happen in a multi-threaded environment that number of counters is
429 different from the size of the corresponding linked lists. */
430 #define LIST_SIZE_MIN_LENGTH 4 * 1024
432 static unsigned *list_sizes
= NULL
;
433 static unsigned list_size_length
= 0;
435 if (list_sizes
== NULL
|| counters
> list_size_length
)
437 list_size_length
= MAX (LIST_SIZE_MIN_LENGTH
, 2 * counters
);
438 #if !defined(inhibit_libc) && HAVE_SYS_MMAN_H
440 = (unsigned *)malloc_mmap (list_size_length
* sizeof (unsigned));
443 /* Malloc fallback. */
444 if (list_sizes
== NULL
)
446 (unsigned *)(*allocate_fn
) (list_size_length
* sizeof (unsigned),
450 unsigned pair_total
= 0;
452 for (unsigned i
= 0; i
< counters
; i
++)
454 gcov_type start
= ci_ptr
->values
[GCOV_TOPN_MEM_COUNTERS
* i
+ 2];
457 for (struct gcov_kvp
*node
= (struct gcov_kvp
*)(__INTPTR_TYPE__
)start
;
458 node
!= NULL
; node
= node
->next
)
462 list_sizes
[i
] = sizes
;
465 unsigned disk_size
= GCOV_TOPN_DISK_COUNTERS
* counters
+ 2 * pair_total
;
466 dump_unsigned (GCOV_TAG_FOR_COUNTER (t_ix
), dump_fn
, arg
),
467 dump_unsigned (GCOV_TAG_COUNTER_LENGTH (disk_size
), dump_fn
, arg
);
469 for (unsigned i
= 0; i
< counters
; i
++)
471 dump_counter (ci_ptr
->values
[GCOV_TOPN_MEM_COUNTERS
* i
], dump_fn
, arg
);
472 dump_counter (list_sizes
[i
], dump_fn
, arg
);
473 gcov_type start
= ci_ptr
->values
[GCOV_TOPN_MEM_COUNTERS
* i
+ 2];
476 for (struct gcov_kvp
*node
= (struct gcov_kvp
*)(__INTPTR_TYPE__
)start
;
477 j
< list_sizes
[i
]; node
= node
->next
, j
++)
479 dump_counter (node
->value
, dump_fn
, arg
);
480 dump_counter (node
->count
, dump_fn
, arg
);
485 /* Write counters in GI_PTR and the summary in PRG to a gcda file. In
486 the case of appending to an existing file, SUMMARY_POS will be non-zero.
487 We will write the file starting from SUMMAY_POS. */
490 write_one_data (const struct gcov_info
*gi_ptr
,
491 const struct gcov_summary
*prg_p ATTRIBUTE_UNUSED
,
492 void (*dump_fn
) (const void *, unsigned, void *),
493 void *(*allocate_fn
) (unsigned, void *),
498 dump_unsigned (GCOV_DATA_MAGIC
, dump_fn
, arg
);
499 dump_unsigned (GCOV_VERSION
, dump_fn
, arg
);
500 dump_unsigned (gi_ptr
->stamp
, dump_fn
, arg
);
501 dump_unsigned (gi_ptr
->checksum
, dump_fn
, arg
);
504 /* Generate whole program statistics. */
505 gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY
, prg_p
);
508 /* Write execution counts for each function. */
509 for (f_ix
= 0; f_ix
!= gi_ptr
->n_functions
; f_ix
++)
512 unsigned buffered
= 0;
514 const struct gcov_fn_info
*gfi_ptr
;
515 const struct gcov_ctr_info
*ci_ptr
;
516 gcov_unsigned_t length
;
520 if (fn_buffer
&& fn_buffer
->fn_ix
== f_ix
)
522 /* Buffered data from another program. */
524 gfi_ptr
= &fn_buffer
->info
;
525 length
= GCOV_TAG_FUNCTION_LENGTH
;
530 gfi_ptr
= gi_ptr
->functions
[f_ix
];
531 if (gfi_ptr
&& gfi_ptr
->key
== gi_ptr
)
532 length
= GCOV_TAG_FUNCTION_LENGTH
;
537 dump_unsigned (GCOV_TAG_FUNCTION
, dump_fn
, arg
);
538 dump_unsigned (length
, dump_fn
, arg
);
542 dump_unsigned (gfi_ptr
->ident
, dump_fn
, arg
);
543 dump_unsigned (gfi_ptr
->lineno_checksum
, dump_fn
, arg
);
544 dump_unsigned (gfi_ptr
->cfg_checksum
, dump_fn
, arg
);
546 ci_ptr
= gfi_ptr
->ctrs
;
547 for (t_ix
= 0; t_ix
< GCOV_COUNTERS
; t_ix
++)
549 gcov_position_t n_counts
;
551 if (!gi_ptr
->merge
[t_ix
])
554 n_counts
= ci_ptr
->num
;
556 if (t_ix
== GCOV_COUNTER_V_TOPN
|| t_ix
== GCOV_COUNTER_V_INDIR
)
557 write_topn_counters (ci_ptr
, t_ix
, n_counts
, dump_fn
, allocate_fn
,
561 dump_unsigned (GCOV_TAG_FOR_COUNTER (t_ix
), dump_fn
, arg
);
562 if (are_all_counters_zero (ci_ptr
))
563 /* Do not stream when all counters are zero. */
564 dump_unsigned (GCOV_TAG_COUNTER_LENGTH (-n_counts
),
568 dump_unsigned (GCOV_TAG_COUNTER_LENGTH (n_counts
),
570 for (unsigned i
= 0; i
< n_counts
; i
++)
571 dump_counter (ci_ptr
->values
[i
], dump_fn
, arg
);
579 fn_buffer
= free_fn_data (gi_ptr
, fn_buffer
, GCOV_COUNTERS
);
583 dump_unsigned (0, dump_fn
, arg
);
585 #endif /* NEED_L_GCOV || NEED_L_GCOV_INFO_TO_GCDA */
588 /* Dump the coverage counts for one gcov_info object. We merge with existing
589 counts when possible, to avoid growing the .da files ad infinitum. We use
590 this program's checksum to make sure we only accumulate whole program
591 statistics to the correct summary. An object file might be embedded
592 in two separate programs, and we must keep the two program
593 summaries separate. */
596 dump_one_gcov (struct gcov_info
*gi_ptr
, struct gcov_filename
*gf
,
597 unsigned run_counted ATTRIBUTE_UNUSED
,
598 gcov_type run_max ATTRIBUTE_UNUSED
)
600 struct gcov_summary summary
= {};
605 error
= gcov_exit_open_gcda_file (gi_ptr
, gf
);
609 tag
= gcov_read_unsigned ();
612 /* Merge data from file. */
613 if (tag
!= GCOV_DATA_MAGIC
)
615 gcov_error (GCOV_PROF_PREFIX
"Not a gcov data file\n",
619 error
= merge_one_data (gf
->filename
, gi_ptr
, &summary
);
630 summary
.sum_max
+= run_max
;
633 summary
= gi_ptr
->summary
;
636 write_one_data (gi_ptr
, &summary
, gcov_dump_handler
, gcov_allocate_handler
,
642 fn_buffer
= free_fn_data (gi_ptr
, fn_buffer
, GCOV_COUNTERS
);
644 if ((error
= gcov_close ()))
645 gcov_error ((error
< 0 ? GCOV_PROF_PREFIX
"Overflow writing\n"
646 : GCOV_PROF_PREFIX
"Error writing\n"), gf
->filename
);
650 /* Dump all the coverage counts for the program. It first computes program
651 summary and then traverses gcov_list list and dumps the gcov_info
652 objects one by one. */
658 gcov_do_dump (struct gcov_info
*list
, int run_counted
)
660 struct gcov_info
*gi_ptr
;
661 struct gcov_filename gf
;
663 /* Compute run_max of this program run. */
664 gcov_type run_max
= 0;
665 for (gi_ptr
= list
; gi_ptr
; gi_ptr
= gi_ptr
->next
)
666 for (unsigned f_ix
= 0; (unsigned)f_ix
!= gi_ptr
->n_functions
; f_ix
++)
668 const struct gcov_ctr_info
*cinfo
669 = &gi_ptr
->functions
[f_ix
]->ctrs
[GCOV_COUNTER_ARCS
];
671 for (unsigned i
= 0; i
< cinfo
->num
; i
++)
672 if (run_max
< cinfo
->values
[i
])
673 run_max
= cinfo
->values
[i
];
676 allocate_filename_struct (&gf
);
678 /* Now merge each file. */
679 for (gi_ptr
= list
; gi_ptr
; gi_ptr
= gi_ptr
->next
)
681 dump_one_gcov (gi_ptr
, &gf
, run_counted
, run_max
);
690 __attribute__ ((unused
))
691 gcov_get_filename (struct gcov_info
*list
)
693 return list
->filename
;
699 __gcov_dump_one (struct gcov_root
*root
)
704 gcov_do_dump (root
->list
, root
->run_counted
);
707 root
->run_counted
= 1;
710 /* Per-dynamic-object gcov state. */
711 struct gcov_root __gcov_root
;
713 /* Exactly one of these will be live in the process image. */
714 struct gcov_master __gcov_master
=
717 /* Dynamic pool for gcov_kvp structures. */
718 struct gcov_kvp
*__gcov_kvp_dynamic_pool
;
720 /* Index into __gcov_kvp_dynamic_pool array. */
721 unsigned __gcov_kvp_dynamic_pool_index
;
723 /* Size of _gcov_kvp_dynamic_pool array. */
724 unsigned __gcov_kvp_dynamic_pool_size
;
729 __gcov_dump_one (&__gcov_root
);
730 if (__gcov_root
.next
)
731 __gcov_root
.next
->prev
= __gcov_root
.prev
;
732 if (__gcov_root
.prev
)
733 __gcov_root
.prev
->next
= __gcov_root
.next
;
735 __gcov_master
.root
= __gcov_root
.next
;
740 /* Add a new object file onto the bb chain. Invoked automatically
741 when running an object file's global ctors. */
744 __gcov_init (struct gcov_info
*info
)
746 if (!info
->version
|| !info
->n_functions
)
748 if (gcov_version (info
, info
->version
, 0))
750 if (!__gcov_root
.list
)
752 /* Add to master list and at exit function. */
753 if (gcov_version (NULL
, __gcov_master
.version
, "<master>"))
755 __gcov_root
.next
= __gcov_master
.root
;
756 if (__gcov_master
.root
)
757 __gcov_master
.root
->prev
= &__gcov_root
;
758 __gcov_master
.root
= &__gcov_root
;
762 info
->next
= __gcov_root
.list
;
763 __gcov_root
.list
= info
;
766 #endif /* !IN_GCOV_TOOL */
767 #endif /* NEED_L_GCOV */
769 #ifdef NEED_L_GCOV_INFO_TO_GCDA
770 /* Convert the gcov info to a gcda data stream. It is intended for
771 free-standing environments which do not support the C library file I/O. */
774 __gcov_info_to_gcda (const struct gcov_info
*gi_ptr
,
775 void (*filename_fn
) (const char *, void *),
776 void (*dump_fn
) (const void *, unsigned, void *),
777 void *(*allocate_fn
) (unsigned, void *),
780 (*filename_fn
) (gi_ptr
->filename
, arg
);
781 write_one_data (gi_ptr
, NULL
, dump_fn
, allocate_fn
, arg
);
783 #endif /* NEED_L_GCOV_INFO_TO_GCDA */