gcc/
[official-gcc.git] / gcc / coverage.c
blobd936cb0f200be986137a588a6e984d256950fd53
1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2014 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
8 This file is part of GCC.
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.
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.
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/>. */
25 #define GCOV_LINKAGE
27 #include "config.h"
28 #include "system.h"
29 #include "coretypes.h"
30 #include "tm.h"
31 #include "rtl.h"
32 #include "tree.h"
33 #include "stringpool.h"
34 #include "stor-layout.h"
35 #include "flags.h"
36 #include "output.h"
37 #include "regs.h"
38 #include "expr.h"
39 #include "function.h"
40 #include "basic-block.h"
41 #include "toplev.h"
42 #include "tm_p.h"
43 #include "ggc.h"
44 #include "coverage.h"
45 #include "langhooks.h"
46 #include "hash-table.h"
47 #include "tree-iterator.h"
48 #include "context.h"
49 #include "pass_manager.h"
50 #include "tree-pass.h"
51 #include "cgraph.h"
52 #include "dumpfile.h"
53 #include "diagnostic-core.h"
54 #include "intl.h"
55 #include "filenames.h"
56 #include "target.h"
57 #include "params.h"
59 #include "gcov-io.h"
60 #include "gcov-io.c"
62 struct GTY((chain_next ("%h.next"))) coverage_data
64 struct coverage_data *next; /* next function */
65 unsigned ident; /* function ident */
66 unsigned lineno_checksum; /* function lineno checksum */
67 unsigned cfg_checksum; /* function cfg checksum */
68 tree fn_decl; /* the function decl */
69 tree ctr_vars[GCOV_COUNTERS]; /* counter variables. */
72 /* Counts information for a function. */
73 typedef struct counts_entry
75 /* We hash by */
76 unsigned ident;
77 unsigned ctr;
79 /* Store */
80 unsigned lineno_checksum;
81 unsigned cfg_checksum;
82 gcov_type *counts;
83 struct gcov_ctr_summary summary;
85 /* hash_table support. */
86 typedef counts_entry value_type;
87 typedef counts_entry compare_type;
88 static inline hashval_t hash (const value_type *);
89 static int equal (const value_type *, const compare_type *);
90 static void remove (value_type *);
91 } counts_entry_t;
93 static GTY(()) struct coverage_data *functions_head = 0;
94 static struct coverage_data **functions_tail = &functions_head;
95 static unsigned no_coverage = 0;
97 /* Cumulative counter information for whole program. */
98 static unsigned prg_ctr_mask; /* Mask of counter types generated. */
100 /* Counter information for current function. */
101 static unsigned fn_ctr_mask; /* Mask of counters used. */
102 static GTY(()) tree fn_v_ctrs[GCOV_COUNTERS]; /* counter variables. */
103 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
104 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
106 /* Coverage info VAR_DECL and function info type nodes. */
107 static GTY(()) tree gcov_info_var;
108 static GTY(()) tree gcov_fn_info_type;
109 static GTY(()) tree gcov_fn_info_ptr_type;
111 /* Name of the notes (gcno) output file. The "bbg" prefix is for
112 historical reasons, when the notes file contained only the
113 basic block graph notes.
114 If this is NULL we're not writing to the notes file. */
115 static char *bbg_file_name;
117 /* File stamp for notes file. */
118 static unsigned bbg_file_stamp;
120 /* Name of the count data (gcda) file. */
121 static char *da_file_name;
123 /* The names of merge functions for counters. */
124 #define STR(str) #str
125 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
126 static const char *const ctr_merge_functions[GCOV_COUNTERS] = {
127 #include "gcov-counter.def"
129 #undef DEF_GCOV_COUNTER
130 #undef STR
132 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
133 static const char *const ctr_names[GCOV_COUNTERS] = {
134 #include "gcov-counter.def"
136 #undef DEF_GCOV_COUNTER
138 /* Forward declarations. */
139 static void read_counts_file (void);
140 static tree build_var (tree, tree, int);
141 static void build_fn_info_type (tree, unsigned, tree);
142 static void build_info_type (tree, tree);
143 static tree build_fn_info (const struct coverage_data *, tree, tree);
144 static tree build_info (tree, tree);
145 static bool coverage_obj_init (void);
146 static vec<constructor_elt, va_gc> *coverage_obj_fn
147 (vec<constructor_elt, va_gc> *, tree, struct coverage_data const *);
148 static void coverage_obj_finish (vec<constructor_elt, va_gc> *);
150 /* Return the type node for gcov_type. */
152 tree
153 get_gcov_type (void)
155 enum machine_mode mode = smallest_mode_for_size (GCOV_TYPE_SIZE, MODE_INT);
156 return lang_hooks.types.type_for_mode (mode, false);
159 /* Return the type node for gcov_unsigned_t. */
161 static tree
162 get_gcov_unsigned_t (void)
164 enum machine_mode mode = smallest_mode_for_size (32, MODE_INT);
165 return lang_hooks.types.type_for_mode (mode, true);
168 inline hashval_t
169 counts_entry::hash (const value_type *entry)
171 return entry->ident * GCOV_COUNTERS + entry->ctr;
174 inline int
175 counts_entry::equal (const value_type *entry1,
176 const compare_type *entry2)
178 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
181 inline void
182 counts_entry::remove (value_type *entry)
184 free (entry->counts);
185 free (entry);
188 /* Hash table of count data. */
189 static hash_table<counts_entry> *counts_hash;
191 /* Read in the counts file, if available. */
193 static void
194 read_counts_file (void)
196 gcov_unsigned_t fn_ident = 0;
197 struct gcov_summary summary;
198 unsigned new_summary = 1;
199 gcov_unsigned_t tag;
200 int is_error = 0;
201 unsigned lineno_checksum = 0;
202 unsigned cfg_checksum = 0;
204 if (!gcov_open (da_file_name, 1))
205 return;
207 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
209 warning (0, "%qs is not a gcov data file", da_file_name);
210 gcov_close ();
211 return;
213 else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
215 char v[4], e[4];
217 GCOV_UNSIGNED2STRING (v, tag);
218 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
220 warning (0, "%qs is version %q.*s, expected version %q.*s",
221 da_file_name, 4, v, 4, e);
222 gcov_close ();
223 return;
226 /* Read the stamp, used for creating a generation count. */
227 tag = gcov_read_unsigned ();
228 bbg_file_stamp = crc32_unsigned (bbg_file_stamp, tag);
230 counts_hash = new hash_table<counts_entry> (10);
231 while ((tag = gcov_read_unsigned ()))
233 gcov_unsigned_t length;
234 gcov_position_t offset;
236 length = gcov_read_unsigned ();
237 offset = gcov_position ();
238 if (tag == GCOV_TAG_FUNCTION)
240 if (length)
242 fn_ident = gcov_read_unsigned ();
243 lineno_checksum = gcov_read_unsigned ();
244 cfg_checksum = gcov_read_unsigned ();
246 else
247 fn_ident = lineno_checksum = cfg_checksum = 0;
248 new_summary = 1;
250 else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
252 struct gcov_summary sum;
253 unsigned ix;
255 if (new_summary)
256 memset (&summary, 0, sizeof (summary));
258 gcov_read_summary (&sum);
259 for (ix = 0; ix != GCOV_COUNTERS_SUMMABLE; ix++)
261 summary.ctrs[ix].runs += sum.ctrs[ix].runs;
262 summary.ctrs[ix].sum_all += sum.ctrs[ix].sum_all;
263 if (summary.ctrs[ix].run_max < sum.ctrs[ix].run_max)
264 summary.ctrs[ix].run_max = sum.ctrs[ix].run_max;
265 summary.ctrs[ix].sum_max += sum.ctrs[ix].sum_max;
267 if (new_summary)
268 memcpy (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
269 sum.ctrs[GCOV_COUNTER_ARCS].histogram,
270 sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
271 else
272 gcov_histogram_merge (summary.ctrs[GCOV_COUNTER_ARCS].histogram,
273 sum.ctrs[GCOV_COUNTER_ARCS].histogram);
274 new_summary = 0;
276 else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
278 counts_entry_t **slot, *entry, elt;
279 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
280 unsigned ix;
282 elt.ident = fn_ident;
283 elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
285 slot = counts_hash->find_slot (&elt, INSERT);
286 entry = *slot;
287 if (!entry)
289 *slot = entry = XCNEW (counts_entry_t);
290 entry->ident = fn_ident;
291 entry->ctr = elt.ctr;
292 entry->lineno_checksum = lineno_checksum;
293 entry->cfg_checksum = cfg_checksum;
294 if (elt.ctr < GCOV_COUNTERS_SUMMABLE)
295 entry->summary = summary.ctrs[elt.ctr];
296 entry->summary.num = n_counts;
297 entry->counts = XCNEWVEC (gcov_type, n_counts);
299 else if (entry->lineno_checksum != lineno_checksum
300 || entry->cfg_checksum != cfg_checksum)
302 error ("Profile data for function %u is corrupted", fn_ident);
303 error ("checksum is (%x,%x) instead of (%x,%x)",
304 entry->lineno_checksum, entry->cfg_checksum,
305 lineno_checksum, cfg_checksum);
306 delete counts_hash;
307 counts_hash = NULL;
308 break;
310 else if (entry->summary.num != n_counts)
312 error ("Profile data for function %u is corrupted", fn_ident);
313 error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
314 delete counts_hash;
315 counts_hash = NULL;
316 break;
318 else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
320 error ("cannot merge separate %s counters for function %u",
321 ctr_names[elt.ctr], fn_ident);
322 goto skip_merge;
324 else
326 entry->summary.runs += summary.ctrs[elt.ctr].runs;
327 entry->summary.sum_all += summary.ctrs[elt.ctr].sum_all;
328 if (entry->summary.run_max < summary.ctrs[elt.ctr].run_max)
329 entry->summary.run_max = summary.ctrs[elt.ctr].run_max;
330 entry->summary.sum_max += summary.ctrs[elt.ctr].sum_max;
332 for (ix = 0; ix != n_counts; ix++)
333 entry->counts[ix] += gcov_read_counter ();
334 skip_merge:;
336 gcov_sync (offset, length);
337 if ((is_error = gcov_is_error ()))
339 error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
340 da_file_name);
341 delete counts_hash;
342 counts_hash = NULL;
343 break;
347 gcov_close ();
350 /* Returns the counters for a particular tag. */
352 gcov_type *
353 get_coverage_counts (unsigned counter, unsigned expected,
354 unsigned cfg_checksum, unsigned lineno_checksum,
355 const struct gcov_ctr_summary **summary)
357 counts_entry_t *entry, elt;
359 /* No hash table, no counts. */
360 if (!counts_hash)
362 static int warned = 0;
364 if (!warned++ && dump_enabled_p ())
365 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
366 (flag_guess_branch_prob
367 ? "file %s not found, execution counts estimated\n"
368 : "file %s not found, execution counts assumed to "
369 "be zero\n"),
370 da_file_name);
371 return NULL;
373 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
374 elt.ident = current_function_funcdef_no + 1;
375 else
377 gcc_assert (coverage_node_map_initialized_p ());
378 elt.ident = cgraph_node::get (cfun->decl)->profile_id;
380 elt.ctr = counter;
381 entry = counts_hash->find (&elt);
382 if (!entry || !entry->summary.num)
383 /* The function was not emitted, or is weak and not chosen in the
384 final executable. Silently fail, because there's nothing we
385 can do about it. */
386 return NULL;
388 if (entry->cfg_checksum != cfg_checksum
389 || entry->summary.num != expected)
391 static int warned = 0;
392 bool warning_printed = false;
393 tree id = DECL_ASSEMBLER_NAME (current_function_decl);
395 warning_printed =
396 warning_at (input_location, OPT_Wcoverage_mismatch,
397 "the control flow of function %qE does not match "
398 "its profile data (counter %qs)", id, ctr_names[counter]);
399 if (warning_printed && dump_enabled_p ())
401 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
402 "use -Wno-error=coverage-mismatch to tolerate "
403 "the mismatch but performance may drop if the "
404 "function is hot\n");
406 if (!seen_error ()
407 && !warned++)
409 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, input_location,
410 "coverage mismatch ignored\n");
411 dump_printf (MSG_OPTIMIZED_LOCATIONS,
412 flag_guess_branch_prob
413 ? G_("execution counts estimated\n")
414 : G_("execution counts assumed to be zero\n"));
415 if (!flag_guess_branch_prob)
416 dump_printf (MSG_OPTIMIZED_LOCATIONS,
417 "this can result in poorly optimized code\n");
421 return NULL;
423 else if (entry->lineno_checksum != lineno_checksum)
425 warning (OPT_Wcoverage_mismatch,
426 "source locations for function %qE have changed,"
427 " the profile data may be out of date",
428 DECL_ASSEMBLER_NAME (current_function_decl));
431 if (summary)
432 *summary = &entry->summary;
434 return entry->counts;
437 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
438 allocation succeeded. */
441 coverage_counter_alloc (unsigned counter, unsigned num)
443 if (no_coverage)
444 return 0;
446 if (!num)
447 return 1;
449 if (!fn_v_ctrs[counter])
451 tree array_type = build_array_type (get_gcov_type (), NULL_TREE);
453 fn_v_ctrs[counter]
454 = build_var (current_function_decl, array_type, counter);
457 fn_b_ctrs[counter] = fn_n_ctrs[counter];
458 fn_n_ctrs[counter] += num;
460 fn_ctr_mask |= 1 << counter;
461 return 1;
464 /* Generate a tree to access COUNTER NO. */
466 tree
467 tree_coverage_counter_ref (unsigned counter, unsigned no)
469 tree gcov_type_node = get_gcov_type ();
471 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
473 no += fn_b_ctrs[counter];
475 /* "no" here is an array index, scaled to bytes later. */
476 return build4 (ARRAY_REF, gcov_type_node, fn_v_ctrs[counter],
477 build_int_cst (integer_type_node, no), NULL, NULL);
480 /* Generate a tree to access the address of COUNTER NO. */
482 tree
483 tree_coverage_counter_addr (unsigned counter, unsigned no)
485 tree gcov_type_node = get_gcov_type ();
487 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
488 no += fn_b_ctrs[counter];
490 /* "no" here is an array index, scaled to bytes later. */
491 return build_fold_addr_expr (build4 (ARRAY_REF, gcov_type_node,
492 fn_v_ctrs[counter],
493 build_int_cst (integer_type_node, no),
494 NULL, NULL));
498 /* Generate a checksum for a string. CHKSUM is the current
499 checksum. */
501 static unsigned
502 coverage_checksum_string (unsigned chksum, const char *string)
504 int i;
505 char *dup = NULL;
507 /* Look for everything that looks if it were produced by
508 get_file_function_name and zero out the second part
509 that may result from flag_random_seed. This is not critical
510 as the checksums are used only for sanity checking. */
511 for (i = 0; string[i]; i++)
513 int offset = 0;
514 if (!strncmp (string + i, "_GLOBAL__N_", 11))
515 offset = 11;
516 if (!strncmp (string + i, "_GLOBAL__", 9))
517 offset = 9;
519 /* C++ namespaces do have scheme:
520 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
521 since filename might contain extra underscores there seems
522 to be no better chance then walk all possible offsets looking
523 for magicnumber. */
524 if (offset)
526 for (i = i + offset; string[i]; i++)
527 if (string[i]=='_')
529 int y;
531 for (y = 1; y < 9; y++)
532 if (!(string[i + y] >= '0' && string[i + y] <= '9')
533 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
534 break;
535 if (y != 9 || string[i + 9] != '_')
536 continue;
537 for (y = 10; y < 18; y++)
538 if (!(string[i + y] >= '0' && string[i + y] <= '9')
539 && !(string[i + y] >= 'A' && string[i + y] <= 'F'))
540 break;
541 if (y != 18)
542 continue;
543 if (!dup)
544 string = dup = xstrdup (string);
545 for (y = 10; y < 18; y++)
546 dup[i + y] = '0';
548 break;
552 chksum = crc32_string (chksum, string);
553 free (dup);
555 return chksum;
558 /* Compute checksum for the current function. We generate a CRC32. */
560 unsigned
561 coverage_compute_lineno_checksum (void)
563 expanded_location xloc
564 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
565 unsigned chksum = xloc.line;
567 chksum = coverage_checksum_string (chksum, xloc.file);
568 chksum = coverage_checksum_string
569 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
571 return chksum;
574 /* Compute profile ID. This is better to be unique in whole program. */
576 unsigned
577 coverage_compute_profile_id (struct cgraph_node *n)
579 unsigned chksum;
581 /* Externally visible symbols have unique name. */
582 if (TREE_PUBLIC (n->decl) || DECL_EXTERNAL (n->decl) || n->unique_name)
584 chksum = coverage_checksum_string
585 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
587 else
589 expanded_location xloc
590 = expand_location (DECL_SOURCE_LOCATION (n->decl));
591 bool use_name_only = (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID) == 0);
593 chksum = (use_name_only ? 0 : xloc.line);
594 chksum = coverage_checksum_string (chksum, xloc.file);
595 chksum = coverage_checksum_string
596 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n->decl)));
597 if (!use_name_only && first_global_object_name)
598 chksum = coverage_checksum_string
599 (chksum, first_global_object_name);
600 chksum = coverage_checksum_string
601 (chksum, aux_base_name);
604 /* Non-negative integers are hopefully small enough to fit in all targets.
605 Gcov file formats wants non-zero function IDs. */
606 chksum = chksum & 0x7fffffff;
607 return chksum + (!chksum);
610 /* Compute cfg checksum for the function FN given as argument.
611 The checksum is calculated carefully so that
612 source code changes that doesn't affect the control flow graph
613 won't change the checksum.
614 This is to make the profile data useable across source code change.
615 The downside of this is that the compiler may use potentially
616 wrong profile data - that the source code change has non-trivial impact
617 on the validity of profile data (e.g. the reversed condition)
618 but the compiler won't detect the change and use the wrong profile data. */
620 unsigned
621 coverage_compute_cfg_checksum (struct function *fn)
623 basic_block bb;
624 unsigned chksum = n_basic_blocks_for_fn (fn);
626 FOR_EACH_BB_FN (bb, fn)
628 edge e;
629 edge_iterator ei;
630 chksum = crc32_byte (chksum, bb->index);
631 FOR_EACH_EDGE (e, ei, bb->succs)
633 chksum = crc32_byte (chksum, e->dest->index);
637 return chksum;
640 /* Begin output to the notes file for the current function.
641 Writes the function header. Returns nonzero if data should be output. */
644 coverage_begin_function (unsigned lineno_checksum, unsigned cfg_checksum)
646 expanded_location xloc;
647 unsigned long offset;
649 /* We don't need to output .gcno file unless we're under -ftest-coverage
650 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
651 if (no_coverage || !bbg_file_name)
652 return 0;
654 xloc = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
656 /* Announce function */
657 offset = gcov_write_tag (GCOV_TAG_FUNCTION);
658 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
659 gcov_write_unsigned (current_function_funcdef_no + 1);
660 else
662 gcc_assert (coverage_node_map_initialized_p ());
663 gcov_write_unsigned (
664 cgraph_node::get (current_function_decl)->profile_id);
667 gcov_write_unsigned (lineno_checksum);
668 gcov_write_unsigned (cfg_checksum);
669 gcov_write_string (IDENTIFIER_POINTER
670 (DECL_ASSEMBLER_NAME (current_function_decl)));
671 gcov_write_string (xloc.file);
672 gcov_write_unsigned (xloc.line);
673 gcov_write_length (offset);
675 return !gcov_is_error ();
678 /* Finish coverage data for the current function. Verify no output
679 error has occurred. Save function coverage counts. */
681 void
682 coverage_end_function (unsigned lineno_checksum, unsigned cfg_checksum)
684 unsigned i;
686 if (bbg_file_name && gcov_is_error ())
688 warning (0, "error writing %qs", bbg_file_name);
689 unlink (bbg_file_name);
690 bbg_file_name = NULL;
693 if (fn_ctr_mask)
695 struct coverage_data *item = 0;
697 item = ggc_alloc<coverage_data> ();
699 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID))
700 item->ident = current_function_funcdef_no + 1;
701 else
703 gcc_assert (coverage_node_map_initialized_p ());
704 item->ident = cgraph_node::get (cfun->decl)->profile_id;
707 item->lineno_checksum = lineno_checksum;
708 item->cfg_checksum = cfg_checksum;
710 item->fn_decl = current_function_decl;
711 item->next = 0;
712 *functions_tail = item;
713 functions_tail = &item->next;
715 for (i = 0; i != GCOV_COUNTERS; i++)
717 tree var = fn_v_ctrs[i];
719 if (item)
720 item->ctr_vars[i] = var;
721 if (var)
723 tree array_type = build_index_type (size_int (fn_n_ctrs[i] - 1));
724 array_type = build_array_type (get_gcov_type (), array_type);
725 TREE_TYPE (var) = array_type;
726 DECL_SIZE (var) = TYPE_SIZE (array_type);
727 DECL_SIZE_UNIT (var) = TYPE_SIZE_UNIT (array_type);
728 varpool_node::finalize_decl (var);
731 fn_b_ctrs[i] = fn_n_ctrs[i] = 0;
732 fn_v_ctrs[i] = NULL_TREE;
734 prg_ctr_mask |= fn_ctr_mask;
735 fn_ctr_mask = 0;
739 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
740 >= 0 it is a counter array, otherwise it is the function structure. */
742 static tree
743 build_var (tree fn_decl, tree type, int counter)
745 tree var = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE, type);
746 const char *fn_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl));
747 char *buf;
748 size_t fn_name_len, len;
750 fn_name = targetm.strip_name_encoding (fn_name);
751 fn_name_len = strlen (fn_name);
752 buf = XALLOCAVEC (char, fn_name_len + 8 + sizeof (int) * 3);
754 if (counter < 0)
755 strcpy (buf, "__gcov__");
756 else
757 sprintf (buf, "__gcov%u_", counter);
758 len = strlen (buf);
759 #ifndef NO_DOT_IN_LABEL
760 buf[len - 1] = '.';
761 #elif !defined NO_DOLLAR_IN_LABEL
762 buf[len - 1] = '$';
763 #endif
764 memcpy (buf + len, fn_name, fn_name_len + 1);
765 DECL_NAME (var) = get_identifier (buf);
766 TREE_STATIC (var) = 1;
767 TREE_ADDRESSABLE (var) = 1;
768 DECL_NONALIASED (var) = 1;
769 DECL_ALIGN (var) = TYPE_ALIGN (type);
771 return var;
774 /* Creates the gcov_fn_info RECORD_TYPE. */
776 static void
777 build_fn_info_type (tree type, unsigned counters, tree gcov_info_type)
779 tree ctr_info = lang_hooks.types.make_type (RECORD_TYPE);
780 tree field, fields;
781 tree array_type;
783 gcc_assert (counters);
785 /* ctr_info::num */
786 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
787 get_gcov_unsigned_t ());
788 fields = field;
790 /* ctr_info::values */
791 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
792 build_pointer_type (get_gcov_type ()));
793 DECL_CHAIN (field) = fields;
794 fields = field;
796 finish_builtin_struct (ctr_info, "__gcov_ctr_info", fields, NULL_TREE);
798 /* key */
799 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
800 build_pointer_type (build_qualified_type
801 (gcov_info_type, TYPE_QUAL_CONST)));
802 fields = field;
804 /* ident */
805 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
806 get_gcov_unsigned_t ());
807 DECL_CHAIN (field) = fields;
808 fields = field;
810 /* lineno_checksum */
811 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
812 get_gcov_unsigned_t ());
813 DECL_CHAIN (field) = fields;
814 fields = field;
816 /* cfg checksum */
817 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
818 get_gcov_unsigned_t ());
819 DECL_CHAIN (field) = fields;
820 fields = field;
822 array_type = build_index_type (size_int (counters - 1));
823 array_type = build_array_type (ctr_info, array_type);
825 /* counters */
826 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE, array_type);
827 DECL_CHAIN (field) = fields;
828 fields = field;
830 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
833 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
834 the coverage data for the function and TYPE is the gcov_fn_info
835 RECORD_TYPE. KEY is the object file key. */
837 static tree
838 build_fn_info (const struct coverage_data *data, tree type, tree key)
840 tree fields = TYPE_FIELDS (type);
841 tree ctr_type;
842 unsigned ix;
843 vec<constructor_elt, va_gc> *v1 = NULL;
844 vec<constructor_elt, va_gc> *v2 = NULL;
846 /* key */
847 CONSTRUCTOR_APPEND_ELT (v1, fields,
848 build1 (ADDR_EXPR, TREE_TYPE (fields), key));
849 fields = DECL_CHAIN (fields);
851 /* ident */
852 CONSTRUCTOR_APPEND_ELT (v1, fields,
853 build_int_cstu (get_gcov_unsigned_t (),
854 data->ident));
855 fields = DECL_CHAIN (fields);
857 /* lineno_checksum */
858 CONSTRUCTOR_APPEND_ELT (v1, fields,
859 build_int_cstu (get_gcov_unsigned_t (),
860 data->lineno_checksum));
861 fields = DECL_CHAIN (fields);
863 /* cfg_checksum */
864 CONSTRUCTOR_APPEND_ELT (v1, fields,
865 build_int_cstu (get_gcov_unsigned_t (),
866 data->cfg_checksum));
867 fields = DECL_CHAIN (fields);
869 /* counters */
870 ctr_type = TREE_TYPE (TREE_TYPE (fields));
871 for (ix = 0; ix != GCOV_COUNTERS; ix++)
872 if (prg_ctr_mask & (1 << ix))
874 vec<constructor_elt, va_gc> *ctr = NULL;
875 tree var = data->ctr_vars[ix];
876 unsigned count = 0;
878 if (var)
879 count
880 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var))))
881 + 1;
883 CONSTRUCTOR_APPEND_ELT (ctr, TYPE_FIELDS (ctr_type),
884 build_int_cstu (get_gcov_unsigned_t (),
885 count));
887 if (var)
888 CONSTRUCTOR_APPEND_ELT (ctr, DECL_CHAIN (TYPE_FIELDS (ctr_type)),
889 build_fold_addr_expr (var));
891 CONSTRUCTOR_APPEND_ELT (v2, NULL, build_constructor (ctr_type, ctr));
894 CONSTRUCTOR_APPEND_ELT (v1, fields,
895 build_constructor (TREE_TYPE (fields), v2));
897 return build_constructor (type, v1);
900 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
901 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
903 static void
904 build_info_type (tree type, tree fn_info_ptr_type)
906 tree field, fields = NULL_TREE;
907 tree merge_fn_type;
909 /* Version ident */
910 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
911 get_gcov_unsigned_t ());
912 DECL_CHAIN (field) = fields;
913 fields = field;
915 /* next pointer */
916 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
917 build_pointer_type (build_qualified_type
918 (type, TYPE_QUAL_CONST)));
919 DECL_CHAIN (field) = fields;
920 fields = field;
922 /* stamp */
923 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
924 get_gcov_unsigned_t ());
925 DECL_CHAIN (field) = fields;
926 fields = field;
928 /* Filename */
929 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
930 build_pointer_type (build_qualified_type
931 (char_type_node, TYPE_QUAL_CONST)));
932 DECL_CHAIN (field) = fields;
933 fields = field;
935 /* merge fn array */
936 merge_fn_type
937 = build_function_type_list (void_type_node,
938 build_pointer_type (get_gcov_type ()),
939 get_gcov_unsigned_t (), NULL_TREE);
940 merge_fn_type
941 = build_array_type (build_pointer_type (merge_fn_type),
942 build_index_type (size_int (GCOV_COUNTERS - 1)));
943 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
944 merge_fn_type);
945 DECL_CHAIN (field) = fields;
946 fields = field;
948 /* n_functions */
949 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
950 get_gcov_unsigned_t ());
951 DECL_CHAIN (field) = fields;
952 fields = field;
954 /* function_info pointer pointer */
955 fn_info_ptr_type = build_pointer_type
956 (build_qualified_type (fn_info_ptr_type, TYPE_QUAL_CONST));
957 field = build_decl (BUILTINS_LOCATION, FIELD_DECL, NULL_TREE,
958 fn_info_ptr_type);
959 DECL_CHAIN (field) = fields;
960 fields = field;
962 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
965 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
966 gcov_info structure type, FN_ARY is the array of pointers to
967 function info objects. */
969 static tree
970 build_info (tree info_type, tree fn_ary)
972 tree info_fields = TYPE_FIELDS (info_type);
973 tree merge_fn_type, n_funcs;
974 unsigned ix;
975 tree filename_string;
976 int da_file_name_len;
977 vec<constructor_elt, va_gc> *v1 = NULL;
978 vec<constructor_elt, va_gc> *v2 = NULL;
980 /* Version ident */
981 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
982 build_int_cstu (TREE_TYPE (info_fields),
983 GCOV_VERSION));
984 info_fields = DECL_CHAIN (info_fields);
986 /* next -- NULL */
987 CONSTRUCTOR_APPEND_ELT (v1, info_fields, null_pointer_node);
988 info_fields = DECL_CHAIN (info_fields);
990 /* stamp */
991 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
992 build_int_cstu (TREE_TYPE (info_fields),
993 bbg_file_stamp));
994 info_fields = DECL_CHAIN (info_fields);
996 /* Filename */
997 da_file_name_len = strlen (da_file_name);
998 filename_string = build_string (da_file_name_len + 1, da_file_name);
999 TREE_TYPE (filename_string) = build_array_type
1000 (char_type_node, build_index_type (size_int (da_file_name_len)));
1001 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1002 build1 (ADDR_EXPR, TREE_TYPE (info_fields),
1003 filename_string));
1004 info_fields = DECL_CHAIN (info_fields);
1006 /* merge fn array -- NULL slots indicate unmeasured counters */
1007 merge_fn_type = TREE_TYPE (TREE_TYPE (info_fields));
1008 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1010 tree ptr = null_pointer_node;
1012 if ((1u << ix) & prg_ctr_mask)
1014 tree merge_fn = build_decl (BUILTINS_LOCATION,
1015 FUNCTION_DECL,
1016 get_identifier (ctr_merge_functions[ix]),
1017 TREE_TYPE (merge_fn_type));
1018 DECL_EXTERNAL (merge_fn) = 1;
1019 TREE_PUBLIC (merge_fn) = 1;
1020 DECL_ARTIFICIAL (merge_fn) = 1;
1021 TREE_NOTHROW (merge_fn) = 1;
1022 /* Initialize assembler name so we can stream out. */
1023 DECL_ASSEMBLER_NAME (merge_fn);
1024 ptr = build1 (ADDR_EXPR, merge_fn_type, merge_fn);
1026 CONSTRUCTOR_APPEND_ELT (v2, NULL, ptr);
1028 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1029 build_constructor (TREE_TYPE (info_fields), v2));
1030 info_fields = DECL_CHAIN (info_fields);
1032 /* n_functions */
1033 n_funcs = TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary)));
1034 n_funcs = fold_build2 (PLUS_EXPR, TREE_TYPE (info_fields),
1035 n_funcs, size_one_node);
1036 CONSTRUCTOR_APPEND_ELT (v1, info_fields, n_funcs);
1037 info_fields = DECL_CHAIN (info_fields);
1039 /* functions */
1040 CONSTRUCTOR_APPEND_ELT (v1, info_fields,
1041 build1 (ADDR_EXPR, TREE_TYPE (info_fields), fn_ary));
1042 info_fields = DECL_CHAIN (info_fields);
1044 gcc_assert (!info_fields);
1045 return build_constructor (info_type, v1);
1048 /* Generate the constructor function to call __gcov_init. */
1050 static void
1051 build_init_ctor (tree gcov_info_type)
1053 tree ctor, stmt, init_fn;
1055 /* Build a decl for __gcov_init. */
1056 init_fn = build_pointer_type (gcov_info_type);
1057 init_fn = build_function_type_list (void_type_node, init_fn, NULL);
1058 init_fn = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,
1059 get_identifier ("__gcov_init"), init_fn);
1060 TREE_PUBLIC (init_fn) = 1;
1061 DECL_EXTERNAL (init_fn) = 1;
1062 DECL_ASSEMBLER_NAME (init_fn);
1064 /* Generate a call to __gcov_init(&gcov_info). */
1065 ctor = NULL;
1066 stmt = build_fold_addr_expr (gcov_info_var);
1067 stmt = build_call_expr (init_fn, 1, stmt);
1068 append_to_statement_list (stmt, &ctor);
1070 /* Generate a constructor to run it. */
1071 cgraph_build_static_cdtor ('I', ctor, DEFAULT_INIT_PRIORITY);
1074 /* Create the gcov_info types and object. Generate the constructor
1075 function to call __gcov_init. Does not generate the initializer
1076 for the object. Returns TRUE if coverage data is being emitted. */
1078 static bool
1079 coverage_obj_init (void)
1081 tree gcov_info_type;
1082 unsigned n_counters = 0;
1083 unsigned ix;
1084 struct coverage_data *fn;
1085 struct coverage_data **fn_prev;
1086 char name_buf[32];
1088 no_coverage = 1; /* Disable any further coverage. */
1090 if (!prg_ctr_mask)
1091 return false;
1093 if (symtab->dump_file)
1094 fprintf (symtab->dump_file, "Using data file %s\n", da_file_name);
1096 /* Prune functions. */
1097 for (fn_prev = &functions_head; (fn = *fn_prev);)
1098 if (DECL_STRUCT_FUNCTION (fn->fn_decl))
1099 fn_prev = &fn->next;
1100 else
1101 /* The function is not being emitted, remove from list. */
1102 *fn_prev = fn->next;
1104 if (functions_head == NULL)
1105 return false;
1107 for (ix = 0; ix != GCOV_COUNTERS; ix++)
1108 if ((1u << ix) & prg_ctr_mask)
1109 n_counters++;
1111 /* Build the info and fn_info types. These are mutually recursive. */
1112 gcov_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1113 gcov_fn_info_type = lang_hooks.types.make_type (RECORD_TYPE);
1114 gcov_fn_info_ptr_type = build_pointer_type
1115 (build_qualified_type (gcov_fn_info_type, TYPE_QUAL_CONST));
1116 build_fn_info_type (gcov_fn_info_type, n_counters, gcov_info_type);
1117 build_info_type (gcov_info_type, gcov_fn_info_ptr_type);
1119 /* Build the gcov info var, this is referred to in its own
1120 initializer. */
1121 gcov_info_var = build_decl (BUILTINS_LOCATION,
1122 VAR_DECL, NULL_TREE, gcov_info_type);
1123 TREE_STATIC (gcov_info_var) = 1;
1124 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
1125 DECL_NAME (gcov_info_var) = get_identifier (name_buf);
1127 build_init_ctor (gcov_info_type);
1129 return true;
1132 /* Generate the coverage function info for FN and DATA. Append a
1133 pointer to that object to CTOR and return the appended CTOR. */
1135 static vec<constructor_elt, va_gc> *
1136 coverage_obj_fn (vec<constructor_elt, va_gc> *ctor, tree fn,
1137 struct coverage_data const *data)
1139 tree init = build_fn_info (data, gcov_fn_info_type, gcov_info_var);
1140 tree var = build_var (fn, gcov_fn_info_type, -1);
1142 DECL_INITIAL (var) = init;
1143 varpool_node::finalize_decl (var);
1145 CONSTRUCTOR_APPEND_ELT (ctor, NULL,
1146 build1 (ADDR_EXPR, gcov_fn_info_ptr_type, var));
1147 return ctor;
1150 /* Finalize the coverage data. Generates the array of pointers to
1151 function objects from CTOR. Generate the gcov_info initializer. */
1153 static void
1154 coverage_obj_finish (vec<constructor_elt, va_gc> *ctor)
1156 unsigned n_functions = vec_safe_length (ctor);
1157 tree fn_info_ary_type = build_array_type
1158 (build_qualified_type (gcov_fn_info_ptr_type, TYPE_QUAL_CONST),
1159 build_index_type (size_int (n_functions - 1)));
1160 tree fn_info_ary = build_decl (BUILTINS_LOCATION, VAR_DECL, NULL_TREE,
1161 fn_info_ary_type);
1162 char name_buf[32];
1164 TREE_STATIC (fn_info_ary) = 1;
1165 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 1);
1166 DECL_NAME (fn_info_ary) = get_identifier (name_buf);
1167 DECL_INITIAL (fn_info_ary) = build_constructor (fn_info_ary_type, ctor);
1168 varpool_node::finalize_decl (fn_info_ary);
1170 DECL_INITIAL (gcov_info_var)
1171 = build_info (TREE_TYPE (gcov_info_var), fn_info_ary);
1172 varpool_node::finalize_decl (gcov_info_var);
1175 /* Perform file-level initialization. Read in data file, generate name
1176 of notes file. */
1178 void
1179 coverage_init (const char *filename)
1181 int len = strlen (filename);
1182 int prefix_len = 0;
1184 /* Since coverage_init is invoked very early, before the pass
1185 manager, we need to set up the dumping explicitly. This is
1186 similar to the handling in finish_optimization_passes. */
1187 int profile_pass_num =
1188 g->get_passes ()->get_pass_profile ()->static_pass_number;
1189 g->get_dumps ()->dump_start (profile_pass_num, NULL);
1191 if (!profile_data_prefix && !IS_ABSOLUTE_PATH (filename))
1192 profile_data_prefix = getpwd ();
1194 if (profile_data_prefix)
1195 prefix_len = strlen (profile_data_prefix);
1197 /* Name of da file. */
1198 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX)
1199 + prefix_len + 2);
1201 if (profile_data_prefix)
1203 memcpy (da_file_name, profile_data_prefix, prefix_len);
1204 da_file_name[prefix_len++] = '/';
1206 memcpy (da_file_name + prefix_len, filename, len);
1207 strcpy (da_file_name + prefix_len + len, GCOV_DATA_SUFFIX);
1209 bbg_file_stamp = local_tick;
1211 if (flag_branch_probabilities)
1212 read_counts_file ();
1214 /* Name of bbg file. */
1215 if (flag_test_coverage && !flag_compare_debug)
1217 bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
1218 memcpy (bbg_file_name, filename, len);
1219 strcpy (bbg_file_name + len, GCOV_NOTE_SUFFIX);
1221 if (!gcov_open (bbg_file_name, -1))
1223 error ("cannot open %s", bbg_file_name);
1224 bbg_file_name = NULL;
1226 else
1228 gcov_write_unsigned (GCOV_NOTE_MAGIC);
1229 gcov_write_unsigned (GCOV_VERSION);
1230 gcov_write_unsigned (bbg_file_stamp);
1234 g->get_dumps ()->dump_finish (profile_pass_num);
1237 /* Performs file-level cleanup. Close notes file, generate coverage
1238 variables and constructor. */
1240 void
1241 coverage_finish (void)
1243 if (bbg_file_name && gcov_close ())
1244 unlink (bbg_file_name);
1246 if (!flag_branch_probabilities && flag_test_coverage
1247 && (!local_tick || local_tick == (unsigned)-1))
1248 /* Only remove the da file, if we're emitting coverage code and
1249 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1250 unlink (da_file_name);
1252 if (coverage_obj_init ())
1254 vec<constructor_elt, va_gc> *fn_ctor = NULL;
1255 struct coverage_data *fn;
1257 for (fn = functions_head; fn; fn = fn->next)
1258 fn_ctor = coverage_obj_fn (fn_ctor, fn->fn_decl, fn);
1259 coverage_obj_finish (fn_ctor);
1262 XDELETEVEC (da_file_name);
1263 da_file_name = NULL;
1266 #include "gt-coverage.h"