1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2018 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
6 Further mangled by Nathan Sidwell, CodeSourcery
7
8 This file is part of GCC.
9
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
13 version.
14
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
23
24
25 #define GCOV_LINKAGE
26
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "backend.h"
31 #include "target.h"
32 #include "rtl.h"
33 #include "tree.h"
34 #include "tree-pass.h"
35 #include "memmodel.h"
36 #include "tm_p.h"
37 #include "stringpool.h"
38 #include "cgraph.h"
39 #include "coverage.h"
40 #include "diagnostic-core.h"
41 #include "fold-const.h"
42 #include "stor-layout.h"
43 #include "output.h"
44 #include "toplev.h"
45 #include "langhooks.h"
46 #include "tree-iterator.h"
47 #include "context.h"
48 #include "pass_manager.h"
49 #include "intl.h"
50 #include "params.h"
51 #include "auto-profile.h"
52
53 #include "gcov-io.c"
54
55 struct GTY((chain_next ("%h.next"))) coverage_data
56 {
57 struct coverage_data *next; /* next function */
58 unsigned ident; /* function ident */
59 unsigned lineno_checksum; /* function lineno checksum */
60 unsigned cfg_checksum; /* function cfg checksum */
61 tree fn_decl; /* the function decl */
62 tree ctr_vars[GCOV_COUNTERS]; /* counter variables. */
63 };
64
65 /* Counts information for a function. */
66 struct counts_entry : pointer_hash <counts_entry>
67 {
68 /* We hash by */
69 unsigned ident;
70 unsigned ctr;
71
72 /* Store */
73 unsigned lineno_checksum;
74 unsigned cfg_checksum;
75 gcov_type *counts;
76 struct gcov_ctr_summary summary;
77
78 /* hash_table support. */
79 static inline hashval_t hash (const counts_entry *);
80 static int equal (const counts_entry *, const counts_entry *);
81 static void remove (counts_entry *);
82 };
83
84 static GTY(()) struct coverage_data *functions_head = 0;
85 static struct coverage_data **functions_tail = &functions_head;
86 static unsigned no_coverage = 0;
87
88 /* Cumulative counter information for whole program. */
89 static unsigned prg_ctr_mask; /* Mask of counter types generated. */
90
91 /* Counter information for current function. */
92 static unsigned fn_ctr_mask; /* Mask of counters used. */
93 static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */
94 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
95 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
96
97 /* Coverage info VAR_DECL and function info type nodes. */
98 static GTY(()) tree gcov_info_var;
99 static GTY(()) tree gcov_fn_info_type;
100 static GTY(()) tree gcov_fn_info_ptr_type;
101
102 /* Name of the notes (gcno) output file. The "bbg" prefix is for
103 historical reasons, when the notes file contained only the
104 basic block graph notes.
105 If this is NULL we're not writing to the notes file. */
106 static char *bbg_file_name;
107
108 /* File stamp for notes file. */
109 static unsigned bbg_file_stamp;
110
111 /* Name of the count data (gcda) file. */
112 static char *da_file_name;
113
114 /* The names of merge functions for counters. */
115 #define STR(str) #str
116 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
117 static const char *const ctr_merge_functions[GCOV_COUNTERS] = {
118 #include "gcov-counter.def"
119 };
120 #undef DEF_GCOV_COUNTER
121 #undef STR
122
123 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
124 static const char *const ctr_names[GCOV_COUNTERS] = {
125 #include "gcov-counter.def"
126 };
127 #undef DEF_GCOV_COUNTER
128
129 /* Forward declarations. */
130 static void read_counts_file (void);
131 static tree build_var (tree, tree, int);
132 static void build_fn_info_type (tree, unsigned, tree);
133 static void build_info_type (tree, tree);
134 static tree build_fn_info (const struct coverage_data *, tree, tree);
135 static tree build_info (tree, tree);
136 static bool coverage_obj_init (void);
137 static vec<constructor_elt, va_gc> *coverage_obj_fn
138 (vec<constructor_elt, va_gc> *, tree, struct coverage_data const *);
139 static void coverage_obj_finish (vec<constructor_elt, va_gc> *);
140
141 /* Return the type node for gcov_type. */
142
143 tree
get_gcov_type(void)144 get_gcov_type (void)
145 {
146 scalar_int_mode mode
147 = smallest_int_mode_for_size (LONG_LONG_TYPE_SIZE > 32 ? 64 : 32);
148 return lang_hooks.types.type_for_mode (mode, false);
149 }
150
151 /* Return the type node for gcov_unsigned_t. */
152
153 static tree
get_gcov_unsigned_t(void)154 get_gcov_unsigned_t (void)
155 {
156 scalar_int_mode mode = smallest_int_mode_for_size (32);
157 return lang_hooks.types.type_for_mode (mode, true);
158 }
159
160 inline hashval_t
hash(const counts_entry * entry)161 counts_entry::hash (const counts_entry *entry)
162 {
163 return entry->ident * GCOV_COUNTERS + entry->ctr;
164 }
165
166 inline int
equal(const counts_entry * entry1,const counts_entry * entry2)167 counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2)
168 {
169 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
170 }
171
172 inline void
remove(counts_entry * entry)173 counts_entry::remove (counts_entry *entry)
174 {
175 free (entry->counts);
176 free (entry);
177 }
178
179 /* Hash table of count data. */
180 static hash_table<counts_entry> *counts_hash;
181
182 /* Read in the counts file, if available. */
183
184 static void
read_counts_file(void)185 read_counts_file (void)
186 {
187 gcov_unsigned_t fn_ident = 0;
188 struct gcov_summary summary;
189 unsigned new_summary = 1;
190 gcov_unsigned_t tag;
191 int is_error = 0;
192 unsigned lineno_checksum = 0;
193 unsigned cfg_checksum = 0;
194
195 if (!gcov_open (da_file_name, 1))
196 return;
197
198 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
199 {
200 warning (0, "%qs is not a gcov data file", da_file_name);
201 gcov_close ();
202 return;
203 }
204 else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
205 {
206 char v[4], e[4];
207
208 GCOV_UNSIGNED2STRING (v, tag);
209 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
210
211 warning (0, "%qs is version %q.*s, expected version %q.*s",
212 da_file_name, 4, v, 4, e);
213 gcov_close ();
214 return;
215 }
216
217 /* Read the stamp, used for creating a generation count. */
218 tag = gcov_read_unsigned ();
219 bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag);
220
221 counts_hash = new hash_table<counts_entry> (10);
222 while ((tag = gcov_read_unsigned ()))
223 {
224 gcov_unsigned_t length;
225 gcov_position_t offset;
226
227 length = gcov_read_unsigned ();
228 offset = gcov_position ();
229 if (tag == GCOV_TAG_FUNCTION)
230 {
231 if (length)
232 {
233 fn_ident = gcov_read_unsigned ();
234 lineno_checksum = gcov_read_unsigned ();
235 cfg_checksum = gcov_read_unsigned ();
236 }
237 else
238 fn_ident = lineno_checksum = cfg_checksum = 0;
239 new_summary = 1;
240 }
241 else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
242 {
243 struct gcov_summary sum;
244 unsigned ix;
245
246 if (new_summary)
247 memset (&summary, 0, sizeof (summary));
248
249 gcov_read_summary (&sum);
250 for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
251 {
252 summary.ctrs[ix].runs += sum.ctrs[ix].runs;
253 summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all;
254 if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max)
255 summary.ctrs[ix].run_max = sum.ctrs[ix].run_max;
256 summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max;
257 }
258 if (new_summary)
259 memcpy (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
260 sum.ctrs[GCOV_COUNTER_ARCS].histogram,
261 sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
262 else
263 gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
264 sum.ctrs[GCOV_COUNTER_ARCS].histogram);
265 new_summary = 0;
266 }
267 else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
268 {
269 counts_entry **slot, *entry, elt;
270 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
271 unsigned ix;
272
273 elt.ident = fn_ident;
274 elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
275
276 slot = counts_hash->find_slot (&elt, INSERT);
277 entry = *slot;
278 if (!entry)
279 {
280 *slot = entry = XCNEW (counts_entry);
281 entry->ident = fn_ident;
282 entry->ctr = elt.ctr;
283 entry->lineno_checksum = lineno_checksum;
284 entry->cfg_checksum = cfg_checksum;
285 if (elt.ctr < GCOV_COUNTERS_SUMMABLE)
286 entry->summary = summary.ctrs[elt.ctr];
287 entry->summary.num = n_counts;
288 entry->counts = XCNEWVEC (gcov_type, n_counts);
289 }
290 else if (entry->lineno_checksum != lineno_checksum
291 || entry->cfg_checksum != cfg_checksum)
292 {
293 error ("Profile data for function %u is corrupted", fn_ident);
294 error ("checksum is (%x,%x) instead of (%x,%x)",
295 entry->lineno_checksum, entry->cfg_checksum,
296 lineno_checksum, cfg_checksum);
297 delete counts_hash;
298 counts_hash = NULL;
299 break;
300 }
301 else if (entry->summary.num != n_counts)
302 {
303 error ("Profile data for function %u is corrupted", fn_ident);
304 error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
305 delete counts_hash;
306 counts_hash = NULL;
307 break;
308 }
309 else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
310 {
311 error ("cannot merge separate %s counters for function %u",
312 ctr_names[elt.ctr], fn_ident);
313 goto skip_merge;
314 }
315 else
316 {
317 entry->summary.runs += summary.ctrs[elt.ctr].runs;
318 entry->summary.sum_all += summary.ctrs[elt.ctr].sum_all;
319 if (entry->summary.run_max < summary.ctrs[elt.ctr].run_max)
320 entry->summary.run_max = summary.ctrs[elt.ctr].run_max;
321 entry->summary.sum_max += summary.ctrs[elt.ctr].sum_max;
322 }
323 for (ix = 0; ix != n_counts; ix++)
324 entry->counts[ix] += gcov_read_counter ();
325 skip_merge:;
326 }
327 gcov_sync (offset, length);
328 if ((is_error = gcov_is_error ()))
329 {
330 error (is_error < 0
331 ? G_("%qs has overflowed")
332 : G_("%qs is corrupted"),
333 da_file_name);
334 delete counts_hash;
335 counts_hash = NULL;
336 break;
337 }
338 }
339
340 gcov_close ();
341 }
342
343 /* Returns the counters for a particular tag. */
344
345 gcov_type *
get_coverage_counts(unsigned counter,unsigned expected,unsigned cfg_checksum,unsigned lineno_checksum,const struct gcov_ctr_summary ** summary)346 get_coverage_counts (unsigned counter, unsigned expected,
347 unsigned cfg_checksum, unsigned lineno_checksum,
348 const struct gcov_ctr_summary **summary)
349 {
350 counts_entry *entry, elt;
351
352 /* No hash table, no counts. */
353 if (!counts_hash)
354 {
355 static int warned = 0;
356
357 if (!warned++ && dump_enabled_p ())
358 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
359 (flag_guess_branch_prob
360 ? "file %s not found, execution counts estimated\n"
361 : "file %s not found, execution counts assumed to "
362 "be zero\n"),
363 da_file_name);
364 return NULL;
365 }
366 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
367 elt.ident = current_function_funcdef_no + 1;
368 else
369 {
370 gcc_assert (coverage_node_map_initialized_p ());
371 elt.ident = cgraph_node::get (current_function_decl)->profile_id;
372 }
373 elt.ctr = counter;
374 entry = counts_hash->find (&elt);
375 if (!entry || !entry->summary.num)
376 /* The function was not emitted, or is weak and not chosen in the
377 final executable. Silently fail, because there's nothing we
378 can do about it. */
379 return NULL;
380
381 if (entry->cfg_checksum != cfg_checksum
382 || entry->summary.num != expected)
383 {
384 static int warned = 0;
385 bool warning_printed = false;
386 tree id = DECL_ASSEMBLER_NAME (current_function_decl);
387
388 warning_printed =
389 warning_at (input_location, OPT_Wcoverage_mismatch,
390 "the control flow of function %qE does not match "
391 "its profile data (counter %qs)", id, ctr_names[counter]);
392 if (warning_printed && dump_enabled_p ())
393 {
394 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
395 "use -Wno-error=coverage-mismatch to tolerate "
396 "the mismatch but performance may drop if the "
397 "function is hot\n");
398
399 if (!seen_error ()
400 && !warned++)
401 {
402 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
403 "coverage mismatch ignored\n");
404 dump_printf (MSG_OPTIMIZED_LOCATIONS,
405 flag_guess_branch_prob
406 ? G_("execution counts estimated\n")
407 : G_("execution counts assumed to be zero\n"));
408 if (!flag_guess_branch_prob)
409 dump_printf (MSG_OPTIMIZED_LOCATIONS,
410 "this can result in poorly optimized code\n");
411 }
412 }
413
414 return NULL;
415 }
416 else if (entry->lineno_checksum != lineno_checksum)
417 {
418 warning (OPT_Wcoverage_mismatch,
419 "source locations for function %qE have changed,"
420 " the profile data may be out of date",
421 DECL_ASSEMBLER_NAME (current_function_decl));
422 }
423
424 if (summary)
425 *summary = &entry->summary;
426
427 return entry->counts;
428 }
429
430 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
431 allocation succeeded. */
432
433 int
coverage_counter_alloc(unsigned counter,unsigned num)434 coverage_counter_alloc (unsigned counter, unsigned num)
435 {
436 if (no_coverage)
437 return 0;
438
439 if (!num)
440 return 1;
441
442 if (!fn_v_ctrs[counter])
443 {
444 tree array_type = build_array_type (get_gcov_type (), NULL_TREE);
445
446 fn_v_ctrs[counter]
447 = build_var (current_function_decl, array_type, counter);
448 }
449
450 fn_b_ctrs[counter] = fn_n_ctrs[counter];
451 fn_n_ctrs[counter] += num;
452
453 fn_ctr_mask |= 1 << counter;
454 return 1;
455 }
456
457 /* Generate a tree to access COUNTER NO. */
458
459 tree
tree_coverage_counter_ref(unsigned counter,unsigned no)460 tree_coverage_counter_ref (unsigned counter, unsigned no)
461 {
462 tree gcov_type_node = get_gcov_type ();
463
464 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
465
466 no += fn_b_ctrs[counter];
467
468 /* "no" here is an array index, scaled to bytes later. */
469 return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter],
470 build_int_cst (integer_type_node, no), NULL, NULL);
471 }
472
473 /* Generate a tree to access the address of COUNTER NO. */
474
475 tree
tree_coverage_counter_addr(unsigned counter,unsigned no)476 tree_coverage_counter_addr (unsigned counter, unsigned no)
477 {
478 tree gcov_type_node = get_gcov_type ();
479
480 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
481 no += fn_b_ctrs[counter];
482
483 /* "no" here is an array index, scaled to bytes later. */
484 return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,
485 fn_v_ctrs[counter],
486 build_int_cst (integer_type_node, no),
487 NULL, NULL));
488 }
489
490
491 /* Generate a checksum for a string. CHKSUM is the current
492 checksum. */
493
494 static unsigned
coverage_checksum_string(unsigned chksum,const char * string)495 coverage_checksum_string (unsigned chksum, const char *string)
496 {
497 int i;
498 char *dup = NULL;
499
500 /* Look for everything that looks if it were produced by
501 get_file_function_name and zero out the second part
502 that may result from flag_random_seed. This is not critical
503 as the checksums are used only for sanity checking. */
504 for (i = 0; string[i]; i++)
505 {
506 int offset = 0;
507 if (!strncmp (string + i, "_GLOBAL__N_", 11))
508 offset = 11;
509 if (!strncmp (string + i, "_GLOBAL__", 9))
510 offset = 9;
511
512 /* C++ namespaces do have scheme:
513 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
514 since filename might contain extra underscores there seems
515 to be no better chance then walk all possible offsets looking
516 for magicnumber. */
517 if (offset)
518 {
519 for (i = i + offset; string[i]; i++)
520 if (string[i]=='_')
521 {
522 int y;
523
524 for (y = 1; y < 9; y++)
525 if (!(string[i + y] >= '0' && string[i + y] <= '9')
526 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
527 break;
528 if (y != 9 || string[i + 9] != '_')
529 continue;
530 for (y = 10; y < 18; y++)
531 if (!(string[i + y] >= '0' && string[i + y] <= '9')
532 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
533 break;
534 if (y != 18)
535 continue;
536 if (!dup)
537 string = dup = xstrdup (string);
538 for (y = 10; y < 18; y++)
539 dup[i + y] = '0';
540 }
541 break;
542 }
543 }
544
545 chksum = crc32_string (chksum, string);
546 free (dup);
547
548 return chksum;
549 }
550
551 /* Compute checksum for the current function. We generate a CRC32. */
552
553 unsigned
coverage_compute_lineno_checksum(void)554 coverage_compute_lineno_checksum (void)
555 {
556 expanded_location xloc
557 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
558 unsigned chksum = xloc.line;
559
560 if (xloc.file)
561 chksum = coverage_checksum_string (chksum, xloc.file);
562 chksum = coverage_checksum_string
563 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
564
565 return chksum;
566 }
567
568 /* Compute profile ID. This is better to be unique in whole program. */
569
570 unsigned
coverage_compute_profile_id(struct cgraph_node * n)571 coverage_compute_profile_id (struct cgraph_node *n)
572 {
573 unsigned chksum;
574
575 /* Externally visible symbols have unique name. */
576 if (TREE_PUBLIC (n->decl) || DECL_EXTERNAL (n->decl) || n->unique_name)
577 {
578 chksum = coverage_checksum_string
579 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
580 }
581 else
582 {
583 expanded_location xloc
584 = expand_location (DECL_SOURCE_LOCATION (n->decl));
585 bool use_name_only = (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID) == 0);
586
587 chksum = (use_name_only ? 0 : xloc.line);
588 if (xloc.file)
589 chksum = coverage_checksum_string (chksum, xloc.file);
590 chksum = coverage_checksum_string
591 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
592 if (!use_name_only && first_global_object_name)
593 chksum = coverage_checksum_string
594 (chksum, first_global_object_name);
595 chksum = coverage_checksum_string
596 (chksum, aux_base_name);
597 }
598
599 /* Non-negative integers are hopefully small enough to fit in all targets.
600 Gcov file formats wants non-zero function IDs. */
601 chksum = chksum & 0x7fffffff;
602 return chksum + (!chksum);
603 }
604
605 /* Compute cfg checksum for the function FN given as argument.
606 The checksum is calculated carefully so that
607 source code changes that doesn't affect the control flow graph
608 won't change the checksum.
609 This is to make the profile data useable across source code change.
610 The downside of this is that the compiler may use potentially
611 wrong profile data - that the source code change has non-trivial impact
612 on the validity of profile data (e.g. the reversed condition)
613 but the compiler won't detect the change and use the wrong profile data. */
614
615 unsigned
coverage_compute_cfg_checksum(struct function * fn)616 coverage_compute_cfg_checksum (struct function *fn)
617 {
618 basic_block bb;
619 unsigned chksum = n_basic_blocks_for_fn (fn);
620
621 FOR_EACH_BB_FN (bb, fn)
622 {
623 edge e;
624 edge_iterator ei;
625 chksum = crc32_byte (chksum, bb->index);
626 FOR_EACH_EDGE (e, ei, bb->succs)
627 {
628 chksum = crc32_byte (chksum, e->dest->index);
629 }
630 }
631
632 return chksum;
633 }
634
635 /* Begin output to the notes file for the current function.
636 Writes the function header. Returns nonzero if data should be output. */
637
638 int
coverage_begin_function(unsigned lineno_checksum,unsigned cfg_checksum)639 coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
640 {
641 expanded_location xloc;
642 unsigned long offset;
643
644 /* We don't need to output .gcno file unless we're under -ftest-coverage
645 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
646 if (no_coverage || !bbg_file_name)
647 return 0;
648
649 xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
650
651 /* Announce function */
652 offset = gcov_write_tag (GCOV_TAG_FUNCTION);
653 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
654 gcov_write_unsigned (current_function_funcdef_no + 1);
655 else
656 {
657 gcc_assert (coverage_node_map_initialized_p ());
658 gcov_write_unsigned (
659 cgraph_node::get (current_function_decl)->profile_id);
660 }
661
662 gcov_write_unsigned (lineno_checksum);
663 gcov_write_unsigned (cfg_checksum);
664 gcov_write_string (IDENTIFIER_POINTER
665 (DECL_ASSEMBLER_NAME (current_function_decl)));
666 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl)
667 && !DECL_LAMBDA_FUNCTION (current_function_decl));
668 gcov_write_filename (xloc.file);
669 gcov_write_unsigned (xloc.line);
670 gcov_write_unsigned (xloc.column);
671
672 expanded_location endloc = expand_location (cfun->function_end_locus);
673
674 /* Function can start in a single file and end in another one. */
675 /* Work-around for PR gcov-profile/88045. */
676 int end_line = endloc.file == xloc.file ? endloc.line : xloc.line;
677 if (xloc.line > end_line)
678 end_line = xloc.line;
679 gcov_write_unsigned (end_line);
680 gcov_write_length (offset);
681
682 return !gcov_is_error ();
683 }
684
685 /* Finish coverage data for the current function. Verify no output
686 error has occurred. Save function coverage counts. */
687
688 void
coverage_end_function(unsigned lineno_checksum,unsigned cfg_checksum)689 coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
690 {
691 unsigned i;
692
693 if (bbg_file_name && gcov_is_error ())
694 {
695 warning (0, "error writing %qs", bbg_file_name);
696 unlink (bbg_file_name);
697 bbg_file_name = NULL;
698 }
699
700 if (fn_ctr_mask)
701 {
702 struct coverage_data *item = 0;
703
704 item = ggc_alloc<coverage_data> ();
705
706 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
707 item->ident = current_function_funcdef_no + 1;
708 else
709 {
710 gcc_assert (coverage_node_map_initialized_p ());
711 item->ident = cgraph_node::get (cfun->decl)->profile_id;
712 }
713
714 item->lineno_checksum = lineno_checksum;
715 item->cfg_checksum = cfg_checksum;
716
717 item->fn_decl = current_function_decl;
718 item->next = 0;
719 *functions_tail = item;
720 functions_tail = &item->next;
721
722 for (i = 0; i != GCOV_COUNTERS; i++)
723 {
724 tree var = fn_v_ctrs[i];
725
726 if (item)
727 item->ctr_vars[i] = var;
728 if (var)
729 {
730 tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1));
731 array_type = build_array_type (get_gcov_type (), array_type);
732 TREE_TYPE (var) = array_type;
733 DECL_SIZE (var) = TYPE_SIZE (array_type);
734 DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
735 varpool_node::finalize_decl (var);
736 }
737
738 fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
739 fn_v_ctrs[i] = NULL_TREE;
740 }
741 prg_ctr_mask |= fn_ctr_mask;
742 fn_ctr_mask = 0;
743 }
744 }
745
746 /* Remove coverage file if opened. */
747
748 void
coverage_remove_note_file(void)749 coverage_remove_note_file (void)
750 {
751 if (bbg_file_name)
752 {
753 gcov_close ();
754 unlink (bbg_file_name);
755 }
756 }
757
758 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
759 >= 0 it is a counter array, otherwise it is the function structure. */
760
761 static tree
build_var(tree fn_decl,tree type,int counter)762 build_var (tree fn_decl, tree type, int counter)
763 {
764 tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type);
765 const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl));
766 char *buf;
767 size_t fn_name_len, len;
768
769 fn_name = targetm.strip_name_encoding (fn_name);
770 fn_name_len = strlen (fn_name);
771 buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3);
772
773 if (counter < 0)
774 strcpy (buf, "__gcov__");
775 else
776 sprintf (buf, "__gcov%u_", counter);
777 len = strlen (buf);
778 buf[len - 1] = symbol_table::symbol_suffix_separator ();
779 memcpy (buf + len, fn_name, fn_name_len + 1);
780 DECL_NAME (var) = get_identifier (buf);
781 TREE_STATIC (var) = 1;
782 TREE_ADDRESSABLE (var) = 1;
783 DECL_NONALIASED (var) = 1;
784 SET_DECL_ALIGN (var, TYPE_ALIGN (type));
785
786 return var;
787 }
788
789 /* Creates the gcov_fn_info RECORD_TYPE. */
790
791 static void
build_fn_info_type(tree type,unsigned counters,tree gcov_info_type)792 build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
793 {
794 tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
795 tree field, fields;
796 tree array_type;
797
798 gcc_assert (counters);
799
800 /* ctr_info::num */
801 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
802 get_gcov_unsigned_t ());
803 fields = field;
804
805 /* ctr_info::values */
806 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
807 build_pointer_type (get_gcov_type ()));
808 DECL_CHAIN (field) = fields;
809 fields = field;
810
811 finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE);
812
813 /* key */
814 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
815 build_pointer_type (build_qualified_type
816 (gcov_info_type, TYPE_QUAL_CONST)));
817 fields = field;
818
819 /* ident */
820 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
821 get_gcov_unsigned_t ());
822 DECL_CHAIN (field) = fields;
823 fields = field;
824
825 /* lineno_checksum */
826 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
827 get_gcov_unsigned_t ());
828 DECL_CHAIN (field) = fields;
829 fields = field;
830
831 /* cfg checksum */
832 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
833 get_gcov_unsigned_t ());
834 DECL_CHAIN (field) = fields;
835 fields = field;
836
837 array_type = build_index_type (size_int (counters - 1));
838 array_type = build_array_type (ctr_info, array_type);
839
840 /* counters */
841 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type);
842 DECL_CHAIN (field) = fields;
843 fields = field;
844
845 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
846 }
847
848 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
849 the coverage data for the function and TYPE is the gcov_fn_info
850 RECORD_TYPE. KEY is the object file key. */
851
852 static tree
build_fn_info(const struct coverage_data * data,tree type,tree key)853 build_fn_info (const struct coverage_data *data, tree type, tree key)
854 {
855 tree fields = TYPE_FIELDS (type);
856 tree ctr_type;
857 unsigned ix;
858 vec<constructor_elt, va_gc> *v1 = NULL;
859 vec<constructor_elt, va_gc> *v2 = NULL;
860
861 /* key */
862 CONSTRUCTOR_APPEND_ELT (v1, fields,
863 build1 (ADDR_EXPR, TREE_TYPE (fields), key));
864 fields = DECL_CHAIN (fields);
865
866 /* ident */
867 CONSTRUCTOR_APPEND_ELT (v1, fields,
868 build_int_cstu (get_gcov_unsigned_t (),
869 data->ident));
870 fields = DECL_CHAIN (fields);
871
872 /* lineno_checksum */
873 CONSTRUCTOR_APPEND_ELT (v1, fields,
874 build_int_cstu (get_gcov_unsigned_t (),
875 data->lineno_checksum));
876 fields = DECL_CHAIN (fields);
877
878 /* cfg_checksum */
879 CONSTRUCTOR_APPEND_ELT (v1, fields,
880 build_int_cstu (get_gcov_unsigned_t (),
881 data->cfg_checksum));
882 fields = DECL_CHAIN (fields);
883
884 /* counters */
885 ctr_type = TREE_TYPE (TREE_TYPE (fields));
886 for (ix = 0; ix != GCOV_COUNTERS; ix++)
887 if (prg_ctr_mask & (1 << ix))
888 {
889 vec<constructor_elt, va_gc> *ctr = NULL;
890 tree var = data->ctr_vars[ix];
891 unsigned count = 0;
892
893 if (var)
894 count
895 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var))))
896 + 1;
897
898 CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),
899 build_int_cstu (get_gcov_unsigned_t (),
900 count));
901
902 if (var)
903 CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),
904 build_fold_addr_expr (var));
905
906 CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr));
907 }
908
909 CONSTRUCTOR_APPEND_ELT (v1, fields,
910 build_constructor (TREE_TYPE (fields), v2));
911
912 return build_constructor (type, v1);
913 }
914
915 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
916 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
917
918 static void
build_info_type(tree type,tree fn_info_ptr_type)919 build_info_type (tree type, tree fn_info_ptr_type)
920 {
921 tree field, fields = NULL_TREE;
922 tree merge_fn_type;
923
924 /* Version ident */
925 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
926 get_gcov_unsigned_t ());
927 DECL_CHAIN (field) = fields;
928 fields = field;
929
930 /* next pointer */
931 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
932 build_pointer_type (build_qualified_type
933 (type, TYPE_QUAL_CONST)));
934 DECL_CHAIN (field) = fields;
935 fields = field;
936
937 /* stamp */
938 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
939 get_gcov_unsigned_t ());
940 DECL_CHAIN (field) = fields;
941 fields = field;
942
943 /* Filename */
944 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
945 build_pointer_type (build_qualified_type
946 (char_type_node, TYPE_QUAL_CONST)));
947 DECL_CHAIN (field) = fields;
948 fields = field;
949
950 /* merge fn array */
951 merge_fn_type
952 = build_function_type_list (void_type_node,
953 build_pointer_type (get_gcov_type ()),
954 get_gcov_unsigned_t (), NULL_TREE);
955 merge_fn_type
956 = build_array_type (build_pointer_type (merge_fn_type),
957 build_index_type (size_int (GCOV_COUNTERS - 1)));
958 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
959 merge_fn_type);
960 DECL_CHAIN (field) = fields;
961 fields = field;
962
963 /* n_functions */
964 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
965 get_gcov_unsigned_t ());
966 DECL_CHAIN (field) = fields;
967 fields = field;
968
969 /* function_info pointer pointer */
970 fn_info_ptr_type = build_pointer_type
971 (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
972 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
973 fn_info_ptr_type);
974 DECL_CHAIN (field) = fields;
975 fields = field;
976
977 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
978 }
979
980 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
981 gcov_info structure type, FN_ARY is the array of pointers to
982 function info objects. */
983
984 static tree
build_info(tree info_type,tree fn_ary)985 build_info (tree info_type, tree fn_ary)
986 {
987 tree info_fields = TYPE_FIELDS (info_type);
988 tree merge_fn_type, n_funcs;
989 unsigned ix;
990 tree filename_string;
991 int da_file_name_len;
992 vec<constructor_elt, va_gc> *v1 = NULL;
993 vec<constructor_elt, va_gc> *v2 = NULL;
994
995 /* Version ident */
996 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
997 build_int_cstu (TREE_TYPE (info_fields),
998 GCOV_VERSION));
999 info_fields = DECL_CHAIN (info_fields);
1000
1001 /* next -- NULL */
1002 CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node);
1003 info_fields = DECL_CHAIN (info_fields);
1004
1005 /* stamp */
1006 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1007 build_int_cstu (TREE_TYPE (info_fields),
1008 bbg_file_stamp));
1009 info_fields = DECL_CHAIN (info_fields);
1010
1011 /* Filename */
1012 da_file_name_len = strlen (da_file_name);
1013 filename_string = build_string (da_file_name_len + 1, da_file_name);
1014 TREE_TYPE (filename_string) = build_array_type
1015 (char_type_node, build_index_type (size_int (da_file_name_len)));
1016 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1017 build1 (ADDR_EXPR, TREE_TYPE (info_fields),
1018 filename_string));
1019 info_fields = DECL_CHAIN (info_fields);
1020
1021 /* merge fn array -- NULL slots indicate unmeasured counters */
1022 merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields));
1023 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1024 {
1025 tree ptr = null_pointer_node;
1026
1027 if ((1u << ix) & prg_ctr_mask)
1028 {
1029 tree merge_fn = build_decl (BUILTINS_LOCATION,
1030 FUNCTION_DECL,
1031 get_identifier (ctr_merge_functions[ix]),
1032 TREE_TYPE (merge_fn_type));
1033 DECL_EXTERNAL (merge_fn) = 1;
1034 TREE_PUBLIC (merge_fn) = 1;
1035 DECL_ARTIFICIAL (merge_fn) = 1;
1036 TREE_NOTHROW (merge_fn) = 1;
1037 /* Initialize assembler name so we can stream out. */
1038 DECL_ASSEMBLER_NAME (merge_fn);
1039 ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
1040 }
1041 CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr);
1042 }
1043 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1044 build_constructor (TREE_TYPE (info_fields), v2));
1045 info_fields = DECL_CHAIN (info_fields);
1046
1047 /* n_functions */
1048 n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)));
1049 n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),
1050 n_funcs, size_one_node);
1051 CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs);
1052 info_fields = DECL_CHAIN (info_fields);
1053
1054 /* functions */
1055 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1056 build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary));
1057 info_fields = DECL_CHAIN (info_fields);
1058
1059 gcc_assert (!info_fields);
1060 return build_constructor (info_type, v1);
1061 }
1062
1063 /* Generate the constructor function to call __gcov_init. */
1064
1065 static void
build_init_ctor(tree gcov_info_type)1066 build_init_ctor (tree gcov_info_type)
1067 {
1068 tree ctor, stmt, init_fn;
1069
1070 /* Build a decl for __gcov_init. */
1071 init_fn = build_pointer_type (gcov_info_type);
1072 init_fn = build_function_type_list (void_type_node, init_fn, NULL);
1073 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1074 get_identifier ("__gcov_init"), init_fn);
1075 TREE_PUBLIC (init_fn) = 1;
1076 DECL_EXTERNAL (init_fn) = 1;
1077 DECL_ASSEMBLER_NAME (init_fn);
1078
1079 /* Generate a call to __gcov_init(&gcov_info). */
1080 ctor = NULL;
1081 stmt = build_fold_addr_expr (gcov_info_var);
1082 stmt = build_call_expr (init_fn, 1, stmt);
1083 append_to_statement_list (stmt, &ctor);
1084
1085 /* Generate a constructor to run it. */
1086 int priority = SUPPORTS_INIT_PRIORITY
1087 ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
1088 cgraph_build_static_cdtor ('I', ctor, priority);
1089 }
1090
1091 /* Generate the destructor function to call __gcov_exit. */
1092
1093 static void
build_gcov_exit_decl(void)1094 build_gcov_exit_decl (void)
1095 {
1096 tree init_fn = build_function_type_list (void_type_node, void_type_node,
1097 NULL);
1098 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1099 get_identifier ("__gcov_exit"), init_fn);
1100 TREE_PUBLIC (init_fn) = 1;
1101 DECL_EXTERNAL (init_fn) = 1;
1102 DECL_ASSEMBLER_NAME (init_fn);
1103
1104 /* Generate a call to __gcov_exit (). */
1105 tree dtor = NULL;
1106 tree stmt = build_call_expr (init_fn, 0);
1107 append_to_statement_list (stmt, &dtor);
1108
1109 /* Generate a destructor to run it. */
1110 int priority = SUPPORTS_INIT_PRIORITY
1111 ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
1112
1113 cgraph_build_static_cdtor ('D', dtor, priority);
1114 }
1115
1116 /* Create the gcov_info types and object. Generate the constructor
1117 function to call __gcov_init. Does not generate the initializer
1118 for the object. Returns TRUE if coverage data is being emitted. */
1119
1120 static bool
coverage_obj_init(void)1121 coverage_obj_init (void)
1122 {
1123 tree gcov_info_type;
1124 unsigned n_counters = 0;
1125 unsigned ix;
1126 struct coverage_data *fn;
1127 struct coverage_data **fn_prev;
1128 char name_buf[32];
1129
1130 no_coverage = 1; /* Disable any further coverage. */
1131
1132 if (!prg_ctr_mask)
1133 return false;
1134
1135 if (symtab->dump_file)
1136 fprintf (symtab->dump_file, "Using data file %s\n", da_file_name);
1137
1138 /* Prune functions. */
1139 for (fn_prev = &functions_head; (fn = *fn_prev);)
1140 if (DECL_STRUCT_FUNCTION (fn->fn_decl))
1141 fn_prev = &fn->next;
1142 else
1143 /* The function is not being emitted, remove from list. */
1144 *fn_prev = fn->next;
1145
1146 if (functions_head == NULL)
1147 return false;
1148
1149 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1150 if ((1u << ix) & prg_ctr_mask)
1151 n_counters++;
1152
1153 /* Build the info and fn_info types. These are mutually recursive. */
1154 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1155 gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1156 build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
1157 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1158 gcov_fn_info_ptr_type = build_pointer_type
1159 (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
1160 build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
1161
1162 /* Build the gcov info var, this is referred to in its own
1163 initializer. */
1164 gcov_info_var = build_decl (BUILTINS_LOCATION,
1165 VAR_DECL, NULL_TREE, gcov_info_type);
1166 TREE_STATIC (gcov_info_var) = 1;
1167 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
1168 DECL_NAME (gcov_info_var) = get_identifier (name_buf);
1169
1170 build_init_ctor (gcov_info_type);
1171 build_gcov_exit_decl ();
1172
1173 return true;
1174 }
1175
1176 /* Generate the coverage function info for FN and DATA. Append a
1177 pointer to that object to CTOR and return the appended CTOR. */
1178
1179 static vec<constructor_elt, va_gc> *
coverage_obj_fn(vec<constructor_elt,va_gc> * ctor,tree fn,struct coverage_data const * data)1180 coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
1181 struct coverage_data const *data)
1182 {
1183 tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
1184 tree var = build_var (fn, gcov_fn_info_type, -1);
1185
1186 DECL_INITIAL (var) = init;
1187 varpool_node::finalize_decl (var);
1188
1189 CONSTRUCTOR_APPEND_ELT (ctor, NULL,
1190 build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
1191 return ctor;
1192 }
1193
1194 /* Finalize the coverage data. Generates the array of pointers to
1195 function objects from CTOR. Generate the gcov_info initializer. */
1196
1197 static void
coverage_obj_finish(vec<constructor_elt,va_gc> * ctor)1198 coverage_obj_finish (vec<constructor_elt, va_gc> *ctor)
1199 {
1200 unsigned n_functions = vec_safe_length (ctor);
1201 tree fn_info_ary_type = build_array_type
1202 (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
1203 build_index_type (size_int (n_functions - 1)));
1204 tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE,
1205 fn_info_ary_type);
1206 char name_buf[32];
1207
1208 TREE_STATIC (fn_info_ary) = 1;
1209 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
1210 DECL_NAME (fn_info_ary) = get_identifier (name_buf);
1211 DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
1212 varpool_node::finalize_decl (fn_info_ary);
1213
1214 DECL_INITIAL (gcov_info_var)
1215 = build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
1216 varpool_node::finalize_decl (gcov_info_var);
1217 }
1218
1219 /* Perform file-level initialization. Read in data file, generate name
1220 of notes file. */
1221
1222 void
coverage_init(const char * filename)1223 coverage_init (const char *filename)
1224 {
1225 int len = strlen (filename);
1226 int prefix_len = 0;
1227
1228 /* Since coverage_init is invoked very early, before the pass
1229 manager, we need to set up the dumping explicitly. This is
1230 similar to the handling in finish_optimization_passes. */
1231 int profile_pass_num =
1232 g->get_passes ()->get_pass_profile ()->static_pass_number;
1233 g->get_dumps ()->dump_start (profile_pass_num, NULL);
1234
1235 if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename))
1236 profile_data_prefix = getpwd ();
1237
1238 if (profile_data_prefix)
1239 prefix_len = strlen (profile_data_prefix);
1240
1241 /* Name of da file. */
1242 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
1243 + prefix_len + 2);
1244
1245 if (profile_data_prefix)
1246 {
1247 memcpy (da_file_name, profile_data_prefix, prefix_len);
1248 da_file_name[prefix_len++] = '/';
1249 }
1250 memcpy (da_file_name + prefix_len, filename, len);
1251 strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX);
1252
1253 bbg_file_stamp = local_tick;
1254
1255 if (flag_auto_profile)
1256 read_autofdo_file ();
1257 else if (flag_branch_probabilities)
1258 read_counts_file ();
1259
1260 /* Name of bbg file. */
1261 if (flag_test_coverage && !flag_compare_debug)
1262 {
1263 bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
1264 memcpy (bbg_file_name, filename, len);
1265 strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX);
1266
1267 if (!gcov_open (bbg_file_name, -1))
1268 {
1269 error ("cannot open %s", bbg_file_name);
1270 bbg_file_name = NULL;
1271 }
1272 else
1273 {
1274 gcov_write_unsigned (GCOV_NOTE_MAGIC);
1275 gcov_write_unsigned (GCOV_VERSION);
1276 gcov_write_unsigned (bbg_file_stamp);
1277
1278 /* Do not support has_unexecuted_blocks for Ada. */
1279 gcov_write_unsigned (strcmp (lang_hooks.name, "GNU Ada") != 0);
1280 }
1281 }
1282
1283 g->get_dumps ()->dump_finish (profile_pass_num);
1284 }
1285
1286 /* Performs file-level cleanup. Close notes file, generate coverage
1287 variables and constructor. */
1288
1289 void
coverage_finish(void)1290 coverage_finish (void)
1291 {
1292 if (bbg_file_name && gcov_close ())
1293 unlink (bbg_file_name);
1294
1295 if (!flag_branch_probabilities && flag_test_coverage
1296 && (!local_tick || local_tick == (unsigned)-1))
1297 /* Only remove the da file, if we're emitting coverage code and
1298 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1299 unlink (da_file_name);
1300
1301 if (coverage_obj_init ())
1302 {
1303 vec<constructor_elt, va_gc> *fn_ctor = NULL;
1304 struct coverage_data *fn;
1305
1306 for (fn = functions_head; fn; fn = fn->next)
1307 fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
1308 coverage_obj_finish (fn_ctor);
1309 }
1310
1311 XDELETEVEC (da_file_name);
1312 da_file_name = NULL;
1313 }
1314
1315 #include "gt-coverage.h"
1316