/* 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.
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
#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. */
};
/* We hash by */
unsigned ident;
unsigned ctr;
-
+
/* Store */
unsigned checksum;
gcov_type *counts;
/* Workspace */
struct counts_entry *chain;
-
+
} counts_entry_t;
-static unsigned fn_ident = 1;
static struct function_list *functions_head = 0;
static struct function_list **functions_tail = &functions_head;
+static unsigned no_coverage = 0;
/* Cumulative counter information for whole program. */
static unsigned prg_ctr_mask; /* Mask of counter types generated. */
-static unsigned prg_n_ctrs[GCOV_COUNTERS];
+static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */
/* Counter information for current function. */
-static unsigned fn_ctr_mask;
-static unsigned fn_n_ctrs[GCOV_COUNTERS];
+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. */
/* Name of the output file for coverage output file. */
static char *bbg_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. */
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);
+\f
+/* 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);
+}
\f
static hashval_t
-htab_counts_entry_hash (of)
- const void *of;
+htab_counts_entry_hash (const void *of)
{
const counts_entry_t *entry = 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;
}
static void
-htab_counts_entry_del (of)
- void *of;
+htab_counts_entry_del (void *of)
{
counts_entry_t *entry = 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 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 (0, "%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 (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. */
+ gcov_read_unsigned ();
counts_hash = htab_create (10,
htab_counts_entry_hash, htab_counts_entry_eq,
htab_counts_entry_del);
- while (!gcov_is_eof ())
+ while ((tag = gcov_read_unsigned ()))
{
- gcov_unsigned_t tag, length;
+ gcov_unsigned_t length;
gcov_position_t offset;
- int error;
-
- tag = gcov_read_unsigned ();
+
length = gcov_read_unsigned ();
offset = gcov_position ();
if (tag == GCOV_TAG_FUNCTION)
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;
{
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)
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;
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)
+ {
+ 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)
{
- 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;
}
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;
skip_merge:;
}
gcov_sync (offset, length);
- if ((error = gcov_is_error ()))
+ if ((is_error = gcov_is_error ()))
{
- warning (error < 0 ? "`%s' has overflowed" : "`%s' is corrupted",
- da_file_name);
+ error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
+ da_file_name);
htab_delete (counts_hash);
break;
}
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;
}
- elt.ident = fn_ident;
+ elt.ident = current_function_funcdef_no + 1;
elt.ctr = counter;
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;
}
-
- 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;
return entry->counts;
}
-/* Generate a MEM rtl to access COUNTER NO . */
+/* Allocate NUM counters of type COUNTER. Returns nonzero if the
+ allocation succeeded. */
-rtx
-coverage_counter_ref (unsigned counter, unsigned no)
+int
+coverage_counter_alloc (unsigned counter, unsigned num)
{
- 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_coverage)
+ return 0;
- if (!ctr_labels[counter])
+ if (!num)
+ return 1;
+
+ 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 gcov_type_node = get_gcov_type ();
+ 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));
- }
- if (no + 1 > fn_n_ctrs[counter])
- {
- fn_n_ctrs[counter] = no + 1;
- fn_ctr_mask |= 1 << counter;
+ 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;
+ fn_ctr_mask |= 1 << counter;
+ return 1;
+}
- no += prg_n_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 ());
+/* Generate a tree to access COUNTER NO. */
- return ref;
+tree
+tree_coverage_counter_ref (unsigned counter, unsigned no)
+{
+ tree gcov_type_node = get_gcov_type ();
+ 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))));
}
\f
/* 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;
\f
/* Begin output to the graph file for the current function.
Opens the output file, if not already done. Writes the
- function header, if not already done. Returns non-zero if data
+ function header, if not already done. Returns nonzero if data
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 (fn_ident);
+ 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;
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 (0, "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;
- /* It would be nice to use the unique source location. */
- item->ident = fn_ident;
+ item->ident = current_function_funcdef_no + 1;
item->checksum = compute_checksum ();
for (i = 0; i != GCOV_COUNTERS; i++)
{
item->n_ctrs[i] = fn_n_ctrs[i];
prg_n_ctrs[i] += fn_n_ctrs[i];
- fn_n_ctrs[i] = 0;
+ fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
}
prg_ctr_mask |= fn_ctr_mask;
fn_ctr_mask = 0;
}
bbg_function_announced = 0;
- fn_ident++;
}
/* 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);
+ 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_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;
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 (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 (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));
+
+ /* 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;
}
/* 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_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;
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);
/* 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;
-
- 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
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;
}
CONSTRUCTOR. */
static tree
-build_gcov_info ()
+build_gcov_info (void)
{
unsigned n_ctr_types, ix;
tree type, const_type;
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);
+ 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 */
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, get_gcov_unsigned_t ());
+ TREE_CHAIN (field) = fields;
+ fields = field;
+ value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
+ value);
+
/* Filename */
string_type = build_pointer_type (build_qualified_type (char_type_node,
TYPE_QUAL_CONST));
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
{
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);
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;
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))
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;
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));
-
+ /* FIXME: use build_constructor directly. */
+ value = build_constructor_from_list (type, nreverse (value));
+
return value;
}
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;
- int save_flag_inline_functions = flag_inline_functions;
+ 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);
-
- 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);
- cfun->arc_profile = 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);
-
- /* Since ctor isn't in the list of globals, it would never be emitted
- when it's considered to be 'safe' for inlining, so turn off
- flag_inline_functions. */
- flag_inline_functions = 0;
-
- rest_of_compilation (ctor);
-
- /* Reset flag_inline_functions to its original value. */
- flag_inline_functions = save_flag_inline_functions;
-
- 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);
}
\f
/* 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 ();
}
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);
}
}