X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcoverage.c;h=a4f4d001c13cc0e7bcf2dc92aecfdadb90828eeb;hb=b7837065e4ec51e8a0ed5fdb0303f2273d3a5d92;hp=9f33b811605e7beeb4531389264368e3345a1160;hpb=7ef5b942a1ad681e5124f1949bd5f62c0d7456a4;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/coverage.c b/gcc/coverage.c index 9f33b811605..a4f4d001c13 100644 --- a/gcc/coverage.c +++ b/gcc/coverage.c @@ -1,6 +1,6 @@ /* Read and write coverage files, and associated functionality. Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999, - 2000, 2001, 2003 Free Software Foundation, Inc. + 2000, 2001, 2003, 2004 Free Software Foundation, Inc. Contributed by James E. Wilson, UC Berkeley/Cygnus Support; based on some ideas from Dain Samples of UC Berkeley. Further mangling by Bob Manson, Cygnus Support. @@ -39,18 +39,18 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "function.h" #include "toplev.h" #include "ggc.h" -#include "target.h" #include "coverage.h" -#include "libfuncs.h" #include "langhooks.h" #include "hashtab.h" +#include "tree-iterator.h" +#include "cgraph.h" #include "gcov-io.c" struct function_list { - struct function_list *next; /* next function */ - unsigned ident; /* function ident */ + struct function_list *next; /* next function */ + unsigned ident; /* function ident */ unsigned checksum; /* function checksum */ unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */ }; @@ -61,7 +61,7 @@ typedef struct counts_entry /* We hash by */ unsigned ident; unsigned ctr; - + /* Store */ unsigned checksum; gcov_type *counts; @@ -69,7 +69,7 @@ typedef struct counts_entry /* Workspace */ struct counts_entry *chain; - + } counts_entry_t; static struct function_list *functions_head = 0; @@ -81,7 +81,7 @@ static unsigned prg_ctr_mask; /* Mask of counter types generated. */ static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */ /* Counter information for current function. */ -static unsigned fn_ctr_mask; /* Mask of counters used. */ +static unsigned fn_ctr_mask; /* Mask of counters used. */ static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */ static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */ @@ -96,7 +96,11 @@ static char *da_file_name; /* Hash table of count data. */ static htab_t counts_hash = NULL; -/* The names of the counter tables. */ +/* Trees representing the counter table arrays. */ +static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS]; + +/* The names of the counter tables. Not used if we're + generating counters at tree level. */ static GTY(()) rtx ctr_labels[GCOV_COUNTERS]; /* The names of merge functions for counters. */ @@ -104,23 +108,22 @@ static const char *const ctr_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIO static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES; /* Forward declarations. */ -static hashval_t htab_counts_entry_hash PARAMS ((const void *)); -static int htab_counts_entry_eq PARAMS ((const void *, const void *)); -static void htab_counts_entry_del PARAMS ((void *)); -static void read_counts_file PARAMS ((void)); -static unsigned compute_checksum PARAMS ((void)); -static unsigned checksum_string PARAMS ((unsigned, const char *)); -static tree build_fn_info_type PARAMS ((unsigned)); -static tree build_fn_info_value PARAMS ((const struct function_list *, tree)); -static tree build_ctr_info_type PARAMS ((void)); -static tree build_ctr_info_value PARAMS ((unsigned, tree)); -static tree build_gcov_info PARAMS ((void)); -static void create_coverage PARAMS ((void)); +static hashval_t htab_counts_entry_hash (const void *); +static int htab_counts_entry_eq (const void *, const void *); +static void htab_counts_entry_del (void *); +static void read_counts_file (void); +static unsigned compute_checksum (void); +static unsigned coverage_checksum_string (unsigned, const char *); +static tree build_fn_info_type (unsigned); +static tree build_fn_info_value (const struct function_list *, tree); +static tree build_ctr_info_type (void); +static tree build_ctr_info_value (unsigned, tree); +static tree build_gcov_info (void); +static void create_coverage (void); static hashval_t -htab_counts_entry_hash (of) - const void *of; +htab_counts_entry_hash (const void *of) { const counts_entry_t *entry = of; @@ -128,9 +131,7 @@ htab_counts_entry_hash (of) } static int -htab_counts_entry_eq (of1, of2) - const void *of1; - const void *of2; +htab_counts_entry_eq (const void *of1, const void *of2) { const counts_entry_t *entry1 = of1; const counts_entry_t *entry2 = of2; @@ -139,8 +140,7 @@ htab_counts_entry_eq (of1, of2) } static void -htab_counts_entry_del (of) - void *of; +htab_counts_entry_del (void *of) { counts_entry_t *entry = of; @@ -151,40 +151,39 @@ htab_counts_entry_del (of) /* Read in the counts file, if available. */ static void -read_counts_file () +read_counts_file (void) { gcov_unsigned_t fn_ident = 0; - gcov_unsigned_t version, checksum = -1; - unsigned ix; + gcov_unsigned_t checksum = -1; counts_entry_t *summaried = NULL; unsigned seen_summary = 0; gcov_unsigned_t tag; - int error = 0; + int is_error = 0; if (!gcov_open (da_file_name, 1)) return; - - if (gcov_read_unsigned () != GCOV_DATA_MAGIC) + + if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC)) { - warning ("`%s' is not a gcov data file", da_file_name); + warning ("%qs is not a gcov data file", da_file_name); gcov_close (); return; } - else if ((version = gcov_read_unsigned ()) != GCOV_VERSION) + else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION) { char v[4], e[4]; - gcov_unsigned_t required = GCOV_VERSION; - - for (ix = 4; ix--; required >>= 8, version >>= 8) - { - v[ix] = version; - e[ix] = required; - } - warning ("`%s' is version `%.4s', expected version `%.4s'", - da_file_name, v, e); + + GCOV_UNSIGNED2STRING (v, tag); + GCOV_UNSIGNED2STRING (e, GCOV_VERSION); + + warning ("%qs is version %q.*s, expected version %q.*s", + da_file_name, 4, v, 4, e); gcov_close (); return; } + + /* Read and discard the stamp. */ + gcov_read_unsigned (); counts_hash = htab_create (10, htab_counts_entry_hash, htab_counts_entry_eq, @@ -193,7 +192,7 @@ read_counts_file () { gcov_unsigned_t length; gcov_position_t offset; - + length = gcov_read_unsigned (); offset = gcov_position (); if (tag == GCOV_TAG_FUNCTION) @@ -206,7 +205,7 @@ read_counts_file () new function begins a new set of program runs. We must unlink the summaried chain. */ counts_entry_t *entry, *chain; - + for (entry = summaried; entry; entry = chain) { chain = entry->chain; @@ -220,13 +219,13 @@ read_counts_file () { counts_entry_t *entry; struct gcov_summary summary; - + gcov_read_summary (&summary); seen_summary = 1; for (entry = summaried; entry; entry = entry->chain) { struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr]; - + entry->summary.runs += csum->runs; entry->summary.sum_all += csum->sum_all; if (entry->summary.run_max < csum->run_max) @@ -237,7 +236,7 @@ read_counts_file () else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident) { counts_entry_t **slot, *entry, elt; - unsigned n_counts = length / 8; + unsigned n_counts = GCOV_TAG_COUNTER_NUM (length); unsigned ix; elt.ident = fn_ident; @@ -255,24 +254,33 @@ read_counts_file () entry->summary.num = n_counts; entry->counts = xcalloc (n_counts, sizeof (gcov_type)); } - else if (entry->checksum != checksum - || entry->summary.num != n_counts) + else if (entry->checksum != checksum) { - warning ("coverage mismatch for function %u", fn_ident); + error ("coverage mismatch for function %u while reading execution counters.", + fn_ident); + error ("checksum is %x instead of %x", entry->checksum, checksum); + htab_delete (counts_hash); + break; + } + else if (entry->summary.num != n_counts) + { + error ("coverage mismatch for function %u while reading execution counters.", + fn_ident); + error ("number of counters is %d instead of %d", entry->summary.num, n_counts); htab_delete (counts_hash); break; } else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE) { - warning ("cannot merge separate %s counters for function %u", - ctr_names[elt.ctr], fn_ident); + error ("cannot merge separate %s counters for function %u", + ctr_names[elt.ctr], fn_ident); goto skip_merge; } if (elt.ctr < GCOV_COUNTERS_SUMMABLE /* This should always be true for a just allocated entry, - and always false for an existing one. Check this way, in - case the gcov file is corrupt. */ + and always false for an existing one. Check this way, in + case the gcov file is corrupt. */ && (!entry->chain || summaried != entry)) { entry->chain = summaried; @@ -283,17 +291,15 @@ read_counts_file () skip_merge:; } gcov_sync (offset, length); - if ((error = gcov_is_error ())) - break; + if ((is_error = gcov_is_error ())) + { + error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted", + da_file_name); + htab_delete (counts_hash); + break; + } } - if (!gcov_is_eof ()) - { - warning (error < 0 ? "`%s' has overflowed" : "`%s' is corrupted", - da_file_name); - htab_delete (counts_hash); - } - gcov_close (); } @@ -304,15 +310,18 @@ get_coverage_counts (unsigned counter, unsigned expected, const struct gcov_ctr_summary **summary) { counts_entry_t *entry, elt; + gcov_unsigned_t checksum = -1; - /* No hash table, no counts. */ + /* No hash table, no counts. */ if (!counts_hash) { static int warned = 0; if (!warned++) - warning ("file %s not found, execution counts assumed to be zero", - da_file_name); + inform ((flag_guess_branch_prob + ? "file %s not found, execution counts estimated" + : "file %s not found, execution counts assumed to be zero"), + da_file_name); return NULL; } @@ -321,19 +330,29 @@ get_coverage_counts (unsigned counter, unsigned expected, entry = htab_find (counts_hash, &elt); if (!entry) { - warning ("no coverage for function '%s' found.", IDENTIFIER_POINTER + warning ("no coverage for function %qs found.", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); return 0; } - - if (expected != entry->summary.num - || compute_checksum () != entry->checksum) + + checksum = compute_checksum (); + if (entry->checksum != checksum) { - warning ("coverage mismatch for `%s'", IDENTIFIER_POINTER - (DECL_ASSEMBLER_NAME (current_function_decl))); - return NULL; + error ("coverage mismatch for function %qs while reading counter %qs.", + IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)), + ctr_names[counter]); + error ("checksum is %x instead of %x", entry->checksum, checksum); + return 0; } - + else if (entry->summary.num != expected) + { + error ("coverage mismatch for function %qs while reading counter %qs.", + IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)), + ctr_names[counter]); + error ("number of counters is %d instead of %d", entry->summary.num, expected); + return 0; + } + if (summary) *summary = &entry->summary; @@ -348,17 +367,26 @@ coverage_counter_alloc (unsigned counter, unsigned num) { if (no_coverage) return 0; - + if (!num) return 1; - - if (!ctr_labels[counter]) + + if (!tree_ctr_tables[counter]) { /* Generate and save a copy of this so it can be shared. */ + /* We don't know the size yet; make it big enough that nobody + will make any clever transformation on it. */ char buf[20]; - + tree domain_tree + = build_index_type (build_int_cst (NULL_TREE, 1000)); /* replaced later */ + tree gcov_type_array_type + = build_array_type (GCOV_TYPE_NODE, domain_tree); + tree_ctr_tables[counter] + = build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type); + TREE_STATIC (tree_ctr_tables[counter]) = 1; ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1); - ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf)); + DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf); + DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (GCOV_TYPE_NODE); } fn_b_ctrs[counter] = fn_n_ctrs[counter]; fn_n_ctrs[counter] += num; @@ -369,56 +397,113 @@ coverage_counter_alloc (unsigned counter, unsigned num) /* Generate a MEM rtl to access COUNTER NO. */ rtx -coverage_counter_ref (unsigned counter, unsigned no) +rtl_coverage_counter_ref (unsigned counter, unsigned no) { unsigned gcov_size = tree_low_cst (TYPE_SIZE (GCOV_TYPE_NODE), 1); enum machine_mode mode = mode_for_size (gcov_size, MODE_INT, 0); rtx ref; - if (no >= fn_n_ctrs[counter] - fn_b_ctrs[counter]) - abort (); + gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); no += prg_n_ctrs[counter] + fn_b_ctrs[counter]; + if (!ctr_labels[counter]) + { + ctr_labels[counter] = gen_rtx_SYMBOL_REF (Pmode, + ggc_strdup (IDENTIFIER_POINTER (DECL_NAME + (tree_ctr_tables[counter])))); + SYMBOL_REF_FLAGS (ctr_labels[counter]) = SYMBOL_FLAG_LOCAL; + } ref = plus_constant (ctr_labels[counter], gcov_size / BITS_PER_UNIT * no); ref = gen_rtx_MEM (mode, ref); set_mem_alias_set (ref, new_alias_set ()); + MEM_NOTRAP_P (ref) = 1; return ref; } + +/* Generate a tree to access COUNTER NO. */ + +tree +tree_coverage_counter_ref (unsigned counter, unsigned no) +{ + tree domain_type = TYPE_DOMAIN (TREE_TYPE (tree_ctr_tables[counter])); + + gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]); + no += prg_n_ctrs[counter] + fn_b_ctrs[counter]; + + /* "no" here is an array index, scaled to bytes later. */ + return build4 (ARRAY_REF, GCOV_TYPE_NODE, tree_ctr_tables[counter], + fold_convert (domain_type, + build_int_cst (NULL_TREE, no)), + TYPE_MIN_VALUE (domain_type), + size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (GCOV_TYPE_NODE), + size_int (TYPE_ALIGN_UNIT (GCOV_TYPE_NODE)))); +} /* Generate a checksum for a string. CHKSUM is the current - checksum. */ + checksum. */ static unsigned -checksum_string (unsigned chksum, const char *string) +coverage_checksum_string (unsigned chksum, const char *string) { - do + int i; + char *dup = NULL; + + /* Look for everything that looks if it were produced by + get_file_function_name_long and zero out the second part + that may result from flag_random_seed. This is not critical + as the checksums are used only for sanity checking. */ + for (i = 0; string[i]; i++) { - unsigned value = *string << 24; - unsigned ix; - - for (ix = 8; ix--; value <<= 1) - { - unsigned feedback; - - feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; - chksum <<= 1; - chksum ^= feedback; - } + if (!strncmp (string + i, "_GLOBAL__", 9)) + for (i = i + 9; string[i]; i++) + if (string[i]=='_') + { + int y; + unsigned seed; + int scan; + + for (y = 1; y < 9; y++) + if (!(string[i + y] >= '0' && string[i + y] <= '9') + && !(string[i + y] >= 'A' && string[i + y] <= 'F')) + break; + if (y != 9 || string[i + 9] != '_') + continue; + for (y = 10; y < 18; y++) + if (!(string[i + y] >= '0' && string[i + y] <= '9') + && !(string[i + y] >= 'A' && string[i + y] <= 'F')) + break; + if (y != 18) + continue; + scan = sscanf (string + i + 10, "%X", &seed); + gcc_assert (scan); + if (seed != crc32_string (0, flag_random_seed)) + continue; + string = dup = xstrdup (string); + for (y = 10; y < 18; y++) + dup[i + y] = '0'; + break; + } + break; } - while (*string++); - + + chksum = crc32_string (chksum, string); + if (dup) + free (dup); + return chksum; } /* Compute checksum for the current function. We generate a CRC32. */ static unsigned -compute_checksum () +compute_checksum (void) { - unsigned chksum = DECL_SOURCE_LINE (current_function_decl); + expanded_location xloc + = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); + unsigned chksum = xloc.line; - chksum = checksum_string (chksum, DECL_SOURCE_FILE (current_function_decl)); - chksum = checksum_string + chksum = coverage_checksum_string (chksum, xloc.file); + chksum = coverage_checksum_string (chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); return chksum; @@ -430,37 +515,38 @@ compute_checksum () should be output. */ int -coverage_begin_output () +coverage_begin_output (void) { if (no_coverage) return 0; - + if (!bbg_function_announced) { - const char *file = DECL_SOURCE_FILE (current_function_decl); - unsigned line = DECL_SOURCE_LINE (current_function_decl); + expanded_location xloc + = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); unsigned long offset; - + if (!bbg_file_opened) { if (!gcov_open (bbg_file_name, -1)) error ("cannot open %s", bbg_file_name); else { - gcov_write_unsigned (GCOV_GRAPH_MAGIC); + gcov_write_unsigned (GCOV_NOTE_MAGIC); gcov_write_unsigned (GCOV_VERSION); + gcov_write_unsigned (local_tick); } bbg_file_opened = 1; } - + /* Announce function */ offset = gcov_write_tag (GCOV_TAG_FUNCTION); gcov_write_unsigned (current_function_funcdef_no + 1); gcov_write_unsigned (compute_checksum ()); gcov_write_string (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); - gcov_write_string (file); - gcov_write_unsigned (line); + gcov_write_string (xloc.file); + gcov_write_unsigned (xloc.line); gcov_write_length (offset); bbg_function_announced = 1; @@ -472,25 +558,25 @@ coverage_begin_output () error has occurred. Save function coverage counts. */ void -coverage_end_function () +coverage_end_function (void) { unsigned i; - + if (bbg_file_opened > 1 && gcov_is_error ()) - { - warning ("error writing `%s'", bbg_file_name); + { + warning ("error writing %qs", bbg_file_name); bbg_file_opened = -1; } if (fn_ctr_mask) { struct function_list *item; - + item = xmalloc (sizeof (struct function_list)); - + *functions_tail = item; functions_tail = &item->next; - + item->next = 0; item->ident = current_function_funcdef_no + 1; item->checksum = compute_checksum (); @@ -509,13 +595,12 @@ coverage_end_function () /* Creates the gcov_fn_info RECORD_TYPE. */ static tree -build_fn_info_type (counters) - unsigned counters; +build_fn_info_type (unsigned int counters) { - tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); + tree type = lang_hooks.types.make_type (RECORD_TYPE); tree field, fields; tree array_type; - + /* ident */ fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); @@ -524,9 +609,10 @@ build_fn_info_type (counters) TREE_CHAIN (field) = fields; fields = field; - array_type = build_index_type (build_int_2 (counters - 1, 0)); + array_type = build_int_cst (NULL_TREE, counters - 1); + array_type = build_index_type (array_type); array_type = build_array_type (unsigned_type_node, array_type); - + /* counters */ field = build_decl (FIELD_DECL, NULL_TREE, array_type); TREE_CHAIN (field) = fields; @@ -542,53 +628,47 @@ build_fn_info_type (counters) RECORD_TYPE. */ static tree -build_fn_info_value (function, type) - const struct function_list *function; - tree type; +build_fn_info_value (const struct function_list *function, tree type) { tree value = NULL_TREE; tree fields = TYPE_FIELDS (type); unsigned ix; tree array_value = NULL_TREE; - + /* ident */ - value = tree_cons (fields, - convert (unsigned_intSI_type_node, - build_int_2 (function->ident, 0)), - value); + value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node, + function->ident), value); fields = TREE_CHAIN (fields); - + /* checksum */ - value = tree_cons (fields, - convert (unsigned_intSI_type_node, - build_int_2 (function->checksum, 0)), - value); + value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node, + function->checksum), value); fields = TREE_CHAIN (fields); - + /* counters */ for (ix = 0; ix != GCOV_COUNTERS; ix++) if (prg_ctr_mask & (1 << ix)) { - tree counters = convert (unsigned_type_node, - build_int_2 (function->n_ctrs[ix], 0)); - + tree counters = build_int_cstu (unsigned_type_node, + function->n_ctrs[ix]); + array_value = tree_cons (NULL_TREE, counters, array_value); } - + array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value)); value = tree_cons (fields, array_value, value); value = build_constructor (type, nreverse (value)); - + return value; } /* Creates the gcov_ctr_info RECORD_TYPE. */ static tree -build_ctr_info_type () +build_ctr_info_type (void) { - tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); + tree type = lang_hooks.types.make_type (RECORD_TYPE); tree field, fields = NULL_TREE; tree gcov_ptr_type = build_pointer_type (GCOV_TYPE_NODE); tree gcov_merge_fn_type; @@ -623,9 +703,7 @@ build_ctr_info_type () RECORD_TYPE. */ static tree -build_ctr_info_value (counter, type) - unsigned counter; - tree type; +build_ctr_info_value (unsigned int counter, tree type) { tree value = NULL_TREE; tree fields = TYPE_FIELDS (type); @@ -633,26 +711,29 @@ build_ctr_info_value (counter, type) /* counters */ value = tree_cons (fields, - convert (unsigned_intSI_type_node, - build_int_2 (prg_n_ctrs[counter], 0)), + build_int_cstu (unsigned_intSI_type_node, + prg_n_ctrs[counter]), value); fields = TREE_CHAIN (fields); if (prg_n_ctrs[counter]) { - tree array_type, array; - - array_type = build_index_type (build_int_2 (prg_n_ctrs[counter] - 1, 0)); + tree array_type; + + array_type = build_int_cstu (unsigned_type_node, + prg_n_ctrs[counter] - 1); + array_type = build_index_type (array_type); array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)), array_type); - - array = build (VAR_DECL, array_type, NULL_TREE, NULL_TREE); - TREE_STATIC (array) = 1; - DECL_NAME (array) = get_identifier (XSTR (ctr_labels[counter], 0)); - assemble_variable (array, 0, 0, 0); - + + TREE_TYPE (tree_ctr_tables[counter]) = array_type; + DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type); + DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type); + assemble_variable (tree_ctr_tables[counter], 0, 0, 0); + value = tree_cons (fields, - build1 (ADDR_EXPR, TREE_TYPE (fields), array), + build1 (ADDR_EXPR, TREE_TYPE (fields), + tree_ctr_tables[counter]), value); } else @@ -671,7 +752,7 @@ build_ctr_info_value (counter, type) value); value = build_constructor (type, nreverse (value)); - + return value; } @@ -679,7 +760,7 @@ build_ctr_info_value (counter, type) CONSTRUCTOR. */ static tree -build_gcov_info () +build_gcov_info (void) { unsigned n_ctr_types, ix; tree type, const_type; @@ -694,29 +775,35 @@ build_gcov_info () unsigned n_fns; const struct function_list *fn; tree string_type; - + /* Count the number of active counters. */ for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++) if (prg_ctr_mask & (1 << ix)) n_ctr_types++; - - type = (*lang_hooks.types.make_type) (RECORD_TYPE); + + type = lang_hooks.types.make_type (RECORD_TYPE); const_type = build_qualified_type (type, TYPE_QUAL_CONST); - + /* Version ident */ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); TREE_CHAIN (field) = fields; fields = field; - value = tree_cons (field, convert (unsigned_intSI_type_node, - build_int_2 (GCOV_VERSION, 0)), - value); - + value = tree_cons (field, build_int_cstu (unsigned_intSI_type_node, + GCOV_VERSION), value); + /* next -- NULL */ field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type)); TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, null_pointer_node, value); - + + /* stamp */ + field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); + TREE_CHAIN (field) = fields; + fields = field; + value = tree_cons (field, build_int_cstu (unsigned_intSI_type_node, + local_tick), value); + /* Filename */ string_type = build_pointer_type (build_qualified_type (char_type_node, TYPE_QUAL_CONST)); @@ -731,12 +818,12 @@ build_gcov_info () filename_string = build_string (filename_len + 1, filename); if (filename != da_file_name) free (filename); - TREE_TYPE (filename_string) = - build_array_type (char_type_node, - build_index_type (build_int_2 (filename_len, 0))); + TREE_TYPE (filename_string) = build_array_type + (char_type_node, build_index_type + (build_int_cst (NULL_TREE, filename_len))); value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string), value); - + /* Build the fn_info type and initializer. */ fn_info_type = build_fn_info_type (n_ctr_types); fn_info_ptr_type = build_pointer_type (build_qualified_type @@ -749,23 +836,23 @@ build_gcov_info () { tree array_type; - array_type = build_index_type (build_int_2 (n_fns - 1, 0)); + array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1)); array_type = build_array_type (fn_info_type, array_type); - + fn_info_value = build_constructor (array_type, nreverse (fn_info_value)); fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value); } else fn_info_value = null_pointer_node; - + /* number of functions */ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node); TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, - convert (unsigned_type_node, build_int_2 (n_fns, 0)), + build_int_cstu (unsigned_type_node, n_fns), value); - + /* fn_info table */ field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type); TREE_CHAIN (field) = fields; @@ -777,13 +864,13 @@ build_gcov_info () TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, - convert (unsigned_type_node, - build_int_2 (prg_ctr_mask, 0)), + build_int_cstu (unsigned_type_node, prg_ctr_mask), value); - + /* counters */ ctr_info_type = build_ctr_info_type (); - ctr_info_ary_type = build_index_type (build_int_2 (n_ctr_types, 0)); + ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE, + n_ctr_types)); ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type); for (ix = 0; ix != GCOV_COUNTERS; ix++) if (prg_ctr_mask & (1 << ix)) @@ -797,11 +884,11 @@ build_gcov_info () TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, ctr_info_value, value); - + finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE); value = build_constructor (type, nreverse (value)); - + return value; } @@ -810,94 +897,63 @@ build_gcov_info () gcov-io.h. Write out the constructor to call __gcov_init. */ static void -create_coverage () +create_coverage (void) { - tree gcov_info, gcov_info_value; - char name[20]; - char *ctor_name; - tree ctor; - rtx gcov_info_address; + tree gcov_info, gcov_init, body, t; + char name_buf[32]; no_coverage = 1; /* Disable any further coverage. */ - + if (!prg_ctr_mask) return; - - gcov_info_value = build_gcov_info (); - gcov_info = build (VAR_DECL, TREE_TYPE (gcov_info_value), - NULL_TREE, NULL_TREE); - DECL_INITIAL (gcov_info) = gcov_info_value; + t = build_gcov_info (); + gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t)); TREE_STATIC (gcov_info) = 1; - ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 0); - DECL_NAME (gcov_info) = get_identifier (name); - + ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0); + DECL_NAME (gcov_info) = get_identifier (name_buf); + DECL_INITIAL (gcov_info) = t; + /* Build structure. */ assemble_variable (gcov_info, 0, 0, 0); - /* Build the constructor function to invoke __gcov_init. */ - ctor_name = concat (IDENTIFIER_POINTER (get_file_function_name ('I')), - "_GCOV", NULL); - ctor = build_decl (FUNCTION_DECL, get_identifier (ctor_name), - build_function_type (void_type_node, NULL_TREE)); - free (ctor_name); - DECL_EXTERNAL (ctor) = 0; - - /* It can be a static function as long as collect2 does not have - to scan the object file to find its ctor/dtor routine. */ - TREE_PUBLIC (ctor) = ! targetm.have_ctors_dtors; - TREE_USED (ctor) = 1; - DECL_RESULT (ctor) = build_decl (RESULT_DECL, NULL_TREE, void_type_node); - DECL_UNINLINABLE (ctor) = 1; - - ctor = (*lang_hooks.decls.pushdecl) (ctor); - rest_of_decl_compilation (ctor, 0, 1, 0); - announce_function (ctor); - current_function_decl = ctor; - DECL_INITIAL (ctor) = error_mark_node; - make_decl_rtl (ctor, NULL); - init_function_start (ctor, input_filename, input_line); - (*lang_hooks.decls.pushlevel) (0); - expand_function_start (ctor, 0); - - /* Actually generate the code to call __gcov_init. */ - gcov_info_address = force_reg (Pmode, XEXP (DECL_RTL (gcov_info), 0)); - emit_library_call (gcov_init_libfunc, LCT_NORMAL, VOIDmode, 1, - gcov_info_address, Pmode); - - expand_function_end (input_filename, input_line, 0); - (*lang_hooks.decls.poplevel) (1, 0, 1); - - rest_of_compilation (ctor); - - if (! quiet_flag) - fflush (asm_out_file); - current_function_decl = NULL_TREE; - - if (targetm.have_ctors_dtors) - (* targetm.asm_out.constructor) (XEXP (DECL_RTL (ctor), 0), - DEFAULT_INIT_PRIORITY); + /* Build a decl for __gcov_init. */ + t = build_pointer_type (TREE_TYPE (gcov_info)); + t = build_function_type_list (void_type_node, t, NULL); + t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t); + TREE_PUBLIC (t) = 1; + DECL_EXTERNAL (t) = 1; + gcov_init = t; + + /* Generate a call to __gcov_init(&gcov_info). */ + body = NULL; + t = build_fold_addr_expr (gcov_info); + t = tree_cons (NULL, t, NULL); + t = build_function_call_expr (gcov_init, t); + append_to_statement_list (t, &body); + + /* Generate a constructor to run it. */ + cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY); } /* Perform file-level initialization. Read in data file, generate name - of graph file. */ + of graph file. */ void -coverage_init (filename) - const char *filename; +coverage_init (const char *filename) { int len = strlen (filename); /* Name of da file. */ - da_file_name = (char *) xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1); + da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1); strcpy (da_file_name, filename); strcat (da_file_name, GCOV_DATA_SUFFIX); - + /* Name of bbg file. */ - bbg_file_name = (char *) xmalloc (len + strlen (GCOV_GRAPH_SUFFIX) + 1); + bbg_file_name = xmalloc (len + strlen (GCOV_NOTE_SUFFIX) + 1); strcpy (bbg_file_name, filename); - strcat (bbg_file_name, GCOV_GRAPH_SUFFIX); + strcat (bbg_file_name, GCOV_NOTE_SUFFIX); read_counts_file (); } @@ -906,22 +962,18 @@ coverage_init (filename) variables and constructor. */ void -coverage_finish () +coverage_finish (void) { create_coverage (); if (bbg_file_opened) { int error = gcov_close (); - + if (error) unlink (bbg_file_name); -#if SELF_COVERAGE - /* If the compiler is instrumented, we should not - unconditionally remove the counts file, because we might be - recompiling ourselves. The .da files are all removed during - copying the stage1 files. */ - if (error) -#endif + if (!local_tick) + /* Only remove the da file, if we cannot stamp it. If we can + stamp it, libgcov will DTRT. */ unlink (da_file_name); } }