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;
307 if (!warned
++ && dump_enabled_p ())
309 dump_user_location_t loc
310 = dump_user_location_t::from_location_t (input_location
);
311 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
312 (flag_guess_branch_prob
313 ? "file %s not found, execution counts estimated\n"
314 : "file %s not found, execution counts assumed to "
320 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
321 elt
.ident
= current_function_funcdef_no
+ 1;
324 gcc_assert (coverage_node_map_initialized_p ());
325 elt
.ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
328 entry
= counts_hash
->find (&elt
);
330 /* The function was not emitted, or is weak and not chosen in the
331 final executable. Silently fail, because there's nothing we
335 if (entry
->cfg_checksum
!= cfg_checksum
)
337 static int warned
= 0;
338 bool warning_printed
= false;
341 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
342 OPT_Wcoverage_mismatch
,
343 "the control flow of function %qD does not match "
344 "its profile data (counter %qs)", current_function_decl
,
346 if (warning_printed
&& dump_enabled_p ())
348 dump_user_location_t loc
349 = dump_user_location_t::from_location_t (input_location
);
350 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
351 "use -Wno-error=coverage-mismatch to tolerate "
352 "the mismatch but performance may drop if the "
353 "function is hot\n");
358 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
359 "coverage mismatch ignored\n");
360 dump_printf (MSG_OPTIMIZED_LOCATIONS
,
361 flag_guess_branch_prob
362 ? G_("execution counts estimated\n")
363 : G_("execution counts assumed to be zero\n"));
364 if (!flag_guess_branch_prob
)
365 dump_printf (MSG_OPTIMIZED_LOCATIONS
,
366 "this can result in poorly optimized code\n");
372 else if (entry
->lineno_checksum
!= lineno_checksum
)
374 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
375 OPT_Wcoverage_mismatch
,
376 "source locations for function %qD have changed,"
377 " the profile data may be out of date",
378 current_function_decl
);
381 return entry
->counts
;
384 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
385 allocation succeeded. */
388 coverage_counter_alloc (unsigned counter
, unsigned num
)
396 if (!fn_v_ctrs
[counter
])
398 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
401 = build_var (current_function_decl
, array_type
, counter
);
404 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
405 fn_n_ctrs
[counter
] += num
;
407 fn_ctr_mask
|= 1 << counter
;
411 /* Generate a tree to access COUNTER NO. */
414 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
416 tree gcov_type_node
= get_gcov_type ();
418 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
420 no
+= fn_b_ctrs
[counter
];
422 /* "no" here is an array index, scaled to bytes later. */
423 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
424 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
427 /* Generate a tree to access the address of COUNTER NO. */
430 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
432 tree gcov_type_node
= get_gcov_type ();
434 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
435 no
+= fn_b_ctrs
[counter
];
437 /* "no" here is an array index, scaled to bytes later. */
438 return build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
440 build_int_cst (integer_type_node
, no
),
445 /* Generate a checksum for a string. CHKSUM is the current
449 coverage_checksum_string (unsigned chksum
, const char *string
)
454 /* Look for everything that looks if it were produced by
455 get_file_function_name and zero out the second part
456 that may result from flag_random_seed. This is not critical
457 as the checksums are used only for sanity checking. */
458 for (i
= 0; string
[i
]; i
++)
461 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
463 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
466 /* C++ namespaces do have scheme:
467 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
468 since filename might contain extra underscores there seems
469 to be no better chance then walk all possible offsets looking
473 for (i
= i
+ offset
; string
[i
]; i
++)
478 for (y
= 1; y
< 9; y
++)
479 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
480 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
482 if (y
!= 9 || string
[i
+ 9] != '_')
484 for (y
= 10; y
< 18; y
++)
485 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
486 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
491 string
= dup
= xstrdup (string
);
492 for (y
= 10; y
< 18; y
++)
499 chksum
= crc32_string (chksum
, string
);
505 /* Compute checksum for the current function. We generate a CRC32. */
508 coverage_compute_lineno_checksum (void)
510 expanded_location xloc
511 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
512 unsigned chksum
= xloc
.line
;
515 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
516 chksum
= coverage_checksum_string
517 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
522 /* Compute profile ID. This is better to be unique in whole program. */
525 coverage_compute_profile_id (struct cgraph_node
*n
)
529 /* Externally visible symbols have unique name. */
530 if (TREE_PUBLIC (n
->decl
) || DECL_EXTERNAL (n
->decl
) || n
->unique_name
)
532 chksum
= coverage_checksum_string
533 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
537 expanded_location xloc
538 = expand_location (DECL_SOURCE_LOCATION (n
->decl
));
539 bool use_name_only
= (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
) == 0);
541 chksum
= (use_name_only
? 0 : xloc
.line
);
543 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
544 chksum
= coverage_checksum_string
545 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
546 if (!use_name_only
&& first_global_object_name
)
547 chksum
= coverage_checksum_string
548 (chksum
, first_global_object_name
);
549 chksum
= coverage_checksum_string
550 (chksum
, aux_base_name
);
553 /* Non-negative integers are hopefully small enough to fit in all targets.
554 Gcov file formats wants non-zero function IDs. */
555 chksum
= chksum
& 0x7fffffff;
556 return chksum
+ (!chksum
);
559 /* Compute cfg checksum for the function FN given as argument.
560 The checksum is calculated carefully so that
561 source code changes that doesn't affect the control flow graph
562 won't change the checksum.
563 This is to make the profile data useable across source code change.
564 The downside of this is that the compiler may use potentially
565 wrong profile data - that the source code change has non-trivial impact
566 on the validity of profile data (e.g. the reversed condition)
567 but the compiler won't detect the change and use the wrong profile data. */
570 coverage_compute_cfg_checksum (struct function
*fn
)
573 unsigned chksum
= n_basic_blocks_for_fn (fn
);
575 FOR_EACH_BB_FN (bb
, fn
)
579 chksum
= crc32_byte (chksum
, bb
->index
);
580 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
582 chksum
= crc32_byte (chksum
, e
->dest
->index
);
589 /* Begin output to the notes file for the current function.
590 Writes the function header. Returns nonzero if data should be output. */
593 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
595 expanded_location xloc
;
596 unsigned long offset
;
598 /* We don't need to output .gcno file unless we're under -ftest-coverage
599 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
600 if (no_coverage
|| !bbg_file_name
)
603 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
605 /* Announce function */
606 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
607 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
608 gcov_write_unsigned (current_function_funcdef_no
+ 1);
611 gcc_assert (coverage_node_map_initialized_p ());
612 gcov_write_unsigned (
613 cgraph_node::get (current_function_decl
)->profile_id
);
616 gcov_write_unsigned (lineno_checksum
);
617 gcov_write_unsigned (cfg_checksum
);
618 gcov_write_string (IDENTIFIER_POINTER
619 (DECL_ASSEMBLER_NAME (current_function_decl
)));
620 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl
)
621 && !DECL_FUNCTION_VERSIONED (current_function_decl
));
622 gcov_write_filename (xloc
.file
);
623 gcov_write_unsigned (xloc
.line
);
624 gcov_write_unsigned (xloc
.column
);
626 expanded_location endloc
= expand_location (cfun
->function_end_locus
);
628 /* Function can start in a single file and end in another one. */
629 gcov_write_unsigned (endloc
.file
== xloc
.file
? endloc
.line
: xloc
.line
);
630 gcov_write_length (offset
);
632 return !gcov_is_error ();
635 /* Finish coverage data for the current function. Verify no output
636 error has occurred. Save function coverage counts. */
639 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
643 if (bbg_file_name
&& gcov_is_error ())
645 warning (0, "error writing %qs", bbg_file_name
);
646 unlink (bbg_file_name
);
647 bbg_file_name
= NULL
;
652 struct coverage_data
*item
= 0;
654 item
= ggc_alloc
<coverage_data
> ();
656 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
657 item
->ident
= current_function_funcdef_no
+ 1;
660 gcc_assert (coverage_node_map_initialized_p ());
661 item
->ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
664 item
->lineno_checksum
= lineno_checksum
;
665 item
->cfg_checksum
= cfg_checksum
;
667 item
->fn_decl
= current_function_decl
;
669 *functions_tail
= item
;
670 functions_tail
= &item
->next
;
672 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
674 tree var
= fn_v_ctrs
[i
];
677 item
->ctr_vars
[i
] = var
;
680 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
681 array_type
= build_array_type (get_gcov_type (), array_type
);
682 TREE_TYPE (var
) = array_type
;
683 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
684 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
685 varpool_node::finalize_decl (var
);
688 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
689 fn_v_ctrs
[i
] = NULL_TREE
;
691 prg_ctr_mask
|= fn_ctr_mask
;
696 /* Remove coverage file if opened. */
699 coverage_remove_note_file (void)
704 unlink (bbg_file_name
);
708 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
709 >= 0 it is a counter array, otherwise it is the function structure. */
712 build_var (tree fn_decl
, tree type
, int counter
)
714 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
715 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
717 size_t fn_name_len
, len
;
719 fn_name
= targetm
.strip_name_encoding (fn_name
);
720 fn_name_len
= strlen (fn_name
);
721 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
724 strcpy (buf
, "__gcov__");
726 sprintf (buf
, "__gcov%u_", counter
);
728 buf
[len
- 1] = symbol_table::symbol_suffix_separator ();
729 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
730 DECL_NAME (var
) = get_identifier (buf
);
731 TREE_STATIC (var
) = 1;
732 TREE_ADDRESSABLE (var
) = 1;
733 DECL_NONALIASED (var
) = 1;
734 SET_DECL_ALIGN (var
, TYPE_ALIGN (type
));
739 /* Creates the gcov_fn_info RECORD_TYPE. */
742 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
744 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
748 gcc_assert (counters
);
751 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
752 get_gcov_unsigned_t ());
755 /* ctr_info::values */
756 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
757 build_pointer_type (get_gcov_type ()));
758 DECL_CHAIN (field
) = fields
;
761 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
764 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
765 build_pointer_type (build_qualified_type
766 (gcov_info_type
, TYPE_QUAL_CONST
)));
770 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
771 get_gcov_unsigned_t ());
772 DECL_CHAIN (field
) = fields
;
775 /* lineno_checksum */
776 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
777 get_gcov_unsigned_t ());
778 DECL_CHAIN (field
) = fields
;
782 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
783 get_gcov_unsigned_t ());
784 DECL_CHAIN (field
) = fields
;
787 array_type
= build_index_type (size_int (counters
- 1));
788 array_type
= build_array_type (ctr_info
, array_type
);
791 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
792 DECL_CHAIN (field
) = fields
;
795 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
798 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
799 the coverage data for the function and TYPE is the gcov_fn_info
800 RECORD_TYPE. KEY is the object file key. */
803 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
805 tree fields
= TYPE_FIELDS (type
);
808 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
809 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
812 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
813 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
814 fields
= DECL_CHAIN (fields
);
817 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
818 build_int_cstu (get_gcov_unsigned_t (),
820 fields
= DECL_CHAIN (fields
);
822 /* lineno_checksum */
823 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
824 build_int_cstu (get_gcov_unsigned_t (),
825 data
->lineno_checksum
));
826 fields
= DECL_CHAIN (fields
);
829 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
830 build_int_cstu (get_gcov_unsigned_t (),
831 data
->cfg_checksum
));
832 fields
= DECL_CHAIN (fields
);
835 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
836 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
837 if (prg_ctr_mask
& (1 << ix
))
839 vec
<constructor_elt
, va_gc
> *ctr
= NULL
;
840 tree var
= data
->ctr_vars
[ix
];
845 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))))
848 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
849 build_int_cstu (get_gcov_unsigned_t (),
853 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
854 build_fold_addr_expr (var
));
856 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
859 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
860 build_constructor (TREE_TYPE (fields
), v2
));
862 return build_constructor (type
, v1
);
865 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
866 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
869 build_info_type (tree type
, tree fn_info_ptr_type
)
871 tree field
, fields
= NULL_TREE
;
875 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
876 get_gcov_unsigned_t ());
877 DECL_CHAIN (field
) = fields
;
881 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
882 build_pointer_type (build_qualified_type
883 (type
, TYPE_QUAL_CONST
)));
884 DECL_CHAIN (field
) = fields
;
888 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
889 get_gcov_unsigned_t ());
890 DECL_CHAIN (field
) = fields
;
894 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
895 build_pointer_type (build_qualified_type
896 (char_type_node
, TYPE_QUAL_CONST
)));
897 DECL_CHAIN (field
) = fields
;
902 = build_function_type_list (void_type_node
,
903 build_pointer_type (get_gcov_type ()),
904 get_gcov_unsigned_t (), NULL_TREE
);
906 = build_array_type (build_pointer_type (merge_fn_type
),
907 build_index_type (size_int (GCOV_COUNTERS
- 1)));
908 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
910 DECL_CHAIN (field
) = fields
;
914 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
915 get_gcov_unsigned_t ());
916 DECL_CHAIN (field
) = fields
;
919 /* function_info pointer pointer */
920 fn_info_ptr_type
= build_pointer_type
921 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
922 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
924 DECL_CHAIN (field
) = fields
;
927 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
930 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
931 gcov_info structure type, FN_ARY is the array of pointers to
932 function info objects. */
935 build_info (tree info_type
, tree fn_ary
)
937 tree info_fields
= TYPE_FIELDS (info_type
);
938 tree merge_fn_type
, n_funcs
;
940 tree filename_string
;
941 int da_file_name_len
;
942 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
943 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
946 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
947 build_int_cstu (TREE_TYPE (info_fields
),
949 info_fields
= DECL_CHAIN (info_fields
);
952 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
953 info_fields
= DECL_CHAIN (info_fields
);
956 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
957 build_int_cstu (TREE_TYPE (info_fields
),
959 info_fields
= DECL_CHAIN (info_fields
);
962 da_file_name_len
= strlen (da_file_name
);
963 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
964 TREE_TYPE (filename_string
) = build_array_type
965 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
966 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
967 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
969 info_fields
= DECL_CHAIN (info_fields
);
971 /* merge fn array -- NULL slots indicate unmeasured counters */
972 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
973 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
975 tree ptr
= null_pointer_node
;
977 if ((1u << ix
) & prg_ctr_mask
)
979 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
981 get_identifier (ctr_merge_functions
[ix
]),
982 TREE_TYPE (merge_fn_type
));
983 DECL_EXTERNAL (merge_fn
) = 1;
984 TREE_PUBLIC (merge_fn
) = 1;
985 DECL_ARTIFICIAL (merge_fn
) = 1;
986 TREE_NOTHROW (merge_fn
) = 1;
987 /* Initialize assembler name so we can stream out. */
988 DECL_ASSEMBLER_NAME (merge_fn
);
989 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
991 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
993 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
994 build_constructor (TREE_TYPE (info_fields
), v2
));
995 info_fields
= DECL_CHAIN (info_fields
);
998 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
999 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
1000 n_funcs
, size_one_node
);
1001 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
1002 info_fields
= DECL_CHAIN (info_fields
);
1005 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1006 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
1007 info_fields
= DECL_CHAIN (info_fields
);
1009 gcc_assert (!info_fields
);
1010 return build_constructor (info_type
, v1
);
1013 /* Generate the constructor function to call __gcov_init. */
1016 build_init_ctor (tree gcov_info_type
)
1018 tree ctor
, stmt
, init_fn
;
1020 /* Build a decl for __gcov_init. */
1021 init_fn
= build_pointer_type (gcov_info_type
);
1022 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1023 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1024 get_identifier ("__gcov_init"), init_fn
);
1025 TREE_PUBLIC (init_fn
) = 1;
1026 DECL_EXTERNAL (init_fn
) = 1;
1027 DECL_ASSEMBLER_NAME (init_fn
);
1029 /* Generate a call to __gcov_init(&gcov_info). */
1031 stmt
= build_fold_addr_expr (gcov_info_var
);
1032 stmt
= build_call_expr (init_fn
, 1, stmt
);
1033 append_to_statement_list (stmt
, &ctor
);
1035 /* Generate a constructor to run it. */
1036 int priority
= SUPPORTS_INIT_PRIORITY
1037 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1038 cgraph_build_static_cdtor ('I', ctor
, priority
);
1041 /* Generate the destructor function to call __gcov_exit. */
1044 build_gcov_exit_decl (void)
1046 tree init_fn
= build_function_type_list (void_type_node
, void_type_node
,
1048 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1049 get_identifier ("__gcov_exit"), init_fn
);
1050 TREE_PUBLIC (init_fn
) = 1;
1051 DECL_EXTERNAL (init_fn
) = 1;
1052 DECL_ASSEMBLER_NAME (init_fn
);
1054 /* Generate a call to __gcov_exit (). */
1056 tree stmt
= build_call_expr (init_fn
, 0);
1057 append_to_statement_list (stmt
, &dtor
);
1059 /* Generate a destructor to run it. */
1060 int priority
= SUPPORTS_INIT_PRIORITY
1061 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1063 cgraph_build_static_cdtor ('D', dtor
, priority
);
1066 /* Create the gcov_info types and object. Generate the constructor
1067 function to call __gcov_init. Does not generate the initializer
1068 for the object. Returns TRUE if coverage data is being emitted. */
1071 coverage_obj_init (void)
1073 tree gcov_info_type
;
1074 unsigned n_counters
= 0;
1076 struct coverage_data
*fn
;
1077 struct coverage_data
**fn_prev
;
1080 no_coverage
= 1; /* Disable any further coverage. */
1085 if (symtab
->dump_file
)
1086 fprintf (symtab
->dump_file
, "Using data file %s\n", da_file_name
);
1088 /* Prune functions. */
1089 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
1090 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
1091 fn_prev
= &fn
->next
;
1093 /* The function is not being emitted, remove from list. */
1094 *fn_prev
= fn
->next
;
1096 if (functions_head
== NULL
)
1099 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1100 if ((1u << ix
) & prg_ctr_mask
)
1103 /* Build the info and fn_info types. These are mutually recursive. */
1104 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1105 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1106 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1107 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1108 gcov_fn_info_ptr_type
= build_pointer_type
1109 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1110 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1112 /* Build the gcov info var, this is referred to in its own
1114 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1115 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1116 TREE_STATIC (gcov_info_var
) = 1;
1117 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1118 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1120 build_init_ctor (gcov_info_type
);
1121 build_gcov_exit_decl ();
1126 /* Generate the coverage function info for FN and DATA. Append a
1127 pointer to that object to CTOR and return the appended CTOR. */
1129 static vec
<constructor_elt
, va_gc
> *
1130 coverage_obj_fn (vec
<constructor_elt
, va_gc
> *ctor
, tree fn
,
1131 struct coverage_data
const *data
)
1133 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1134 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1136 DECL_INITIAL (var
) = init
;
1137 varpool_node::finalize_decl (var
);
1139 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1140 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1144 /* Finalize the coverage data. Generates the array of pointers to
1145 function objects from CTOR. Generate the gcov_info initializer. */
1148 coverage_obj_finish (vec
<constructor_elt
, va_gc
> *ctor
)
1150 unsigned n_functions
= vec_safe_length (ctor
);
1151 tree fn_info_ary_type
= build_array_type
1152 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1153 build_index_type (size_int (n_functions
- 1)));
1154 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1158 TREE_STATIC (fn_info_ary
) = 1;
1159 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1160 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1161 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1162 varpool_node::finalize_decl (fn_info_ary
);
1164 DECL_INITIAL (gcov_info_var
)
1165 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1166 varpool_node::finalize_decl (gcov_info_var
);
1169 /* Perform file-level initialization. Read in data file, generate name
1173 coverage_init (const char *filename
)
1175 int len
= strlen (filename
);
1178 /* Since coverage_init is invoked very early, before the pass
1179 manager, we need to set up the dumping explicitly. This is
1180 similar to the handling in finish_optimization_passes. */
1181 int profile_pass_num
=
1182 g
->get_passes ()->get_pass_profile ()->static_pass_number
;
1183 g
->get_dumps ()->dump_start (profile_pass_num
, NULL
);
1185 if (!IS_ABSOLUTE_PATH (filename
))
1187 /* When a profile_data_prefix is provided, then mangle full path
1188 of filename in order to prevent file path clashing. */
1189 if (profile_data_prefix
)
1191 #if HAVE_DOS_BASED_FILE_SYSTEM
1192 const char *separator
= "\\";
1194 const char *separator
= "/";
1196 filename
= concat (getpwd (), separator
, filename
, NULL
);
1197 filename
= mangle_path (filename
);
1198 len
= strlen (filename
);
1201 profile_data_prefix
= getpwd ();
1204 if (profile_data_prefix
)
1205 prefix_len
= strlen (profile_data_prefix
);
1207 /* Name of da file. */
1208 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1211 if (profile_data_prefix
)
1213 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1214 da_file_name
[prefix_len
++] = '/';
1216 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1217 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1219 bbg_file_stamp
= local_tick
;
1221 if (flag_auto_profile
)
1222 read_autofdo_file ();
1223 else if (flag_branch_probabilities
)
1224 read_counts_file ();
1226 /* Name of bbg file. */
1227 if (flag_test_coverage
&& !flag_compare_debug
)
1229 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1230 memcpy (bbg_file_name
, filename
, len
);
1231 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1233 if (!gcov_open (bbg_file_name
, -1))
1235 error ("cannot open %s", bbg_file_name
);
1236 bbg_file_name
= NULL
;
1240 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1241 gcov_write_unsigned (GCOV_VERSION
);
1242 gcov_write_unsigned (bbg_file_stamp
);
1243 gcov_write_string (getpwd ());
1245 /* Do not support has_unexecuted_blocks for Ada. */
1246 gcov_write_unsigned (strcmp (lang_hooks
.name
, "GNU Ada") != 0);
1250 g
->get_dumps ()->dump_finish (profile_pass_num
);
1253 /* Performs file-level cleanup. Close notes file, generate coverage
1254 variables and constructor. */
1257 coverage_finish (void)
1259 if (bbg_file_name
&& gcov_close ())
1260 unlink (bbg_file_name
);
1262 if (!flag_branch_probabilities
&& flag_test_coverage
1263 && (!local_tick
|| local_tick
== (unsigned)-1))
1264 /* Only remove the da file, if we're emitting coverage code and
1265 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1266 unlink (da_file_name
);
1268 if (coverage_obj_init ())
1270 vec
<constructor_elt
, va_gc
> *fn_ctor
= NULL
;
1271 struct coverage_data
*fn
;
1273 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1274 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1275 coverage_obj_finish (fn_ctor
);
1278 XDELETEVEC (da_file_name
);
1279 da_file_name
= NULL
;
1282 #include "gt-coverage.h"