1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990-2019 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
;
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_VALUE (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
|| entry
->n_counts
!= n_counts
)
351 static int warned
= 0;
352 bool warning_printed
= false;
354 if (entry
->n_counts
!= n_counts
)
356 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
357 OPT_Wcoverage_mismatch
,
358 "number of counters in profile data for function %qD "
360 "its profile data (counter %qs, expected %i and have %i)",
361 current_function_decl
,
362 ctr_names
[counter
], entry
->n_counts
, n_counts
);
365 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
366 OPT_Wcoverage_mismatch
,
367 "the control flow of function %qD does not match "
368 "its profile data (counter %qs)", current_function_decl
,
370 if (warning_printed
&& dump_enabled_p ())
372 dump_user_location_t loc
373 = dump_user_location_t::from_function_decl (current_function_decl
);
374 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
375 "use -Wno-error=coverage-mismatch to tolerate "
376 "the mismatch but performance may drop if the "
377 "function is hot\n");
382 dump_printf_loc (MSG_MISSED_OPTIMIZATION
, loc
,
383 "coverage mismatch ignored\n");
384 dump_printf (MSG_MISSED_OPTIMIZATION
,
385 flag_guess_branch_prob
386 ? G_("execution counts estimated\n")
387 : G_("execution counts assumed to be zero\n"));
388 if (!flag_guess_branch_prob
)
389 dump_printf (MSG_MISSED_OPTIMIZATION
,
390 "this can result in poorly optimized code\n");
396 else if (entry
->lineno_checksum
!= lineno_checksum
)
398 warning_at (DECL_SOURCE_LOCATION (current_function_decl
),
399 OPT_Wcoverage_mismatch
,
400 "source locations for function %qD have changed,"
401 " the profile data may be out of date",
402 current_function_decl
);
405 return entry
->counts
;
408 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
409 allocation succeeded. */
412 coverage_counter_alloc (unsigned counter
, unsigned num
)
420 if (!fn_v_ctrs
[counter
])
422 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
425 = build_var (current_function_decl
, array_type
, counter
);
428 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
429 fn_n_ctrs
[counter
] += num
;
431 fn_ctr_mask
|= 1 << counter
;
435 /* Generate a tree to access COUNTER NO. */
438 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
440 tree gcov_type_node
= get_gcov_type ();
442 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
444 no
+= fn_b_ctrs
[counter
];
446 /* "no" here is an array index, scaled to bytes later. */
447 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
448 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
451 /* Generate a tree to access the address of COUNTER NO. */
454 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
456 tree gcov_type_node
= get_gcov_type ();
458 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
459 no
+= fn_b_ctrs
[counter
];
461 /* "no" here is an array index, scaled to bytes later. */
462 return build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
464 build_int_cst (integer_type_node
, no
),
469 /* Generate a checksum for a string. CHKSUM is the current
473 coverage_checksum_string (unsigned chksum
, const char *string
)
478 /* Look for everything that looks if it were produced by
479 get_file_function_name and zero out the second part
480 that may result from flag_random_seed. This is not critical
481 as the checksums are used only for sanity checking. */
482 for (i
= 0; string
[i
]; i
++)
485 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
487 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
490 /* C++ namespaces do have scheme:
491 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
492 since filename might contain extra underscores there seems
493 to be no better chance then walk all possible offsets looking
497 for (i
= i
+ offset
; string
[i
]; i
++)
502 for (y
= 1; y
< 9; y
++)
503 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
504 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
506 if (y
!= 9 || string
[i
+ 9] != '_')
508 for (y
= 10; y
< 18; y
++)
509 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
510 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
515 string
= dup
= xstrdup (string
);
516 for (y
= 10; y
< 18; y
++)
523 chksum
= crc32_string (chksum
, string
);
529 /* Compute checksum for the current function. We generate a CRC32. */
532 coverage_compute_lineno_checksum (void)
534 expanded_location xloc
535 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
536 unsigned chksum
= xloc
.line
;
539 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
540 chksum
= coverage_checksum_string
541 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
546 /* Compute profile ID. This is better to be unique in whole program. */
549 coverage_compute_profile_id (struct cgraph_node
*n
)
553 /* Externally visible symbols have unique name. */
554 if (TREE_PUBLIC (n
->decl
) || DECL_EXTERNAL (n
->decl
) || n
->unique_name
)
556 chksum
= coverage_checksum_string
557 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
561 expanded_location xloc
562 = expand_location (DECL_SOURCE_LOCATION (n
->decl
));
563 bool use_name_only
= (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
) == 0);
565 chksum
= (use_name_only
? 0 : xloc
.line
);
567 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
568 chksum
= coverage_checksum_string
569 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
570 if (!use_name_only
&& first_global_object_name
)
571 chksum
= coverage_checksum_string
572 (chksum
, first_global_object_name
);
573 chksum
= coverage_checksum_string
574 (chksum
, aux_base_name
);
577 /* Non-negative integers are hopefully small enough to fit in all targets.
578 Gcov file formats wants non-zero function IDs. */
579 chksum
= chksum
& 0x7fffffff;
580 return chksum
+ (!chksum
);
583 /* Compute cfg checksum for the function FN given as argument.
584 The checksum is calculated carefully so that
585 source code changes that doesn't affect the control flow graph
586 won't change the checksum.
587 This is to make the profile data useable across source code change.
588 The downside of this is that the compiler may use potentially
589 wrong profile data - that the source code change has non-trivial impact
590 on the validity of profile data (e.g. the reversed condition)
591 but the compiler won't detect the change and use the wrong profile data. */
594 coverage_compute_cfg_checksum (struct function
*fn
)
597 unsigned chksum
= n_basic_blocks_for_fn (fn
);
599 FOR_EACH_BB_FN (bb
, fn
)
603 chksum
= crc32_byte (chksum
, bb
->index
);
604 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
606 chksum
= crc32_byte (chksum
, e
->dest
->index
);
613 /* Begin output to the notes file for the current function.
614 Writes the function header. Returns nonzero if data should be output. */
617 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
619 expanded_location xloc
;
620 unsigned long offset
;
622 /* We don't need to output .gcno file unless we're under -ftest-coverage
623 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
624 if (no_coverage
|| !bbg_file_name
)
627 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
629 /* Announce function */
630 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
631 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
632 gcov_write_unsigned (current_function_funcdef_no
+ 1);
635 gcc_assert (coverage_node_map_initialized_p ());
636 gcov_write_unsigned (
637 cgraph_node::get (current_function_decl
)->profile_id
);
640 gcov_write_unsigned (lineno_checksum
);
641 gcov_write_unsigned (cfg_checksum
);
642 gcov_write_string (IDENTIFIER_POINTER
643 (DECL_ASSEMBLER_NAME (current_function_decl
)));
644 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl
)
645 && !DECL_FUNCTION_VERSIONED (current_function_decl
)
646 && !DECL_LAMBDA_FUNCTION (current_function_decl
));
647 gcov_write_filename (xloc
.file
);
648 gcov_write_unsigned (xloc
.line
);
649 gcov_write_unsigned (xloc
.column
);
651 expanded_location endloc
= expand_location (cfun
->function_end_locus
);
653 /* Function can start in a single file and end in another one. */
654 int end_line
= endloc
.file
== xloc
.file
? endloc
.line
: xloc
.line
;
655 gcc_assert (xloc
.line
<= end_line
);
656 gcov_write_unsigned (end_line
);
657 gcov_write_length (offset
);
659 return !gcov_is_error ();
662 /* Finish coverage data for the current function. Verify no output
663 error has occurred. Save function coverage counts. */
666 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
670 if (bbg_file_name
&& gcov_is_error ())
672 warning (0, "error writing %qs", bbg_file_name
);
673 unlink (bbg_file_name
);
674 bbg_file_name
= NULL
;
679 struct coverage_data
*item
= 0;
681 item
= ggc_alloc
<coverage_data
> ();
683 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
684 item
->ident
= current_function_funcdef_no
+ 1;
687 gcc_assert (coverage_node_map_initialized_p ());
688 item
->ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
691 item
->lineno_checksum
= lineno_checksum
;
692 item
->cfg_checksum
= cfg_checksum
;
694 item
->fn_decl
= current_function_decl
;
696 *functions_tail
= item
;
697 functions_tail
= &item
->next
;
699 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
701 tree var
= fn_v_ctrs
[i
];
704 item
->ctr_vars
[i
] = var
;
707 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
708 array_type
= build_array_type (get_gcov_type (), array_type
);
709 TREE_TYPE (var
) = array_type
;
710 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
711 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
712 varpool_node::finalize_decl (var
);
715 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
716 fn_v_ctrs
[i
] = NULL_TREE
;
718 prg_ctr_mask
|= fn_ctr_mask
;
723 /* Remove coverage file if opened. */
726 coverage_remove_note_file (void)
731 unlink (bbg_file_name
);
735 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
736 >= 0 it is a counter array, otherwise it is the function structure. */
739 build_var (tree fn_decl
, tree type
, int counter
)
741 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
742 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
744 size_t fn_name_len
, len
;
746 fn_name
= targetm
.strip_name_encoding (fn_name
);
747 fn_name_len
= strlen (fn_name
);
748 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
751 strcpy (buf
, "__gcov__");
753 sprintf (buf
, "__gcov%u_", counter
);
755 buf
[len
- 1] = symbol_table::symbol_suffix_separator ();
756 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
757 DECL_NAME (var
) = get_identifier (buf
);
758 TREE_STATIC (var
) = 1;
759 TREE_ADDRESSABLE (var
) = 1;
760 DECL_NONALIASED (var
) = 1;
761 SET_DECL_ALIGN (var
, TYPE_ALIGN (type
));
766 /* Creates the gcov_fn_info RECORD_TYPE. */
769 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
771 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
775 gcc_assert (counters
);
778 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
779 get_gcov_unsigned_t ());
782 /* ctr_info::values */
783 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
784 build_pointer_type (get_gcov_type ()));
785 DECL_CHAIN (field
) = fields
;
788 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
791 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
792 build_pointer_type (build_qualified_type
793 (gcov_info_type
, TYPE_QUAL_CONST
)));
797 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
798 get_gcov_unsigned_t ());
799 DECL_CHAIN (field
) = fields
;
802 /* lineno_checksum */
803 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
804 get_gcov_unsigned_t ());
805 DECL_CHAIN (field
) = fields
;
809 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
810 get_gcov_unsigned_t ());
811 DECL_CHAIN (field
) = fields
;
814 array_type
= build_index_type (size_int (counters
- 1));
815 array_type
= build_array_type (ctr_info
, array_type
);
818 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
819 DECL_CHAIN (field
) = fields
;
822 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
825 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
826 the coverage data for the function and TYPE is the gcov_fn_info
827 RECORD_TYPE. KEY is the object file key. */
830 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
832 tree fields
= TYPE_FIELDS (type
);
835 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
836 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
839 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
840 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
841 fields
= DECL_CHAIN (fields
);
844 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
845 build_int_cstu (get_gcov_unsigned_t (),
847 fields
= DECL_CHAIN (fields
);
849 /* lineno_checksum */
850 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
851 build_int_cstu (get_gcov_unsigned_t (),
852 data
->lineno_checksum
));
853 fields
= DECL_CHAIN (fields
);
856 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
857 build_int_cstu (get_gcov_unsigned_t (),
858 data
->cfg_checksum
));
859 fields
= DECL_CHAIN (fields
);
862 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
863 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
864 if (prg_ctr_mask
& (1 << ix
))
866 vec
<constructor_elt
, va_gc
> *ctr
= NULL
;
867 tree var
= data
->ctr_vars
[ix
];
872 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))))
875 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
876 build_int_cstu (get_gcov_unsigned_t (),
880 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
881 build_fold_addr_expr (var
));
883 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
886 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
887 build_constructor (TREE_TYPE (fields
), v2
));
889 return build_constructor (type
, v1
);
892 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
893 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
896 build_info_type (tree type
, tree fn_info_ptr_type
)
898 tree field
, fields
= NULL_TREE
;
902 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
903 get_gcov_unsigned_t ());
904 DECL_CHAIN (field
) = fields
;
908 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
909 build_pointer_type (build_qualified_type
910 (type
, TYPE_QUAL_CONST
)));
911 DECL_CHAIN (field
) = fields
;
915 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
916 get_gcov_unsigned_t ());
917 DECL_CHAIN (field
) = fields
;
921 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
922 build_pointer_type (build_qualified_type
923 (char_type_node
, TYPE_QUAL_CONST
)));
924 DECL_CHAIN (field
) = fields
;
929 = build_function_type_list (void_type_node
,
930 build_pointer_type (get_gcov_type ()),
931 get_gcov_unsigned_t (), NULL_TREE
);
933 = build_array_type (build_pointer_type (merge_fn_type
),
934 build_index_type (size_int (GCOV_COUNTERS
- 1)));
935 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
937 DECL_CHAIN (field
) = fields
;
941 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
942 get_gcov_unsigned_t ());
943 DECL_CHAIN (field
) = fields
;
946 /* function_info pointer pointer */
947 fn_info_ptr_type
= build_pointer_type
948 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
949 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
951 DECL_CHAIN (field
) = fields
;
954 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
957 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
958 gcov_info structure type, FN_ARY is the array of pointers to
959 function info objects. */
962 build_info (tree info_type
, tree fn_ary
)
964 tree info_fields
= TYPE_FIELDS (info_type
);
965 tree merge_fn_type
, n_funcs
;
967 tree filename_string
;
968 int da_file_name_len
;
969 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
970 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
973 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
974 build_int_cstu (TREE_TYPE (info_fields
),
976 info_fields
= DECL_CHAIN (info_fields
);
979 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
980 info_fields
= DECL_CHAIN (info_fields
);
983 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
984 build_int_cstu (TREE_TYPE (info_fields
),
986 info_fields
= DECL_CHAIN (info_fields
);
989 da_file_name_len
= strlen (da_file_name
);
990 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
991 TREE_TYPE (filename_string
) = build_array_type
992 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
993 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
994 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
996 info_fields
= DECL_CHAIN (info_fields
);
998 /* merge fn array -- NULL slots indicate unmeasured counters */
999 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
1000 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1002 tree ptr
= null_pointer_node
;
1004 if ((1u << ix
) & prg_ctr_mask
)
1006 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
1008 get_identifier (ctr_merge_functions
[ix
]),
1009 TREE_TYPE (merge_fn_type
));
1010 DECL_EXTERNAL (merge_fn
) = 1;
1011 TREE_PUBLIC (merge_fn
) = 1;
1012 DECL_ARTIFICIAL (merge_fn
) = 1;
1013 TREE_NOTHROW (merge_fn
) = 1;
1014 /* Initialize assembler name so we can stream out. */
1015 DECL_ASSEMBLER_NAME (merge_fn
);
1016 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
1018 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
1020 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1021 build_constructor (TREE_TYPE (info_fields
), v2
));
1022 info_fields
= DECL_CHAIN (info_fields
);
1025 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
1026 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
1027 n_funcs
, size_one_node
);
1028 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
1029 info_fields
= DECL_CHAIN (info_fields
);
1032 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1033 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
1034 info_fields
= DECL_CHAIN (info_fields
);
1036 gcc_assert (!info_fields
);
1037 return build_constructor (info_type
, v1
);
1040 /* Generate the constructor function to call __gcov_init. */
1043 build_init_ctor (tree gcov_info_type
)
1045 tree ctor
, stmt
, init_fn
;
1047 /* Build a decl for __gcov_init. */
1048 init_fn
= build_pointer_type (gcov_info_type
);
1049 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1050 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1051 get_identifier ("__gcov_init"), init_fn
);
1052 TREE_PUBLIC (init_fn
) = 1;
1053 DECL_EXTERNAL (init_fn
) = 1;
1054 DECL_ASSEMBLER_NAME (init_fn
);
1056 /* Generate a call to __gcov_init(&gcov_info). */
1058 stmt
= build_fold_addr_expr (gcov_info_var
);
1059 stmt
= build_call_expr (init_fn
, 1, stmt
);
1060 append_to_statement_list (stmt
, &ctor
);
1062 /* Generate a constructor to run it. */
1063 int priority
= SUPPORTS_INIT_PRIORITY
1064 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1065 cgraph_build_static_cdtor ('I', ctor
, priority
);
1068 /* Generate the destructor function to call __gcov_exit. */
1071 build_gcov_exit_decl (void)
1073 tree init_fn
= build_function_type_list (void_type_node
, void_type_node
,
1075 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1076 get_identifier ("__gcov_exit"), init_fn
);
1077 TREE_PUBLIC (init_fn
) = 1;
1078 DECL_EXTERNAL (init_fn
) = 1;
1079 DECL_ASSEMBLER_NAME (init_fn
);
1081 /* Generate a call to __gcov_exit (). */
1083 tree stmt
= build_call_expr (init_fn
, 0);
1084 append_to_statement_list (stmt
, &dtor
);
1086 /* Generate a destructor to run it. */
1087 int priority
= SUPPORTS_INIT_PRIORITY
1088 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1090 cgraph_build_static_cdtor ('D', dtor
, priority
);
1093 /* Create the gcov_info types and object. Generate the constructor
1094 function to call __gcov_init. Does not generate the initializer
1095 for the object. Returns TRUE if coverage data is being emitted. */
1098 coverage_obj_init (void)
1100 tree gcov_info_type
;
1101 unsigned n_counters
= 0;
1103 struct coverage_data
*fn
;
1104 struct coverage_data
**fn_prev
;
1107 no_coverage
= 1; /* Disable any further coverage. */
1112 if (symtab
->dump_file
)
1113 fprintf (symtab
->dump_file
, "Using data file %s\n", da_file_name
);
1115 /* Prune functions. */
1116 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
1117 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
1118 fn_prev
= &fn
->next
;
1120 /* The function is not being emitted, remove from list. */
1121 *fn_prev
= fn
->next
;
1123 if (functions_head
== NULL
)
1126 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1127 if ((1u << ix
) & prg_ctr_mask
)
1130 /* Build the info and fn_info types. These are mutually recursive. */
1131 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1132 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1133 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1134 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1135 gcov_fn_info_ptr_type
= build_pointer_type
1136 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1137 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1139 /* Build the gcov info var, this is referred to in its own
1141 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1142 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1143 TREE_STATIC (gcov_info_var
) = 1;
1144 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1145 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1147 build_init_ctor (gcov_info_type
);
1148 build_gcov_exit_decl ();
1153 /* Generate the coverage function info for FN and DATA. Append a
1154 pointer to that object to CTOR and return the appended CTOR. */
1156 static vec
<constructor_elt
, va_gc
> *
1157 coverage_obj_fn (vec
<constructor_elt
, va_gc
> *ctor
, tree fn
,
1158 struct coverage_data
const *data
)
1160 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1161 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1163 DECL_INITIAL (var
) = init
;
1164 varpool_node::finalize_decl (var
);
1166 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1167 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1171 /* Finalize the coverage data. Generates the array of pointers to
1172 function objects from CTOR. Generate the gcov_info initializer. */
1175 coverage_obj_finish (vec
<constructor_elt
, va_gc
> *ctor
)
1177 unsigned n_functions
= vec_safe_length (ctor
);
1178 tree fn_info_ary_type
= build_array_type
1179 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1180 build_index_type (size_int (n_functions
- 1)));
1181 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1185 TREE_STATIC (fn_info_ary
) = 1;
1186 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1187 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1188 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1189 varpool_node::finalize_decl (fn_info_ary
);
1191 DECL_INITIAL (gcov_info_var
)
1192 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1193 varpool_node::finalize_decl (gcov_info_var
);
1196 /* Perform file-level initialization. Read in data file, generate name
1200 coverage_init (const char *filename
)
1202 int len
= strlen (filename
);
1205 /* Since coverage_init is invoked very early, before the pass
1206 manager, we need to set up the dumping explicitly. This is
1207 similar to the handling in finish_optimization_passes. */
1208 int profile_pass_num
=
1209 g
->get_passes ()->get_pass_profile ()->static_pass_number
;
1210 g
->get_dumps ()->dump_start (profile_pass_num
, NULL
);
1212 if (!IS_ABSOLUTE_PATH (filename
))
1214 /* When a profile_data_prefix is provided, then mangle full path
1215 of filename in order to prevent file path clashing. */
1216 if (profile_data_prefix
)
1218 #if HAVE_DOS_BASED_FILE_SYSTEM
1219 const char *separator
= "\\";
1221 const char *separator
= "/";
1223 filename
= concat (getpwd (), separator
, filename
, NULL
);
1224 filename
= mangle_path (filename
);
1225 len
= strlen (filename
);
1228 profile_data_prefix
= getpwd ();
1231 if (profile_data_prefix
)
1232 prefix_len
= strlen (profile_data_prefix
);
1234 /* Name of da file. */
1235 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1238 if (profile_data_prefix
)
1240 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1241 da_file_name
[prefix_len
++] = '/';
1243 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1244 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1246 bbg_file_stamp
= local_tick
;
1248 if (flag_auto_profile
)
1249 read_autofdo_file ();
1250 else if (flag_branch_probabilities
)
1251 read_counts_file ();
1253 /* Name of bbg file. */
1254 if (flag_test_coverage
&& !flag_compare_debug
)
1256 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1257 memcpy (bbg_file_name
, filename
, len
);
1258 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1260 if (!gcov_open (bbg_file_name
, -1))
1262 error ("cannot open %s", bbg_file_name
);
1263 bbg_file_name
= NULL
;
1267 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1268 gcov_write_unsigned (GCOV_VERSION
);
1269 gcov_write_unsigned (bbg_file_stamp
);
1270 gcov_write_string (getpwd ());
1272 /* Do not support has_unexecuted_blocks for Ada. */
1273 gcov_write_unsigned (strcmp (lang_hooks
.name
, "GNU Ada") != 0);
1277 g
->get_dumps ()->dump_finish (profile_pass_num
);
1280 /* Performs file-level cleanup. Close notes file, generate coverage
1281 variables and constructor. */
1284 coverage_finish (void)
1286 if (bbg_file_name
&& gcov_close ())
1287 unlink (bbg_file_name
);
1289 if (!flag_branch_probabilities
&& flag_test_coverage
1290 && (!local_tick
|| local_tick
== (unsigned)-1))
1291 /* Only remove the da file, if we're emitting coverage code and
1292 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1293 unlink (da_file_name
);
1295 if (coverage_obj_init ())
1297 vec
<constructor_elt
, va_gc
> *fn_ctor
= NULL
;
1298 struct coverage_data
*fn
;
1300 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1301 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1302 coverage_obj_finish (fn_ctor
);
1305 XDELETEVEC (da_file_name
);
1306 da_file_name
= NULL
;
1309 #include "gt-coverage.h"