1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2020 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
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
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/>. */
29 #include "coretypes.h"
34 #include "tree-pass.h"
37 #include "stringpool.h"
40 #include "diagnostic-core.h"
41 #include "fold-const.h"
42 #include "stor-layout.h"
45 #include "langhooks.h"
46 #include "tree-iterator.h"
48 #include "pass_manager.h"
50 #include "auto-profile.h"
52 #include "diagnostic.h"
56 struct GTY((chain_next ("%h.next"))) coverage_data
58 struct coverage_data
*next
; /* next function */
59 unsigned ident
; /* function ident */
60 unsigned lineno_checksum
; /* function lineno checksum */
61 unsigned cfg_checksum
; /* function cfg checksum */
62 tree fn_decl
; /* the function decl */
63 tree ctr_vars
[GCOV_COUNTERS
]; /* counter variables. */
66 /* Counts information for a function. */
67 struct counts_entry
: pointer_hash
<counts_entry
>
74 unsigned lineno_checksum
;
75 unsigned cfg_checksum
;
79 /* hash_table support. */
80 static inline hashval_t
hash (const counts_entry
*);
81 static int equal (const counts_entry
*, const counts_entry
*);
82 static void remove (counts_entry
*);
85 static GTY(()) struct coverage_data
*functions_head
= 0;
86 static struct coverage_data
**functions_tail
= &functions_head
;
87 static unsigned no_coverage
= 0;
89 /* Cumulative counter information for whole program. */
90 static unsigned prg_ctr_mask
; /* Mask of counter types generated. */
92 /* Counter information for current function. */
93 static unsigned fn_ctr_mask
; /* Mask of counters used. */
94 static GTY(()) tree fn_v_ctrs
[GCOV_COUNTERS
]; /* counter variables. */
95 static unsigned fn_n_ctrs
[GCOV_COUNTERS
]; /* Counters allocated. */
96 static unsigned fn_b_ctrs
[GCOV_COUNTERS
]; /* Allocation base. */
98 /* Coverage info VAR_DECL and function info type nodes. */
99 static GTY(()) tree gcov_info_var
;
100 static GTY(()) tree gcov_fn_info_type
;
101 static GTY(()) tree gcov_fn_info_ptr_type
;
103 /* Name of the notes (gcno) output file. The "bbg" prefix is for
104 historical reasons, when the notes file contained only the
105 basic block graph notes.
106 If this is NULL we're not writing to the notes file. */
107 static char *bbg_file_name
;
109 /* File stamp for notes file. */
110 static unsigned bbg_file_stamp
;
112 /* Name of the count data (gcda) file. */
113 static char *da_file_name
;
115 /* The names of merge functions for counters. */
116 #define STR(str) #str
117 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
118 static const char *const ctr_merge_functions
[GCOV_COUNTERS
] = {
119 #include "gcov-counter.def"
121 #undef DEF_GCOV_COUNTER
124 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
125 static const char *const ctr_names
[GCOV_COUNTERS
] = {
126 #include "gcov-counter.def"
128 #undef DEF_GCOV_COUNTER
130 /* Forward declarations. */
131 static void read_counts_file (void);
132 static tree
build_var (tree
, tree
, int);
133 static void build_fn_info_type (tree
, unsigned, tree
);
134 static void build_info_type (tree
, tree
);
135 static tree
build_fn_info (const struct coverage_data
*, tree
, tree
);
136 static tree
build_info (tree
, tree
);
137 static bool coverage_obj_init (void);
138 static vec
<constructor_elt
, va_gc
> *coverage_obj_fn
139 (vec
<constructor_elt
, va_gc
> *, tree
, struct coverage_data
const *);
140 static void coverage_obj_finish (vec
<constructor_elt
, va_gc
> *);
142 /* Return the type node for gcov_type. */
148 = smallest_int_mode_for_size (LONG_LONG_TYPE_SIZE
> 32 ? 64 : 32);
149 return lang_hooks
.types
.type_for_mode (mode
, false);
152 /* Return the type node for gcov_unsigned_t. */
155 get_gcov_unsigned_t (void)
157 scalar_int_mode mode
= smallest_int_mode_for_size (32);
158 return lang_hooks
.types
.type_for_mode (mode
, true);
162 counts_entry::hash (const counts_entry
*entry
)
164 return entry
->ident
* GCOV_COUNTERS
+ entry
->ctr
;
168 counts_entry::equal (const counts_entry
*entry1
, const counts_entry
*entry2
)
170 return entry1
->ident
== entry2
->ident
&& entry1
->ctr
== entry2
->ctr
;
174 counts_entry::remove (counts_entry
*entry
)
176 free (entry
->counts
);
180 /* Hash table of count data. */
181 static hash_table
<counts_entry
> *counts_hash
;
183 /* Read in the counts file, if available. */
186 read_counts_file (void)
188 gcov_unsigned_t fn_ident
= 0;
191 unsigned lineno_checksum
= 0;
192 unsigned cfg_checksum
= 0;
194 if (!gcov_open (da_file_name
, 1))
197 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
199 warning (0, "%qs is not a gcov data file", da_file_name
);
203 else if ((tag
= gcov_read_unsigned ()) != GCOV_VERSION
)
207 GCOV_UNSIGNED2STRING (v
, tag
);
208 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
210 warning (0, "%qs is version %q.*s, expected version %q.*s",
211 da_file_name
, 4, v
, 4, e
);
216 /* Read the stamp, used for creating a generation count. */
217 tag
= gcov_read_unsigned ();
218 bbg_file_stamp
= crc32_unsigned (bbg_file_stamp
, tag
);
220 counts_hash
= new hash_table
<counts_entry
> (10);
221 while ((tag
= gcov_read_unsigned ()))
223 gcov_unsigned_t length
;
224 gcov_position_t offset
;
226 length
= gcov_read_unsigned ();
227 offset
= gcov_position ();
228 if (tag
== GCOV_TAG_FUNCTION
)
232 fn_ident
= gcov_read_unsigned ();
233 lineno_checksum
= gcov_read_unsigned ();
234 cfg_checksum
= gcov_read_unsigned ();
237 fn_ident
= lineno_checksum
= cfg_checksum
= 0;
239 else if (tag
== GCOV_TAG_OBJECT_SUMMARY
)
241 profile_info
= XCNEW (gcov_summary
);
242 profile_info
->runs
= gcov_read_unsigned ();
243 profile_info
->sum_max
= gcov_read_unsigned ();
245 else if (GCOV_TAG_IS_COUNTER (tag
) && fn_ident
)
247 counts_entry
**slot
, *entry
, elt
;
248 unsigned n_counts
= GCOV_TAG_COUNTER_NUM (length
);
251 elt
.ident
= fn_ident
;
252 elt
.ctr
= GCOV_COUNTER_FOR_TAG (tag
);
254 slot
= counts_hash
->find_slot (&elt
, INSERT
);
258 *slot
= entry
= XCNEW (counts_entry
);
259 entry
->ident
= fn_ident
;
260 entry
->ctr
= elt
.ctr
;
261 entry
->lineno_checksum
= lineno_checksum
;
262 entry
->cfg_checksum
= cfg_checksum
;
263 entry
->counts
= XCNEWVEC (gcov_type
, n_counts
);
264 entry
->n_counts
= n_counts
;
266 else if (entry
->lineno_checksum
!= lineno_checksum
267 || entry
->cfg_checksum
!= cfg_checksum
)
269 error ("profile data for function %u is corrupted", fn_ident
);
270 error ("checksum is (%x,%x) instead of (%x,%x)",
271 entry
->lineno_checksum
, entry
->cfg_checksum
,
272 lineno_checksum
, cfg_checksum
);
277 for (ix
= 0; ix
!= n_counts
; ix
++)
278 entry
->counts
[ix
] += gcov_read_counter ();
280 gcov_sync (offset
, length
);
281 if ((is_error
= gcov_is_error ()))
284 ? G_("%qs has overflowed")
285 : G_("%qs is corrupted"),
296 /* Returns the counters for a particular tag. */
299 get_coverage_counts (unsigned counter
, unsigned cfg_checksum
,
300 unsigned lineno_checksum
, unsigned int n_counts
)
302 counts_entry
*entry
, elt
;
304 /* No hash table, no counts. */
307 static int warned
= 0;
311 warning (OPT_Wmissing_profile
,
312 "%qs profile count data file not found",
314 if (dump_enabled_p ())
316 dump_user_location_t loc
317 = dump_user_location_t::from_location_t (input_location
);
318 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
319 "file %s not found, %s\n", da_file_name
,
320 (flag_guess_branch_prob
321 ? "execution counts estimated"
322 : "execution counts assumed to be zero"));
327 if (param_profile_func_internal_id
)
328 elt
.ident
= current_function_funcdef_no
+ 1;
331 gcc_assert (coverage_node_map_initialized_p ());
332 elt
.ident
= cgraph_node::get (current_function_decl
)->profile_id
;
335 entry
= counts_hash
->find (&elt
);
338 if (counter
== GCOV_COUNTER_ARCS
)
339 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
340 OPT_Wmissing_profile
,
341 "profile for function %qD not found in profile data",
342 current_function_decl
);
343 /* The function was not emitted, or is weak and not chosen in the
344 final executable. Silently fail, because there's nothing we
349 if (entry
->cfg_checksum
!= cfg_checksum
350 || (counter
!= GCOV_COUNTER_V_INDIR
351 && counter
!= GCOV_COUNTER_V_TOPN
352 && entry
->n_counts
!= n_counts
))
354 static int warned
= 0;
355 bool warning_printed
= false;
357 if (entry
->n_counts
!= n_counts
)
359 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
360 OPT_Wcoverage_mismatch
,
361 "number of counters in profile data for function %qD "
363 "its profile data (counter %qs, expected %i and have %i)",
364 current_function_decl
,
365 ctr_names
[counter
], entry
->n_counts
, n_counts
);
368 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
369 OPT_Wcoverage_mismatch
,
370 "the control flow of function %qD does not match "
371 "its profile data (counter %qs)", current_function_decl
,
373 if (warning_printed
&& dump_enabled_p ())
375 dump_user_location_t loc
376 = dump_user_location_t::from_function_decl (current_function_decl
);
377 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
378 "use -Wno-error=coverage-mismatch to tolerate "
379 "the mismatch but performance may drop if the "
380 "function is hot\n");
385 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
386 "coverage mismatch ignored\n");
387 dump_printf (MSG_MISSED_OPTIMIZATION
,
388 flag_guess_branch_prob
389 ? G_("execution counts estimated\n")
390 : G_("execution counts assumed to be zero\n"));
391 if (!flag_guess_branch_prob
)
392 dump_printf (MSG_MISSED_OPTIMIZATION
,
393 "this can result in poorly optimized code\n");
399 else if (entry
->lineno_checksum
!= lineno_checksum
)
401 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
402 OPT_Wcoverage_mismatch
,
403 "source locations for function %qD have changed,"
404 " the profile data may be out of date",
405 current_function_decl
);
408 return entry
->counts
;
411 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
412 allocation succeeded. */
415 coverage_counter_alloc (unsigned counter
, unsigned num
)
423 if (!fn_v_ctrs
[counter
])
425 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
428 = build_var (current_function_decl
, array_type
, counter
);
431 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
432 fn_n_ctrs
[counter
] += num
;
434 fn_ctr_mask
|= 1 << counter
;
438 /* Generate a tree to access COUNTER NO. */
441 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
443 tree gcov_type_node
= get_gcov_type ();
445 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
447 no
+= fn_b_ctrs
[counter
];
449 /* "no" here is an array index, scaled to bytes later. */
450 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
451 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
454 /* Generate a tree to access the address of COUNTER NO. */
457 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
459 tree gcov_type_node
= get_gcov_type ();
461 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
462 no
+= fn_b_ctrs
[counter
];
464 /* "no" here is an array index, scaled to bytes later. */
465 return build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
467 build_int_cst (integer_type_node
, no
),
472 /* Generate a checksum for a string. CHKSUM is the current
476 coverage_checksum_string (unsigned chksum
, const char *string
)
481 /* Look for everything that looks if it were produced by
482 get_file_function_name and zero out the second part
483 that may result from flag_random_seed. This is not critical
484 as the checksums are used only for sanity checking. */
485 for (i
= 0; string
[i
]; i
++)
488 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
490 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
493 /* C++ namespaces do have scheme:
494 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
495 since filename might contain extra underscores there seems
496 to be no better chance then walk all possible offsets looking
500 for (i
= i
+ offset
; string
[i
]; i
++)
505 for (y
= 1; y
< 9; y
++)
506 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
507 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
509 if (y
!= 9 || string
[i
+ 9] != '_')
511 for (y
= 10; y
< 18; y
++)
512 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
513 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
518 string
= dup
= xstrdup (string
);
519 for (y
= 10; y
< 18; y
++)
526 chksum
= crc32_string (chksum
, string
);
532 /* Compute checksum for the current function. We generate a CRC32. */
535 coverage_compute_lineno_checksum (void)
537 expanded_location xloc
538 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
539 unsigned chksum
= xloc
.line
;
542 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
543 chksum
= coverage_checksum_string
544 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
549 /* Compute profile ID. This is better to be unique in whole program. */
552 coverage_compute_profile_id (struct cgraph_node
*n
)
556 /* Externally visible symbols have unique name. */
557 if (TREE_PUBLIC (n
->decl
) || DECL_EXTERNAL (n
->decl
) || n
->unique_name
)
559 chksum
= coverage_checksum_string
560 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
564 expanded_location xloc
565 = expand_location (DECL_SOURCE_LOCATION (n
->decl
));
566 bool use_name_only
= (param_profile_func_internal_id
== 0);
568 chksum
= (use_name_only
? 0 : xloc
.line
);
570 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
571 chksum
= coverage_checksum_string
572 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
573 if (!use_name_only
&& first_global_object_name
)
574 chksum
= coverage_checksum_string
575 (chksum
, first_global_object_name
);
576 chksum
= coverage_checksum_string
577 (chksum
, aux_base_name
);
580 /* Non-negative integers are hopefully small enough to fit in all targets.
581 Gcov file formats wants non-zero function IDs. */
582 chksum
= chksum
& 0x7fffffff;
583 return chksum
+ (!chksum
);
586 /* Compute cfg checksum for the function FN given as argument.
587 The checksum is calculated carefully so that
588 source code changes that doesn't affect the control flow graph
589 won't change the checksum.
590 This is to make the profile data useable across source code change.
591 The downside of this is that the compiler may use potentially
592 wrong profile data - that the source code change has non-trivial impact
593 on the validity of profile data (e.g. the reversed condition)
594 but the compiler won't detect the change and use the wrong profile data. */
597 coverage_compute_cfg_checksum (struct function
*fn
)
600 unsigned chksum
= n_basic_blocks_for_fn (fn
);
602 FOR_EACH_BB_FN (bb
, fn
)
606 chksum
= crc32_byte (chksum
, bb
->index
);
607 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
609 chksum
= crc32_byte (chksum
, e
->dest
->index
);
616 /* Begin output to the notes file for the current function.
617 Writes the function header. Returns nonzero if data should be output. */
620 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
622 expanded_location xloc
;
623 unsigned long offset
;
625 /* We don't need to output .gcno file unless we're under -ftest-coverage
626 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
627 if (no_coverage
|| !bbg_file_name
)
630 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
632 /* Announce function */
633 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
634 if (param_profile_func_internal_id
)
635 gcov_write_unsigned (current_function_funcdef_no
+ 1);
638 gcc_assert (coverage_node_map_initialized_p ());
639 gcov_write_unsigned (
640 cgraph_node::get (current_function_decl
)->profile_id
);
643 gcov_write_unsigned (lineno_checksum
);
644 gcov_write_unsigned (cfg_checksum
);
645 gcov_write_string (IDENTIFIER_POINTER
646 (DECL_ASSEMBLER_NAME (current_function_decl
)));
647 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl
)
648 && !DECL_FUNCTION_VERSIONED (current_function_decl
)
649 && !DECL_LAMBDA_FUNCTION_P (current_function_decl
));
650 gcov_write_filename (xloc
.file
);
651 gcov_write_unsigned (xloc
.line
);
652 gcov_write_unsigned (xloc
.column
);
654 expanded_location endloc
= expand_location (cfun
->function_end_locus
);
656 /* Function can start in a single file and end in another one. */
657 int end_line
= endloc
.file
== xloc
.file
? endloc
.line
: xloc
.line
;
658 int end_column
= endloc
.file
== xloc
.file
? endloc
.column
: xloc
.column
;
659 gcc_assert (xloc
.line
<= end_line
);
660 gcov_write_unsigned (end_line
);
661 gcov_write_unsigned (end_column
);
662 gcov_write_length (offset
);
664 return !gcov_is_error ();
667 /* Finish coverage data for the current function. Verify no output
668 error has occurred. Save function coverage counts. */
671 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
675 if (bbg_file_name
&& gcov_is_error ())
677 warning (0, "error writing %qs", bbg_file_name
);
678 unlink (bbg_file_name
);
679 bbg_file_name
= NULL
;
684 struct coverage_data
*item
= 0;
686 item
= ggc_alloc
<coverage_data
> ();
688 if (param_profile_func_internal_id
)
689 item
->ident
= current_function_funcdef_no
+ 1;
692 gcc_assert (coverage_node_map_initialized_p ());
693 item
->ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
696 item
->lineno_checksum
= lineno_checksum
;
697 item
->cfg_checksum
= cfg_checksum
;
699 item
->fn_decl
= current_function_decl
;
701 *functions_tail
= item
;
702 functions_tail
= &item
->next
;
704 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
706 tree var
= fn_v_ctrs
[i
];
709 item
->ctr_vars
[i
] = var
;
712 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
713 array_type
= build_array_type (get_gcov_type (), array_type
);
714 TREE_TYPE (var
) = array_type
;
715 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
716 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
717 varpool_node::finalize_decl (var
);
720 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
721 fn_v_ctrs
[i
] = NULL_TREE
;
723 prg_ctr_mask
|= fn_ctr_mask
;
728 /* Remove coverage file if opened. */
731 coverage_remove_note_file (void)
736 unlink (bbg_file_name
);
740 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
741 >= 0 it is a counter array, otherwise it is the function structure. */
744 build_var (tree fn_decl
, tree type
, int counter
)
746 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
747 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
749 size_t fn_name_len
, len
;
751 fn_name
= targetm
.strip_name_encoding (fn_name
);
752 fn_name_len
= strlen (fn_name
);
753 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
756 strcpy (buf
, "__gcov__");
758 sprintf (buf
, "__gcov%u_", counter
);
760 buf
[len
- 1] = symbol_table::symbol_suffix_separator ();
761 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
762 DECL_NAME (var
) = get_identifier (buf
);
763 TREE_STATIC (var
) = 1;
764 TREE_ADDRESSABLE (var
) = 1;
765 DECL_NONALIASED (var
) = 1;
766 SET_DECL_ALIGN (var
, TYPE_ALIGN (type
));
771 /* Creates the gcov_fn_info RECORD_TYPE. */
774 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
776 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
780 gcc_assert (counters
);
783 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
784 get_gcov_unsigned_t ());
787 /* ctr_info::values */
788 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
789 build_pointer_type (get_gcov_type ()));
790 DECL_CHAIN (field
) = fields
;
793 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
796 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
797 build_pointer_type (build_qualified_type
798 (gcov_info_type
, TYPE_QUAL_CONST
)));
802 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
803 get_gcov_unsigned_t ());
804 DECL_CHAIN (field
) = fields
;
807 /* lineno_checksum */
808 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
809 get_gcov_unsigned_t ());
810 DECL_CHAIN (field
) = fields
;
814 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
815 get_gcov_unsigned_t ());
816 DECL_CHAIN (field
) = fields
;
819 array_type
= build_index_type (size_int (counters
- 1));
820 array_type
= build_array_type (ctr_info
, array_type
);
823 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
824 DECL_CHAIN (field
) = fields
;
827 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
830 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
831 the coverage data for the function and TYPE is the gcov_fn_info
832 RECORD_TYPE. KEY is the object file key. */
835 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
837 tree fields
= TYPE_FIELDS (type
);
840 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
841 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
844 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
845 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
846 fields
= DECL_CHAIN (fields
);
849 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
850 build_int_cstu (get_gcov_unsigned_t (),
852 fields
= DECL_CHAIN (fields
);
854 /* lineno_checksum */
855 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
856 build_int_cstu (get_gcov_unsigned_t (),
857 data
->lineno_checksum
));
858 fields
= DECL_CHAIN (fields
);
861 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
862 build_int_cstu (get_gcov_unsigned_t (),
863 data
->cfg_checksum
));
864 fields
= DECL_CHAIN (fields
);
867 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
868 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
869 if (prg_ctr_mask
& (1 << ix
))
871 vec
<constructor_elt
, va_gc
> *ctr
= NULL
;
872 tree var
= data
->ctr_vars
[ix
];
877 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))))
880 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
881 build_int_cstu (get_gcov_unsigned_t (),
885 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
886 build_fold_addr_expr (var
));
888 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
891 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
892 build_constructor (TREE_TYPE (fields
), v2
));
894 return build_constructor (type
, v1
);
897 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
898 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
901 build_info_type (tree type
, tree fn_info_ptr_type
)
903 tree field
, fields
= NULL_TREE
;
907 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
908 get_gcov_unsigned_t ());
909 DECL_CHAIN (field
) = fields
;
913 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
914 build_pointer_type (build_qualified_type
915 (type
, TYPE_QUAL_CONST
)));
916 DECL_CHAIN (field
) = fields
;
920 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
921 get_gcov_unsigned_t ());
922 DECL_CHAIN (field
) = fields
;
926 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
927 build_pointer_type (build_qualified_type
928 (char_type_node
, TYPE_QUAL_CONST
)));
929 DECL_CHAIN (field
) = fields
;
934 = build_function_type_list (void_type_node
,
935 build_pointer_type (get_gcov_type ()),
936 get_gcov_unsigned_t (), NULL_TREE
);
938 = build_array_type (build_pointer_type (merge_fn_type
),
939 build_index_type (size_int (GCOV_COUNTERS
- 1)));
940 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
942 DECL_CHAIN (field
) = fields
;
946 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
947 get_gcov_unsigned_t ());
948 DECL_CHAIN (field
) = fields
;
951 /* function_info pointer pointer */
952 fn_info_ptr_type
= build_pointer_type
953 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
954 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
956 DECL_CHAIN (field
) = fields
;
959 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
962 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
963 gcov_info structure type, FN_ARY is the array of pointers to
964 function info objects. */
967 build_info (tree info_type
, tree fn_ary
)
969 tree info_fields
= TYPE_FIELDS (info_type
);
970 tree merge_fn_type
, n_funcs
;
972 tree filename_string
;
973 int da_file_name_len
;
974 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
975 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
978 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
979 build_int_cstu (TREE_TYPE (info_fields
),
981 info_fields
= DECL_CHAIN (info_fields
);
984 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
985 info_fields
= DECL_CHAIN (info_fields
);
988 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
989 build_int_cstu (TREE_TYPE (info_fields
),
991 info_fields
= DECL_CHAIN (info_fields
);
994 da_file_name_len
= strlen (da_file_name
);
995 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
996 TREE_TYPE (filename_string
) = build_array_type
997 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
998 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
999 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
1001 info_fields
= DECL_CHAIN (info_fields
);
1003 /* merge fn array -- NULL slots indicate unmeasured counters */
1004 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
1005 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1007 tree ptr
= null_pointer_node
;
1009 if ((1u << ix
) & prg_ctr_mask
)
1011 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
1013 get_identifier (ctr_merge_functions
[ix
]),
1014 TREE_TYPE (merge_fn_type
));
1015 DECL_EXTERNAL (merge_fn
) = 1;
1016 TREE_PUBLIC (merge_fn
) = 1;
1017 DECL_ARTIFICIAL (merge_fn
) = 1;
1018 TREE_NOTHROW (merge_fn
) = 1;
1019 /* Initialize assembler name so we can stream out. */
1020 DECL_ASSEMBLER_NAME (merge_fn
);
1021 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
1023 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
1025 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1026 build_constructor (TREE_TYPE (info_fields
), v2
));
1027 info_fields
= DECL_CHAIN (info_fields
);
1030 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
1031 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
1032 n_funcs
, size_one_node
);
1033 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
1034 info_fields
= DECL_CHAIN (info_fields
);
1037 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1038 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
1039 info_fields
= DECL_CHAIN (info_fields
);
1041 gcc_assert (!info_fields
);
1042 return build_constructor (info_type
, v1
);
1045 /* Generate the constructor function to call __gcov_init. */
1048 build_init_ctor (tree gcov_info_type
)
1050 tree ctor
, stmt
, init_fn
;
1052 /* Build a decl for __gcov_init. */
1053 init_fn
= build_pointer_type (gcov_info_type
);
1054 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1055 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1056 get_identifier ("__gcov_init"), init_fn
);
1057 TREE_PUBLIC (init_fn
) = 1;
1058 DECL_EXTERNAL (init_fn
) = 1;
1059 DECL_ASSEMBLER_NAME (init_fn
);
1061 /* Generate a call to __gcov_init(&gcov_info). */
1063 stmt
= build_fold_addr_expr (gcov_info_var
);
1064 stmt
= build_call_expr (init_fn
, 1, stmt
);
1065 append_to_statement_list (stmt
, &ctor
);
1067 /* Generate a constructor to run it. */
1068 int priority
= SUPPORTS_INIT_PRIORITY
1069 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1070 cgraph_build_static_cdtor ('I', ctor
, priority
);
1073 /* Generate the destructor function to call __gcov_exit. */
1076 build_gcov_exit_decl (void)
1078 tree init_fn
= build_function_type_list (void_type_node
, NULL
);
1079 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1080 get_identifier ("__gcov_exit"), init_fn
);
1081 TREE_PUBLIC (init_fn
) = 1;
1082 DECL_EXTERNAL (init_fn
) = 1;
1083 DECL_ASSEMBLER_NAME (init_fn
);
1085 /* Generate a call to __gcov_exit (). */
1087 tree stmt
= build_call_expr (init_fn
, 0);
1088 append_to_statement_list (stmt
, &dtor
);
1090 /* Generate a destructor to run it. */
1091 int priority
= SUPPORTS_INIT_PRIORITY
1092 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1094 cgraph_build_static_cdtor ('D', dtor
, priority
);
1097 /* Create the gcov_info types and object. Generate the constructor
1098 function to call __gcov_init. Does not generate the initializer
1099 for the object. Returns TRUE if coverage data is being emitted. */
1102 coverage_obj_init (void)
1104 tree gcov_info_type
;
1105 unsigned n_counters
= 0;
1107 struct coverage_data
*fn
;
1108 struct coverage_data
**fn_prev
;
1111 no_coverage
= 1; /* Disable any further coverage. */
1116 if (symtab
->dump_file
)
1117 fprintf (symtab
->dump_file
, "Using data file %s\n", da_file_name
);
1119 /* Prune functions. */
1120 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
1121 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
1122 fn_prev
= &fn
->next
;
1124 /* The function is not being emitted, remove from list. */
1125 *fn_prev
= fn
->next
;
1127 if (functions_head
== NULL
)
1130 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1131 if ((1u << ix
) & prg_ctr_mask
)
1134 /* Build the info and fn_info types. These are mutually recursive. */
1135 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1136 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1137 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1138 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1139 gcov_fn_info_ptr_type
= build_pointer_type
1140 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1141 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1143 /* Build the gcov info var, this is referred to in its own
1145 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1146 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1147 TREE_STATIC (gcov_info_var
) = 1;
1148 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1149 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1151 build_init_ctor (gcov_info_type
);
1152 build_gcov_exit_decl ();
1157 /* Generate the coverage function info for FN and DATA. Append a
1158 pointer to that object to CTOR and return the appended CTOR. */
1160 static vec
<constructor_elt
, va_gc
> *
1161 coverage_obj_fn (vec
<constructor_elt
, va_gc
> *ctor
, tree fn
,
1162 struct coverage_data
const *data
)
1164 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1165 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1167 DECL_INITIAL (var
) = init
;
1168 varpool_node::finalize_decl (var
);
1170 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1171 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1175 /* Finalize the coverage data. Generates the array of pointers to
1176 function objects from CTOR. Generate the gcov_info initializer. */
1179 coverage_obj_finish (vec
<constructor_elt
, va_gc
> *ctor
)
1181 unsigned n_functions
= vec_safe_length (ctor
);
1182 tree fn_info_ary_type
= build_array_type
1183 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1184 build_index_type (size_int (n_functions
- 1)));
1185 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1189 TREE_STATIC (fn_info_ary
) = 1;
1190 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1191 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1192 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1193 varpool_node::finalize_decl (fn_info_ary
);
1195 DECL_INITIAL (gcov_info_var
)
1196 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1197 varpool_node::finalize_decl (gcov_info_var
);
1200 /* Perform file-level initialization. Read in data file, generate name
1204 coverage_init (const char *filename
)
1206 #if HAVE_DOS_BASED_FILE_SYSTEM
1207 const char *separator
= "\\";
1209 const char *separator
= "/";
1211 int len
= strlen (filename
);
1214 /* Since coverage_init is invoked very early, before the pass
1215 manager, we need to set up the dumping explicitly. This is
1216 similar to the handling in finish_optimization_passes. */
1217 int profile_pass_num
=
1218 g
->get_passes ()->get_pass_profile ()->static_pass_number
;
1219 g
->get_dumps ()->dump_start (profile_pass_num
, NULL
);
1221 if (!IS_ABSOLUTE_PATH (filename
))
1223 /* When a profile_data_prefix is provided, then mangle full path
1224 of filename in order to prevent file path clashing. */
1225 if (profile_data_prefix
)
1227 filename
= concat (getpwd (), separator
, filename
, NULL
);
1228 if (profile_prefix_path
)
1230 if (!strncmp (filename
, profile_prefix_path
,
1231 strlen (profile_prefix_path
)))
1233 filename
+= strlen (profile_prefix_path
);
1234 while (*filename
== *separator
)
1238 warning (0, "filename %qs does not start with profile "
1239 "prefix %qs", filename
, profile_prefix_path
);
1241 filename
= mangle_path (filename
);
1242 len
= strlen (filename
);
1245 profile_data_prefix
= getpwd ();
1248 if (profile_data_prefix
)
1249 prefix_len
= strlen (profile_data_prefix
);
1251 /* Name of da file. */
1252 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1255 if (profile_data_prefix
)
1257 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1258 da_file_name
[prefix_len
++] = *separator
;
1260 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1261 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1263 bbg_file_stamp
= local_tick
;
1265 if (flag_auto_profile
)
1266 read_autofdo_file ();
1267 else if (flag_branch_probabilities
)
1268 read_counts_file ();
1270 /* Name of bbg file. */
1271 if (flag_test_coverage
&& !flag_compare_debug
)
1273 if (profile_note_location
)
1274 bbg_file_name
= xstrdup (profile_note_location
);
1277 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1278 memcpy (bbg_file_name
, filename
, len
);
1279 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1282 if (!gcov_open (bbg_file_name
, -1))
1284 error ("cannot open %s", bbg_file_name
);
1285 bbg_file_name
= NULL
;
1289 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1290 gcov_write_unsigned (GCOV_VERSION
);
1291 gcov_write_unsigned (bbg_file_stamp
);
1292 gcov_write_string (getpwd ());
1294 /* Do not support has_unexecuted_blocks for Ada. */
1295 gcov_write_unsigned (strcmp (lang_hooks
.name
, "GNU Ada") != 0);
1299 g
->get_dumps ()->dump_finish (profile_pass_num
);
1302 /* Performs file-level cleanup. Close notes file, generate coverage
1303 variables and constructor. */
1306 coverage_finish (void)
1308 if (bbg_file_name
&& gcov_close ())
1309 unlink (bbg_file_name
);
1311 if (!flag_branch_probabilities
&& flag_test_coverage
1312 && (!local_tick
|| local_tick
== (unsigned)-1))
1313 /* Only remove the da file, if we're emitting coverage code and
1314 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1315 unlink (da_file_name
);
1317 if (coverage_obj_init ())
1319 vec
<constructor_elt
, va_gc
> *fn_ctor
= NULL
;
1320 struct coverage_data
*fn
;
1322 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1323 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1324 coverage_obj_finish (fn_ctor
);
1327 XDELETEVEC (da_file_name
);
1328 da_file_name
= NULL
;
1331 #include "gt-coverage.h"