1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2018 Free Software Foundation, Inc.
3 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
4 based on some ideas from Dain Samples of UC Berkeley.
5 Further mangling by Bob Manson, Cygnus Support.
6 Further mangled by Nathan Sidwell, CodeSourcery
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"
51 #include "auto-profile.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
;
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
*);
84 static GTY(()) struct coverage_data
*functions_head
= 0;
85 static struct coverage_data
**functions_tail
= &functions_head
;
86 static unsigned no_coverage
= 0;
88 /* Cumulative counter information for whole program. */
89 static unsigned prg_ctr_mask
; /* Mask of counter types generated. */
91 /* Counter information for current function. */
92 static unsigned fn_ctr_mask
; /* Mask of counters used. */
93 static GTY(()) tree fn_v_ctrs
[GCOV_COUNTERS
]; /* counter variables. */
94 static unsigned fn_n_ctrs
[GCOV_COUNTERS
]; /* Counters allocated. */
95 static unsigned fn_b_ctrs
[GCOV_COUNTERS
]; /* Allocation base. */
97 /* Coverage info VAR_DECL and function info type nodes. */
98 static GTY(()) tree gcov_info_var
;
99 static GTY(()) tree gcov_fn_info_type
;
100 static GTY(()) tree gcov_fn_info_ptr_type
;
102 /* Name of the notes (gcno) output file. The "bbg" prefix is for
103 historical reasons, when the notes file contained only the
104 basic block graph notes.
105 If this is NULL we're not writing to the notes file. */
106 static char *bbg_file_name
;
108 /* File stamp for notes file. */
109 static unsigned bbg_file_stamp
;
111 /* Name of the count data (gcda) file. */
112 static char *da_file_name
;
114 /* The names of merge functions for counters. */
115 #define STR(str) #str
116 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) STR(__gcov_merge ## FN_TYPE),
117 static const char *const ctr_merge_functions
[GCOV_COUNTERS
] = {
118 #include "gcov-counter.def"
120 #undef DEF_GCOV_COUNTER
123 #define DEF_GCOV_COUNTER(COUNTER, NAME, FN_TYPE) NAME,
124 static const char *const ctr_names
[GCOV_COUNTERS
] = {
125 #include "gcov-counter.def"
127 #undef DEF_GCOV_COUNTER
129 /* Forward declarations. */
130 static void read_counts_file (void);
131 static tree
build_var (tree
, tree
, int);
132 static void build_fn_info_type (tree
, unsigned, tree
);
133 static void build_info_type (tree
, tree
);
134 static tree
build_fn_info (const struct coverage_data
*, tree
, tree
);
135 static tree
build_info (tree
, tree
);
136 static bool coverage_obj_init (void);
137 static vec
<constructor_elt
, va_gc
> *coverage_obj_fn
138 (vec
<constructor_elt
, va_gc
> *, tree
, struct coverage_data
const *);
139 static void coverage_obj_finish (vec
<constructor_elt
, va_gc
> *);
141 /* Return the type node for gcov_type. */
147 = smallest_int_mode_for_size (LONG_LONG_TYPE_SIZE
> 32 ? 64 : 32);
148 return lang_hooks
.types
.type_for_mode (mode
, false);
151 /* Return the type node for gcov_unsigned_t. */
154 get_gcov_unsigned_t (void)
156 scalar_int_mode mode
= smallest_int_mode_for_size (32);
157 return lang_hooks
.types
.type_for_mode (mode
, true);
161 counts_entry::hash (const counts_entry
*entry
)
163 return entry
->ident
* GCOV_COUNTERS
+ entry
->ctr
;
167 counts_entry::equal (const counts_entry
*entry1
, const counts_entry
*entry2
)
169 return entry1
->ident
== entry2
->ident
&& entry1
->ctr
== entry2
->ctr
;
173 counts_entry::remove (counts_entry
*entry
)
175 free (entry
->counts
);
179 /* Hash table of count data. */
180 static hash_table
<counts_entry
> *counts_hash
;
182 /* Read in the counts file, if available. */
185 read_counts_file (void)
187 gcov_unsigned_t fn_ident
= 0;
190 unsigned lineno_checksum
= 0;
191 unsigned cfg_checksum
= 0;
193 if (!gcov_open (da_file_name
, 1))
196 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
198 warning (0, "%qs is not a gcov data file", da_file_name
);
202 else if ((tag
= gcov_read_unsigned ()) != GCOV_VERSION
)
206 GCOV_UNSIGNED2STRING (v
, tag
);
207 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
209 warning (0, "%qs is version %q.*s, expected version %q.*s",
210 da_file_name
, 4, v
, 4, e
);
215 /* Read the stamp, used for creating a generation count. */
216 tag
= gcov_read_unsigned ();
217 bbg_file_stamp
= crc32_unsigned (bbg_file_stamp
, tag
);
219 counts_hash
= new hash_table
<counts_entry
> (10);
220 while ((tag
= gcov_read_unsigned ()))
222 gcov_unsigned_t length
;
223 gcov_position_t offset
;
225 length
= gcov_read_unsigned ();
226 offset
= gcov_position ();
227 if (tag
== GCOV_TAG_FUNCTION
)
231 fn_ident
= gcov_read_unsigned ();
232 lineno_checksum
= gcov_read_unsigned ();
233 cfg_checksum
= gcov_read_unsigned ();
236 fn_ident
= lineno_checksum
= cfg_checksum
= 0;
238 else if (tag
== GCOV_TAG_OBJECT_SUMMARY
)
240 profile_info
= XCNEW (gcov_summary
);
241 profile_info
->runs
= gcov_read_unsigned ();
242 profile_info
->sum_max
= gcov_read_unsigned ();
244 else if (GCOV_TAG_IS_COUNTER (tag
) && fn_ident
)
246 counts_entry
**slot
, *entry
, elt
;
247 unsigned n_counts
= GCOV_TAG_COUNTER_NUM (length
);
250 elt
.ident
= fn_ident
;
251 elt
.ctr
= GCOV_COUNTER_FOR_TAG (tag
);
253 slot
= counts_hash
->find_slot (&elt
, INSERT
);
257 *slot
= entry
= XCNEW (counts_entry
);
258 entry
->ident
= fn_ident
;
259 entry
->ctr
= elt
.ctr
;
260 entry
->lineno_checksum
= lineno_checksum
;
261 entry
->cfg_checksum
= cfg_checksum
;
262 entry
->counts
= XCNEWVEC (gcov_type
, n_counts
);
264 else if (entry
->lineno_checksum
!= lineno_checksum
265 || entry
->cfg_checksum
!= cfg_checksum
)
267 error ("Profile data for function %u is corrupted", fn_ident
);
268 error ("checksum is (%x,%x) instead of (%x,%x)",
269 entry
->lineno_checksum
, entry
->cfg_checksum
,
270 lineno_checksum
, cfg_checksum
);
275 for (ix
= 0; ix
!= n_counts
; ix
++)
276 entry
->counts
[ix
] += gcov_read_counter ();
278 gcov_sync (offset
, length
);
279 if ((is_error
= gcov_is_error ()))
282 ? G_("%qs has overflowed")
283 : G_("%qs is corrupted"),
294 /* Returns the counters for a particular tag. */
297 get_coverage_counts (unsigned counter
, unsigned cfg_checksum
,
298 unsigned lineno_checksum
)
300 counts_entry
*entry
, elt
;
302 /* No hash table, no counts. */
305 static int warned
= 0;
309 warning (OPT_Wmissing_profile
,
310 "%qs profile count data file not found",
312 if (dump_enabled_p ())
314 dump_user_location_t loc
315 = dump_user_location_t::from_location_t (input_location
);
316 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
317 "file %s not found, %s\n", da_file_name
,
318 (flag_guess_branch_prob
319 ? "execution counts estimated"
320 : "execution counts assumed to be zero"));
325 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
326 elt
.ident
= current_function_funcdef_no
+ 1;
329 gcc_assert (coverage_node_map_initialized_p ());
330 elt
.ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
333 entry
= counts_hash
->find (&elt
);
336 if (counter
== GCOV_COUNTER_ARCS
)
337 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
338 OPT_Wmissing_profile
,
339 "profile for function %qD not found in profile data",
340 current_function_decl
);
341 /* The function was not emitted, or is weak and not chosen in the
342 final executable. Silently fail, because there's nothing we
347 if (entry
->cfg_checksum
!= cfg_checksum
)
349 static int warned
= 0;
350 bool warning_printed
= false;
353 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
354 OPT_Wcoverage_mismatch
,
355 "the control flow of function %qD does not match "
356 "its profile data (counter %qs)", current_function_decl
,
358 if (warning_printed
&& dump_enabled_p ())
360 dump_user_location_t loc
361 = dump_user_location_t::from_function_decl (current_function_decl
);
362 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
363 "use -Wno-error=coverage-mismatch to tolerate "
364 "the mismatch but performance may drop if the "
365 "function is hot\n");
370 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
371 "coverage mismatch ignored\n");
372 dump_printf (MSG_MISSED_OPTIMIZATION
,
373 flag_guess_branch_prob
374 ? G_("execution counts estimated\n")
375 : G_("execution counts assumed to be zero\n"));
376 if (!flag_guess_branch_prob
)
377 dump_printf (MSG_MISSED_OPTIMIZATION
,
378 "this can result in poorly optimized code\n");
384 else if (entry
->lineno_checksum
!= lineno_checksum
)
386 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
387 OPT_Wcoverage_mismatch
,
388 "source locations for function %qD have changed,"
389 " the profile data may be out of date",
390 current_function_decl
);
393 return entry
->counts
;
396 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
397 allocation succeeded. */
400 coverage_counter_alloc (unsigned counter
, unsigned num
)
408 if (!fn_v_ctrs
[counter
])
410 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
413 = build_var (current_function_decl
, array_type
, counter
);
416 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
417 fn_n_ctrs
[counter
] += num
;
419 fn_ctr_mask
|= 1 << counter
;
423 /* Generate a tree to access COUNTER NO. */
426 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
428 tree gcov_type_node
= get_gcov_type ();
430 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
432 no
+= fn_b_ctrs
[counter
];
434 /* "no" here is an array index, scaled to bytes later. */
435 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
436 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
439 /* Generate a tree to access the address of COUNTER NO. */
442 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
444 tree gcov_type_node
= get_gcov_type ();
446 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 build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
452 build_int_cst (integer_type_node
, no
),
457 /* Generate a checksum for a string. CHKSUM is the current
461 coverage_checksum_string (unsigned chksum
, const char *string
)
466 /* Look for everything that looks if it were produced by
467 get_file_function_name and zero out the second part
468 that may result from flag_random_seed. This is not critical
469 as the checksums are used only for sanity checking. */
470 for (i
= 0; string
[i
]; i
++)
473 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
475 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
478 /* C++ namespaces do have scheme:
479 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
480 since filename might contain extra underscores there seems
481 to be no better chance then walk all possible offsets looking
485 for (i
= i
+ offset
; string
[i
]; i
++)
490 for (y
= 1; y
< 9; y
++)
491 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
492 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
494 if (y
!= 9 || string
[i
+ 9] != '_')
496 for (y
= 10; y
< 18; y
++)
497 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
498 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
503 string
= dup
= xstrdup (string
);
504 for (y
= 10; y
< 18; y
++)
511 chksum
= crc32_string (chksum
, string
);
517 /* Compute checksum for the current function. We generate a CRC32. */
520 coverage_compute_lineno_checksum (void)
522 expanded_location xloc
523 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
524 unsigned chksum
= xloc
.line
;
527 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
528 chksum
= coverage_checksum_string
529 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
534 /* Compute profile ID. This is better to be unique in whole program. */
537 coverage_compute_profile_id (struct cgraph_node
*n
)
541 /* Externally visible symbols have unique name. */
542 if (TREE_PUBLIC (n
->decl
) || DECL_EXTERNAL (n
->decl
) || n
->unique_name
)
544 chksum
= coverage_checksum_string
545 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
549 expanded_location xloc
550 = expand_location (DECL_SOURCE_LOCATION (n
->decl
));
551 bool use_name_only
= (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
) == 0);
553 chksum
= (use_name_only
? 0 : xloc
.line
);
555 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
556 chksum
= coverage_checksum_string
557 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
558 if (!use_name_only
&& first_global_object_name
)
559 chksum
= coverage_checksum_string
560 (chksum
, first_global_object_name
);
561 chksum
= coverage_checksum_string
562 (chksum
, aux_base_name
);
565 /* Non-negative integers are hopefully small enough to fit in all targets.
566 Gcov file formats wants non-zero function IDs. */
567 chksum
= chksum
& 0x7fffffff;
568 return chksum
+ (!chksum
);
571 /* Compute cfg checksum for the function FN given as argument.
572 The checksum is calculated carefully so that
573 source code changes that doesn't affect the control flow graph
574 won't change the checksum.
575 This is to make the profile data useable across source code change.
576 The downside of this is that the compiler may use potentially
577 wrong profile data - that the source code change has non-trivial impact
578 on the validity of profile data (e.g. the reversed condition)
579 but the compiler won't detect the change and use the wrong profile data. */
582 coverage_compute_cfg_checksum (struct function
*fn
)
585 unsigned chksum
= n_basic_blocks_for_fn (fn
);
587 FOR_EACH_BB_FN (bb
, fn
)
591 chksum
= crc32_byte (chksum
, bb
->index
);
592 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
594 chksum
= crc32_byte (chksum
, e
->dest
->index
);
601 /* Begin output to the notes file for the current function.
602 Writes the function header. Returns nonzero if data should be output. */
605 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
607 expanded_location xloc
;
608 unsigned long offset
;
610 /* We don't need to output .gcno file unless we're under -ftest-coverage
611 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
612 if (no_coverage
|| !bbg_file_name
)
615 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
617 /* Announce function */
618 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
619 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
620 gcov_write_unsigned (current_function_funcdef_no
+ 1);
623 gcc_assert (coverage_node_map_initialized_p ());
624 gcov_write_unsigned (
625 cgraph_node::get (current_function_decl
)->profile_id
);
628 gcov_write_unsigned (lineno_checksum
);
629 gcov_write_unsigned (cfg_checksum
);
630 gcov_write_string (IDENTIFIER_POINTER
631 (DECL_ASSEMBLER_NAME (current_function_decl
)));
632 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl
)
633 && !DECL_FUNCTION_VERSIONED (current_function_decl
)
634 && !DECL_LAMBDA_FUNCTION (current_function_decl
));
635 gcov_write_filename (xloc
.file
);
636 gcov_write_unsigned (xloc
.line
);
637 gcov_write_unsigned (xloc
.column
);
639 expanded_location endloc
= expand_location (cfun
->function_end_locus
);
641 /* Function can start in a single file and end in another one. */
642 int end_line
= endloc
.file
== xloc
.file
? endloc
.line
: xloc
.line
;
643 gcc_assert (xloc
.line
<= end_line
);
644 gcov_write_unsigned (end_line
);
645 gcov_write_length (offset
);
647 return !gcov_is_error ();
650 /* Finish coverage data for the current function. Verify no output
651 error has occurred. Save function coverage counts. */
654 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
658 if (bbg_file_name
&& gcov_is_error ())
660 warning (0, "error writing %qs", bbg_file_name
);
661 unlink (bbg_file_name
);
662 bbg_file_name
= NULL
;
667 struct coverage_data
*item
= 0;
669 item
= ggc_alloc
<coverage_data
> ();
671 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
672 item
->ident
= current_function_funcdef_no
+ 1;
675 gcc_assert (coverage_node_map_initialized_p ());
676 item
->ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
679 item
->lineno_checksum
= lineno_checksum
;
680 item
->cfg_checksum
= cfg_checksum
;
682 item
->fn_decl
= current_function_decl
;
684 *functions_tail
= item
;
685 functions_tail
= &item
->next
;
687 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
689 tree var
= fn_v_ctrs
[i
];
692 item
->ctr_vars
[i
] = var
;
695 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
696 array_type
= build_array_type (get_gcov_type (), array_type
);
697 TREE_TYPE (var
) = array_type
;
698 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
699 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
700 varpool_node::finalize_decl (var
);
703 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
704 fn_v_ctrs
[i
] = NULL_TREE
;
706 prg_ctr_mask
|= fn_ctr_mask
;
711 /* Remove coverage file if opened. */
714 coverage_remove_note_file (void)
719 unlink (bbg_file_name
);
723 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
724 >= 0 it is a counter array, otherwise it is the function structure. */
727 build_var (tree fn_decl
, tree type
, int counter
)
729 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
730 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
732 size_t fn_name_len
, len
;
734 fn_name
= targetm
.strip_name_encoding (fn_name
);
735 fn_name_len
= strlen (fn_name
);
736 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
739 strcpy (buf
, "__gcov__");
741 sprintf (buf
, "__gcov%u_", counter
);
743 buf
[len
- 1] = symbol_table::symbol_suffix_separator ();
744 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
745 DECL_NAME (var
) = get_identifier (buf
);
746 TREE_STATIC (var
) = 1;
747 TREE_ADDRESSABLE (var
) = 1;
748 DECL_NONALIASED (var
) = 1;
749 SET_DECL_ALIGN (var
, TYPE_ALIGN (type
));
754 /* Creates the gcov_fn_info RECORD_TYPE. */
757 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
759 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
763 gcc_assert (counters
);
766 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
767 get_gcov_unsigned_t ());
770 /* ctr_info::values */
771 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
772 build_pointer_type (get_gcov_type ()));
773 DECL_CHAIN (field
) = fields
;
776 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
779 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
780 build_pointer_type (build_qualified_type
781 (gcov_info_type
, TYPE_QUAL_CONST
)));
785 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
786 get_gcov_unsigned_t ());
787 DECL_CHAIN (field
) = fields
;
790 /* lineno_checksum */
791 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
792 get_gcov_unsigned_t ());
793 DECL_CHAIN (field
) = fields
;
797 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
798 get_gcov_unsigned_t ());
799 DECL_CHAIN (field
) = fields
;
802 array_type
= build_index_type (size_int (counters
- 1));
803 array_type
= build_array_type (ctr_info
, array_type
);
806 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
807 DECL_CHAIN (field
) = fields
;
810 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
813 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
814 the coverage data for the function and TYPE is the gcov_fn_info
815 RECORD_TYPE. KEY is the object file key. */
818 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
820 tree fields
= TYPE_FIELDS (type
);
823 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
824 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
827 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
828 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
829 fields
= DECL_CHAIN (fields
);
832 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
833 build_int_cstu (get_gcov_unsigned_t (),
835 fields
= DECL_CHAIN (fields
);
837 /* lineno_checksum */
838 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
839 build_int_cstu (get_gcov_unsigned_t (),
840 data
->lineno_checksum
));
841 fields
= DECL_CHAIN (fields
);
844 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
845 build_int_cstu (get_gcov_unsigned_t (),
846 data
->cfg_checksum
));
847 fields
= DECL_CHAIN (fields
);
850 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
851 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
852 if (prg_ctr_mask
& (1 << ix
))
854 vec
<constructor_elt
, va_gc
> *ctr
= NULL
;
855 tree var
= data
->ctr_vars
[ix
];
860 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))))
863 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
864 build_int_cstu (get_gcov_unsigned_t (),
868 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
869 build_fold_addr_expr (var
));
871 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
874 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
875 build_constructor (TREE_TYPE (fields
), v2
));
877 return build_constructor (type
, v1
);
880 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
881 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
884 build_info_type (tree type
, tree fn_info_ptr_type
)
886 tree field
, fields
= NULL_TREE
;
890 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
891 get_gcov_unsigned_t ());
892 DECL_CHAIN (field
) = fields
;
896 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
897 build_pointer_type (build_qualified_type
898 (type
, TYPE_QUAL_CONST
)));
899 DECL_CHAIN (field
) = fields
;
903 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
904 get_gcov_unsigned_t ());
905 DECL_CHAIN (field
) = fields
;
909 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
910 build_pointer_type (build_qualified_type
911 (char_type_node
, TYPE_QUAL_CONST
)));
912 DECL_CHAIN (field
) = fields
;
917 = build_function_type_list (void_type_node
,
918 build_pointer_type (get_gcov_type ()),
919 get_gcov_unsigned_t (), NULL_TREE
);
921 = build_array_type (build_pointer_type (merge_fn_type
),
922 build_index_type (size_int (GCOV_COUNTERS
- 1)));
923 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
925 DECL_CHAIN (field
) = fields
;
929 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
930 get_gcov_unsigned_t ());
931 DECL_CHAIN (field
) = fields
;
934 /* function_info pointer pointer */
935 fn_info_ptr_type
= build_pointer_type
936 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
937 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
939 DECL_CHAIN (field
) = fields
;
942 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
945 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
946 gcov_info structure type, FN_ARY is the array of pointers to
947 function info objects. */
950 build_info (tree info_type
, tree fn_ary
)
952 tree info_fields
= TYPE_FIELDS (info_type
);
953 tree merge_fn_type
, n_funcs
;
955 tree filename_string
;
956 int da_file_name_len
;
957 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
958 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
961 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
962 build_int_cstu (TREE_TYPE (info_fields
),
964 info_fields
= DECL_CHAIN (info_fields
);
967 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
968 info_fields
= DECL_CHAIN (info_fields
);
971 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
972 build_int_cstu (TREE_TYPE (info_fields
),
974 info_fields
= DECL_CHAIN (info_fields
);
977 da_file_name_len
= strlen (da_file_name
);
978 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
979 TREE_TYPE (filename_string
) = build_array_type
980 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
981 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
982 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
984 info_fields
= DECL_CHAIN (info_fields
);
986 /* merge fn array -- NULL slots indicate unmeasured counters */
987 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
988 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
990 tree ptr
= null_pointer_node
;
992 if ((1u << ix
) & prg_ctr_mask
)
994 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
996 get_identifier (ctr_merge_functions
[ix
]),
997 TREE_TYPE (merge_fn_type
));
998 DECL_EXTERNAL (merge_fn
) = 1;
999 TREE_PUBLIC (merge_fn
) = 1;
1000 DECL_ARTIFICIAL (merge_fn
) = 1;
1001 TREE_NOTHROW (merge_fn
) = 1;
1002 /* Initialize assembler name so we can stream out. */
1003 DECL_ASSEMBLER_NAME (merge_fn
);
1004 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
1006 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
1008 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1009 build_constructor (TREE_TYPE (info_fields
), v2
));
1010 info_fields
= DECL_CHAIN (info_fields
);
1013 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
1014 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
1015 n_funcs
, size_one_node
);
1016 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
1017 info_fields
= DECL_CHAIN (info_fields
);
1020 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1021 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
1022 info_fields
= DECL_CHAIN (info_fields
);
1024 gcc_assert (!info_fields
);
1025 return build_constructor (info_type
, v1
);
1028 /* Generate the constructor function to call __gcov_init. */
1031 build_init_ctor (tree gcov_info_type
)
1033 tree ctor
, stmt
, init_fn
;
1035 /* Build a decl for __gcov_init. */
1036 init_fn
= build_pointer_type (gcov_info_type
);
1037 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1038 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1039 get_identifier ("__gcov_init"), init_fn
);
1040 TREE_PUBLIC (init_fn
) = 1;
1041 DECL_EXTERNAL (init_fn
) = 1;
1042 DECL_ASSEMBLER_NAME (init_fn
);
1044 /* Generate a call to __gcov_init(&gcov_info). */
1046 stmt
= build_fold_addr_expr (gcov_info_var
);
1047 stmt
= build_call_expr (init_fn
, 1, stmt
);
1048 append_to_statement_list (stmt
, &ctor
);
1050 /* Generate a constructor to run it. */
1051 int priority
= SUPPORTS_INIT_PRIORITY
1052 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1053 cgraph_build_static_cdtor ('I', ctor
, priority
);
1056 /* Generate the destructor function to call __gcov_exit. */
1059 build_gcov_exit_decl (void)
1061 tree init_fn
= build_function_type_list (void_type_node
, void_type_node
,
1063 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1064 get_identifier ("__gcov_exit"), init_fn
);
1065 TREE_PUBLIC (init_fn
) = 1;
1066 DECL_EXTERNAL (init_fn
) = 1;
1067 DECL_ASSEMBLER_NAME (init_fn
);
1069 /* Generate a call to __gcov_exit (). */
1071 tree stmt
= build_call_expr (init_fn
, 0);
1072 append_to_statement_list (stmt
, &dtor
);
1074 /* Generate a destructor to run it. */
1075 int priority
= SUPPORTS_INIT_PRIORITY
1076 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1078 cgraph_build_static_cdtor ('D', dtor
, priority
);
1081 /* Create the gcov_info types and object. Generate the constructor
1082 function to call __gcov_init. Does not generate the initializer
1083 for the object. Returns TRUE if coverage data is being emitted. */
1086 coverage_obj_init (void)
1088 tree gcov_info_type
;
1089 unsigned n_counters
= 0;
1091 struct coverage_data
*fn
;
1092 struct coverage_data
**fn_prev
;
1095 no_coverage
= 1; /* Disable any further coverage. */
1100 if (symtab
->dump_file
)
1101 fprintf (symtab
->dump_file
, "Using data file %s\n", da_file_name
);
1103 /* Prune functions. */
1104 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
1105 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
1106 fn_prev
= &fn
->next
;
1108 /* The function is not being emitted, remove from list. */
1109 *fn_prev
= fn
->next
;
1111 if (functions_head
== NULL
)
1114 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1115 if ((1u << ix
) & prg_ctr_mask
)
1118 /* Build the info and fn_info types. These are mutually recursive. */
1119 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1120 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1121 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1122 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1123 gcov_fn_info_ptr_type
= build_pointer_type
1124 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1125 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1127 /* Build the gcov info var, this is referred to in its own
1129 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1130 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1131 TREE_STATIC (gcov_info_var
) = 1;
1132 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1133 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1135 build_init_ctor (gcov_info_type
);
1136 build_gcov_exit_decl ();
1141 /* Generate the coverage function info for FN and DATA. Append a
1142 pointer to that object to CTOR and return the appended CTOR. */
1144 static vec
<constructor_elt
, va_gc
> *
1145 coverage_obj_fn (vec
<constructor_elt
, va_gc
> *ctor
, tree fn
,
1146 struct coverage_data
const *data
)
1148 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1149 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1151 DECL_INITIAL (var
) = init
;
1152 varpool_node::finalize_decl (var
);
1154 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1155 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1159 /* Finalize the coverage data. Generates the array of pointers to
1160 function objects from CTOR. Generate the gcov_info initializer. */
1163 coverage_obj_finish (vec
<constructor_elt
, va_gc
> *ctor
)
1165 unsigned n_functions
= vec_safe_length (ctor
);
1166 tree fn_info_ary_type
= build_array_type
1167 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1168 build_index_type (size_int (n_functions
- 1)));
1169 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1173 TREE_STATIC (fn_info_ary
) = 1;
1174 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1175 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1176 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1177 varpool_node::finalize_decl (fn_info_ary
);
1179 DECL_INITIAL (gcov_info_var
)
1180 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1181 varpool_node::finalize_decl (gcov_info_var
);
1184 /* Perform file-level initialization. Read in data file, generate name
1188 coverage_init (const char *filename
)
1190 int len
= strlen (filename
);
1193 /* Since coverage_init is invoked very early, before the pass
1194 manager, we need to set up the dumping explicitly. This is
1195 similar to the handling in finish_optimization_passes. */
1196 int profile_pass_num
=
1197 g
->get_passes ()->get_pass_profile ()->static_pass_number
;
1198 g
->get_dumps ()->dump_start (profile_pass_num
, NULL
);
1200 if (!IS_ABSOLUTE_PATH (filename
))
1202 /* When a profile_data_prefix is provided, then mangle full path
1203 of filename in order to prevent file path clashing. */
1204 if (profile_data_prefix
)
1206 #if HAVE_DOS_BASED_FILE_SYSTEM
1207 const char *separator
= "\\";
1209 const char *separator
= "/";
1211 filename
= concat (getpwd (), separator
, filename
, NULL
);
1212 filename
= mangle_path (filename
);
1213 len
= strlen (filename
);
1216 profile_data_prefix
= getpwd ();
1219 if (profile_data_prefix
)
1220 prefix_len
= strlen (profile_data_prefix
);
1222 /* Name of da file. */
1223 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1226 if (profile_data_prefix
)
1228 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1229 da_file_name
[prefix_len
++] = '/';
1231 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1232 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1234 bbg_file_stamp
= local_tick
;
1236 if (flag_auto_profile
)
1237 read_autofdo_file ();
1238 else if (flag_branch_probabilities
)
1239 read_counts_file ();
1241 /* Name of bbg file. */
1242 if (flag_test_coverage
&& !flag_compare_debug
)
1244 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1245 memcpy (bbg_file_name
, filename
, len
);
1246 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1248 if (!gcov_open (bbg_file_name
, -1))
1250 error ("cannot open %s", bbg_file_name
);
1251 bbg_file_name
= NULL
;
1255 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1256 gcov_write_unsigned (GCOV_VERSION
);
1257 gcov_write_unsigned (bbg_file_stamp
);
1258 gcov_write_string (getpwd ());
1260 /* Do not support has_unexecuted_blocks for Ada. */
1261 gcov_write_unsigned (strcmp (lang_hooks
.name
, "GNU Ada") != 0);
1265 g
->get_dumps ()->dump_finish (profile_pass_num
);
1268 /* Performs file-level cleanup. Close notes file, generate coverage
1269 variables and constructor. */
1272 coverage_finish (void)
1274 if (bbg_file_name
&& gcov_close ())
1275 unlink (bbg_file_name
);
1277 if (!flag_branch_probabilities
&& flag_test_coverage
1278 && (!local_tick
|| local_tick
== (unsigned)-1))
1279 /* Only remove the da file, if we're emitting coverage code and
1280 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1281 unlink (da_file_name
);
1283 if (coverage_obj_init ())
1285 vec
<constructor_elt
, va_gc
> *fn_ctor
= NULL
;
1286 struct coverage_data
*fn
;
1288 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1289 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1290 coverage_obj_finish (fn_ctor
);
1293 XDELETEVEC (da_file_name
);
1294 da_file_name
= NULL
;
1297 #include "gt-coverage.h"