/* 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.
#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 */
- const char *name; /* function name */
- unsigned cfg_checksum; /* function checksum */
- unsigned n_counter_sections; /* number of counter sections */
- struct gcov_counter_section counter_sections[MAX_COUNTER_SECTIONS];
- /* the sections */
+ struct function_list *next; /* next function */
+ unsigned ident; /* function ident */
+ unsigned checksum; /* function checksum */
+ unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */
};
/* Counts information for a function. */
typedef struct counts_entry
{
/* We hash by */
- char *function_name;
- unsigned section;
-
+ unsigned ident;
+ unsigned ctr;
+
/* Store */
unsigned checksum;
- unsigned n_counts;
gcov_type *counts;
- unsigned merged;
- gcov_type max_counter;
- gcov_type max_counter_sum;
+ struct gcov_ctr_summary summary;
/* Workspace */
struct counts_entry *chain;
-
+
} counts_entry_t;
static struct function_list *functions_head = 0;
static struct function_list **functions_tail = &functions_head;
+static unsigned no_coverage = 0;
-/* Instantiate the profile info structure. */
+/* Cumulative counter information for whole program. */
+static unsigned prg_ctr_mask; /* Mask of counter types generated. */
+static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */
-struct profile_info profile_info;
+/* Counter information for current function. */
+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 name of the count table. Used by the edge profiling code. */
-static GTY(()) rtx profiler_label;
+/* 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_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
+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 void set_purpose PARAMS ((tree, tree));
-static rtx label_for_tag PARAMS ((unsigned));
-static tree build_counter_section_fields PARAMS ((void));
-static tree build_counter_section_value PARAMS ((unsigned, unsigned));
-static tree build_counter_section_data_fields PARAMS ((void));
-static tree build_counter_section_data_value PARAMS ((unsigned, unsigned));
-static tree build_function_info_fields PARAMS ((void));
-static tree build_function_info_value PARAMS ((struct function_list *));
-static tree build_gcov_info_fields PARAMS ((tree));
-static tree build_gcov_info_value 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
static hashval_t
-htab_counts_entry_hash (of)
- const void *of;
+htab_counts_entry_hash (const void *of)
{
const counts_entry_t *entry = of;
- return htab_hash_string (entry->function_name) ^ entry->section;
+ return entry->ident * GCOV_COUNTERS + entry->ctr;
}
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;
- return !strcmp (entry1->function_name, entry2->function_name)
- && entry1->section == entry2->section;
+ return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
}
static void
-htab_counts_entry_del (of)
- void *of;
+htab_counts_entry_del (void *of)
{
counts_entry_t *entry = of;
- free (entry->function_name);
free (entry->counts);
free (entry);
}
/* Read in the counts file, if available. */
static void
-read_counts_file ()
+read_counts_file (void)
{
- char *function_name_buffer = NULL;
- unsigned version, ix, checksum = -1;
+ gcov_unsigned_t fn_ident = 0;
+ 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 ("%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];
- unsigned 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,
htab_counts_entry_del);
- while (!gcov_is_eof ())
+ while ((tag = gcov_read_unsigned ()))
{
- unsigned tag, length;
- unsigned long offset;
- int error;
-
- tag = gcov_read_unsigned ();
+ gcov_unsigned_t length;
+ gcov_position_t offset;
+
length = gcov_read_unsigned ();
offset = gcov_position ();
if (tag == GCOV_TAG_FUNCTION)
{
- const char *string = gcov_read_string ();
- free (function_name_buffer);
- function_name_buffer = string ? xstrdup (string) : NULL;
+ fn_ident = gcov_read_unsigned ();
checksum = gcov_read_unsigned ();
if (seen_summary)
{
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;
-
- entry->max_counter_sum += entry->max_counter;
entry->chain = NULL;
}
summaried = NULL;
{
counts_entry_t *entry;
struct gcov_summary summary;
-
+
gcov_read_summary (&summary);
seen_summary = 1;
for (entry = summaried; entry; entry = entry->chain)
{
- entry->merged += summary.runs;
- if (entry->max_counter < summary.arc_sum_max)
- entry->max_counter = summary.arc_sum_max;
+ 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)
+ entry->summary.run_max = csum->run_max;
+ entry->summary.sum_max += csum->sum_max;
}
}
- else if (GCOV_TAG_IS_SUBTAG (GCOV_TAG_FUNCTION, tag)
- && function_name_buffer)
+ 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.function_name = function_name_buffer;
- elt.section = tag;
+ elt.ident = fn_ident;
+ elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
slot = (counts_entry_t **) htab_find_slot
(counts_hash, &elt, INSERT);
entry = *slot;
if (!entry)
{
- *slot = entry = xmalloc (sizeof (counts_entry_t));
- entry->function_name = xstrdup (function_name_buffer);
- entry->section = tag;
+ *slot = entry = xcalloc (1, sizeof (counts_entry_t));
+ entry->ident = elt.ident;
+ entry->ctr = elt.ctr;
entry->checksum = checksum;
- entry->n_counts = n_counts;
+ entry->summary.num = n_counts;
entry->counts = xcalloc (n_counts, sizeof (gcov_type));
}
- else if (entry->checksum != checksum || entry->n_counts != n_counts)
+ else if (entry->checksum != checksum)
{
- warning ("profile mismatch for `%s'", function_name_buffer);
+ 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;
}
-
- /* 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. */
- if (!entry->chain || summaried != entry)
+ 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)
+ {
+ 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. */
+ && (!entry->chain || summaried != entry))
{
entry->chain = summaried;
summaried = entry;
}
for (ix = 0; ix != n_counts; ix++)
entry->counts[ix] += gcov_read_counter ();
+ skip_merge:;
}
- gcov_seek (offset, length);
- if ((error = gcov_is_error ()))
+ gcov_sync (offset, length);
+ 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;
}
}
- free (function_name_buffer);
gcov_close ();
}
/* Returns the counters for a particular tag. */
gcov_type *
-get_coverage_counts (unsigned tag, unsigned expected)
+get_coverage_counts (unsigned counter, unsigned expected,
+ const struct gcov_ctr_summary **summary)
{
counts_entry_t *entry, elt;
+ gcov_unsigned_t checksum = -1;
- profile_info.max_counter_in_program = 0;
- profile_info.count_profiles_merged = 0;
-
- /* 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.function_name
- = (char *) IDENTIFIER_POINTER
- (DECL_ASSEMBLER_NAME (current_function_decl));
- elt.section = tag;
+ elt.ident = current_function_funcdef_no + 1;
+ elt.ctr = counter;
entry = htab_find (counts_hash, &elt);
if (!entry)
{
- warning ("No profile for function '%s' found.", elt.function_name);
+ warning ("no coverage for function %qs found.", IDENTIFIER_POINTER
+ (DECL_ASSEMBLER_NAME (current_function_decl)));
return 0;
}
-
- if (expected != entry->n_counts
- || compute_checksum () != entry->checksum)
+
+ checksum = compute_checksum ();
+ if (entry->checksum != checksum)
{
- warning ("profile mismatch for `%s'", elt.function_name);
- 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;
}
- profile_info.count_profiles_merged = entry->merged;
- profile_info.max_counter_in_program = entry->max_counter_sum;
+ if (summary)
+ *summary = &entry->summary;
return entry->counts;
}
+
+/* Allocate NUM counters of type COUNTER. Returns nonzero if the
+ allocation succeeded. */
+
+int
+coverage_counter_alloc (unsigned counter, unsigned num)
+{
+ if (no_coverage)
+ return 0;
+
+ 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 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);
+ 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;
+}
+
+/* Generate a MEM rtl to access COUNTER NO. */
+
+rtx
+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;
+
+ 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))));
+}
\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 (current_function_funcdef_no + 1);
+ gcov_write_unsigned (compute_checksum ());
gcov_write_string (IDENTIFIER_POINTER
(DECL_ASSEMBLER_NAME (current_function_decl)));
- gcov_write_unsigned (compute_checksum ());
- 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 ("error writing %qs", bbg_file_name);
bbg_file_opened = -1;
}
-
- for (i = 0; i != profile_info.n_sections; i++)
- if (profile_info.section_info[i].n_counters_now)
- {
- struct function_list *item;
-
- /* ??? Probably should re-use the existing struct function. */
- item = xmalloc (sizeof (struct function_list));
-
- *functions_tail = item;
- functions_tail = &item->next;
-
- item->next = 0;
- item->name = xstrdup (IDENTIFIER_POINTER
- (DECL_ASSEMBLER_NAME (current_function_decl)));
- item->cfg_checksum = compute_checksum ();
- item->n_counter_sections = 0;
- for (i = 0; i < profile_info.n_sections; i++)
- if (profile_info.section_info[i].n_counters_now)
- {
- item->counter_sections[item->n_counter_sections].tag =
- profile_info.section_info[i].tag;
- item->counter_sections[item->n_counter_sections].n_counters =
- profile_info.section_info[i].n_counters_now;
- item->n_counter_sections++;
- profile_info.section_info[i].n_counters
- += profile_info.section_info[i].n_counters_now;
- profile_info.section_info[i].n_counters_now = 0;
- }
- break;
- }
- bbg_function_announced = 0;
-}
-/* Set FIELDS as purpose to VALUE. */
-static void
-set_purpose (value, fields)
- tree value;
- tree fields;
-{
- tree act_field, act_value;
-
- for (act_field = fields, act_value = value;
- act_field;
- act_field = TREE_CHAIN (act_field), act_value = TREE_CHAIN (act_value))
- TREE_PURPOSE (act_value) = act_field;
-}
-
-/* Returns label for base of counters inside TAG section. */
-static rtx
-label_for_tag (tag)
- unsigned tag;
-{
- switch (tag)
+ if (fn_ctr_mask)
{
- case GCOV_TAG_ARC_COUNTS:
- return profiler_label;
- default:
- abort ();
- }
-}
+ struct function_list *item;
-/* Creates fields of struct counter_section (in gcov-io.h). */
-static tree
-build_counter_section_fields ()
-{
- tree field, fields;
+ item = xmalloc (sizeof (struct function_list));
- /* tag */
- fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ *functions_tail = item;
+ functions_tail = &item->next;
- /* n_counters */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
- TREE_CHAIN (field) = fields;
- fields = field;
-
- return fields;
+ item->next = 0;
+ 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] = fn_b_ctrs[i] = 0;
+ }
+ prg_ctr_mask |= fn_ctr_mask;
+ fn_ctr_mask = 0;
+ }
+ bbg_function_announced = 0;
}
-/* Creates value of struct counter_section (in gcov-io.h). */
-static tree
-build_counter_section_value (tag, n_counters)
- unsigned tag;
- unsigned n_counters;
-{
- tree value = NULL_TREE;
-
- /* tag */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (tag, 0)),
- value);
-
- /* n_counters */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (n_counters, 0)),
- value);
-
- return value;
-}
+/* Creates the gcov_fn_info RECORD_TYPE. */
-/* Creates fields of struct counter_section_data (in gcov-io.h). */
static tree
-build_counter_section_data_fields ()
+build_fn_info_type (unsigned int counters)
{
- tree field, fields, gcov_type, gcov_ptr_type;
-
- gcov_type = make_signed_type (GCOV_TYPE_SIZE);
- gcov_ptr_type =
- build_pointer_type (build_qualified_type (gcov_type,
- TYPE_QUAL_CONST));
+ tree type = lang_hooks.types.make_type (RECORD_TYPE);
+ tree field, fields;
+ tree array_type;
- /* tag */
- fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ /* ident */
+ fields = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
- /* n_counters */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ /* checksum */
+ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
TREE_CHAIN (field) = fields;
fields = field;
+ 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, gcov_ptr_type);
+ field = build_decl (FIELD_DECL, NULL_TREE, array_type);
TREE_CHAIN (field) = fields;
fields = field;
- return fields;
+ finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
+
+ return type;
}
-/* Creates value of struct counter_section_data (in gcov-io.h). */
+/* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
+ the function being processed and TYPE is the gcov_fn_info
+ RECORD_TYPE. */
+
static tree
-build_counter_section_data_value (tag, n_counters)
- unsigned tag;
- unsigned n_counters;
+build_fn_info_value (const struct function_list *function, tree type)
{
- tree value = NULL_TREE, counts_table, gcov_type, gcov_ptr_type;
+ tree value = NULL_TREE;
+ tree fields = TYPE_FIELDS (type);
+ unsigned ix;
+ tree array_value = NULL_TREE;
- gcov_type = make_signed_type (GCOV_TYPE_SIZE);
- gcov_ptr_type
- = build_pointer_type (build_qualified_type
- (gcov_type, TYPE_QUAL_CONST));
+ /* ident */
+ value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node,
+ function->ident), value);
+ fields = TREE_CHAIN (fields);
- /* tag */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (tag, 0)),
- value);
-
- /* n_counters */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (n_counters, 0)),
- value);
+ /* checksum */
+ value = tree_cons (fields, build_int_cstu (unsigned_intSI_type_node,
+ function->checksum), value);
+ fields = TREE_CHAIN (fields);
/* counters */
- if (n_counters)
- {
- tree gcov_type_array_type =
- build_array_type (gcov_type,
- build_index_type (build_int_2 (n_counters - 1,
- 0)));
- counts_table =
- build (VAR_DECL, gcov_type_array_type, NULL_TREE, NULL_TREE);
- TREE_STATIC (counts_table) = 1;
- DECL_NAME (counts_table) = get_identifier (XSTR (label_for_tag (tag), 0));
- assemble_variable (counts_table, 0, 0, 0);
- counts_table = build1 (ADDR_EXPR, gcov_ptr_type, counts_table);
- }
- else
- counts_table = null_pointer_node;
+ for (ix = 0; ix != GCOV_COUNTERS; ix++)
+ if (prg_ctr_mask & (1 << ix))
+ {
+ 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 = tree_cons (NULL_TREE, counts_table, value);
+ value = build_constructor (type, nreverse (value));
return value;
}
-/* Creates fields for struct function_info type (in gcov-io.h). */
+/* Creates the gcov_ctr_info RECORD_TYPE. */
+
static tree
-build_function_info_fields ()
+build_ctr_info_type (void)
{
- tree field, fields, counter_section_fields, counter_section_type;
- tree counter_sections_ptr_type;
- tree string_type =
- build_pointer_type (build_qualified_type (char_type_node,
- TYPE_QUAL_CONST));
- /* name */
- fields = build_decl (FIELD_DECL, NULL_TREE, string_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;
- /* checksum */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ /* counters */
+ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
TREE_CHAIN (field) = fields;
fields = field;
- /* n_counter_sections */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ /* values */
+ field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
TREE_CHAIN (field) = fields;
fields = field;
- /* counter_sections */
- counter_section_fields = build_counter_section_fields ();
- counter_section_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- finish_builtin_struct (counter_section_type, "__counter_section",
- counter_section_fields, NULL_TREE);
- counter_sections_ptr_type =
- build_pointer_type
- (build_qualified_type (counter_section_type,
- TYPE_QUAL_CONST));
- field = build_decl (FIELD_DECL, NULL_TREE, counter_sections_ptr_type);
+ /* merge */
+ gcov_merge_fn_type =
+ build_function_type_list (void_type_node,
+ gcov_ptr_type, unsigned_type_node,
+ NULL_TREE);
+ field = build_decl (FIELD_DECL, NULL_TREE,
+ build_pointer_type (gcov_merge_fn_type));
TREE_CHAIN (field) = fields;
fields = field;
- return fields;
+ finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
+
+ return type;
}
-/* Creates value for struct function_info (in gcov-io.h). */
+/* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
+ the counter being processed and TYPE is the gcov_ctr_info
+ RECORD_TYPE. */
+
static tree
-build_function_info_value (function)
- struct function_list *function;
+build_ctr_info_value (unsigned int counter, tree type)
{
tree value = NULL_TREE;
- size_t name_len = strlen (function->name);
- tree fname = build_string (name_len + 1, function->name);
- tree string_type =
- build_pointer_type (build_qualified_type (char_type_node,
- TYPE_QUAL_CONST));
- tree counter_section_fields, counter_section_type, counter_sections_value;
- tree counter_sections_ptr_type, counter_sections_array_type;
- unsigned i;
-
- /* name */
- TREE_TYPE (fname) =
- build_array_type (char_type_node,
- build_index_type (build_int_2 (name_len, 0)));
- value = tree_cons (NULL_TREE,
- build1 (ADDR_EXPR,
- string_type,
- fname),
- value);
+ tree fields = TYPE_FIELDS (type);
+ tree fn;
- /* checksum */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (function->cfg_checksum, 0)),
+ /* counters */
+ value = tree_cons (fields,
+ build_int_cstu (unsigned_intSI_type_node,
+ prg_n_ctrs[counter]),
value);
+ fields = TREE_CHAIN (fields);
- /* n_counter_sections */
-
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (function->n_counter_sections, 0)),
- value);
-
- /* counter_sections */
- counter_section_fields = build_counter_section_fields ();
- counter_section_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- counter_sections_ptr_type =
- build_pointer_type
- (build_qualified_type (counter_section_type,
- TYPE_QUAL_CONST));
- counter_sections_array_type =
- build_array_type (counter_section_type,
- build_index_type (
- build_int_2 (function->n_counter_sections - 1,
- 0)));
-
- counter_sections_value = NULL_TREE;
- for (i = 0; i < function->n_counter_sections; i++)
+ if (prg_n_ctrs[counter])
{
- tree counter_section_value
- = build_counter_section_value (function->counter_sections[i].tag,
- function->counter_sections[i].n_counters);
- set_purpose (counter_section_value, counter_section_fields);
- counter_sections_value =
- tree_cons (NULL_TREE,
- build_constructor (counter_section_type,
- nreverse (counter_section_value)),
- counter_sections_value);
- }
- finish_builtin_struct (counter_section_type, "__counter_section",
- counter_section_fields, NULL_TREE);
+ tree array_type;
- if (function->n_counter_sections)
- {
- counter_sections_value =
- build_constructor (counter_sections_array_type,
- nreverse (counter_sections_value)),
- counter_sections_value = build1 (ADDR_EXPR,
- counter_sections_ptr_type,
- counter_sections_value);
+ 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);
+
+ 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),
+ tree_ctr_tables[counter]),
+ value);
}
else
- counter_sections_value = null_pointer_node;
+ value = tree_cons (fields, null_pointer_node, value);
+ fields = TREE_CHAIN (fields);
+
+ fn = build_decl (FUNCTION_DECL,
+ get_identifier (ctr_merge_functions[counter]),
+ TREE_TYPE (TREE_TYPE (fields)));
+ DECL_EXTERNAL (fn) = 1;
+ TREE_PUBLIC (fn) = 1;
+ DECL_ARTIFICIAL (fn) = 1;
+ TREE_NOTHROW (fn) = 1;
+ value = tree_cons (fields,
+ build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
+ value);
- value = tree_cons (NULL_TREE, counter_sections_value, value);
+ value = build_constructor (type, nreverse (value));
return value;
}
-/* Creates fields of struct gcov_info type (in gcov-io.h). */
+/* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
+ CONSTRUCTOR. */
+
static tree
-build_gcov_info_fields (gcov_info_type)
- tree gcov_info_type;
+build_gcov_info (void)
{
- tree field, fields;
+ unsigned n_ctr_types, ix;
+ tree type, const_type;
+ tree fn_info_type, fn_info_value = NULL_TREE;
+ tree fn_info_ptr_type;
+ tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
+ tree field, fields = NULL_TREE;
+ tree value = NULL_TREE;
+ tree filename_string;
char *filename;
int filename_len;
- tree string_type =
- build_pointer_type (build_qualified_type (char_type_node,
- TYPE_QUAL_CONST));
- tree function_info_fields, function_info_type, function_info_ptr_type;
- tree counter_section_data_fields, counter_section_data_type;
- tree counter_section_data_ptr_type;
+ unsigned n_fns;
+ const struct function_list *fn;
+ tree string_type;
- /* Version ident */
- fields = build_decl (FIELD_DECL, NULL_TREE, long_unsigned_type_node);
+ /* 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++;
- /* next -- NULL */
- field = build_decl (FIELD_DECL, NULL_TREE,
- build_pointer_type
- (build_qualified_type
- (gcov_info_type, TYPE_QUAL_CONST)));
- TREE_CHAIN (field) = fields;
- fields = field;
-
- /* Filename */
- filename = getpwd ();
- filename = (filename && da_file_name[0] != '/'
- ? concat (filename, "/", da_file_name, NULL)
- : da_file_name);
- filename_len = strlen (filename);
- if (filename != da_file_name)
- free (filename);
+ type = lang_hooks.types.make_type (RECORD_TYPE);
+ const_type = build_qualified_type (type, TYPE_QUAL_CONST);
- field = build_decl (FIELD_DECL, NULL_TREE, string_type);
- TREE_CHAIN (field) = fields;
- fields = field;
-
- /* Workspace */
- field = build_decl (FIELD_DECL, NULL_TREE, long_integer_type_node);
+ /* Version ident */
+ 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,
+ GCOV_VERSION), value);
- /* number of functions */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
- TREE_CHAIN (field) = fields;
- fields = field;
-
- /* function_info table */
- function_info_fields = build_function_info_fields ();
- function_info_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- finish_builtin_struct (function_info_type, "__function_info",
- function_info_fields, NULL_TREE);
- function_info_ptr_type =
- build_pointer_type
- (build_qualified_type (function_info_type,
- TYPE_QUAL_CONST));
- field = build_decl (FIELD_DECL, NULL_TREE, function_info_ptr_type);
- TREE_CHAIN (field) = fields;
- fields = field;
-
- /* n_counter_sections */
- field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ /* next -- NULL */
+ field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
TREE_CHAIN (field) = fields;
fields = field;
-
- /* counter sections */
- counter_section_data_fields = build_counter_section_data_fields ();
- counter_section_data_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- finish_builtin_struct (counter_section_data_type, "__counter_section_data",
- counter_section_data_fields, NULL_TREE);
- counter_section_data_ptr_type =
- build_pointer_type
- (build_qualified_type (counter_section_data_type,
- TYPE_QUAL_CONST));
- field = build_decl (FIELD_DECL, NULL_TREE, counter_section_data_ptr_type);
+ 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);
- return fields;
-}
-
-/* Creates struct gcov_info value (in gcov-io.h). */
-static tree
-build_gcov_info_value ()
-{
- tree value = NULL_TREE;
- tree filename_string;
- char *filename;
- int filename_len;
- unsigned n_functions, i;
- struct function_list *item;
- tree string_type =
- build_pointer_type (build_qualified_type (char_type_node,
- TYPE_QUAL_CONST));
- tree function_info_fields, function_info_type, function_info_ptr_type;
- tree functions;
- tree counter_section_data_fields, counter_section_data_type;
- tree counter_section_data_ptr_type, counter_sections;
-
- /* Version ident */
- value = tree_cons (NULL_TREE,
- convert (long_unsigned_type_node,
- build_int_2 (GCOV_VERSION, 0)),
- value);
-
- /* next -- NULL */
- value = tree_cons (NULL_TREE, null_pointer_node, value);
-
/* Filename */
+ string_type = build_pointer_type (build_qualified_type (char_type_node,
+ TYPE_QUAL_CONST));
+ field = build_decl (FIELD_DECL, NULL_TREE, string_type);
+ TREE_CHAIN (field) = fields;
+ fields = field;
filename = getpwd ();
filename = (filename && da_file_name[0] != '/'
? concat (filename, "/", da_file_name, NULL)
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)));
- value = tree_cons (NULL_TREE,
- build1 (ADDR_EXPR,
- string_type,
- filename_string),
+ 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);
-
- /* Workspace */
- value = tree_cons (NULL_TREE,
- convert (long_integer_type_node, integer_zero_node),
- value);
-
- /* number of functions */
- n_functions = 0;
- for (item = functions_head; item != 0; item = item->next, n_functions++)
- continue;
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (n_functions, 0)),
- value);
-
- /* function_info table */
- function_info_fields = build_function_info_fields ();
- function_info_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- function_info_ptr_type =
- build_pointer_type (
- build_qualified_type (function_info_type,
- TYPE_QUAL_CONST));
- functions = NULL_TREE;
- for (item = functions_head; item != 0; item = item->next)
- {
- tree function_info_value = build_function_info_value (item);
- set_purpose (function_info_value, function_info_fields);
- functions
- = tree_cons (NULL_TREE,
- build_constructor (function_info_type,
- nreverse (function_info_value)),
- functions);
- }
- finish_builtin_struct (function_info_type, "__function_info",
- function_info_fields, NULL_TREE);
- /* Create constructor for array. */
- if (n_functions)
+ /* 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
+ (fn_info_type, TYPE_QUAL_CONST));
+ for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
+ fn_info_value = tree_cons (NULL_TREE,
+ build_fn_info_value (fn, fn_info_type),
+ fn_info_value);
+ if (n_fns)
{
tree array_type;
- array_type = build_array_type (
- function_info_type,
- build_index_type (build_int_2 (n_functions - 1, 0)));
- functions = build_constructor (array_type, nreverse (functions));
- functions = build1 (ADDR_EXPR,
- function_info_ptr_type,
- functions);
+ 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
- functions = null_pointer_node;
+ fn_info_value = null_pointer_node;
- value = tree_cons (NULL_TREE, functions, value);
+ /* number of functions */
+ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ TREE_CHAIN (field) = fields;
+ fields = field;
+ value = tree_cons (field,
+ 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;
+ fields = field;
+ value = tree_cons (field, fn_info_value, value);
- /* n_counter_sections */
- value = tree_cons (NULL_TREE,
- convert (unsigned_type_node,
- build_int_2 (profile_info.n_sections, 0)),
+ /* counter_mask */
+ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ TREE_CHAIN (field) = fields;
+ fields = field;
+ value = tree_cons (field,
+ build_int_cstu (unsigned_type_node, prg_ctr_mask),
value);
-
- /* counter sections */
- counter_section_data_fields = build_counter_section_data_fields ();
- counter_section_data_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- counter_sections = NULL_TREE;
- for (i = 0; i < profile_info.n_sections; i++)
- {
- tree counter_sections_value =
- build_counter_section_data_value (
- profile_info.section_info[i].tag,
- profile_info.section_info[i].n_counters);
- set_purpose (counter_sections_value, counter_section_data_fields);
- counter_sections =
- tree_cons (NULL_TREE,
- build_constructor (counter_section_data_type,
- nreverse (counter_sections_value)),
- counter_sections);
- }
- finish_builtin_struct (counter_section_data_type, "__counter_section_data",
- counter_section_data_fields, NULL_TREE);
- counter_section_data_ptr_type =
- build_pointer_type
- (build_qualified_type (counter_section_data_type,
- TYPE_QUAL_CONST));
-
- if (profile_info.n_sections)
- {
- tree cst_type = build_index_type (build_int_2 (profile_info.n_sections-1,
- 0));
- cst_type = build_array_type (counter_section_data_type, cst_type);
- counter_sections = build_constructor (cst_type,
- nreverse (counter_sections));
- counter_sections = build1 (ADDR_EXPR,
- counter_section_data_ptr_type,
- counter_sections);
- }
- else
- counter_sections = null_pointer_node;
- value = tree_cons (NULL_TREE, counter_sections, value);
+
+ /* counters */
+ ctr_info_type = build_ctr_info_type ();
+ 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));
+
+ 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));
return value;
}
-/* Write out the structure which libgcc uses to locate all the arc
+/* Write out the structure which libgcov uses to locate all the
counters. The structures used here must match those defined in
gcov-io.h. Write out the constructor to call __gcov_init. */
static void
-create_coverage ()
+create_coverage (void)
{
- tree gcov_info_fields, gcov_info_type, gcov_info_value, gcov_info;
- char name[20];
- char *ctor_name;
- tree ctor;
- rtx gcov_info_address;
- int save_flag_inline_functions = flag_inline_functions;
- unsigned i;
+ tree gcov_info, gcov_init, body, t;
+ char name_buf[32];
- for (i = 0; i < profile_info.n_sections; i++)
- if (profile_info.section_info[i].n_counters)
- break;
- if (i == profile_info.n_sections)
+ no_coverage = 1; /* Disable any further coverage. */
+
+ if (!prg_ctr_mask)
return;
-
- gcov_info_type = (*lang_hooks.types.make_type) (RECORD_TYPE);
- gcov_info_fields = build_gcov_info_fields (gcov_info_type);
- gcov_info_value = build_gcov_info_value ();
- set_purpose (gcov_info_value, gcov_info_fields);
- finish_builtin_struct (gcov_info_type, "__gcov_info",
- gcov_info_fields, NULL_TREE);
- gcov_info = build (VAR_DECL, gcov_info_type, NULL_TREE, NULL_TREE);
- DECL_INITIAL (gcov_info) =
- build_constructor (gcov_info_type, nreverse (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, lineno);
- (*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, lineno, 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
-/* Find (and create if not present) a section with TAG for the current
- function. */
-struct section_info *
-find_counters_section (tag)
- unsigned tag;
-{
- unsigned i;
-
- for (i = 0; i < profile_info.n_sections; i++)
- if (profile_info.section_info[i].tag == tag)
- return profile_info.section_info + i;
-
- if (i == MAX_COUNTER_SECTIONS)
- abort ();
-
- profile_info.section_info[i].tag = tag;
- profile_info.section_info[i].present = 0;
- profile_info.section_info[i].n_counters = 0;
- profile_info.section_info[i].n_counters_now = 0;
- profile_info.n_sections++;
-
- return profile_info.section_info + i;
-}
-
-/* Generate a MEM rtl to access counter NO in counter section TAG. */
-
-rtx
-coverage_counter_ref (unsigned tag, unsigned no)
-{
- enum machine_mode mode = mode_for_size (GCOV_TYPE_SIZE, MODE_INT, 0);
- struct section_info *sect = find_counters_section (tag);
- rtx ref;
-
- if (!profiler_label)
- {
- /* Generate and save a copy of this so it can be shared. */
- char buf[20];
-
- ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", 2);
- profiler_label = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
- }
- if (no + 1 > (unsigned) sect->n_counters_now)
- sect->n_counters_now = no + 1;
-
- no += sect->n_counters;
- ref = plus_constant (profiler_label, GCOV_TYPE_SIZE / BITS_PER_UNIT * no);
- ref = gen_rtx_MEM (mode, ref);
- set_mem_alias_set (ref, new_alias_set ());
-
- return ref;
-}
-
-\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);
- da_file_name = (char *) xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
+ /* Name of da file. */
+ da_file_name = xmalloc (len + strlen (GCOV_DATA_SUFFIX) + 1);
strcpy (da_file_name, filename);
strcat (da_file_name, GCOV_DATA_SUFFIX);
-
- read_counts_file ();
- /* Open the bbg output file. */
- bbg_file_name = (char *) xmalloc (len + strlen (GCOV_GRAPH_SUFFIX) + 1);
+ /* Name of bbg file. */
+ 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 ();
}
/* Performs file-level cleanup. Close graph file, generate coverage
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);
}
}
-
#include "gt-coverage.h"
OSDN Git Service
