1/* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2017 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
8This file is part of GCC.
9
10GCC is free software; you can redistribute it and/or modify it under
11the terms of the GNU General Public License as published by the Free
12Software Foundation; either version 3, or (at your option) any later
13version.
14
15GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16WARRANTY; without even the implied warranty of MERCHANTABILITY or
17FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18for more details.
19
20You should have received a copy of the GNU General Public License
21along 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
55struct 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. */
66struct 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
84static GTY(()) struct coverage_data *functions_head = 0;
85static struct coverage_data **functions_tail = &functions_head;
86static unsigned no_coverage = 0;
87
88/* Cumulative counter information for whole program. */
89static unsigned prg_ctr_mask; /* Mask of counter types generated. */
90
91/* Counter information for current function. */
92static unsigned fn_ctr_mask; /* Mask of counters used. */
93static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */
94static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
95static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
96
97/* Coverage info VAR_DECL and function info type nodes. */
98static GTY(()) tree gcov_info_var;
99static GTY(()) tree gcov_fn_info_type;
100static 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. */
106static char *bbg_file_name;
107
108/* File stamp for notes file. */
109static unsigned bbg_file_stamp;
110
111/* Name of the count data (gcda) file. */
112static 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),
117static 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,
124static const char *const ctr_names[GCOV_COUNTERS] = {
125#include "gcov-counter.def"
126};
127#undef DEF_GCOV_COUNTER
128
129/* Forward declarations. */
130static void read_counts_file (void);
131static tree build_var (tree, tree, int);
132static void build_fn_info_type (tree, unsigned, tree);
133static void build_info_type (tree, tree);
134static tree build_fn_info (const struct coverage_data *, tree, tree);
135static tree build_info (tree, tree);
136static bool coverage_obj_init (void);
137static vec<constructor_elt, va_gc> *coverage_obj_fn
138(vec<constructor_elt, va_gc> *, tree, struct coverage_data const *);
139static void coverage_obj_finish (vec<constructor_elt, va_gc> *);
140
141/* Return the type node for gcov_type. */
142
143tree
144get_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
153static tree
154get_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
160inline hashval_t
161counts_entry::hash (const counts_entry *entry)
162{
163 return entry->ident * GCOV_COUNTERS + entry->ctr;
164}
165
166inline int
167counts_entry::equal (const counts_entry *entry1, const counts_entry *entry2)
168{
169 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
170}
171
172inline void
173counts_entry::remove (counts_entry *entry)
174{
175 free (entry->counts);
176 free (entry);
177}
178
179/* Hash table of count data. */
180static hash_table<counts_entry> *counts_hash;
181
182/* Read in the counts file, if available. */
183
184static void
185read_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
345gcov_type *
346get_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 (cfun->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
433int
434coverage_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
459tree
460tree_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
475tree
476tree_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
494static unsigned
495coverage_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
553unsigned
554coverage_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
570unsigned
571coverage_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
615unsigned
616coverage_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
638int
639coverage_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 gcov_write_filename (xloc.file);
668 gcov_write_unsigned (xloc.line);
669 gcov_write_unsigned (xloc.column);
670
671 expanded_location endloc = expand_location (cfun->function_end_locus);
672
673 /* Function can start in a single file and end in another one. */
674 gcov_write_unsigned (endloc.file == xloc.file ? endloc.line : xloc.line);
675 gcov_write_length (offset);
676
677 return !gcov_is_error ();
678}
679
680/* Finish coverage data for the current function. Verify no output
681 error has occurred. Save function coverage counts. */
682
683void
684coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
685{
686 unsigned i;
687
688 if (bbg_file_name && gcov_is_error ())
689 {
690 warning (0, "error writing %qs", bbg_file_name);
691 unlink (bbg_file_name);
692 bbg_file_name = NULL;
693 }
694
695 if (fn_ctr_mask)
696 {
697 struct coverage_data *item = 0;
698
699 item = ggc_alloc<coverage_data> ();
700
701 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
702 item->ident = current_function_funcdef_no + 1;
703 else
704 {
705 gcc_assert (coverage_node_map_initialized_p ());
706 item->ident = cgraph_node::get (cfun->decl)->profile_id;
707 }
708
709 item->lineno_checksum = lineno_checksum;
710 item->cfg_checksum = cfg_checksum;
711
712 item->fn_decl = current_function_decl;
713 item->next = 0;
714 *functions_tail = item;
715 functions_tail = &item->next;
716
717 for (i = 0; i != GCOV_COUNTERS; i++)
718 {
719 tree var = fn_v_ctrs[i];
720
721 if (item)
722 item->ctr_vars[i] = var;
723 if (var)
724 {
725 tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1));
726 array_type = build_array_type (get_gcov_type (), array_type);
727 TREE_TYPE (var) = array_type;
728 DECL_SIZE (var) = TYPE_SIZE (array_type);
729 DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
730 varpool_node::finalize_decl (var);
731 }
732
733 fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
734 fn_v_ctrs[i] = NULL_TREE;
735 }
736 prg_ctr_mask |= fn_ctr_mask;
737 fn_ctr_mask = 0;
738 }
739}
740
741/* Remove coverage file if opened. */
742
743void
744coverage_remove_note_file (void)
745{
746 if (bbg_file_name)
747 {
748 gcov_close ();
749 unlink (bbg_file_name);
750 }
751}
752
753/* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
754 >= 0 it is a counter array, otherwise it is the function structure. */
755
756static tree
757build_var (tree fn_decl, tree type, int counter)
758{
759 tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type);
760 const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl));
761 char *buf;
762 size_t fn_name_len, len;
763
764 fn_name = targetm.strip_name_encoding (fn_name);
765 fn_name_len = strlen (fn_name);
766 buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3);
767
768 if (counter < 0)
769 strcpy (buf, "__gcov__");
770 else
771 sprintf (buf, "__gcov%u_", counter);
772 len = strlen (buf);
773 buf[len - 1] = symbol_table::symbol_suffix_separator ();
774 memcpy (buf + len, fn_name, fn_name_len + 1);
775 DECL_NAME (var) = get_identifier (buf);
776 TREE_STATIC (var) = 1;
777 TREE_ADDRESSABLE (var) = 1;
778 DECL_NONALIASED (var) = 1;
779 SET_DECL_ALIGN (var, TYPE_ALIGN (type));
780
781 return var;
782}
783
784/* Creates the gcov_fn_info RECORD_TYPE. */
785
786static void
787build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
788{
789 tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
790 tree field, fields;
791 tree array_type;
792
793 gcc_assert (counters);
794
795 /* ctr_info::num */
796 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
797 get_gcov_unsigned_t ());
798 fields = field;
799
800 /* ctr_info::values */
801 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
802 build_pointer_type (get_gcov_type ()));
803 DECL_CHAIN (field) = fields;
804 fields = field;
805
806 finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE);
807
808 /* key */
809 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
810 build_pointer_type (build_qualified_type
811 (gcov_info_type, TYPE_QUAL_CONST)));
812 fields = field;
813
814 /* ident */
815 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
816 get_gcov_unsigned_t ());
817 DECL_CHAIN (field) = fields;
818 fields = field;
819
820 /* lineno_checksum */
821 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
822 get_gcov_unsigned_t ());
823 DECL_CHAIN (field) = fields;
824 fields = field;
825
826 /* cfg checksum */
827 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
828 get_gcov_unsigned_t ());
829 DECL_CHAIN (field) = fields;
830 fields = field;
831
832 array_type = build_index_type (size_int (counters - 1));
833 array_type = build_array_type (ctr_info, array_type);
834
835 /* counters */
836 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type);
837 DECL_CHAIN (field) = fields;
838 fields = field;
839
840 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
841}
842
843/* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
844 the coverage data for the function and TYPE is the gcov_fn_info
845 RECORD_TYPE. KEY is the object file key. */
846
847static tree
848build_fn_info (const struct coverage_data *data, tree type, tree key)
849{
850 tree fields = TYPE_FIELDS (type);
851 tree ctr_type;
852 unsigned ix;
853 vec<constructor_elt, va_gc> *v1 = NULL;
854 vec<constructor_elt, va_gc> *v2 = NULL;
855
856 /* key */
857 CONSTRUCTOR_APPEND_ELT (v1, fields,
858 build1 (ADDR_EXPR, TREE_TYPE (fields), key));
859 fields = DECL_CHAIN (fields);
860
861 /* ident */
862 CONSTRUCTOR_APPEND_ELT (v1, fields,
863 build_int_cstu (get_gcov_unsigned_t (),
864 data->ident));
865 fields = DECL_CHAIN (fields);
866
867 /* lineno_checksum */
868 CONSTRUCTOR_APPEND_ELT (v1, fields,
869 build_int_cstu (get_gcov_unsigned_t (),
870 data->lineno_checksum));
871 fields = DECL_CHAIN (fields);
872
873 /* cfg_checksum */
874 CONSTRUCTOR_APPEND_ELT (v1, fields,
875 build_int_cstu (get_gcov_unsigned_t (),
876 data->cfg_checksum));
877 fields = DECL_CHAIN (fields);
878
879 /* counters */
880 ctr_type = TREE_TYPE (TREE_TYPE (fields));
881 for (ix = 0; ix != GCOV_COUNTERS; ix++)
882 if (prg_ctr_mask & (1 << ix))
883 {
884 vec<constructor_elt, va_gc> *ctr = NULL;
885 tree var = data->ctr_vars[ix];
886 unsigned count = 0;
887
888 if (var)
889 count
890 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var))))
891 + 1;
892
893 CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),
894 build_int_cstu (get_gcov_unsigned_t (),
895 count));
896
897 if (var)
898 CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),
899 build_fold_addr_expr (var));
900
901 CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr));
902 }
903
904 CONSTRUCTOR_APPEND_ELT (v1, fields,
905 build_constructor (TREE_TYPE (fields), v2));
906
907 return build_constructor (type, v1);
908}
909
910/* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
911 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
912
913static void
914build_info_type (tree type, tree fn_info_ptr_type)
915{
916 tree field, fields = NULL_TREE;
917 tree merge_fn_type;
918
919 /* Version ident */
920 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
921 get_gcov_unsigned_t ());
922 DECL_CHAIN (field) = fields;
923 fields = field;
924
925 /* next pointer */
926 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
927 build_pointer_type (build_qualified_type
928 (type, TYPE_QUAL_CONST)));
929 DECL_CHAIN (field) = fields;
930 fields = field;
931
932 /* stamp */
933 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
934 get_gcov_unsigned_t ());
935 DECL_CHAIN (field) = fields;
936 fields = field;
937
938 /* Filename */
939 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
940 build_pointer_type (build_qualified_type
941 (char_type_node, TYPE_QUAL_CONST)));
942 DECL_CHAIN (field) = fields;
943 fields = field;
944
945 /* merge fn array */
946 merge_fn_type
947 = build_function_type_list (void_type_node,
948 build_pointer_type (get_gcov_type ()),
949 get_gcov_unsigned_t (), NULL_TREE);
950 merge_fn_type
951 = build_array_type (build_pointer_type (merge_fn_type),
952 build_index_type (size_int (GCOV_COUNTERS - 1)));
953 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
954 merge_fn_type);
955 DECL_CHAIN (field) = fields;
956 fields = field;
957
958 /* n_functions */
959 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
960 get_gcov_unsigned_t ());
961 DECL_CHAIN (field) = fields;
962 fields = field;
963
964 /* function_info pointer pointer */
965 fn_info_ptr_type = build_pointer_type
966 (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
967 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
968 fn_info_ptr_type);
969 DECL_CHAIN (field) = fields;
970 fields = field;
971
972 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
973}
974
975/* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
976 gcov_info structure type, FN_ARY is the array of pointers to
977 function info objects. */
978
979static tree
980build_info (tree info_type, tree fn_ary)
981{
982 tree info_fields = TYPE_FIELDS (info_type);
983 tree merge_fn_type, n_funcs;
984 unsigned ix;
985 tree filename_string;
986 int da_file_name_len;
987 vec<constructor_elt, va_gc> *v1 = NULL;
988 vec<constructor_elt, va_gc> *v2 = NULL;
989
990 /* Version ident */
991 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
992 build_int_cstu (TREE_TYPE (info_fields),
993 GCOV_VERSION));
994 info_fields = DECL_CHAIN (info_fields);
995
996 /* next -- NULL */
997 CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node);
998 info_fields = DECL_CHAIN (info_fields);
999
1000 /* stamp */
1001 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1002 build_int_cstu (TREE_TYPE (info_fields),
1003 bbg_file_stamp));
1004 info_fields = DECL_CHAIN (info_fields);
1005
1006 /* Filename */
1007 da_file_name_len = strlen (da_file_name);
1008 filename_string = build_string (da_file_name_len + 1, da_file_name);
1009 TREE_TYPE (filename_string) = build_array_type
1010 (char_type_node, build_index_type (size_int (da_file_name_len)));
1011 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1012 build1 (ADDR_EXPR, TREE_TYPE (info_fields),
1013 filename_string));
1014 info_fields = DECL_CHAIN (info_fields);
1015
1016 /* merge fn array -- NULL slots indicate unmeasured counters */
1017 merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields));
1018 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1019 {
1020 tree ptr = null_pointer_node;
1021
1022 if ((1u << ix) & prg_ctr_mask)
1023 {
1024 tree merge_fn = build_decl (BUILTINS_LOCATION,
1025 FUNCTION_DECL,
1026 get_identifier (ctr_merge_functions[ix]),
1027 TREE_TYPE (merge_fn_type));
1028 DECL_EXTERNAL (merge_fn) = 1;
1029 TREE_PUBLIC (merge_fn) = 1;
1030 DECL_ARTIFICIAL (merge_fn) = 1;
1031 TREE_NOTHROW (merge_fn) = 1;
1032 /* Initialize assembler name so we can stream out. */
1033 DECL_ASSEMBLER_NAME (merge_fn);
1034 ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
1035 }
1036 CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr);
1037 }
1038 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1039 build_constructor (TREE_TYPE (info_fields), v2));
1040 info_fields = DECL_CHAIN (info_fields);
1041
1042 /* n_functions */
1043 n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)));
1044 n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),
1045 n_funcs, size_one_node);
1046 CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs);
1047 info_fields = DECL_CHAIN (info_fields);
1048
1049 /* functions */
1050 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1051 build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary));
1052 info_fields = DECL_CHAIN (info_fields);
1053
1054 gcc_assert (!info_fields);
1055 return build_constructor (info_type, v1);
1056}
1057
1058/* Generate the constructor function to call __gcov_init. */
1059
1060static void
1061build_init_ctor (tree gcov_info_type)
1062{
1063 tree ctor, stmt, init_fn;
1064
1065 /* Build a decl for __gcov_init. */
1066 init_fn = build_pointer_type (gcov_info_type);
1067 init_fn = build_function_type_list (void_type_node, init_fn, NULL);
1068 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1069 get_identifier ("__gcov_init"), init_fn);
1070 TREE_PUBLIC (init_fn) = 1;
1071 DECL_EXTERNAL (init_fn) = 1;
1072 DECL_ASSEMBLER_NAME (init_fn);
1073
1074 /* Generate a call to __gcov_init(&gcov_info). */
1075 ctor = NULL;
1076 stmt = build_fold_addr_expr (gcov_info_var);
1077 stmt = build_call_expr (init_fn, 1, stmt);
1078 append_to_statement_list (stmt, &ctor);
1079
1080 /* Generate a constructor to run it. */
1081 int priority = SUPPORTS_INIT_PRIORITY
1082 ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
1083 cgraph_build_static_cdtor ('I', ctor, priority);
1084}
1085
1086/* Generate the destructor function to call __gcov_exit. */
1087
1088static void
1089build_gcov_exit_decl (void)
1090{
1091 tree init_fn = build_function_type_list (void_type_node, void_type_node,
1092 NULL);
1093 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1094 get_identifier ("__gcov_exit"), init_fn);
1095 TREE_PUBLIC (init_fn) = 1;
1096 DECL_EXTERNAL (init_fn) = 1;
1097 DECL_ASSEMBLER_NAME (init_fn);
1098
1099 /* Generate a call to __gcov_exit (). */
1100 tree dtor = NULL;
1101 tree stmt = build_call_expr (init_fn, 0);
1102 append_to_statement_list (stmt, &dtor);
1103
1104 /* Generate a destructor to run it. */
1105 int priority = SUPPORTS_INIT_PRIORITY
1106 ? MAX_RESERVED_INIT_PRIORITY: DEFAULT_INIT_PRIORITY;
1107
1108 cgraph_build_static_cdtor ('D', dtor, priority);
1109}
1110
1111/* Create the gcov_info types and object. Generate the constructor
1112 function to call __gcov_init. Does not generate the initializer
1113 for the object. Returns TRUE if coverage data is being emitted. */
1114
1115static bool
1116coverage_obj_init (void)
1117{
1118 tree gcov_info_type;
1119 unsigned n_counters = 0;
1120 unsigned ix;
1121 struct coverage_data *fn;
1122 struct coverage_data **fn_prev;
1123 char name_buf[32];
1124
1125 no_coverage = 1; /* Disable any further coverage. */
1126
1127 if (!prg_ctr_mask)
1128 return false;
1129
1130 if (symtab->dump_file)
1131 fprintf (symtab->dump_file, "Using data file %s\n", da_file_name);
1132
1133 /* Prune functions. */
1134 for (fn_prev = &functions_head; (fn = *fn_prev);)
1135 if (DECL_STRUCT_FUNCTION (fn->fn_decl))
1136 fn_prev = &fn->next;
1137 else
1138 /* The function is not being emitted, remove from list. */
1139 *fn_prev = fn->next;
1140
1141 if (functions_head == NULL)
1142 return false;
1143
1144 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1145 if ((1u << ix) & prg_ctr_mask)
1146 n_counters++;
1147
1148 /* Build the info and fn_info types. These are mutually recursive. */
1149 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1150 gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1151 build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
1152 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1153 gcov_fn_info_ptr_type = build_pointer_type
1154 (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
1155 build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
1156
1157 /* Build the gcov info var, this is referred to in its own
1158 initializer. */
1159 gcov_info_var = build_decl (BUILTINS_LOCATION,
1160 VAR_DECL, NULL_TREE, gcov_info_type);
1161 TREE_STATIC (gcov_info_var) = 1;
1162 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
1163 DECL_NAME (gcov_info_var) = get_identifier (name_buf);
1164
1165 build_init_ctor (gcov_info_type);
1166 build_gcov_exit_decl ();
1167
1168 return true;
1169}
1170
1171/* Generate the coverage function info for FN and DATA. Append a
1172 pointer to that object to CTOR and return the appended CTOR. */
1173
1174static vec<constructor_elt, va_gc> *
1175coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
1176 struct coverage_data const *data)
1177{
1178 tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
1179 tree var = build_var (fn, gcov_fn_info_type, -1);
1180
1181 DECL_INITIAL (var) = init;
1182 varpool_node::finalize_decl (var);
1183
1184 CONSTRUCTOR_APPEND_ELT (ctor, NULL,
1185 build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
1186 return ctor;
1187}
1188
1189/* Finalize the coverage data. Generates the array of pointers to
1190 function objects from CTOR. Generate the gcov_info initializer. */
1191
1192static void
1193coverage_obj_finish (vec<constructor_elt, va_gc> *ctor)
1194{
1195 unsigned n_functions = vec_safe_length (ctor);
1196 tree fn_info_ary_type = build_array_type
1197 (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
1198 build_index_type (size_int (n_functions - 1)));
1199 tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE,
1200 fn_info_ary_type);
1201 char name_buf[32];
1202
1203 TREE_STATIC (fn_info_ary) = 1;
1204 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
1205 DECL_NAME (fn_info_ary) = get_identifier (name_buf);
1206 DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
1207 varpool_node::finalize_decl (fn_info_ary);
1208
1209 DECL_INITIAL (gcov_info_var)
1210 = build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
1211 varpool_node::finalize_decl (gcov_info_var);
1212}
1213
1214/* Perform file-level initialization. Read in data file, generate name
1215 of notes file. */
1216
1217void
1218coverage_init (const char *filename)
1219{
1220 int len = strlen (filename);
1221 int prefix_len = 0;
1222
1223 /* Since coverage_init is invoked very early, before the pass
1224 manager, we need to set up the dumping explicitly. This is
1225 similar to the handling in finish_optimization_passes. */
1226 int profile_pass_num =
1227 g->get_passes ()->get_pass_profile ()->static_pass_number;
1228 g->get_dumps ()->dump_start (profile_pass_num, NULL);
1229
1230 if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename))
1231 profile_data_prefix = getpwd ();
1232
1233 if (profile_data_prefix)
1234 prefix_len = strlen (profile_data_prefix);
1235
1236 /* Name of da file. */
1237 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
1238 + prefix_len + 2);
1239
1240 if (profile_data_prefix)
1241 {
1242 memcpy (da_file_name, profile_data_prefix, prefix_len);
1243 da_file_name[prefix_len++] = '/';
1244 }
1245 memcpy (da_file_name + prefix_len, filename, len);
1246 strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX);
1247
1248 bbg_file_stamp = local_tick;
1249
1250 if (flag_auto_profile)
1251 read_autofdo_file ();
1252 else if (flag_branch_probabilities)
1253 read_counts_file ();
1254
1255 /* Name of bbg file. */
1256 if (flag_test_coverage && !flag_compare_debug)
1257 {
1258 bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
1259 memcpy (bbg_file_name, filename, len);
1260 strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX);
1261
1262 if (!gcov_open (bbg_file_name, -1))
1263 {
1264 error ("cannot open %s", bbg_file_name);
1265 bbg_file_name = NULL;
1266 }
1267 else
1268 {
1269 gcov_write_unsigned (GCOV_NOTE_MAGIC);
1270 gcov_write_unsigned (GCOV_VERSION);
1271 gcov_write_unsigned (bbg_file_stamp);
1272
1273 /* Do not support has_unexecuted_blocks for Ada. */
1274 gcov_write_unsigned (strcmp (lang_hooks.name, "GNU Ada") != 0);
1275 }
1276 }
1277
1278 g->get_dumps ()->dump_finish (profile_pass_num);
1279}
1280
1281/* Performs file-level cleanup. Close notes file, generate coverage
1282 variables and constructor. */
1283
1284void
1285coverage_finish (void)
1286{
1287 if (bbg_file_name && gcov_close ())
1288 unlink (bbg_file_name);
1289
1290 if (!flag_branch_probabilities && flag_test_coverage
1291 && (!local_tick || local_tick == (unsigned)-1))
1292 /* Only remove the da file, if we're emitting coverage code and
1293 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1294 unlink (da_file_name);
1295
1296 if (coverage_obj_init ())
1297 {
1298 vec<constructor_elt, va_gc> *fn_ctor = NULL;
1299 struct coverage_data *fn;
1300
1301 for (fn = functions_head; fn; fn = fn->next)
1302 fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
1303 coverage_obj_finish (fn_ctor);
1304 }
1305
1306 XDELETEVEC (da_file_name);
1307 da_file_name = NULL;
1308}
1309
1310#include "gt-coverage.h"
1311