1 /* Routines required for instrumenting a program. */
2 /* Compile this one with gcc. */
3 /* Copyright (C) 1989-2020 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 #if defined(inhibit_libc)
30 /* If libc and its header files are not available, provide dummy functions. */
33 void __gcov_init (struct gcov_info
*p
__attribute__ ((unused
))) {}
36 #else /* inhibit_libc */
47 /* A utility function for outputting errors. */
48 static int gcov_error (const char *, ...);
51 static void gcov_error_exit (void);
56 #define GCOV_PROF_PREFIX "libgcov profiling error:%s:"
60 struct gcov_fn_buffer
*next
;
62 struct gcov_fn_info info
;
63 /* note gcov_fn_info ends in a trailing array. */
66 struct gcov_summary_buffer
68 struct gcov_summary_buffer
*next
;
69 struct gcov_summary summary
;
72 /* A struct that bundles all the related information about the
77 char *filename
; /* filename buffer */
78 int strip
; /* leading chars to strip from filename */
79 char *prefix
; /* prefix string */
82 static struct gcov_fn_buffer
*
83 free_fn_data (const struct gcov_info
*gi_ptr
, struct gcov_fn_buffer
*buffer
,
86 struct gcov_fn_buffer
*next
;
87 unsigned ix
, n_ctr
= 0;
93 for (ix
= 0; ix
!= limit
; ix
++)
94 if (gi_ptr
->merge
[ix
])
95 free (buffer
->info
.ctrs
[n_ctr
++].values
);
100 static struct gcov_fn_buffer
**
101 buffer_fn_data (const char *filename
, const struct gcov_info
*gi_ptr
,
102 struct gcov_fn_buffer
**end_ptr
, unsigned fn_ix
)
104 unsigned n_ctrs
= 0, ix
= 0;
105 struct gcov_fn_buffer
*fn_buffer
;
108 for (ix
= GCOV_COUNTERS
; ix
--;)
109 if (gi_ptr
->merge
[ix
])
112 len
= sizeof (*fn_buffer
) + sizeof (fn_buffer
->info
.ctrs
[0]) * n_ctrs
;
113 fn_buffer
= (struct gcov_fn_buffer
*) xmalloc (len
);
119 fn_buffer
->fn_ix
= fn_ix
;
120 fn_buffer
->info
.ident
= gcov_read_unsigned ();
121 fn_buffer
->info
.lineno_checksum
= gcov_read_unsigned ();
122 fn_buffer
->info
.cfg_checksum
= gcov_read_unsigned ();
124 for (n_ctrs
= ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
126 gcov_unsigned_t length
;
129 if (!gi_ptr
->merge
[ix
])
132 if (gcov_read_unsigned () != GCOV_TAG_FOR_COUNTER (ix
))
138 length
= GCOV_TAG_COUNTER_NUM (gcov_read_unsigned ());
139 len
= length
* sizeof (gcov_type
);
140 values
= (gcov_type
*) xmalloc (len
);
144 fn_buffer
->info
.ctrs
[n_ctrs
].num
= length
;
145 fn_buffer
->info
.ctrs
[n_ctrs
].values
= values
;
148 *values
++ = gcov_read_counter ();
152 *end_ptr
= fn_buffer
;
153 return &fn_buffer
->next
;
156 gcov_error (GCOV_PROF_PREFIX
"Function %u %s %u \n", filename
, fn_ix
,
157 len
? "cannot allocate" : "counter mismatch", len
? len
: ix
);
159 return (struct gcov_fn_buffer
**)free_fn_data (gi_ptr
, fn_buffer
, ix
);
162 /* Convert VERSION into a string description and return the it.
163 BUFFER is used for storage of the string. The code should be
164 aligned wit gcov-iov.c. */
167 gcov_version_string (char *buffer
, char version
[4])
169 if (version
[0] < 'A' || version
[0] > 'Z'
170 || version
[1] < '0' || version
[1] > '9'
171 || version
[2] < '0' || version
[2] > '9')
172 sprintf (buffer
, "(unknown)");
175 unsigned major
= 10 * (version
[0] - 'A') + (version
[1] - '0');
176 unsigned minor
= version
[2] - '0';
177 sprintf (buffer
, "%u.%u (%s)", major
, minor
,
178 version
[3] == '*' ? "release" : "experimental");
183 /* Check if VERSION of the info block PTR matches libgcov one.
184 Return 1 on success, or zero in case of versions mismatch.
185 If FILENAME is not NULL, its value used for reporting purposes
186 instead of value from the info block. */
189 gcov_version (struct gcov_info
*ptr
, gcov_unsigned_t version
,
190 const char *filename
)
192 if (version
!= GCOV_VERSION
)
195 char version_string
[128], expected_string
[128];
197 GCOV_UNSIGNED2STRING (v
, version
);
198 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
200 gcov_error (GCOV_PROF_PREFIX
"Version mismatch - expected %s (%.4s) "
202 filename
? filename
: ptr
->filename
,
203 gcov_version_string (expected_string
, e
), e
,
204 gcov_version_string (version_string
, v
), v
);
210 /* buffer for the fn_data from another program. */
211 static struct gcov_fn_buffer
*fn_buffer
;
213 /* Including system dependent components. */
214 #include "libgcov-driver-system.c"
216 /* Prune TOP N value COUNTERS. It's needed in order to preserve
217 reproducibility of builds. */
220 prune_topn_counter (gcov_type
*counters
, gcov_type all
)
222 for (unsigned i
= 0; i
< GCOV_TOPN_VALUES
; i
++)
223 if (counters
[2 * i
+ 1] < all
)
226 counters
[2 * i
+ 1] = 0;
230 /* Prune counters so that they are ready to store or merge. */
233 prune_counters (struct gcov_info
*gi
)
235 for (unsigned i
= 0; i
< gi
->n_functions
; i
++)
237 const struct gcov_fn_info
*gfi
= gi
->functions
[i
];
238 const struct gcov_ctr_info
*ci
= gfi
->ctrs
;
240 for (unsigned j
= 0; j
< GCOV_COUNTERS
; j
++)
242 if (gi
->merge
[j
] == NULL
)
245 if (gi
->merge
[j
] == __gcov_merge_topn
)
247 gcc_assert (!(ci
->num
% GCOV_TOPN_VALUES_COUNTERS
));
248 for (unsigned k
= 0; k
< (ci
->num
/ GCOV_TOPN_VALUES_COUNTERS
);
252 = ci
->values
+ (k
* GCOV_TOPN_VALUES_COUNTERS
);
253 prune_topn_counter (counters
+ 1, *counters
);
261 /* This function merges counters in GI_PTR to an existing gcda file.
263 Return -1 on error. In this case, caller will goto read_fatal. */
266 merge_one_data (const char *filename
,
267 struct gcov_info
*gi_ptr
,
268 struct gcov_summary
*summary
)
270 gcov_unsigned_t tag
, length
;
274 struct gcov_fn_buffer
**fn_tail
= &fn_buffer
;
276 length
= gcov_read_unsigned ();
277 if (!gcov_version (gi_ptr
, length
, filename
))
280 length
= gcov_read_unsigned ();
281 if (length
!= gi_ptr
->stamp
)
283 /* Read from a different compilation. Overwrite the file. */
284 gcov_error (GCOV_PROF_PREFIX
"overwriting an existing profile data "
285 "with a different timestamp\n", filename
);
289 tag
= gcov_read_unsigned ();
290 if (tag
!= GCOV_TAG_OBJECT_SUMMARY
)
292 length
= gcov_read_unsigned ();
293 gcc_assert (length
> 0);
294 gcov_read_summary (summary
);
296 tag
= gcov_read_unsigned ();
297 /* Merge execution counts for each function. */
298 for (f_ix
= 0; (unsigned)f_ix
!= gi_ptr
->n_functions
;
299 f_ix
++, tag
= gcov_read_unsigned ())
301 const struct gcov_ctr_info
*ci_ptr
;
302 const struct gcov_fn_info
*gfi_ptr
= gi_ptr
->functions
[f_ix
];
304 if (tag
!= GCOV_TAG_FUNCTION
)
307 length
= gcov_read_unsigned ();
309 /* This function did not appear in the other program.
310 We have nothing to merge. */
313 if (length
!= GCOV_TAG_FUNCTION_LENGTH
)
316 if (!gfi_ptr
|| gfi_ptr
->key
!= gi_ptr
)
318 /* This function appears in the other program. We
319 need to buffer the information in order to write
320 it back out -- we'll be inserting data before
321 this point, so cannot simply keep the data in the
323 fn_tail
= buffer_fn_data (filename
, gi_ptr
, fn_tail
, f_ix
);
329 length
= gcov_read_unsigned ();
330 if (length
!= gfi_ptr
->ident
)
333 length
= gcov_read_unsigned ();
334 if (length
!= gfi_ptr
->lineno_checksum
)
337 length
= gcov_read_unsigned ();
338 if (length
!= gfi_ptr
->cfg_checksum
)
341 ci_ptr
= gfi_ptr
->ctrs
;
342 for (t_ix
= 0; t_ix
< GCOV_COUNTERS
; t_ix
++)
344 gcov_merge_fn merge
= gi_ptr
->merge
[t_ix
];
349 tag
= gcov_read_unsigned ();
350 length
= gcov_read_unsigned ();
351 if (tag
!= GCOV_TAG_FOR_COUNTER (t_ix
)
352 || length
!= GCOV_TAG_COUNTER_LENGTH (ci_ptr
->num
))
354 (*merge
) (ci_ptr
->values
, ci_ptr
->num
);
357 if ((error
= gcov_is_error ()))
364 gcov_error (GCOV_PROF_PREFIX
"Merge mismatch for %s %u\n",
365 filename
, f_ix
>= 0 ? "function" : "summary",
366 f_ix
< 0 ? -1 - f_ix
: f_ix
);
372 gcov_error (GCOV_PROF_PREFIX
"%s merging\n", filename
,
373 error
< 0 ? "Overflow": "Error");
377 /* Write counters in GI_PTR and the summary in PRG to a gcda file. In
378 the case of appending to an existing file, SUMMARY_POS will be non-zero.
379 We will write the file starting from SUMMAY_POS. */
382 write_one_data (const struct gcov_info
*gi_ptr
,
383 const struct gcov_summary
*prg_p
)
387 gcov_write_tag_length (GCOV_DATA_MAGIC
, GCOV_VERSION
);
388 gcov_write_unsigned (gi_ptr
->stamp
);
390 /* Generate whole program statistics. */
391 gcov_write_summary (GCOV_TAG_OBJECT_SUMMARY
, prg_p
);
393 /* Write execution counts for each function. */
394 for (f_ix
= 0; f_ix
!= gi_ptr
->n_functions
; f_ix
++)
396 unsigned buffered
= 0;
397 const struct gcov_fn_info
*gfi_ptr
;
398 const struct gcov_ctr_info
*ci_ptr
;
399 gcov_unsigned_t length
;
402 if (fn_buffer
&& fn_buffer
->fn_ix
== f_ix
)
404 /* Buffered data from another program. */
406 gfi_ptr
= &fn_buffer
->info
;
407 length
= GCOV_TAG_FUNCTION_LENGTH
;
411 gfi_ptr
= gi_ptr
->functions
[f_ix
];
412 if (gfi_ptr
&& gfi_ptr
->key
== gi_ptr
)
413 length
= GCOV_TAG_FUNCTION_LENGTH
;
418 gcov_write_tag_length (GCOV_TAG_FUNCTION
, length
);
422 gcov_write_unsigned (gfi_ptr
->ident
);
423 gcov_write_unsigned (gfi_ptr
->lineno_checksum
);
424 gcov_write_unsigned (gfi_ptr
->cfg_checksum
);
426 ci_ptr
= gfi_ptr
->ctrs
;
427 for (t_ix
= 0; t_ix
< GCOV_COUNTERS
; t_ix
++)
429 gcov_unsigned_t n_counts
;
432 if (!gi_ptr
->merge
[t_ix
])
435 n_counts
= ci_ptr
->num
;
436 gcov_write_tag_length (GCOV_TAG_FOR_COUNTER (t_ix
),
437 GCOV_TAG_COUNTER_LENGTH (n_counts
));
438 c_ptr
= ci_ptr
->values
;
440 gcov_write_counter (*c_ptr
++);
444 fn_buffer
= free_fn_data (gi_ptr
, fn_buffer
, GCOV_COUNTERS
);
447 gcov_write_unsigned (0);
450 /* Helper function for merging summary. */
453 merge_summary (int run_counted
, struct gcov_summary
*summary
,
459 summary
->sum_max
+= run_max
;
463 /* Dump the coverage counts for one gcov_info object. We merge with existing
464 counts when possible, to avoid growing the .da files ad infinitum. We use
465 this program's checksum to make sure we only accumulate whole program
466 statistics to the correct summary. An object file might be embedded
467 in two separate programs, and we must keep the two program
468 summaries separate. */
471 dump_one_gcov (struct gcov_info
*gi_ptr
, struct gcov_filename
*gf
,
472 unsigned run_counted
, gcov_type run_max
)
474 struct gcov_summary summary
= {};
479 /* Prune current counters before we merge them. */
480 prune_counters (gi_ptr
);
482 error
= gcov_exit_open_gcda_file (gi_ptr
, gf
);
486 tag
= gcov_read_unsigned ();
489 /* Merge data from file. */
490 if (tag
!= GCOV_DATA_MAGIC
)
492 gcov_error (GCOV_PROF_PREFIX
"Not a gcov data file\n",
496 error
= merge_one_data (gf
->filename
, gi_ptr
, &summary
);
503 merge_summary (run_counted
, &summary
, run_max
);
505 write_one_data (gi_ptr
, &summary
);
510 fn_buffer
= free_fn_data (gi_ptr
, fn_buffer
, GCOV_COUNTERS
);
512 if ((error
= gcov_close ()))
513 gcov_error (error
< 0 ?
514 GCOV_PROF_PREFIX
"Overflow writing\n" :
515 GCOV_PROF_PREFIX
"Error writing\n",
520 /* Dump all the coverage counts for the program. It first computes program
521 summary and then traverses gcov_list list and dumps the gcov_info
522 objects one by one. */
528 gcov_do_dump (struct gcov_info
*list
, int run_counted
)
530 struct gcov_info
*gi_ptr
;
531 struct gcov_filename gf
;
533 /* Compute run_max of this program run. */
534 gcov_type run_max
= 0;
535 for (gi_ptr
= list
; gi_ptr
; gi_ptr
= gi_ptr
->next
)
536 for (unsigned f_ix
= 0; (unsigned)f_ix
!= gi_ptr
->n_functions
; f_ix
++)
538 const struct gcov_ctr_info
*cinfo
539 = &gi_ptr
->functions
[f_ix
]->ctrs
[GCOV_COUNTER_ARCS
];
541 for (unsigned i
= 0; i
< cinfo
->num
; i
++)
542 if (run_max
< cinfo
->values
[i
])
543 run_max
= cinfo
->values
[i
];
546 allocate_filename_struct (&gf
);
548 /* Now merge each file. */
549 for (gi_ptr
= list
; gi_ptr
; gi_ptr
= gi_ptr
->next
)
551 dump_one_gcov (gi_ptr
, &gf
, run_counted
, run_max
);
560 __attribute__ ((unused
))
561 gcov_get_filename (struct gcov_info
*list
)
563 return list
->filename
;
569 __gcov_dump_one (struct gcov_root
*root
)
574 gcov_do_dump (root
->list
, root
->run_counted
);
577 root
->run_counted
= 1;
580 /* Per-dynamic-object gcov state. */
581 struct gcov_root __gcov_root
;
583 /* Exactly one of these will be live in the process image. */
584 struct gcov_master __gcov_master
=
590 __gcov_dump_one (&__gcov_root
);
591 if (__gcov_root
.next
)
592 __gcov_root
.next
->prev
= __gcov_root
.prev
;
593 if (__gcov_root
.prev
)
594 __gcov_root
.prev
->next
= __gcov_root
.next
;
596 __gcov_master
.root
= __gcov_root
.next
;
601 /* Add a new object file onto the bb chain. Invoked automatically
602 when running an object file's global ctors. */
605 __gcov_init (struct gcov_info
*info
)
607 if (!info
->version
|| !info
->n_functions
)
609 if (gcov_version (info
, info
->version
, 0))
611 if (!__gcov_root
.list
)
613 /* Add to master list and at exit function. */
614 if (gcov_version (NULL
, __gcov_master
.version
, "<master>"))
616 __gcov_root
.next
= __gcov_master
.root
;
617 if (__gcov_master
.root
)
618 __gcov_master
.root
->prev
= &__gcov_root
;
619 __gcov_master
.root
= &__gcov_root
;
623 info
->next
= __gcov_root
.list
;
624 __gcov_root
.list
= info
;
627 #endif /* !IN_GCOV_TOOL */
629 #endif /* inhibit_libc */