1 /* Read and write coverage files, and associated functionality.
2 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
3 2000, 2001, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
6 based on some ideas from Dain Samples of UC Berkeley.
7 Further mangling by Bob Manson, Cygnus Support.
8 Further mangled by Nathan Sidwell, CodeSourcery
10 This file is part of GCC.
12 GCC is free software; you can redistribute it and/or modify it under
13 the terms of the GNU General Public License as published by the Free
14 Software Foundation; either version 3, or (at your option) any later
17 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
18 WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
22 You should have received a copy of the GNU General Public License
23 along with GCC; see the file COPYING3. If not see
24 <http://www.gnu.org/licenses/>. */
31 #include "coretypes.h"
40 #include "basic-block.h"
45 #include "langhooks.h"
47 #include "tree-iterator.h"
49 #include "tree-pass.h"
50 #include "diagnostic-core.h"
52 #include "filenames.h"
58 struct GTY((chain_next ("%h.next"))) coverage_data
60 struct coverage_data
*next
; /* next function */
61 unsigned ident
; /* function ident */
62 unsigned lineno_checksum
; /* function lineno checksum */
63 unsigned cfg_checksum
; /* function cfg checksum */
64 tree fn_decl
; /* the function decl */
65 tree ctr_vars
[GCOV_COUNTERS
]; /* counter variables. */
68 /* Counts information for a function. */
69 typedef struct counts_entry
76 unsigned lineno_checksum
;
77 unsigned cfg_checksum
;
79 struct gcov_ctr_summary summary
;
82 static GTY(()) struct coverage_data
*functions_head
= 0;
83 static struct coverage_data
**functions_tail
= &functions_head
;
84 static unsigned no_coverage
= 0;
86 /* Cumulative counter information for whole program. */
87 static unsigned prg_ctr_mask
; /* Mask of counter types generated. */
89 /* Counter information for current function. */
90 static unsigned fn_ctr_mask
; /* Mask of counters used. */
91 static GTY(()) tree fn_v_ctrs
[GCOV_COUNTERS
]; /* counter variables. */
92 static unsigned fn_n_ctrs
[GCOV_COUNTERS
]; /* Counters allocated. */
93 static unsigned fn_b_ctrs
[GCOV_COUNTERS
]; /* Allocation base. */
95 /* Coverage info VAR_DECL and function info type nodes. */
96 static GTY(()) tree gcov_info_var
;
97 static GTY(()) tree gcov_fn_info_type
;
98 static GTY(()) tree gcov_fn_info_ptr_type
;
100 /* Name of the output file for coverage output file. If this is NULL
101 we're not writing to the notes file. */
102 static char *bbg_file_name
;
104 /* Name of the count data file. */
105 static char *da_file_name
;
107 /* Hash table of count data. */
108 static htab_t counts_hash
= NULL
;
110 /* The names of merge functions for counters. */
111 static const char *const ctr_merge_functions
[GCOV_COUNTERS
] = GCOV_MERGE_FUNCTIONS
;
112 static const char *const ctr_names
[GCOV_COUNTERS
] = GCOV_COUNTER_NAMES
;
114 /* Forward declarations. */
115 static hashval_t
htab_counts_entry_hash (const void *);
116 static int htab_counts_entry_eq (const void *, const void *);
117 static void htab_counts_entry_del (void *);
118 static void read_counts_file (void);
119 static tree
build_var (tree
, tree
, int);
120 static void build_fn_info_type (tree
, unsigned, tree
);
121 static void build_info_type (tree
, tree
);
122 static tree
build_fn_info (const struct coverage_data
*, tree
, tree
);
123 static tree
build_info (tree
, tree
);
124 static bool coverage_obj_init (void);
125 static VEC(constructor_elt
,gc
) *coverage_obj_fn
126 (VEC(constructor_elt
,gc
) *, tree
, struct coverage_data
const *);
127 static void coverage_obj_finish (VEC(constructor_elt
,gc
) *);
129 /* Return the type node for gcov_type. */
134 enum machine_mode mode
= smallest_mode_for_size (GCOV_TYPE_SIZE
, MODE_INT
);
135 return lang_hooks
.types
.type_for_mode (mode
, false);
138 /* Return the type node for gcov_unsigned_t. */
141 get_gcov_unsigned_t (void)
143 enum machine_mode mode
= smallest_mode_for_size (32, MODE_INT
);
144 return lang_hooks
.types
.type_for_mode (mode
, true);
148 htab_counts_entry_hash (const void *of
)
150 const counts_entry_t
*const entry
= (const counts_entry_t
*) of
;
152 return entry
->ident
* GCOV_COUNTERS
+ entry
->ctr
;
156 htab_counts_entry_eq (const void *of1
, const void *of2
)
158 const counts_entry_t
*const entry1
= (const counts_entry_t
*) of1
;
159 const counts_entry_t
*const entry2
= (const counts_entry_t
*) of2
;
161 return entry1
->ident
== entry2
->ident
&& entry1
->ctr
== entry2
->ctr
;
165 htab_counts_entry_del (void *of
)
167 counts_entry_t
*const entry
= (counts_entry_t
*) of
;
169 free (entry
->counts
);
173 /* Read in the counts file, if available. */
176 read_counts_file (void)
178 gcov_unsigned_t fn_ident
= 0;
179 struct gcov_summary summary
;
180 unsigned new_summary
= 1;
183 unsigned lineno_checksum
= 0;
184 unsigned cfg_checksum
= 0;
186 if (!gcov_open (da_file_name
, 1))
189 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
191 warning (0, "%qs is not a gcov data file", da_file_name
);
195 else if ((tag
= gcov_read_unsigned ()) != GCOV_VERSION
)
199 GCOV_UNSIGNED2STRING (v
, tag
);
200 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
202 warning (0, "%qs is version %q.*s, expected version %q.*s",
203 da_file_name
, 4, v
, 4, e
);
208 /* Read and discard the stamp. */
209 gcov_read_unsigned ();
211 counts_hash
= htab_create (10,
212 htab_counts_entry_hash
, htab_counts_entry_eq
,
213 htab_counts_entry_del
);
214 while ((tag
= gcov_read_unsigned ()))
216 gcov_unsigned_t length
;
217 gcov_position_t offset
;
219 length
= gcov_read_unsigned ();
220 offset
= gcov_position ();
221 if (tag
== GCOV_TAG_FUNCTION
)
225 fn_ident
= gcov_read_unsigned ();
226 lineno_checksum
= gcov_read_unsigned ();
227 cfg_checksum
= gcov_read_unsigned ();
230 fn_ident
= lineno_checksum
= cfg_checksum
= 0;
233 else if (tag
== GCOV_TAG_PROGRAM_SUMMARY
)
235 struct gcov_summary sum
;
239 memset (&summary
, 0, sizeof (summary
));
241 gcov_read_summary (&sum
);
242 for (ix
= 0; ix
!= GCOV_COUNTERS_SUMMABLE
; ix
++)
244 summary
.ctrs
[ix
].runs
+= sum
.ctrs
[ix
].runs
;
245 summary
.ctrs
[ix
].sum_all
+= sum
.ctrs
[ix
].sum_all
;
246 if (summary
.ctrs
[ix
].run_max
< sum
.ctrs
[ix
].run_max
)
247 summary
.ctrs
[ix
].run_max
= sum
.ctrs
[ix
].run_max
;
248 summary
.ctrs
[ix
].sum_max
+= sum
.ctrs
[ix
].sum_max
;
252 else if (GCOV_TAG_IS_COUNTER (tag
) && fn_ident
)
254 counts_entry_t
**slot
, *entry
, elt
;
255 unsigned n_counts
= GCOV_TAG_COUNTER_NUM (length
);
258 elt
.ident
= fn_ident
;
259 elt
.ctr
= GCOV_COUNTER_FOR_TAG (tag
);
261 slot
= (counts_entry_t
**) htab_find_slot
262 (counts_hash
, &elt
, INSERT
);
266 *slot
= entry
= XCNEW (counts_entry_t
);
267 entry
->ident
= fn_ident
;
268 entry
->ctr
= elt
.ctr
;
269 entry
->lineno_checksum
= lineno_checksum
;
270 entry
->cfg_checksum
= cfg_checksum
;
271 entry
->summary
= summary
.ctrs
[elt
.ctr
];
272 entry
->summary
.num
= n_counts
;
273 entry
->counts
= XCNEWVEC (gcov_type
, n_counts
);
275 else if (entry
->lineno_checksum
!= lineno_checksum
276 || entry
->cfg_checksum
!= cfg_checksum
)
278 error ("Profile data for function %u is corrupted", fn_ident
);
279 error ("checksum is (%x,%x) instead of (%x,%x)",
280 entry
->lineno_checksum
, entry
->cfg_checksum
,
281 lineno_checksum
, cfg_checksum
);
282 htab_delete (counts_hash
);
285 else if (entry
->summary
.num
!= n_counts
)
287 error ("Profile data for function %u is corrupted", fn_ident
);
288 error ("number of counters is %d instead of %d", entry
->summary
.num
, n_counts
);
289 htab_delete (counts_hash
);
292 else if (elt
.ctr
>= GCOV_COUNTERS_SUMMABLE
)
294 error ("cannot merge separate %s counters for function %u",
295 ctr_names
[elt
.ctr
], fn_ident
);
300 entry
->summary
.runs
+= summary
.ctrs
[elt
.ctr
].runs
;
301 entry
->summary
.sum_all
+= summary
.ctrs
[elt
.ctr
].sum_all
;
302 if (entry
->summary
.run_max
< summary
.ctrs
[elt
.ctr
].run_max
)
303 entry
->summary
.run_max
= summary
.ctrs
[elt
.ctr
].run_max
;
304 entry
->summary
.sum_max
+= summary
.ctrs
[elt
.ctr
].sum_max
;
306 for (ix
= 0; ix
!= n_counts
; ix
++)
307 entry
->counts
[ix
] += gcov_read_counter ();
310 gcov_sync (offset
, length
);
311 if ((is_error
= gcov_is_error ()))
313 error (is_error
< 0 ? "%qs has overflowed" : "%qs is corrupted",
315 htab_delete (counts_hash
);
323 /* Returns the counters for a particular tag. */
326 get_coverage_counts (unsigned counter
, unsigned expected
,
327 unsigned cfg_checksum
, unsigned lineno_checksum
,
328 const struct gcov_ctr_summary
**summary
)
330 counts_entry_t
*entry
, elt
;
332 /* No hash table, no counts. */
335 static int warned
= 0;
338 inform (input_location
, (flag_guess_branch_prob
339 ? "file %s not found, execution counts estimated"
340 : "file %s not found, execution counts assumed to be zero"),
345 elt
.ident
= current_function_funcdef_no
+ 1;
347 entry
= (counts_entry_t
*) htab_find (counts_hash
, &elt
);
348 if (!entry
|| !entry
->summary
.num
)
349 /* The function was not emitted, or is weak and not chosen in the
350 final executable. Silently fail, because there's nothing we
354 if (entry
->cfg_checksum
!= cfg_checksum
355 || entry
->summary
.num
!= expected
)
357 static int warned
= 0;
358 bool warning_printed
= false;
359 tree id
= DECL_ASSEMBLER_NAME (current_function_decl
);
362 warning_at (input_location
, OPT_Wcoverage_mismatch
,
363 "the control flow of function %qE does not match "
364 "its profile data (counter %qs)", id
, ctr_names
[counter
]);
367 inform (input_location
, "use -Wno-error=coverage-mismatch to tolerate "
368 "the mismatch but performance may drop if the function is hot");
373 inform (input_location
, "coverage mismatch ignored");
374 inform (input_location
, flag_guess_branch_prob
375 ? G_("execution counts estimated")
376 : G_("execution counts assumed to be zero"));
377 if (!flag_guess_branch_prob
)
378 inform (input_location
,
379 "this can result in poorly optimized code");
385 else if (entry
->lineno_checksum
!= lineno_checksum
)
387 warning (0, "source locations for function %qE have changed,"
388 " the profile data may be out of date",
389 DECL_ASSEMBLER_NAME (current_function_decl
));
393 *summary
= &entry
->summary
;
395 return entry
->counts
;
398 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
399 allocation succeeded. */
402 coverage_counter_alloc (unsigned counter
, unsigned num
)
410 if (!fn_v_ctrs
[counter
])
412 tree array_type
= build_array_type (get_gcov_type (), NULL_TREE
);
415 = build_var (current_function_decl
, array_type
, counter
);
418 fn_b_ctrs
[counter
] = fn_n_ctrs
[counter
];
419 fn_n_ctrs
[counter
] += num
;
421 fn_ctr_mask
|= 1 << counter
;
425 /* Generate a tree to access COUNTER NO. */
428 tree_coverage_counter_ref (unsigned counter
, unsigned no
)
430 tree gcov_type_node
= get_gcov_type ();
432 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
434 no
+= fn_b_ctrs
[counter
];
436 /* "no" here is an array index, scaled to bytes later. */
437 return build4 (ARRAY_REF
, gcov_type_node
, fn_v_ctrs
[counter
],
438 build_int_cst (integer_type_node
, no
), NULL
, NULL
);
441 /* Generate a tree to access the address of COUNTER NO. */
444 tree_coverage_counter_addr (unsigned counter
, unsigned no
)
446 tree gcov_type_node
= get_gcov_type ();
448 gcc_assert (no
< fn_n_ctrs
[counter
] - fn_b_ctrs
[counter
]);
449 no
+= fn_b_ctrs
[counter
];
451 /* "no" here is an array index, scaled to bytes later. */
452 return build_fold_addr_expr (build4 (ARRAY_REF
, gcov_type_node
,
454 build_int_cst (integer_type_node
, no
),
459 /* Generate a checksum for a string. CHKSUM is the current
463 coverage_checksum_string (unsigned chksum
, const char *string
)
468 /* Look for everything that looks if it were produced by
469 get_file_function_name and zero out the second part
470 that may result from flag_random_seed. This is not critical
471 as the checksums are used only for sanity checking. */
472 for (i
= 0; string
[i
]; i
++)
475 if (!strncmp (string
+ i
, "_GLOBAL__N_", 11))
477 if (!strncmp (string
+ i
, "_GLOBAL__", 9))
480 /* C++ namespaces do have scheme:
481 _GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
482 since filename might contain extra underscores there seems
483 to be no better chance then walk all possible offsets looking
487 for (i
= i
+ offset
; string
[i
]; i
++)
492 for (y
= 1; y
< 9; y
++)
493 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
494 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
496 if (y
!= 9 || string
[i
+ 9] != '_')
498 for (y
= 10; y
< 18; y
++)
499 if (!(string
[i
+ y
] >= '0' && string
[i
+ y
] <= '9')
500 && !(string
[i
+ y
] >= 'A' && string
[i
+ y
] <= 'F'))
505 string
= dup
= xstrdup (string
);
506 for (y
= 10; y
< 18; y
++)
513 chksum
= crc32_string (chksum
, string
);
519 /* Compute checksum for the current function. We generate a CRC32. */
522 coverage_compute_lineno_checksum (void)
524 expanded_location xloc
525 = expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
526 unsigned chksum
= xloc
.line
;
528 chksum
= coverage_checksum_string (chksum
, xloc
.file
);
529 chksum
= coverage_checksum_string
530 (chksum
, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl
)));
535 /* Compute cfg checksum for the current function.
536 The checksum is calculated carefully so that
537 source code changes that doesn't affect the control flow graph
538 won't change the checksum.
539 This is to make the profile data useable across source code change.
540 The downside of this is that the compiler may use potentially
541 wrong profile data - that the source code change has non-trivial impact
542 on the validity of profile data (e.g. the reversed condition)
543 but the compiler won't detect the change and use the wrong profile data. */
546 coverage_compute_cfg_checksum (void)
549 unsigned chksum
= n_basic_blocks
;
555 chksum
= crc32_byte (chksum
, bb
->index
);
556 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
558 chksum
= crc32_byte (chksum
, e
->dest
->index
);
565 /* Begin output to the graph file for the current function.
566 Writes the function header. Returns nonzero if data should be output. */
569 coverage_begin_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
571 expanded_location xloc
;
572 unsigned long offset
;
574 /* We don't need to output .gcno file unless we're under -ftest-coverage
575 (e.g. -fprofile-arcs/generate/use don't need .gcno to work). */
576 if (no_coverage
|| !bbg_file_name
)
579 xloc
= expand_location (DECL_SOURCE_LOCATION (current_function_decl
));
581 /* Announce function */
582 offset
= gcov_write_tag (GCOV_TAG_FUNCTION
);
583 gcov_write_unsigned (current_function_funcdef_no
+ 1);
584 gcov_write_unsigned (lineno_checksum
);
585 gcov_write_unsigned (cfg_checksum
);
586 gcov_write_string (IDENTIFIER_POINTER
587 (DECL_ASSEMBLER_NAME (current_function_decl
)));
588 gcov_write_string (xloc
.file
);
589 gcov_write_unsigned (xloc
.line
);
590 gcov_write_length (offset
);
592 return !gcov_is_error ();
595 /* Finish coverage data for the current function. Verify no output
596 error has occurred. Save function coverage counts. */
599 coverage_end_function (unsigned lineno_checksum
, unsigned cfg_checksum
)
603 if (bbg_file_name
&& gcov_is_error ())
605 warning (0, "error writing %qs", bbg_file_name
);
606 unlink (bbg_file_name
);
607 bbg_file_name
= NULL
;
612 struct coverage_data
*item
= 0;
614 /* If the function is extern (i.e. extern inline), then we won't
615 be outputting it, so don't chain it onto the function
617 if (!DECL_EXTERNAL (current_function_decl
))
619 item
= ggc_alloc_coverage_data ();
621 item
->ident
= current_function_funcdef_no
+ 1;
622 item
->lineno_checksum
= lineno_checksum
;
623 item
->cfg_checksum
= cfg_checksum
;
625 item
->fn_decl
= current_function_decl
;
627 *functions_tail
= item
;
628 functions_tail
= &item
->next
;
631 for (i
= 0; i
!= GCOV_COUNTERS
; i
++)
633 tree var
= fn_v_ctrs
[i
];
636 item
->ctr_vars
[i
] = var
;
639 tree array_type
= build_index_type (size_int (fn_n_ctrs
[i
] - 1));
640 array_type
= build_array_type (get_gcov_type (), array_type
);
641 TREE_TYPE (var
) = array_type
;
642 DECL_SIZE (var
) = TYPE_SIZE (array_type
);
643 DECL_SIZE_UNIT (var
) = TYPE_SIZE_UNIT (array_type
);
644 varpool_finalize_decl (var
);
647 fn_b_ctrs
[i
] = fn_n_ctrs
[i
] = 0;
648 fn_v_ctrs
[i
] = NULL_TREE
;
650 prg_ctr_mask
|= fn_ctr_mask
;
655 /* Build a coverage variable of TYPE for function FN_DECL. If COUNTER
656 >= 0 it is a counter array, otherwise it is the function structure. */
659 build_var (tree fn_decl
, tree type
, int counter
)
661 tree var
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
, type
);
662 const char *fn_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn_decl
));
664 size_t fn_name_len
, len
;
666 fn_name
= targetm
.strip_name_encoding (fn_name
);
667 fn_name_len
= strlen (fn_name
);
668 buf
= XALLOCAVEC (char, fn_name_len
+ 8 + sizeof (int) * 3);
671 strcpy (buf
, "__gcov__");
673 sprintf (buf
, "__gcov%u_", counter
);
675 #ifndef NO_DOT_IN_LABEL
677 #elif !defined NO_DOLLAR_IN_LABEL
680 memcpy (buf
+ len
, fn_name
, fn_name_len
+ 1);
681 DECL_NAME (var
) = get_identifier (buf
);
682 TREE_STATIC (var
) = 1;
683 TREE_ADDRESSABLE (var
) = 1;
684 DECL_ALIGN (var
) = TYPE_ALIGN (type
);
689 /* Creates the gcov_fn_info RECORD_TYPE. */
692 build_fn_info_type (tree type
, unsigned counters
, tree gcov_info_type
)
694 tree ctr_info
= lang_hooks
.types
.make_type (RECORD_TYPE
);
698 gcc_assert (counters
);
701 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
702 get_gcov_unsigned_t ());
705 /* ctr_info::values */
706 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
707 build_pointer_type (get_gcov_type ()));
708 DECL_CHAIN (field
) = fields
;
711 finish_builtin_struct (ctr_info
, "__gcov_ctr_info", fields
, NULL_TREE
);
714 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
715 build_pointer_type (build_qualified_type
716 (gcov_info_type
, TYPE_QUAL_CONST
)));
720 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
721 get_gcov_unsigned_t ());
722 DECL_CHAIN (field
) = fields
;
725 /* lineno_checksum */
726 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
727 get_gcov_unsigned_t ());
728 DECL_CHAIN (field
) = fields
;
732 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
733 get_gcov_unsigned_t ());
734 DECL_CHAIN (field
) = fields
;
737 array_type
= build_index_type (size_int (counters
- 1));
738 array_type
= build_array_type (ctr_info
, array_type
);
741 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
, array_type
);
742 DECL_CHAIN (field
) = fields
;
745 finish_builtin_struct (type
, "__gcov_fn_info", fields
, NULL_TREE
);
748 /* Returns a CONSTRUCTOR for a gcov_fn_info. DATA is
749 the coverage data for the function and TYPE is the gcov_fn_info
750 RECORD_TYPE. KEY is the object file key. */
753 build_fn_info (const struct coverage_data
*data
, tree type
, tree key
)
755 tree fields
= TYPE_FIELDS (type
);
758 VEC(constructor_elt
,gc
) *v1
= NULL
;
759 VEC(constructor_elt
,gc
) *v2
= NULL
;
762 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
763 build1 (ADDR_EXPR
, TREE_TYPE (fields
), key
));
764 fields
= DECL_CHAIN (fields
);
767 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
768 build_int_cstu (get_gcov_unsigned_t (),
770 fields
= DECL_CHAIN (fields
);
772 /* lineno_checksum */
773 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
774 build_int_cstu (get_gcov_unsigned_t (),
775 data
->lineno_checksum
));
776 fields
= DECL_CHAIN (fields
);
779 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
780 build_int_cstu (get_gcov_unsigned_t (),
781 data
->cfg_checksum
));
782 fields
= DECL_CHAIN (fields
);
785 ctr_type
= TREE_TYPE (TREE_TYPE (fields
));
786 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
787 if (prg_ctr_mask
& (1 << ix
))
789 VEC(constructor_elt
,gc
) *ctr
= NULL
;
790 tree var
= data
->ctr_vars
[ix
];
795 = tree_low_cst (TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (var
))), 0)
798 CONSTRUCTOR_APPEND_ELT (ctr
, TYPE_FIELDS (ctr_type
),
799 build_int_cstu (get_gcov_unsigned_t (),
803 CONSTRUCTOR_APPEND_ELT (ctr
, DECL_CHAIN (TYPE_FIELDS (ctr_type
)),
804 build_fold_addr_expr (var
));
806 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, build_constructor (ctr_type
, ctr
));
809 CONSTRUCTOR_APPEND_ELT (v1
, fields
,
810 build_constructor (TREE_TYPE (fields
), v2
));
812 return build_constructor (type
, v1
);
815 /* Create gcov_info struct. TYPE is the incomplete RECORD_TYPE to be
816 completed, and FN_INFO_PTR_TYPE is a pointer to the function info type. */
819 build_info_type (tree type
, tree fn_info_ptr_type
)
821 tree field
, fields
= NULL_TREE
;
825 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
826 get_gcov_unsigned_t ());
827 DECL_CHAIN (field
) = fields
;
831 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
832 build_pointer_type (build_qualified_type
833 (type
, TYPE_QUAL_CONST
)));
834 DECL_CHAIN (field
) = fields
;
838 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
839 get_gcov_unsigned_t ());
840 DECL_CHAIN (field
) = fields
;
844 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
845 build_pointer_type (build_qualified_type
846 (char_type_node
, TYPE_QUAL_CONST
)));
847 DECL_CHAIN (field
) = fields
;
852 = build_function_type_list (void_type_node
,
853 build_pointer_type (get_gcov_type ()),
854 get_gcov_unsigned_t (), NULL_TREE
);
856 = build_array_type (build_pointer_type (merge_fn_type
),
857 build_index_type (size_int (GCOV_COUNTERS
- 1)));
858 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
860 DECL_CHAIN (field
) = fields
;
864 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
865 get_gcov_unsigned_t ());
866 DECL_CHAIN (field
) = fields
;
869 /* function_info pointer pointer */
870 fn_info_ptr_type
= build_pointer_type
871 (build_qualified_type (fn_info_ptr_type
, TYPE_QUAL_CONST
));
872 field
= build_decl (BUILTINS_LOCATION
, FIELD_DECL
, NULL_TREE
,
874 DECL_CHAIN (field
) = fields
;
877 finish_builtin_struct (type
, "__gcov_info", fields
, NULL_TREE
);
880 /* Returns a CONSTRUCTOR for the gcov_info object. INFO_TYPE is the
881 gcov_info structure type, FN_ARY is the array of pointers to
882 function info objects. */
885 build_info (tree info_type
, tree fn_ary
)
887 tree info_fields
= TYPE_FIELDS (info_type
);
888 tree merge_fn_type
, n_funcs
;
890 tree filename_string
;
891 int da_file_name_len
;
892 VEC(constructor_elt
,gc
) *v1
= NULL
;
893 VEC(constructor_elt
,gc
) *v2
= NULL
;
896 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
897 build_int_cstu (TREE_TYPE (info_fields
),
899 info_fields
= DECL_CHAIN (info_fields
);
902 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, null_pointer_node
);
903 info_fields
= DECL_CHAIN (info_fields
);
906 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
907 build_int_cstu (TREE_TYPE (info_fields
),
909 info_fields
= DECL_CHAIN (info_fields
);
912 da_file_name_len
= strlen (da_file_name
);
913 filename_string
= build_string (da_file_name_len
+ 1, da_file_name
);
914 TREE_TYPE (filename_string
) = build_array_type
915 (char_type_node
, build_index_type (size_int (da_file_name_len
)));
916 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
917 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
),
919 info_fields
= DECL_CHAIN (info_fields
);
921 /* merge fn array -- NULL slots indicate unmeasured counters */
922 merge_fn_type
= TREE_TYPE (TREE_TYPE (info_fields
));
923 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
925 tree ptr
= null_pointer_node
;
927 if ((1u << ix
) & prg_ctr_mask
)
929 tree merge_fn
= build_decl (BUILTINS_LOCATION
,
931 get_identifier (ctr_merge_functions
[ix
]),
932 TREE_TYPE (merge_fn_type
));
933 DECL_EXTERNAL (merge_fn
) = 1;
934 TREE_PUBLIC (merge_fn
) = 1;
935 DECL_ARTIFICIAL (merge_fn
) = 1;
936 TREE_NOTHROW (merge_fn
) = 1;
937 /* Initialize assembler name so we can stream out. */
938 DECL_ASSEMBLER_NAME (merge_fn
);
939 ptr
= build1 (ADDR_EXPR
, merge_fn_type
, merge_fn
);
941 CONSTRUCTOR_APPEND_ELT (v2
, NULL
, ptr
);
943 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
944 build_constructor (TREE_TYPE (info_fields
), v2
));
945 info_fields
= DECL_CHAIN (info_fields
);
948 n_funcs
= TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (fn_ary
)));
949 n_funcs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (info_fields
),
950 n_funcs
, size_one_node
);
951 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
, n_funcs
);
952 info_fields
= DECL_CHAIN (info_fields
);
955 CONSTRUCTOR_APPEND_ELT (v1
, info_fields
,
956 build1 (ADDR_EXPR
, TREE_TYPE (info_fields
), fn_ary
));
957 info_fields
= DECL_CHAIN (info_fields
);
959 gcc_assert (!info_fields
);
960 return build_constructor (info_type
, v1
);
963 /* Create the gcov_info types and object. Generate the constructor
964 function to call __gcov_init. Does not generate the initializer
965 for the object. Returns TRUE if coverage data is being emitted. */
968 coverage_obj_init (void)
970 tree gcov_info_type
, ctor
, stmt
, init_fn
;
971 unsigned n_counters
= 0;
973 struct coverage_data
*fn
;
974 struct coverage_data
**fn_prev
;
977 no_coverage
= 1; /* Disable any further coverage. */
982 if (cgraph_dump_file
)
983 fprintf (cgraph_dump_file
, "Using data file %s\n", da_file_name
);
985 /* Prune functions. */
986 for (fn_prev
= &functions_head
; (fn
= *fn_prev
);)
987 if (DECL_STRUCT_FUNCTION (fn
->fn_decl
))
990 /* The function is not being emitted, remove from list. */
993 for (ix
= 0; ix
!= GCOV_COUNTERS
; ix
++)
994 if ((1u << ix
) & prg_ctr_mask
)
997 /* Build the info and fn_info types. These are mutually recursive. */
998 gcov_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
999 gcov_fn_info_type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
1000 gcov_fn_info_ptr_type
= build_pointer_type
1001 (build_qualified_type (gcov_fn_info_type
, TYPE_QUAL_CONST
));
1002 build_fn_info_type (gcov_fn_info_type
, n_counters
, gcov_info_type
);
1003 build_info_type (gcov_info_type
, gcov_fn_info_ptr_type
);
1005 /* Build the gcov info var, this is referred to in its own
1007 gcov_info_var
= build_decl (BUILTINS_LOCATION
,
1008 VAR_DECL
, NULL_TREE
, gcov_info_type
);
1009 TREE_STATIC (gcov_info_var
) = 1;
1010 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 0);
1011 DECL_NAME (gcov_info_var
) = get_identifier (name_buf
);
1013 /* Build a decl for __gcov_init. */
1014 init_fn
= build_pointer_type (gcov_info_type
);
1015 init_fn
= build_function_type_list (void_type_node
, init_fn
, NULL
);
1016 init_fn
= build_decl (BUILTINS_LOCATION
, FUNCTION_DECL
,
1017 get_identifier ("__gcov_init"), init_fn
);
1018 TREE_PUBLIC (init_fn
) = 1;
1019 DECL_EXTERNAL (init_fn
) = 1;
1020 DECL_ASSEMBLER_NAME (init_fn
);
1022 /* Generate a call to __gcov_init(&gcov_info). */
1024 stmt
= build_fold_addr_expr (gcov_info_var
);
1025 stmt
= build_call_expr (init_fn
, 1, stmt
);
1026 append_to_statement_list (stmt
, &ctor
);
1028 /* Generate a constructor to run it. */
1029 cgraph_build_static_cdtor ('I', ctor
, DEFAULT_INIT_PRIORITY
);
1034 /* Generate the coverage function info for FN and DATA. Append a
1035 pointer to that object to CTOR and return the appended CTOR. */
1037 static VEC(constructor_elt
,gc
) *
1038 coverage_obj_fn (VEC(constructor_elt
,gc
) *ctor
, tree fn
,
1039 struct coverage_data
const *data
)
1041 tree init
= build_fn_info (data
, gcov_fn_info_type
, gcov_info_var
);
1042 tree var
= build_var (fn
, gcov_fn_info_type
, -1);
1044 DECL_INITIAL (var
) = init
;
1045 varpool_finalize_decl (var
);
1047 CONSTRUCTOR_APPEND_ELT (ctor
, NULL
,
1048 build1 (ADDR_EXPR
, gcov_fn_info_ptr_type
, var
));
1052 /* Finalize the coverage data. Generates the array of pointers to
1053 function objects from CTOR. Generate the gcov_info initializer. */
1056 coverage_obj_finish (VEC(constructor_elt
,gc
) *ctor
)
1058 unsigned n_functions
= VEC_length(constructor_elt
, ctor
);
1059 tree fn_info_ary_type
= build_array_type
1060 (build_qualified_type (gcov_fn_info_ptr_type
, TYPE_QUAL_CONST
),
1061 build_index_type (size_int (n_functions
- 1)));
1062 tree fn_info_ary
= build_decl (BUILTINS_LOCATION
, VAR_DECL
, NULL_TREE
,
1066 TREE_STATIC (fn_info_ary
) = 1;
1067 ASM_GENERATE_INTERNAL_LABEL (name_buf
, "LPBX", 1);
1068 DECL_NAME (fn_info_ary
) = get_identifier (name_buf
);
1069 DECL_INITIAL (fn_info_ary
) = build_constructor (fn_info_ary_type
, ctor
);
1070 varpool_finalize_decl (fn_info_ary
);
1072 DECL_INITIAL (gcov_info_var
)
1073 = build_info (TREE_TYPE (gcov_info_var
), fn_info_ary
);
1074 varpool_finalize_decl (gcov_info_var
);
1077 /* Perform file-level initialization. Read in data file, generate name
1081 coverage_init (const char *filename
)
1083 int len
= strlen (filename
);
1086 if (!profile_data_prefix
&& !IS_ABSOLUTE_PATH (filename
))
1087 profile_data_prefix
= getpwd ();
1089 if (profile_data_prefix
)
1090 prefix_len
= strlen (profile_data_prefix
);
1092 /* Name of da file. */
1093 da_file_name
= XNEWVEC (char, len
+ strlen (GCOV_DATA_SUFFIX
)
1096 if (profile_data_prefix
)
1098 memcpy (da_file_name
, profile_data_prefix
, prefix_len
);
1099 da_file_name
[prefix_len
++] = '/';
1101 memcpy (da_file_name
+ prefix_len
, filename
, len
);
1102 strcpy (da_file_name
+ prefix_len
+ len
, GCOV_DATA_SUFFIX
);
1104 /* Name of bbg file. */
1105 if (flag_test_coverage
&& !flag_compare_debug
)
1107 bbg_file_name
= XNEWVEC (char, len
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1108 memcpy (bbg_file_name
, filename
, len
);
1109 strcpy (bbg_file_name
+ len
, GCOV_NOTE_SUFFIX
);
1111 if (!gcov_open (bbg_file_name
, -1))
1113 error ("cannot open %s", bbg_file_name
);
1114 bbg_file_name
= NULL
;
1118 gcov_write_unsigned (GCOV_NOTE_MAGIC
);
1119 gcov_write_unsigned (GCOV_VERSION
);
1120 gcov_write_unsigned (local_tick
);
1124 if (flag_branch_probabilities
)
1125 read_counts_file ();
1128 /* Performs file-level cleanup. Close graph file, generate coverage
1129 variables and constructor. */
1132 coverage_finish (void)
1134 if (bbg_file_name
&& gcov_close ())
1135 unlink (bbg_file_name
);
1137 if (!local_tick
|| local_tick
== (unsigned)-1)
1138 /* Only remove the da file, if we cannot stamp it. If we can
1139 stamp it, libgcov will DTRT. */
1140 unlink (da_file_name
);
1142 if (coverage_obj_init ())
1144 VEC(constructor_elt
,gc
) *fn_ctor
= NULL
;
1145 struct coverage_data
*fn
;
1147 for (fn
= functions_head
; fn
; fn
= fn
->next
)
1148 fn_ctor
= coverage_obj_fn (fn_ctor
, fn
->fn_decl
, fn
);
1149 coverage_obj_finish (fn_ctor
);
1153 #include "gt-coverage.h"