X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fcoverage.c;h=aaec5edf667d56eba0ef56e6ee2518a3d41eb89a;hb=0305c755745c1d24fb688d9b5bb540c4232417b7;hp=0bc7a26cecb7cf8df8e62cb8196b871444b5f0c7;hpb=b4d48d675e7a3d7a30834741f83259da59c7cf82;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/coverage.c b/gcc/coverage.c index 0bc7a26cecb..aaec5edf667 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, 2005 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. @@ -20,8 +20,8 @@ for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ +Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301, USA. */ #define GCOV_LINKAGE @@ -39,11 +39,11 @@ 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" @@ -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. */ @@ -109,14 +113,29 @@ 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 checksum_string (unsigned, const char *); +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); + +/* Return the type node for gcov_type. */ + +tree +get_gcov_type (void) +{ + return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false); +} + +/* Return the type node for gcov_unsigned_t. */ +static tree +get_gcov_unsigned_t (void) +{ + return lang_hooks.types.type_for_size (32, true); +} static hashval_t htab_counts_entry_hash (const void *of) @@ -154,28 +173,31 @@ read_counts_file (void) 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_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC)) { - warning ("`%s' is not a gcov data file", da_file_name); + warning (0, "%qs is not a gcov data file", da_file_name); gcov_close (); return; } else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION) { - gcov_unsigned_t required = GCOV_VERSION; + char v[4], e[4]; - warning ("`%s' is version `%.4s', expected version `%.4s'", - da_file_name, (const char *)&tag, (const char *)&required); + GCOV_UNSIGNED2STRING (v, tag); + GCOV_UNSIGNED2STRING (e, GCOV_VERSION); + + warning (0, "%qs is version %q.*s, expected version %q.*s", + da_file_name, 4, v, 4, e); gcov_close (); return; } - /* Read and discard the stamp. */ + /* Read and discard the stamp. */ gcov_read_unsigned (); counts_hash = htab_create (10, @@ -229,7 +251,7 @@ read_counts_file (void) 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; @@ -240,24 +262,33 @@ read_counts_file (void) entry = *slot; if (!entry) { - *slot = entry = xcalloc (1, sizeof (counts_entry_t)); + *slot = entry = XCNEW (counts_entry_t); entry->ident = elt.ident; entry->ctr = elt.ctr; entry->checksum = checksum; entry->summary.num = n_counts; - entry->counts = xcalloc (n_counts, sizeof (gcov_type)); + entry->counts = XCNEWVEC (gcov_type, n_counts); + } + else if (entry->checksum != checksum) + { + 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->checksum != checksum - || entry->summary.num != n_counts) + else if (entry->summary.num != n_counts) { - warning ("coverage mismatch for function %u", fn_ident); + 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; } @@ -275,15 +306,13 @@ read_counts_file (void) skip_merge:; } gcov_sync (offset, length); - if ((error = gcov_is_error ())) - break; - } - - if (!gcov_is_eof ()) - { - warning (error < 0 ? "`%s' has overflowed" : "`%s' is corrupted", - da_file_name); - htab_delete (counts_hash); + if ((is_error = gcov_is_error ())) + { + error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted", + da_file_name); + htab_delete (counts_hash); + break; + } } gcov_close (); @@ -296,6 +325,7 @@ 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. */ if (!counts_hash) @@ -303,8 +333,10 @@ get_coverage_counts (unsigned counter, unsigned expected, 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; } @@ -313,16 +345,47 @@ 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 (0, "no coverage for function %qs found", IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl))); - return 0; + return NULL; } - if (expected != entry->summary.num - || compute_checksum () != entry->checksum) + checksum = compute_checksum (); + if (entry->checksum != checksum + || entry->summary.num != expected) { - warning ("coverage mismatch for `%s'", IDENTIFIER_POINTER - (DECL_ASSEMBLER_NAME (current_function_decl))); + static int warned = 0; + const char *id = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME + (current_function_decl)); + + if (warn_coverage_mismatch) + warning (OPT_Wcoverage_mismatch, "coverage mismatch for function " + "%qs while reading counter %qs", id, ctr_names[counter]); + else + error ("coverage mismatch for function %qs while reading counter %qs", + id, ctr_names[counter]); + + if (!inhibit_warnings) + { + if (entry->checksum != checksum) + inform ("checksum is %x instead of %x", entry->checksum, checksum); + else + inform ("number of counters is %d instead of %d", + entry->summary.num, expected); + } + + if (warn_coverage_mismatch + && !inhibit_warnings + && !warned++) + { + inform ("coverage mismatch ignored due to -Wcoverage-mismatch"); + inform (flag_guess_branch_prob + ? "execution counts estimated" + : "execution counts assumed to be zero"); + if (!flag_guess_branch_prob) + inform ("this can result in poorly optimized code"); + } + return NULL; } @@ -344,13 +407,21 @@ coverage_counter_alloc (unsigned counter, unsigned num) 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. */ + /* Generate and save a copy of this so it can be shared. Leave + the index type unspecified for now; it will be set after all + functions have been compiled. */ char buf[20]; - + tree gcov_type_node = get_gcov_type (); + tree gcov_type_array_type + = build_array_type (gcov_type_node, NULL_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; @@ -358,46 +429,78 @@ coverage_counter_alloc (unsigned counter, unsigned num) return 1; } -/* Generate a MEM rtl to access COUNTER NO. */ +/* Generate a tree to access COUNTER NO. */ -rtx -coverage_counter_ref (unsigned counter, unsigned no) +tree +tree_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; + tree gcov_type_node = get_gcov_type (); - 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]; - 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 ()); - return ref; + /* "no" here is an array index, scaled to bytes later. */ + return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter], + build_int_cst (NULL_TREE, no), NULL, NULL); } /* Generate a checksum for a string. CHKSUM is the current 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 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) + int offset = 0; + if (!strncmp (string + i, "_GLOBAL__N_", 11)) + offset = 11; + if (!strncmp (string + i, "_GLOBAL__", 9)) + offset = 9; + + /* C++ namespaces do have scheme: + _GLOBAL__N___functionname + since filename might contain extra underscores there seems + to be no better chance then walk all possible offsets looking + for magicnuber. */ + if (offset) { - unsigned feedback; - - feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0; - chksum <<= 1; - chksum ^= feedback; + for (i = i + offset; string[i]; i++) + if (string[i]=='_') + { + int y; + + 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; + if (!dup) + string = dup = xstrdup (string); + for (y = 10; y < 18; y++) + dup[i + y] = '0'; + } + break; } } - while (*string++); + + chksum = crc32_string (chksum, string); + if (dup) + free (dup); return chksum; } @@ -407,10 +510,12 @@ checksum_string (unsigned chksum, const char *string) static unsigned 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; @@ -429,8 +534,8 @@ coverage_begin_output (void) 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) @@ -452,8 +557,8 @@ coverage_begin_output (void) 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; @@ -471,7 +576,7 @@ coverage_end_function (void) if (bbg_file_opened > 1 && gcov_is_error ()) { - warning ("error writing `%s'", bbg_file_name); + warning (0, "error writing %qs", bbg_file_name); bbg_file_opened = -1; } @@ -479,7 +584,7 @@ coverage_end_function (void) { struct function_list *item; - item = xmalloc (sizeof (struct function_list)); + item = XNEW (struct function_list); *functions_tail = item; functions_tail = &item->next; @@ -504,20 +609,21 @@ coverage_end_function (void) static tree 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); + fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); /* checksum */ - field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; - array_type = build_index_type (build_int_2 (counters - 1, 0)); - array_type = build_array_type (unsigned_type_node, array_type); + array_type = build_int_cst (NULL_TREE, counters - 1); + array_type = build_index_type (array_type); + array_type = build_array_type (get_gcov_unsigned_t (), array_type); /* counters */ field = build_decl (FIELD_DECL, NULL_TREE, array_type); @@ -542,33 +648,32 @@ build_fn_info_value (const struct function_list *function, tree type) 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 (get_gcov_unsigned_t (), + 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 (get_gcov_unsigned_t (), + 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 (get_gcov_unsigned_t (), + function->n_ctrs[ix]); array_value = tree_cons (NULL_TREE, counters, array_value); } - array_value = build_constructor (TREE_TYPE (fields), nreverse (array_value)); + /* FIXME: use build_constructor directly. */ + array_value = build_constructor_from_list (TREE_TYPE (fields), + nreverse (array_value)); value = tree_cons (fields, array_value, value); - value = build_constructor (type, nreverse (value)); + /* FIXME: use build_constructor directly. */ + value = build_constructor_from_list (type, nreverse (value)); return value; } @@ -578,13 +683,13 @@ build_fn_info_value (const struct function_list *function, tree type) static tree 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_ptr_type = build_pointer_type (get_gcov_type ()); tree gcov_merge_fn_type; /* counters */ - field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; @@ -596,7 +701,7 @@ build_ctr_info_type (void) /* merge */ gcov_merge_fn_type = build_function_type_list (void_type_node, - gcov_ptr_type, unsigned_type_node, + gcov_ptr_type, get_gcov_unsigned_t (), NULL_TREE); field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (gcov_merge_fn_type)); @@ -621,26 +726,29 @@ build_ctr_info_value (unsigned int counter, tree type) /* counters */ value = tree_cons (fields, - convert (unsigned_intSI_type_node, - build_int_2 (prg_n_ctrs[counter], 0)), + build_int_cstu (get_gcov_unsigned_t (), + prg_n_ctrs[counter]), value); fields = TREE_CHAIN (fields); if (prg_n_ctrs[counter]) { - tree array_type, array; + tree array_type; - array_type = build_index_type (build_int_2 (prg_n_ctrs[counter] - 1, 0)); + array_type = build_int_cstu (get_gcov_unsigned_t (), + 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 @@ -658,7 +766,8 @@ build_ctr_info_value (unsigned int counter, tree type) build1 (ADDR_EXPR, TREE_TYPE (fields), fn), value); - value = build_constructor (type, nreverse (value)); + /* FIXME: use build_constructor directly. */ + value = build_constructor_from_list (type, nreverse (value)); return value; } @@ -688,15 +797,14 @@ build_gcov_info (void) 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); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; - value = tree_cons (field, convert (unsigned_intSI_type_node, - build_int_2 (GCOV_VERSION, 0)), + value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION), value); /* next -- NULL */ @@ -706,11 +814,10 @@ build_gcov_info (void) value = tree_cons (field, null_pointer_node, value); /* stamp */ - field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; - value = tree_cons (field, convert (unsigned_intSI_type_node, - build_int_2 (local_tick, 0)), + value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick), value); /* Filename */ @@ -727,9 +834,9 @@ build_gcov_info (void) 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); @@ -745,21 +852,23 @@ build_gcov_info (void) { 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)); + /* FIXME: use build_constructor directly. */ + fn_info_value = build_constructor_from_list (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); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, - convert (unsigned_type_node, build_int_2 (n_fns, 0)), + build_int_cstu (get_gcov_unsigned_t (), n_fns), value); /* fn_info table */ @@ -769,25 +878,26 @@ build_gcov_info (void) value = tree_cons (field, fn_info_value, value); /* counter_mask */ - field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node); + field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ()); TREE_CHAIN (field) = fields; fields = field; value = tree_cons (field, - convert (unsigned_type_node, - build_int_2 (prg_ctr_mask, 0)), + build_int_cstu (get_gcov_unsigned_t (), 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)) ctr_info_value = tree_cons (NULL_TREE, build_ctr_info_value (ix, ctr_info_type), ctr_info_value); - ctr_info_value = build_constructor (ctr_info_ary_type, - nreverse (ctr_info_value)); + /* FIXME: use build_constructor directly. */ + ctr_info_value = build_constructor_from_list (ctr_info_ary_type, + nreverse (ctr_info_value)); field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type); TREE_CHAIN (field) = fields; @@ -796,7 +906,8 @@ build_gcov_info (void) finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE); - value = build_constructor (type, nreverse (value)); + /* FIXME: use build_constructor directly. */ + value = build_constructor_from_list (type, nreverse (value)); return value; } @@ -808,72 +919,41 @@ build_gcov_info (void) static void 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); - (*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 (); - (*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 = build_call_expr (gcov_init, 1, 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 @@ -885,12 +965,12 @@ 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 = XNEWVEC (char, 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_NOTE_SUFFIX) + 1); + bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1); strcpy (bbg_file_name, filename); strcat (bbg_file_name, GCOV_NOTE_SUFFIX);