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;
339 tree id
= DECL_ASSEMBLER_NAME (current_function_decl
);
342 warning_at (input_location
, OPT_Wcoverage_mismatch
,
343 "the control flow of function %qE does not match "
344 "its profile data (counter %qs)", id
, ctr_names
[counter
]);
345 if (warning_printed
&& dump_enabled_p ())
347 dump_user_location_t loc
348 = dump_user_location_t::from_location_t (input_location
);
349 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
350 "use -Wno-error=coverage-mismatch to tolerate "
351 "the mismatch but performance may drop if the "
352 "function is hot\n");
357 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, loc
,
358 "coverage mismatch ignored\n");
359 dump_printf (MSG_OPTIMIZED_LOCATIONS
,
360 flag_guess_branch_prob
361 ? G_("execution counts estimated\n")
362 : G_("execution counts assumed to be zero\n"));
363 if (!flag_guess_branch_prob
)
364 dump_printf (MSG_OPTIMIZED_LOCATIONS
,
365 "this can result in poorly optimized code\n");
371 else if (entry
->lineno_checksum
!= lineno_checksum
)
373 warning (OPT_Wcoverage_mismatch
,
374 "source locations for function %qE have changed,"
375 " the profile data may be out of date",
376 DECL_ASSEMBLER_NAME (current_function_decl
));
379 return entry
->counts
;
382 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
383 allocation succeeded. */
386 coverage_counter_alloc (unsigned counter
, unsigned num
)
394 if (!fn_v_ctrs
[counter
])
396 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
399 = build_var (current_function_decl
, array_type
, counter
);
402 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
403 fn_n_ctrs
[counter
] += num
;
405 fn_ctr_mask
|= 1 << counter
;
409 /* Generate a tree to access COUNTER NO. */
412 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
414 tree gcov_type_node
= get_gcov_type ();
416 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
418 no
+= fn_b_ctrs
[counter
];
420 /* "no" here is an array index, scaled to bytes later. */
421 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
422 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
425 /* Generate a tree to access the address of COUNTER NO. */
428 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
430 tree gcov_type_node
= get_gcov_type ();
432 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
433 no
+= fn_b_ctrs
[counter
];
435 /* "no" here is an array index, scaled to bytes later. */
436 return build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
438 build_int_cst (integer_type_node
, no
),
443 /* Generate a checksum for a string. CHKSUM is the current
447 coverage_checksum_string (unsigned chksum
, const char *string
)
452 /* Look for everything that looks if it were produced by
453 get_file_function_name and zero out the second part
454 that may result from flag_random_seed. This is not critical
455 as the checksums are used only for sanity checking. */
456 for (i
= 0; string
[i
]; i
++)
459 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
461 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
464 /* C++ namespaces do have scheme:
465 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
466 since filename might contain extra underscores there seems
467 to be no better chance then walk all possible offsets looking
471 for (i
= i
+ offset
; string
[i
]; i
++)
476 for (y
= 1; y
< 9; y
++)
477 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
478 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
480 if (y
!= 9 || string
[i
+ 9] != '_')
482 for (y
= 10; y
< 18; y
++)
483 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
484 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
489 string
= dup
= xstrdup (string
);
490 for (y
= 10; y
< 18; y
++)
497 chksum
= crc32_string (chksum
, string
);
503 /* Compute checksum for the current function. We generate a CRC32. */
506 coverage_compute_lineno_checksum (void)
508 expanded_location xloc
509 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
510 unsigned chksum
= xloc
.line
;
513 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
514 chksum
= coverage_checksum_string
515 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
520 /* Compute profile ID. This is better to be unique in whole program. */
523 coverage_compute_profile_id (struct cgraph_node
*n
)
527 /* Externally visible symbols have unique name. */
528 if (TREE_PUBLIC (n
->decl
) || DECL_EXTERNAL (n
->decl
) || n
->unique_name
)
530 chksum
= coverage_checksum_string
531 (0, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
535 expanded_location xloc
536 = expand_location (DECL_SOURCE_LOCATION (n
->decl
));
537 bool use_name_only
= (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
) == 0);
539 chksum
= (use_name_only
? 0 : xloc
.line
);
541 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
542 chksum
= coverage_checksum_string
543 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (n
->decl
)));
544 if (!use_name_only
&& first_global_object_name
)
545 chksum
= coverage_checksum_string
546 (chksum
, first_global_object_name
);
547 chksum
= coverage_checksum_string
548 (chksum
, aux_base_name
);
551 /* Non-negative integers are hopefully small enough to fit in all targets.
552 Gcov file formats wants non-zero function IDs. */
553 chksum
= chksum
& 0x7fffffff;
554 return chksum
+ (!chksum
);
557 /* Compute cfg checksum for the function FN given as argument.
558 The checksum is calculated carefully so that
559 source code changes that doesn't affect the control flow graph
560 won't change the checksum.
561 This is to make the profile data useable across source code change.
562 The downside of this is that the compiler may use potentially
563 wrong profile data - that the source code change has non-trivial impact
564 on the validity of profile data (e.g. the reversed condition)
565 but the compiler won't detect the change and use the wrong profile data. */
568 coverage_compute_cfg_checksum (struct function
*fn
)
571 unsigned chksum
= n_basic_blocks_for_fn (fn
);
573 FOR_EACH_BB_FN (bb
, fn
)
577 chksum
= crc32_byte (chksum
, bb
->index
);
578 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
580 chksum
= crc32_byte (chksum
, e
->dest
->index
);
587 /* Begin output to the notes file for the current function.
588 Writes the function header. Returns nonzero if data should be output. */
591 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
593 expanded_location xloc
;
594 unsigned long offset
;
596 /* We don't need to output .gcno file unless we're under -ftest-coverage
597 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
598 if (no_coverage
|| !bbg_file_name
)
601 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
603 /* Announce function */
604 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
605 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
606 gcov_write_unsigned (current_function_funcdef_no
+ 1);
609 gcc_assert (coverage_node_map_initialized_p ());
610 gcov_write_unsigned (
611 cgraph_node::get (current_function_decl
)->profile_id
);
614 gcov_write_unsigned (lineno_checksum
);
615 gcov_write_unsigned (cfg_checksum
);
616 gcov_write_string (IDENTIFIER_POINTER
617 (DECL_ASSEMBLER_NAME (current_function_decl
)));
618 gcov_write_unsigned (DECL_ARTIFICIAL (current_function_decl
)
619 && !DECL_FUNCTION_VERSIONED (current_function_decl
));
620 gcov_write_filename (xloc
.file
);
621 gcov_write_unsigned (xloc
.line
);
622 gcov_write_unsigned (xloc
.column
);
624 expanded_location endloc
= expand_location (cfun
->function_end_locus
);
626 /* Function can start in a single file and end in another one. */
627 gcov_write_unsigned (endloc
.file
== xloc
.file
? endloc
.line
: xloc
.line
);
628 gcov_write_length (offset
);
630 return !gcov_is_error ();
633 /* Finish coverage data for the current function. Verify no output
634 error has occurred. Save function coverage counts. */
637 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
641 if (bbg_file_name
&& gcov_is_error ())
643 warning (0, "error writing %qs", bbg_file_name
);
644 unlink (bbg_file_name
);
645 bbg_file_name
= NULL
;
650 struct coverage_data
*item
= 0;
652 item
= ggc_alloc
<coverage_data
> ();
654 if (PARAM_VALUE (PARAM_PROFILE_FUNC_INTERNAL_ID
))
655 item
->ident
= current_function_funcdef_no
+ 1;
658 gcc_assert (coverage_node_map_initialized_p ());
659 item
->ident
= cgraph_node::get (cfun
->decl
)->profile_id
;
662 item
->lineno_checksum
= lineno_checksum
;
663 item
->cfg_checksum
= cfg_checksum
;
665 item
->fn_decl
= current_function_decl
;
667 *functions_tail
= item
;
668 functions_tail
= &item
->next
;
670 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
672 tree var
= fn_v_ctrs
[i
];
675 item
->ctr_vars
[i
] = var
;
678 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
679 array_type
= build_array_type (get_gcov_type (), array_type
);
680 TREE_TYPE (var
) = array_type
;
681 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
682 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
683 varpool_node::finalize_decl (var
);
686 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
687 fn_v_ctrs
[i
] = NULL_TREE
;
689 prg_ctr_mask
|= fn_ctr_mask
;
694 /* Remove coverage file if opened. */
697 coverage_remove_note_file (void)
702 unlink (bbg_file_name
);
706 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
707 >= 0 it is a counter array, otherwise it is the function structure. */
710 build_var (tree fn_decl
, tree type
, int counter
)
712 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
713 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
715 size_t fn_name_len
, len
;
717 fn_name
= targetm
.strip_name_encoding (fn_name
);
718 fn_name_len
= strlen (fn_name
);
719 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
722 strcpy (buf
, "__gcov__");
724 sprintf (buf
, "__gcov%u_", counter
);
726 buf
[len
- 1] = symbol_table::symbol_suffix_separator ();
727 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
728 DECL_NAME (var
) = get_identifier (buf
);
729 TREE_STATIC (var
) = 1;
730 TREE_ADDRESSABLE (var
) = 1;
731 DECL_NONALIASED (var
) = 1;
732 SET_DECL_ALIGN (var
, TYPE_ALIGN (type
));
737 /* Creates the gcov_fn_info RECORD_TYPE. */
740 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
742 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
746 gcc_assert (counters
);
749 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
750 get_gcov_unsigned_t ());
753 /* ctr_info::values */
754 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
755 build_pointer_type (get_gcov_type ()));
756 DECL_CHAIN (field
) = fields
;
759 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
762 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
763 build_pointer_type (build_qualified_type
764 (gcov_info_type
, TYPE_QUAL_CONST
)));
768 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
769 get_gcov_unsigned_t ());
770 DECL_CHAIN (field
) = fields
;
773 /* lineno_checksum */
774 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
775 get_gcov_unsigned_t ());
776 DECL_CHAIN (field
) = fields
;
780 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
781 get_gcov_unsigned_t ());
782 DECL_CHAIN (field
) = fields
;
785 array_type
= build_index_type (size_int (counters
- 1));
786 array_type
= build_array_type (ctr_info
, array_type
);
789 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
790 DECL_CHAIN (field
) = fields
;
793 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
796 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
797 the coverage data for the function and TYPE is the gcov_fn_info
798 RECORD_TYPE. KEY is the object file key. */
801 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
803 tree fields
= TYPE_FIELDS (type
);
806 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
807 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
810 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
811 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
812 fields
= DECL_CHAIN (fields
);
815 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
816 build_int_cstu (get_gcov_unsigned_t (),
818 fields
= DECL_CHAIN (fields
);
820 /* lineno_checksum */
821 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
822 build_int_cstu (get_gcov_unsigned_t (),
823 data
->lineno_checksum
));
824 fields
= DECL_CHAIN (fields
);
827 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
828 build_int_cstu (get_gcov_unsigned_t (),
829 data
->cfg_checksum
));
830 fields
= DECL_CHAIN (fields
);
833 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
834 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
835 if (prg_ctr_mask
& (1 << ix
))
837 vec
<constructor_elt
, va_gc
> *ctr
= NULL
;
838 tree var
= data
->ctr_vars
[ix
];
843 = tree_to_shwi (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))))
846 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
847 build_int_cstu (get_gcov_unsigned_t (),
851 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
852 build_fold_addr_expr (var
));
854 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
857 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
858 build_constructor (TREE_TYPE (fields
), v2
));
860 return build_constructor (type
, v1
);
863 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
864 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
867 build_info_type (tree type
, tree fn_info_ptr_type
)
869 tree field
, fields
= NULL_TREE
;
873 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
874 get_gcov_unsigned_t ());
875 DECL_CHAIN (field
) = fields
;
879 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
880 build_pointer_type (build_qualified_type
881 (type
, TYPE_QUAL_CONST
)));
882 DECL_CHAIN (field
) = fields
;
886 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
887 get_gcov_unsigned_t ());
888 DECL_CHAIN (field
) = fields
;
892 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
893 build_pointer_type (build_qualified_type
894 (char_type_node
, TYPE_QUAL_CONST
)));
895 DECL_CHAIN (field
) = fields
;
900 = build_function_type_list (void_type_node
,
901 build_pointer_type (get_gcov_type ()),
902 get_gcov_unsigned_t (), NULL_TREE
);
904 = build_array_type (build_pointer_type (merge_fn_type
),
905 build_index_type (size_int (GCOV_COUNTERS
- 1)));
906 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
908 DECL_CHAIN (field
) = fields
;
912 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
913 get_gcov_unsigned_t ());
914 DECL_CHAIN (field
) = fields
;
917 /* function_info pointer pointer */
918 fn_info_ptr_type
= build_pointer_type
919 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
920 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
922 DECL_CHAIN (field
) = fields
;
925 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
928 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
929 gcov_info structure type, FN_ARY is the array of pointers to
930 function info objects. */
933 build_info (tree info_type
, tree fn_ary
)
935 tree info_fields
= TYPE_FIELDS (info_type
);
936 tree merge_fn_type
, n_funcs
;
938 tree filename_string
;
939 int da_file_name_len
;
940 vec
<constructor_elt
, va_gc
> *v1
= NULL
;
941 vec
<constructor_elt
, va_gc
> *v2
= NULL
;
944 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
945 build_int_cstu (TREE_TYPE (info_fields
),
947 info_fields
= DECL_CHAIN (info_fields
);
950 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
951 info_fields
= DECL_CHAIN (info_fields
);
954 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
955 build_int_cstu (TREE_TYPE (info_fields
),
957 info_fields
= DECL_CHAIN (info_fields
);
960 da_file_name_len
= strlen (da_file_name
);
961 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
962 TREE_TYPE (filename_string
) = build_array_type
963 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
964 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
965 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
967 info_fields
= DECL_CHAIN (info_fields
);
969 /* merge fn array -- NULL slots indicate unmeasured counters */
970 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
971 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
973 tree ptr
= null_pointer_node
;
975 if ((1u << ix
) & prg_ctr_mask
)
977 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
979 get_identifier (ctr_merge_functions
[ix
]),
980 TREE_TYPE (merge_fn_type
));
981 DECL_EXTERNAL (merge_fn
) = 1;
982 TREE_PUBLIC (merge_fn
) = 1;
983 DECL_ARTIFICIAL (merge_fn
) = 1;
984 TREE_NOTHROW (merge_fn
) = 1;
985 /* Initialize assembler name so we can stream out. */
986 DECL_ASSEMBLER_NAME (merge_fn
);
987 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
989 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
991 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
992 build_constructor (TREE_TYPE (info_fields
), v2
));
993 info_fields
= DECL_CHAIN (info_fields
);
996 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
997 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
998 n_funcs
, size_one_node
);
999 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
1000 info_fields
= DECL_CHAIN (info_fields
);
1003 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
1004 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
1005 info_fields
= DECL_CHAIN (info_fields
);
1007 gcc_assert (!info_fields
);
1008 return build_constructor (info_type
, v1
);
1011 /* Generate the constructor function to call __gcov_init. */
1014 build_init_ctor (tree gcov_info_type
)
1016 tree ctor
, stmt
, init_fn
;
1018 /* Build a decl for __gcov_init. */
1019 init_fn
= build_pointer_type (gcov_info_type
);
1020 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1021 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1022 get_identifier ("__gcov_init"), init_fn
);
1023 TREE_PUBLIC (init_fn
) = 1;
1024 DECL_EXTERNAL (init_fn
) = 1;
1025 DECL_ASSEMBLER_NAME (init_fn
);
1027 /* Generate a call to __gcov_init(&gcov_info). */
1029 stmt
= build_fold_addr_expr (gcov_info_var
);
1030 stmt
= build_call_expr (init_fn
, 1, stmt
);
1031 append_to_statement_list (stmt
, &ctor
);
1033 /* Generate a constructor to run it. */
1034 int priority
= SUPPORTS_INIT_PRIORITY
1035 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1036 cgraph_build_static_cdtor ('I', ctor
, priority
);
1039 /* Generate the destructor function to call __gcov_exit. */
1042 build_gcov_exit_decl (void)
1044 tree init_fn
= build_function_type_list (void_type_node
, void_type_node
,
1046 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1047 get_identifier ("__gcov_exit"), init_fn
);
1048 TREE_PUBLIC (init_fn
) = 1;
1049 DECL_EXTERNAL (init_fn
) = 1;
1050 DECL_ASSEMBLER_NAME (init_fn
);
1052 /* Generate a call to __gcov_exit (). */
1054 tree stmt
= build_call_expr (init_fn
, 0);
1055 append_to_statement_list (stmt
, &dtor
);
1057 /* Generate a destructor to run it. */
1058 int priority
= SUPPORTS_INIT_PRIORITY
1059 ? MAX_RESERVED_INIT_PRIORITY
: DEFAULT_INIT_PRIORITY
;
1061 cgraph_build_static_cdtor ('D', dtor
, priority
);
1064 /* Create the gcov_info types and object. Generate the constructor
1065 function to call __gcov_init. Does not generate the initializer
1066 for the object. Returns TRUE if coverage data is being emitted. */
1069 coverage_obj_init (void)
1071 tree gcov_info_type
;
1072 unsigned n_counters
= 0;
1074 struct coverage_data
*fn
;
1075 struct coverage_data
**fn_prev
;
1078 no_coverage
= 1; /* Disable any further coverage. */
1083 if (symtab
->dump_file
)
1084 fprintf (symtab
->dump_file
, "Using data file %s\n", da_file_name
);
1086 /* Prune functions. */
1087 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
1088 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
1089 fn_prev
= &fn
->next
;
1091 /* The function is not being emitted, remove from list. */
1092 *fn_prev
= fn
->next
;
1094 if (functions_head
== NULL
)
1097 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
1098 if ((1u << ix
) & prg_ctr_mask
)
1101 /* Build the info and fn_info types. These are mutually recursive. */
1102 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1103 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1104 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1105 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1106 gcov_fn_info_ptr_type
= build_pointer_type
1107 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1108 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1110 /* Build the gcov info var, this is referred to in its own
1112 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1113 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1114 TREE_STATIC (gcov_info_var
) = 1;
1115 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1116 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1118 build_init_ctor (gcov_info_type
);
1119 build_gcov_exit_decl ();
1124 /* Generate the coverage function info for FN and DATA. Append a
1125 pointer to that object to CTOR and return the appended CTOR. */
1127 static vec
<constructor_elt
, va_gc
> *
1128 coverage_obj_fn (vec
<constructor_elt
, va_gc
> *ctor
, tree fn
,
1129 struct coverage_data
const *data
)
1131 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1132 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1134 DECL_INITIAL (var
) = init
;
1135 varpool_node::finalize_decl (var
);
1137 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1138 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1142 /* Finalize the coverage data. Generates the array of pointers to
1143 function objects from CTOR. Generate the gcov_info initializer. */
1146 coverage_obj_finish (vec
<constructor_elt
, va_gc
> *ctor
)
1148 unsigned n_functions
= vec_safe_length (ctor
);
1149 tree fn_info_ary_type
= build_array_type
1150 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1151 build_index_type (size_int (n_functions
- 1)));
1152 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1156 TREE_STATIC (fn_info_ary
) = 1;
1157 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1158 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1159 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1160 varpool_node::finalize_decl (fn_info_ary
);
1162 DECL_INITIAL (gcov_info_var
)
1163 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1164 varpool_node::finalize_decl (gcov_info_var
);
1167 /* Perform file-level initialization. Read in data file, generate name
1171 coverage_init (const char *filename
)
1173 int len
= strlen (filename
);
1176 /* Since coverage_init is invoked very early, before the pass
1177 manager, we need to set up the dumping explicitly. This is
1178 similar to the handling in finish_optimization_passes. */
1179 int profile_pass_num
=
1180 g
->get_passes ()->get_pass_profile ()->static_pass_number
;
1181 g
->get_dumps ()->dump_start (profile_pass_num
, NULL
);
1183 if (!IS_ABSOLUTE_PATH (filename
))
1185 /* When a profile_data_prefix is provided, then mangle full path
1186 of filename in order to prevent file path clashing. */
1187 if (profile_data_prefix
)
1189 #if HAVE_DOS_BASED_FILE_SYSTEM
1190 const char *separator
= "\\";
1192 const char *separator
= "/";
1194 filename
= concat (getpwd (), separator
, filename
, NULL
);
1195 filename
= mangle_path (filename
);
1196 len
= strlen (filename
);
1199 profile_data_prefix
= getpwd ();
1202 if (profile_data_prefix
)
1203 prefix_len
= strlen (profile_data_prefix
);
1205 /* Name of da file. */
1206 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1209 if (profile_data_prefix
)
1211 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1212 da_file_name
[prefix_len
++] = '/';
1214 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1215 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1217 bbg_file_stamp
= local_tick
;
1219 if (flag_auto_profile
)
1220 read_autofdo_file ();
1221 else if (flag_branch_probabilities
)
1222 read_counts_file ();
1224 /* Name of bbg file. */
1225 if (flag_test_coverage
&& !flag_compare_debug
)
1227 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1228 memcpy (bbg_file_name
, filename
, len
);
1229 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1231 if (!gcov_open (bbg_file_name
, -1))
1233 error ("cannot open %s", bbg_file_name
);
1234 bbg_file_name
= NULL
;
1238 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1239 gcov_write_unsigned (GCOV_VERSION
);
1240 gcov_write_unsigned (bbg_file_stamp
);
1241 gcov_write_string (getpwd ());
1243 /* Do not support has_unexecuted_blocks for Ada. */
1244 gcov_write_unsigned (strcmp (lang_hooks
.name
, "GNU Ada") != 0);
1248 g
->get_dumps ()->dump_finish (profile_pass_num
);
1251 /* Performs file-level cleanup. Close notes file, generate coverage
1252 variables and constructor. */
1255 coverage_finish (void)
1257 if (bbg_file_name
&& gcov_close ())
1258 unlink (bbg_file_name
);
1260 if (!flag_branch_probabilities
&& flag_test_coverage
1261 && (!local_tick
|| local_tick
== (unsigned)-1))
1262 /* Only remove the da file, if we're emitting coverage code and
1263 cannot uniquely stamp it. If we can stamp it, libgcov will DTRT. */
1264 unlink (da_file_name
);
1266 if (coverage_obj_init ())
1268 vec
<constructor_elt
, va_gc
> *fn_ctor
= NULL
;
1269 struct coverage_data
*fn
;
1271 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1272 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1273 coverage_obj_finish (fn_ctor
);
1276 XDELETEVEC (da_file_name
);
1277 da_file_name
= NULL
;
1280 #include "gt-coverage.h"