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 Free Software Foundation, Inc.
4 Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
5 based on some ideas from Dain Samples of UC Berkeley.
6 Further mangling by Bob Manson, Cygnus Support.
7 Further mangled by Nathan Sidwell, CodeSourcery
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 2, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING. If not, write to the Free
23 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
31 #include "coretypes.h"
43 #include "langhooks.h"
45 #include "tree-iterator.h"
52 struct function_list *next; /* next function */
53 unsigned ident; /* function ident */
54 unsigned checksum; /* function checksum */
55 unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */
58 /* Counts information for a function. */
59 typedef struct counts_entry
68 struct gcov_ctr_summary summary;
71 struct counts_entry *chain;
75 static struct function_list *functions_head = 0;
76 static struct function_list **functions_tail = &functions_head;
77 static unsigned no_coverage = 0;
79 /* Cumulative counter information for whole program. */
80 static unsigned prg_ctr_mask; /* Mask of counter types generated. */
81 static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */
83 /* Counter information for current function. */
84 static unsigned fn_ctr_mask; /* Mask of counters used. */
85 static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
86 static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
88 /* Name of the output file for coverage output file. */
89 static char *bbg_file_name;
90 static unsigned bbg_file_opened;
91 static int bbg_function_announced;
93 /* Name of the count data file. */
94 static char *da_file_name;
96 /* Hash table of count data. */
97 static htab_t counts_hash = NULL;
99 /* Trees representing the counter table arrays. */
100 static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
102 /* The names of the counter tables. Not used if we're
103 generating counters at tree level. */
104 static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
106 /* The names of merge functions for counters. */
107 static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
108 static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
110 /* Forward declarations. */
111 static hashval_t htab_counts_entry_hash (const void *);
112 static int htab_counts_entry_eq (const void *, const void *);
113 static void htab_counts_entry_del (void *);
114 static void read_counts_file (void);
115 static unsigned compute_checksum (void);
116 static unsigned coverage_checksum_string (unsigned, const char *);
117 static tree build_fn_info_type (unsigned);
118 static tree build_fn_info_value (const struct function_list *, tree);
119 static tree build_ctr_info_type (void);
120 static tree build_ctr_info_value (unsigned, tree);
121 static tree build_gcov_info (void);
122 static void create_coverage (void);
124 /* Return the type node for gcov_type. */
129 return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
132 /* Return the type node for gcov_unsigned_t. */
135 get_gcov_unsigned_t (void)
137 return lang_hooks.types.type_for_size (32, true);
141 htab_counts_entry_hash (const void *of)
143 const counts_entry_t *entry = of;
145 return entry->ident * GCOV_COUNTERS + entry->ctr;
149 htab_counts_entry_eq (const void *of1, const void *of2)
151 const counts_entry_t *entry1 = of1;
152 const counts_entry_t *entry2 = of2;
154 return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
158 htab_counts_entry_del (void *of)
160 counts_entry_t *entry = of;
162 free (entry->counts);
166 /* Read in the counts file, if available. */
169 read_counts_file (void)
171 gcov_unsigned_t fn_ident = 0;
172 gcov_unsigned_t checksum = -1;
173 counts_entry_t *summaried = NULL;
174 unsigned seen_summary = 0;
178 if (!gcov_open (da_file_name, 1))
181 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
183 warning (0, "%qs is not a gcov data file", da_file_name);
187 else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
191 GCOV_UNSIGNED2STRING (v, tag);
192 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
194 warning (0, "%qs is version %q.*s, expected version %q.*s",
195 da_file_name, 4, v, 4, e);
200 /* Read and discard the stamp. */
201 gcov_read_unsigned ();
203 counts_hash = htab_create (10,
204 htab_counts_entry_hash, htab_counts_entry_eq,
205 htab_counts_entry_del);
206 while ((tag = gcov_read_unsigned ()))
208 gcov_unsigned_t length;
209 gcov_position_t offset;
211 length = gcov_read_unsigned ();
212 offset = gcov_position ();
213 if (tag == GCOV_TAG_FUNCTION)
215 fn_ident = gcov_read_unsigned ();
216 checksum = gcov_read_unsigned ();
219 /* We have already seen a summary, this means that this
220 new function begins a new set of program runs. We
221 must unlink the summaried chain. */
222 counts_entry_t *entry, *chain;
224 for (entry = summaried; entry; entry = chain)
226 chain = entry->chain;
233 else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
235 counts_entry_t *entry;
236 struct gcov_summary summary;
238 gcov_read_summary (&summary);
240 for (entry = summaried; entry; entry = entry->chain)
242 struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
244 entry->summary.runs += csum->runs;
245 entry->summary.sum_all += csum->sum_all;
246 if (entry->summary.run_max < csum->run_max)
247 entry->summary.run_max = csum->run_max;
248 entry->summary.sum_max += csum->sum_max;
251 else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
253 counts_entry_t **slot, *entry, elt;
254 unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
257 elt.ident = fn_ident;
258 elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
260 slot = (counts_entry_t **) htab_find_slot
261 (counts_hash, &elt, INSERT);
265 *slot = entry = XCNEW (counts_entry_t);
266 entry->ident = elt.ident;
267 entry->ctr = elt.ctr;
268 entry->checksum = checksum;
269 entry->summary.num = n_counts;
270 entry->counts = XCNEWVEC (gcov_type, n_counts);
272 else if (entry->checksum != checksum)
274 error ("coverage mismatch for function %u while reading execution counters",
276 error ("checksum is %x instead of %x", entry->checksum, checksum);
277 htab_delete (counts_hash);
280 else if (entry->summary.num != n_counts)
282 error ("coverage mismatch for function %u while reading execution counters",
284 error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
285 htab_delete (counts_hash);
288 else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
290 error ("cannot merge separate %s counters for function %u",
291 ctr_names[elt.ctr], fn_ident);
295 if (elt.ctr < GCOV_COUNTERS_SUMMABLE
296 /* This should always be true for a just allocated entry,
297 and always false for an existing one. Check this way, in
298 case the gcov file is corrupt. */
299 && (!entry->chain || summaried != entry))
301 entry->chain = summaried;
304 for (ix = 0; ix != n_counts; ix++)
305 entry->counts[ix] += gcov_read_counter ();
308 gcov_sync (offset, length);
309 if ((is_error = gcov_is_error ()))
311 error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
313 htab_delete (counts_hash);
321 /* Returns the counters for a particular tag. */
324 get_coverage_counts (unsigned counter, unsigned expected,
325 const struct gcov_ctr_summary **summary)
327 counts_entry_t *entry, elt;
328 gcov_unsigned_t checksum = -1;
330 /* No hash table, no counts. */
333 static int warned = 0;
336 inform ((flag_guess_branch_prob
337 ? "file %s not found, execution counts estimated"
338 : "file %s not found, execution counts assumed to be zero"),
343 elt.ident = current_function_funcdef_no + 1;
345 entry = htab_find (counts_hash, &elt);
348 warning (0, "no coverage for function %qs found", IDENTIFIER_POINTER
349 (DECL_ASSEMBLER_NAME (current_function_decl)));
353 checksum = compute_checksum ();
354 if (entry->checksum != checksum)
356 error ("coverage mismatch for function %qs while reading counter %qs",
357 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
359 error ("checksum is %x instead of %x", entry->checksum, checksum);
362 else if (entry->summary.num != expected)
364 error ("coverage mismatch for function %qs while reading counter %qs",
365 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
367 error ("number of counters is %d instead of %d", entry->summary.num, expected);
372 *summary = &entry->summary;
374 return entry->counts;
377 /* Allocate NUM counters of type COUNTER. Returns nonzero if the
378 allocation succeeded. */
381 coverage_counter_alloc (unsigned counter, unsigned num)
389 if (!tree_ctr_tables[counter])
391 /* Generate and save a copy of this so it can be shared. Leave
392 the index type unspecified for now; it will be set after all
393 functions have been compiled. */
395 tree gcov_type_node = get_gcov_type ();
396 tree gcov_type_array_type
397 = build_array_type (gcov_type_node, NULL_TREE);
398 tree_ctr_tables[counter]
399 = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
400 TREE_STATIC (tree_ctr_tables[counter]) = 1;
401 ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
402 DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
403 DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
405 fn_b_ctrs[counter] = fn_n_ctrs[counter];
406 fn_n_ctrs[counter] += num;
407 fn_ctr_mask |= 1 << counter;
411 /* Generate a tree to access COUNTER NO. */
414 tree_coverage_counter_ref (unsigned counter, unsigned no)
416 tree gcov_type_node = get_gcov_type ();
418 gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
419 no += prg_n_ctrs[counter] + fn_b_ctrs[counter];
421 /* "no" here is an array index, scaled to bytes later. */
422 return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
423 build_int_cst (NULL_TREE, no), NULL, NULL);
426 /* Generate a checksum for a string. CHKSUM is the current
430 coverage_checksum_string (unsigned chksum, const char *string)
435 /* Look for everything that looks if it were produced by
436 get_file_function_name and zero out the second part
437 that may result from flag_random_seed. This is not critical
438 as the checksums are used only for sanity checking. */
439 #define GLOBAL_PREFIX "_GLOBAL__"
440 #define TRAILING_N "N_"
441 #define ISCAPXDIGIT(a) (((a) >= '0' && (a) <= '9') || ((a) >= 'A' && (a) <= 'F'))
442 if ((ptr = strstr (string, GLOBAL_PREFIX)))
444 /* Skip _GLOBAL__. */
445 ptr += strlen (GLOBAL_PREFIX);
447 /* Skip optional N_ (in case __GLOBAL_N__). */
448 if (!strncmp (ptr, TRAILING_N, strlen (TRAILING_N)))
449 ptr += strlen (TRAILING_N);
450 /* At this point, ptr should point after "_GLOBAL__N_" or "_GLOBAL__". */
452 while ((ptr = strchr (ptr, '_')) != NULL)
455 /* For every "_" in the rest of the string,
456 try the follwing pattern matching */
461 /* Try matching the pattern:
462 <8-digit hex>_<8-digit hex>
463 The second number is randomly generated
464 so we want to mask it out before computing the checksum. */
465 for (y = 0; *ptr != 0 && y < NDIGITS; y++, ptr++)
466 if (!ISCAPXDIGIT (*ptr))
468 if (y != NDIGITS || *ptr != '_')
470 /* Skip over '_' again. */
472 for (y = 0; *ptr != 0 && y < NDIGITS; y++, ptr++)
473 if (!ISCAPXDIGIT (*ptr))
479 Duplicate the string and mask out
480 the second 8-digit number. */
481 dup = xstrdup (string);
482 ptr = dup + (ptr - string);
483 for(y = -NDIGITS - 1 ; y < 0; y++)
491 /* "ptr" should be NULL if we couldn't find the match
492 (strchr will return NULL if no match is found),
493 or it should point to dup which contains the string
494 with the random part masked. */
497 chksum = crc32_string (chksum, (ptr) ? ptr : string);
505 /* Compute checksum for the current function. We generate a CRC32. */
508 compute_checksum (void)
510 expanded_location xloc
511 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
512 unsigned chksum = xloc.line;
514 chksum = coverage_checksum_string (chksum, xloc.file);
515 chksum = coverage_checksum_string
516 (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
521 /* Begin output to the graph file for the current function.
522 Opens the output file, if not already done. Writes the
523 function header, if not already done. Returns nonzero if data
527 coverage_begin_output (void)
532 if (!bbg_function_announced)
534 expanded_location xloc
535 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
536 unsigned long offset;
538 if (!bbg_file_opened)
540 if (!gcov_open (bbg_file_name, -1))
541 error ("cannot open %s", bbg_file_name);
544 gcov_write_unsigned (GCOV_NOTE_MAGIC);
545 gcov_write_unsigned (GCOV_VERSION);
546 gcov_write_unsigned (local_tick);
551 /* Announce function */
552 offset = gcov_write_tag (GCOV_TAG_FUNCTION);
553 gcov_write_unsigned (current_function_funcdef_no + 1);
554 gcov_write_unsigned (compute_checksum ());
555 gcov_write_string (IDENTIFIER_POINTER
556 (DECL_ASSEMBLER_NAME (current_function_decl)));
557 gcov_write_string (xloc.file);
558 gcov_write_unsigned (xloc.line);
559 gcov_write_length (offset);
561 bbg_function_announced = 1;
563 return !gcov_is_error ();
566 /* Finish coverage data for the current function. Verify no output
567 error has occurred. Save function coverage counts. */
570 coverage_end_function (void)
574 if (bbg_file_opened > 1 && gcov_is_error ())
576 warning (0, "error writing %qs", bbg_file_name);
577 bbg_file_opened = -1;
582 struct function_list *item;
584 item = XNEW (struct function_list);
586 *functions_tail = item;
587 functions_tail = &item->next;
590 item->ident = current_function_funcdef_no + 1;
591 item->checksum = compute_checksum ();
592 for (i = 0; i != GCOV_COUNTERS; i++)
594 item->n_ctrs[i] = fn_n_ctrs[i];
595 prg_n_ctrs[i] += fn_n_ctrs[i];
596 fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
598 prg_ctr_mask |= fn_ctr_mask;
601 bbg_function_announced = 0;
604 /* Creates the gcov_fn_info RECORD_TYPE. */
607 build_fn_info_type (unsigned int counters)
609 tree type = lang_hooks.types.make_type (RECORD_TYPE);
614 fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
617 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
618 TREE_CHAIN (field) = fields;
621 array_type = build_int_cst (NULL_TREE, counters - 1);
622 array_type = build_index_type (array_type);
623 array_type = build_array_type (get_gcov_unsigned_t (), array_type);
626 field = build_decl (FIELD_DECL, NULL_TREE, array_type);
627 TREE_CHAIN (field) = fields;
630 finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
635 /* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
636 the function being processed and TYPE is the gcov_fn_info
640 build_fn_info_value (const struct function_list *function, tree type)
642 tree value = NULL_TREE;
643 tree fields = TYPE_FIELDS (type);
645 tree array_value = NULL_TREE;
648 value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
649 function->ident), value);
650 fields = TREE_CHAIN (fields);
653 value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
654 function->checksum), value);
655 fields = TREE_CHAIN (fields);
658 for (ix = 0; ix != GCOV_COUNTERS; ix++)
659 if (prg_ctr_mask & (1 << ix))
661 tree counters = build_int_cstu (get_gcov_unsigned_t (),
662 function->n_ctrs[ix]);
664 array_value = tree_cons (NULL_TREE, counters, array_value);
667 /* FIXME: use build_constructor directly. */
668 array_value = build_constructor_from_list (TREE_TYPE (fields),
669 nreverse (array_value));
670 value = tree_cons (fields, array_value, value);
672 /* FIXME: use build_constructor directly. */
673 value = build_constructor_from_list (type, nreverse (value));
678 /* Creates the gcov_ctr_info RECORD_TYPE. */
681 build_ctr_info_type (void)
683 tree type = lang_hooks.types.make_type (RECORD_TYPE);
684 tree field, fields = NULL_TREE;
685 tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
686 tree gcov_merge_fn_type;
689 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
690 TREE_CHAIN (field) = fields;
694 field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
695 TREE_CHAIN (field) = fields;
700 build_function_type_list (void_type_node,
701 gcov_ptr_type, get_gcov_unsigned_t (),
703 field = build_decl (FIELD_DECL, NULL_TREE,
704 build_pointer_type (gcov_merge_fn_type));
705 TREE_CHAIN (field) = fields;
708 finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
713 /* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
714 the counter being processed and TYPE is the gcov_ctr_info
718 build_ctr_info_value (unsigned int counter, tree type)
720 tree value = NULL_TREE;
721 tree fields = TYPE_FIELDS (type);
725 value = tree_cons (fields,
726 build_int_cstu (get_gcov_unsigned_t (),
727 prg_n_ctrs[counter]),
729 fields = TREE_CHAIN (fields);
731 if (prg_n_ctrs[counter])
735 array_type = build_int_cstu (get_gcov_unsigned_t (),
736 prg_n_ctrs[counter] - 1);
737 array_type = build_index_type (array_type);
738 array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
741 TREE_TYPE (tree_ctr_tables[counter]) = array_type;
742 DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
743 DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
744 assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
746 value = tree_cons (fields,
747 build1 (ADDR_EXPR, TREE_TYPE (fields),
748 tree_ctr_tables[counter]),
752 value = tree_cons (fields, null_pointer_node, value);
753 fields = TREE_CHAIN (fields);
755 fn = build_decl (FUNCTION_DECL,
756 get_identifier (ctr_merge_functions[counter]),
757 TREE_TYPE (TREE_TYPE (fields)));
758 DECL_EXTERNAL (fn) = 1;
759 TREE_PUBLIC (fn) = 1;
760 DECL_ARTIFICIAL (fn) = 1;
761 TREE_NOTHROW (fn) = 1;
762 value = tree_cons (fields,
763 build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
766 /* FIXME: use build_constructor directly. */
767 value = build_constructor_from_list (type, nreverse (value));
772 /* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
776 build_gcov_info (void)
778 unsigned n_ctr_types, ix;
779 tree type, const_type;
780 tree fn_info_type, fn_info_value = NULL_TREE;
781 tree fn_info_ptr_type;
782 tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
783 tree field, fields = NULL_TREE;
784 tree value = NULL_TREE;
785 tree filename_string;
789 const struct function_list *fn;
792 /* Count the number of active counters. */
793 for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
794 if (prg_ctr_mask & (1 << ix))
797 type = lang_hooks.types.make_type (RECORD_TYPE);
798 const_type = build_qualified_type (type, TYPE_QUAL_CONST);
801 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
802 TREE_CHAIN (field) = fields;
804 value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
808 field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
809 TREE_CHAIN (field) = fields;
811 value = tree_cons (field, null_pointer_node, value);
814 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
815 TREE_CHAIN (field) = fields;
817 value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
821 string_type = build_pointer_type (build_qualified_type (char_type_node,
823 field = build_decl (FIELD_DECL, NULL_TREE, string_type);
824 TREE_CHAIN (field) = fields;
826 filename = getpwd ();
827 filename = (filename && da_file_name[0] != '/'
828 ? concat (filename, "/", da_file_name, NULL)
830 filename_len = strlen (filename);
831 filename_string = build_string (filename_len + 1, filename);
832 if (filename != da_file_name)
834 TREE_TYPE (filename_string) = build_array_type
835 (char_type_node, build_index_type
836 (build_int_cst (NULL_TREE, filename_len)));
837 value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
840 /* Build the fn_info type and initializer. */
841 fn_info_type = build_fn_info_type (n_ctr_types);
842 fn_info_ptr_type = build_pointer_type (build_qualified_type
843 (fn_info_type, TYPE_QUAL_CONST));
844 for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
845 fn_info_value = tree_cons (NULL_TREE,
846 build_fn_info_value (fn, fn_info_type),
852 array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
853 array_type = build_array_type (fn_info_type, array_type);
855 /* FIXME: use build_constructor directly. */
856 fn_info_value = build_constructor_from_list (array_type,
857 nreverse (fn_info_value));
858 fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
861 fn_info_value = null_pointer_node;
863 /* number of functions */
864 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
865 TREE_CHAIN (field) = fields;
867 value = tree_cons (field,
868 build_int_cstu (get_gcov_unsigned_t (), n_fns),
872 field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
873 TREE_CHAIN (field) = fields;
875 value = tree_cons (field, fn_info_value, value);
878 field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
879 TREE_CHAIN (field) = fields;
881 value = tree_cons (field,
882 build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask),
886 ctr_info_type = build_ctr_info_type ();
887 ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
889 ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
890 for (ix = 0; ix != GCOV_COUNTERS; ix++)
891 if (prg_ctr_mask & (1 << ix))
892 ctr_info_value = tree_cons (NULL_TREE,
893 build_ctr_info_value (ix, ctr_info_type),
895 /* FIXME: use build_constructor directly. */
896 ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
897 nreverse (ctr_info_value));
899 field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
900 TREE_CHAIN (field) = fields;
902 value = tree_cons (field, ctr_info_value, value);
904 finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
906 /* FIXME: use build_constructor directly. */
907 value = build_constructor_from_list (type, nreverse (value));
912 /* Write out the structure which libgcov uses to locate all the
913 counters. The structures used here must match those defined in
914 gcov-io.h. Write out the constructor to call __gcov_init. */
917 create_coverage (void)
919 tree gcov_info, gcov_init, body, t;
922 no_coverage = 1; /* Disable any further coverage. */
927 t = build_gcov_info ();
929 gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
930 TREE_STATIC (gcov_info) = 1;
931 ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
932 DECL_NAME (gcov_info) = get_identifier (name_buf);
933 DECL_INITIAL (gcov_info) = t;
935 /* Build structure. */
936 assemble_variable (gcov_info, 0, 0, 0);
938 /* Build a decl for __gcov_init. */
939 t = build_pointer_type (TREE_TYPE (gcov_info));
940 t = build_function_type_list (void_type_node, t, NULL);
941 t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
943 DECL_EXTERNAL (t) = 1;
946 /* Generate a call to __gcov_init(&gcov_info). */
948 t = build_fold_addr_expr (gcov_info);
949 t = tree_cons (NULL, t, NULL);
950 t = build_function_call_expr (gcov_init, t);
951 append_to_statement_list (t, &body);
953 /* Generate a constructor to run it. */
954 cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
957 /* Perform file-level initialization. Read in data file, generate name
961 coverage_init (const char *filename)
963 int len = strlen (filename);
965 /* Name of da file. */
966 da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) + 1);
967 strcpy (da_file_name, filename);
968 strcat (da_file_name, GCOV_DATA_SUFFIX);
970 /* Name of bbg file. */
971 bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
972 strcpy (bbg_file_name, filename);
973 strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
978 /* Performs file-level cleanup. Close graph file, generate coverage
979 variables and constructor. */
982 coverage_finish (void)
987 int error = gcov_close ();
990 unlink (bbg_file_name);
992 /* Only remove the da file, if we cannot stamp it. If we can
993 stamp it, libgcov will DTRT. */
994 unlink (da_file_name);
998 #include "gt-coverage.h"