/* Read and write coverage files, and associated functionality.
|
/* Read and write coverage files, and associated functionality.
|
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
|
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
|
2000, 2001, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
2000, 2001, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
|
Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
|
Contributed by James E. Wilson, UC Berkeley/Cygnus Support;
|
based on some ideas from Dain Samples of UC Berkeley.
|
based on some ideas from Dain Samples of UC Berkeley.
|
Further mangling by Bob Manson, Cygnus Support.
|
Further mangling by Bob Manson, Cygnus Support.
|
Further mangled by Nathan Sidwell, CodeSourcery
|
Further mangled by Nathan Sidwell, CodeSourcery
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
GCC is free software; you can redistribute it and/or modify it under
|
the terms of the GNU General Public License as published by the Free
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
|
#define GCOV_LINKAGE
|
#define GCOV_LINKAGE
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "rtl.h"
|
#include "rtl.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "output.h"
|
#include "output.h"
|
#include "regs.h"
|
#include "regs.h"
|
#include "expr.h"
|
#include "expr.h"
|
#include "function.h"
|
#include "function.h"
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "ggc.h"
|
#include "ggc.h"
|
#include "coverage.h"
|
#include "coverage.h"
|
#include "langhooks.h"
|
#include "langhooks.h"
|
#include "hashtab.h"
|
#include "hashtab.h"
|
#include "tree-iterator.h"
|
#include "tree-iterator.h"
|
#include "cgraph.h"
|
#include "cgraph.h"
|
|
|
#include "gcov-io.c"
|
#include "gcov-io.c"
|
|
|
struct function_list
|
struct function_list
|
{
|
{
|
struct function_list *next; /* next function */
|
struct function_list *next; /* next function */
|
unsigned ident; /* function ident */
|
unsigned ident; /* function ident */
|
unsigned checksum; /* function checksum */
|
unsigned checksum; /* function checksum */
|
unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */
|
unsigned n_ctrs[GCOV_COUNTERS];/* number of counters. */
|
};
|
};
|
|
|
/* Counts information for a function. */
|
/* Counts information for a function. */
|
typedef struct counts_entry
|
typedef struct counts_entry
|
{
|
{
|
/* We hash by */
|
/* We hash by */
|
unsigned ident;
|
unsigned ident;
|
unsigned ctr;
|
unsigned ctr;
|
|
|
/* Store */
|
/* Store */
|
unsigned checksum;
|
unsigned checksum;
|
gcov_type *counts;
|
gcov_type *counts;
|
struct gcov_ctr_summary summary;
|
struct gcov_ctr_summary summary;
|
|
|
/* Workspace */
|
/* Workspace */
|
struct counts_entry *chain;
|
struct counts_entry *chain;
|
|
|
} counts_entry_t;
|
} counts_entry_t;
|
|
|
static struct function_list *functions_head = 0;
|
static struct function_list *functions_head = 0;
|
static struct function_list **functions_tail = &functions_head;
|
static struct function_list **functions_tail = &functions_head;
|
static unsigned no_coverage = 0;
|
static unsigned no_coverage = 0;
|
|
|
/* Cumulative counter information for whole program. */
|
/* Cumulative counter information for whole program. */
|
static unsigned prg_ctr_mask; /* Mask of counter types generated. */
|
static unsigned prg_ctr_mask; /* Mask of counter types generated. */
|
static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */
|
static unsigned prg_n_ctrs[GCOV_COUNTERS]; /* Total counters allocated. */
|
|
|
/* Counter information for current function. */
|
/* Counter information for current function. */
|
static unsigned fn_ctr_mask; /* Mask of counters used. */
|
static unsigned fn_ctr_mask; /* Mask of counters used. */
|
static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
|
static unsigned fn_n_ctrs[GCOV_COUNTERS]; /* Counters allocated. */
|
static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
|
static unsigned fn_b_ctrs[GCOV_COUNTERS]; /* Allocation base. */
|
|
|
/* Name of the output file for coverage output file. */
|
/* Name of the output file for coverage output file. */
|
static char *bbg_file_name;
|
static char *bbg_file_name;
|
static unsigned bbg_file_opened;
|
static unsigned bbg_file_opened;
|
static int bbg_function_announced;
|
static int bbg_function_announced;
|
|
|
/* Name of the count data file. */
|
/* Name of the count data file. */
|
static char *da_file_name;
|
static char *da_file_name;
|
|
|
/* Hash table of count data. */
|
/* Hash table of count data. */
|
static htab_t counts_hash = NULL;
|
static htab_t counts_hash = NULL;
|
|
|
/* Trees representing the counter table arrays. */
|
/* Trees representing the counter table arrays. */
|
static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
|
static GTY(()) tree tree_ctr_tables[GCOV_COUNTERS];
|
|
|
/* The names of the counter tables. Not used if we're
|
/* The names of the counter tables. Not used if we're
|
generating counters at tree level. */
|
generating counters at tree level. */
|
static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
|
static GTY(()) rtx ctr_labels[GCOV_COUNTERS];
|
|
|
/* The names of merge functions for 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_merge_functions[GCOV_COUNTERS] = GCOV_MERGE_FUNCTIONS;
|
static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
|
static const char *const ctr_names[GCOV_COUNTERS] = GCOV_COUNTER_NAMES;
|
|
|
/* Forward declarations. */
|
/* Forward declarations. */
|
static hashval_t htab_counts_entry_hash (const void *);
|
static hashval_t htab_counts_entry_hash (const void *);
|
static int htab_counts_entry_eq (const void *, const void *);
|
static int htab_counts_entry_eq (const void *, const void *);
|
static void htab_counts_entry_del (void *);
|
static void htab_counts_entry_del (void *);
|
static void read_counts_file (void);
|
static void read_counts_file (void);
|
static unsigned compute_checksum (void);
|
static unsigned compute_checksum (void);
|
static unsigned coverage_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_type (unsigned);
|
static tree build_fn_info_value (const struct function_list *, tree);
|
static tree build_fn_info_value (const struct function_list *, tree);
|
static tree build_ctr_info_type (void);
|
static tree build_ctr_info_type (void);
|
static tree build_ctr_info_value (unsigned, tree);
|
static tree build_ctr_info_value (unsigned, tree);
|
static tree build_gcov_info (void);
|
static tree build_gcov_info (void);
|
static void create_coverage (void);
|
static void create_coverage (void);
|
|
|
/* Return the type node for gcov_type. */
|
/* Return the type node for gcov_type. */
|
|
|
tree
|
tree
|
get_gcov_type (void)
|
get_gcov_type (void)
|
{
|
{
|
return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
|
return lang_hooks.types.type_for_size (GCOV_TYPE_SIZE, false);
|
}
|
}
|
|
|
/* Return the type node for gcov_unsigned_t. */
|
/* Return the type node for gcov_unsigned_t. */
|
|
|
static tree
|
static tree
|
get_gcov_unsigned_t (void)
|
get_gcov_unsigned_t (void)
|
{
|
{
|
return lang_hooks.types.type_for_size (32, true);
|
return lang_hooks.types.type_for_size (32, true);
|
}
|
}
|
|
|
static hashval_t
|
static hashval_t
|
htab_counts_entry_hash (const void *of)
|
htab_counts_entry_hash (const void *of)
|
{
|
{
|
const counts_entry_t *entry = of;
|
const counts_entry_t *entry = of;
|
|
|
return entry->ident * GCOV_COUNTERS + entry->ctr;
|
return entry->ident * GCOV_COUNTERS + entry->ctr;
|
}
|
}
|
|
|
static int
|
static int
|
htab_counts_entry_eq (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 *entry1 = of1;
|
const counts_entry_t *entry2 = of2;
|
const counts_entry_t *entry2 = of2;
|
|
|
return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
|
return entry1->ident == entry2->ident && entry1->ctr == entry2->ctr;
|
}
|
}
|
|
|
static void
|
static void
|
htab_counts_entry_del (void *of)
|
htab_counts_entry_del (void *of)
|
{
|
{
|
counts_entry_t *entry = of;
|
counts_entry_t *entry = of;
|
|
|
free (entry->counts);
|
free (entry->counts);
|
free (entry);
|
free (entry);
|
}
|
}
|
|
|
/* Read in the counts file, if available. */
|
/* Read in the counts file, if available. */
|
|
|
static void
|
static void
|
read_counts_file (void)
|
read_counts_file (void)
|
{
|
{
|
gcov_unsigned_t fn_ident = 0;
|
gcov_unsigned_t fn_ident = 0;
|
gcov_unsigned_t checksum = -1;
|
gcov_unsigned_t checksum = -1;
|
counts_entry_t *summaried = NULL;
|
counts_entry_t *summaried = NULL;
|
unsigned seen_summary = 0;
|
unsigned seen_summary = 0;
|
gcov_unsigned_t tag;
|
gcov_unsigned_t tag;
|
int is_error = 0;
|
int is_error = 0;
|
|
|
if (!gcov_open (da_file_name, 1))
|
if (!gcov_open (da_file_name, 1))
|
return;
|
return;
|
|
|
if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
|
if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
|
{
|
{
|
warning (0, "%qs is not a gcov data file", da_file_name);
|
warning (0, "%qs is not a gcov data file", da_file_name);
|
gcov_close ();
|
gcov_close ();
|
return;
|
return;
|
}
|
}
|
else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
|
else if ((tag = gcov_read_unsigned ()) != GCOV_VERSION)
|
{
|
{
|
char v[4], e[4];
|
char v[4], e[4];
|
|
|
GCOV_UNSIGNED2STRING (v, tag);
|
GCOV_UNSIGNED2STRING (v, tag);
|
GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
|
GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
|
|
|
warning (0, "%qs is version %q.*s, expected version %q.*s",
|
warning (0, "%qs is version %q.*s, expected version %q.*s",
|
da_file_name, 4, v, 4, e);
|
da_file_name, 4, v, 4, e);
|
gcov_close ();
|
gcov_close ();
|
return;
|
return;
|
}
|
}
|
|
|
/* Read and discard the stamp. */
|
/* Read and discard the stamp. */
|
gcov_read_unsigned ();
|
gcov_read_unsigned ();
|
|
|
counts_hash = htab_create (10,
|
counts_hash = htab_create (10,
|
htab_counts_entry_hash, htab_counts_entry_eq,
|
htab_counts_entry_hash, htab_counts_entry_eq,
|
htab_counts_entry_del);
|
htab_counts_entry_del);
|
while ((tag = gcov_read_unsigned ()))
|
while ((tag = gcov_read_unsigned ()))
|
{
|
{
|
gcov_unsigned_t length;
|
gcov_unsigned_t length;
|
gcov_position_t offset;
|
gcov_position_t offset;
|
|
|
length = gcov_read_unsigned ();
|
length = gcov_read_unsigned ();
|
offset = gcov_position ();
|
offset = gcov_position ();
|
if (tag == GCOV_TAG_FUNCTION)
|
if (tag == GCOV_TAG_FUNCTION)
|
{
|
{
|
fn_ident = gcov_read_unsigned ();
|
fn_ident = gcov_read_unsigned ();
|
checksum = gcov_read_unsigned ();
|
checksum = gcov_read_unsigned ();
|
if (seen_summary)
|
if (seen_summary)
|
{
|
{
|
/* We have already seen a summary, this means that this
|
/* We have already seen a summary, this means that this
|
new function begins a new set of program runs. We
|
new function begins a new set of program runs. We
|
must unlink the summaried chain. */
|
must unlink the summaried chain. */
|
counts_entry_t *entry, *chain;
|
counts_entry_t *entry, *chain;
|
|
|
for (entry = summaried; entry; entry = chain)
|
for (entry = summaried; entry; entry = chain)
|
{
|
{
|
chain = entry->chain;
|
chain = entry->chain;
|
entry->chain = NULL;
|
entry->chain = NULL;
|
}
|
}
|
summaried = NULL;
|
summaried = NULL;
|
seen_summary = 0;
|
seen_summary = 0;
|
}
|
}
|
}
|
}
|
else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
|
else if (tag == GCOV_TAG_PROGRAM_SUMMARY)
|
{
|
{
|
counts_entry_t *entry;
|
counts_entry_t *entry;
|
struct gcov_summary summary;
|
struct gcov_summary summary;
|
|
|
gcov_read_summary (&summary);
|
gcov_read_summary (&summary);
|
seen_summary = 1;
|
seen_summary = 1;
|
for (entry = summaried; entry; entry = entry->chain)
|
for (entry = summaried; entry; entry = entry->chain)
|
{
|
{
|
struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
|
struct gcov_ctr_summary *csum = &summary.ctrs[entry->ctr];
|
|
|
entry->summary.runs += csum->runs;
|
entry->summary.runs += csum->runs;
|
entry->summary.sum_all += csum->sum_all;
|
entry->summary.sum_all += csum->sum_all;
|
if (entry->summary.run_max < csum->run_max)
|
if (entry->summary.run_max < csum->run_max)
|
entry->summary.run_max = csum->run_max;
|
entry->summary.run_max = csum->run_max;
|
entry->summary.sum_max += csum->sum_max;
|
entry->summary.sum_max += csum->sum_max;
|
}
|
}
|
}
|
}
|
else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
|
else if (GCOV_TAG_IS_COUNTER (tag) && fn_ident)
|
{
|
{
|
counts_entry_t **slot, *entry, elt;
|
counts_entry_t **slot, *entry, elt;
|
unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
|
unsigned n_counts = GCOV_TAG_COUNTER_NUM (length);
|
unsigned ix;
|
unsigned ix;
|
|
|
elt.ident = fn_ident;
|
elt.ident = fn_ident;
|
elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
|
elt.ctr = GCOV_COUNTER_FOR_TAG (tag);
|
|
|
slot = (counts_entry_t **) htab_find_slot
|
slot = (counts_entry_t **) htab_find_slot
|
(counts_hash, &elt, INSERT);
|
(counts_hash, &elt, INSERT);
|
entry = *slot;
|
entry = *slot;
|
if (!entry)
|
if (!entry)
|
{
|
{
|
*slot = entry = XCNEW (counts_entry_t);
|
*slot = entry = XCNEW (counts_entry_t);
|
entry->ident = elt.ident;
|
entry->ident = elt.ident;
|
entry->ctr = elt.ctr;
|
entry->ctr = elt.ctr;
|
entry->checksum = checksum;
|
entry->checksum = checksum;
|
entry->summary.num = n_counts;
|
entry->summary.num = n_counts;
|
entry->counts = XCNEWVEC (gcov_type, n_counts);
|
entry->counts = XCNEWVEC (gcov_type, n_counts);
|
}
|
}
|
else if (entry->checksum != checksum)
|
else if (entry->checksum != checksum)
|
{
|
{
|
error ("coverage mismatch for function %u while reading execution counters",
|
error ("coverage mismatch for function %u while reading execution counters",
|
fn_ident);
|
fn_ident);
|
error ("checksum is %x instead of %x", entry->checksum, checksum);
|
error ("checksum is %x instead of %x", entry->checksum, checksum);
|
htab_delete (counts_hash);
|
htab_delete (counts_hash);
|
break;
|
break;
|
}
|
}
|
else if (entry->summary.num != n_counts)
|
else if (entry->summary.num != n_counts)
|
{
|
{
|
error ("coverage mismatch for function %u while reading execution counters",
|
error ("coverage mismatch for function %u while reading execution counters",
|
fn_ident);
|
fn_ident);
|
error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
|
error ("number of counters is %d instead of %d", entry->summary.num, n_counts);
|
htab_delete (counts_hash);
|
htab_delete (counts_hash);
|
break;
|
break;
|
}
|
}
|
else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
|
else if (elt.ctr >= GCOV_COUNTERS_SUMMABLE)
|
{
|
{
|
error ("cannot merge separate %s counters for function %u",
|
error ("cannot merge separate %s counters for function %u",
|
ctr_names[elt.ctr], fn_ident);
|
ctr_names[elt.ctr], fn_ident);
|
goto skip_merge;
|
goto skip_merge;
|
}
|
}
|
|
|
if (elt.ctr < GCOV_COUNTERS_SUMMABLE
|
if (elt.ctr < GCOV_COUNTERS_SUMMABLE
|
/* This should always be true for a just allocated entry,
|
/* This should always be true for a just allocated entry,
|
and always false for an existing one. Check this way, in
|
and always false for an existing one. Check this way, in
|
case the gcov file is corrupt. */
|
case the gcov file is corrupt. */
|
&& (!entry->chain || summaried != entry))
|
&& (!entry->chain || summaried != entry))
|
{
|
{
|
entry->chain = summaried;
|
entry->chain = summaried;
|
summaried = entry;
|
summaried = entry;
|
}
|
}
|
for (ix = 0; ix != n_counts; ix++)
|
for (ix = 0; ix != n_counts; ix++)
|
entry->counts[ix] += gcov_read_counter ();
|
entry->counts[ix] += gcov_read_counter ();
|
skip_merge:;
|
skip_merge:;
|
}
|
}
|
gcov_sync (offset, length);
|
gcov_sync (offset, length);
|
if ((is_error = gcov_is_error ()))
|
if ((is_error = gcov_is_error ()))
|
{
|
{
|
error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
|
error (is_error < 0 ? "%qs has overflowed" : "%qs is corrupted",
|
da_file_name);
|
da_file_name);
|
htab_delete (counts_hash);
|
htab_delete (counts_hash);
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
gcov_close ();
|
gcov_close ();
|
}
|
}
|
|
|
/* Returns the counters for a particular tag. */
|
/* Returns the counters for a particular tag. */
|
|
|
gcov_type *
|
gcov_type *
|
get_coverage_counts (unsigned counter, unsigned expected,
|
get_coverage_counts (unsigned counter, unsigned expected,
|
const struct gcov_ctr_summary **summary)
|
const struct gcov_ctr_summary **summary)
|
{
|
{
|
counts_entry_t *entry, elt;
|
counts_entry_t *entry, elt;
|
gcov_unsigned_t checksum = -1;
|
gcov_unsigned_t checksum = -1;
|
|
|
/* No hash table, no counts. */
|
/* No hash table, no counts. */
|
if (!counts_hash)
|
if (!counts_hash)
|
{
|
{
|
static int warned = 0;
|
static int warned = 0;
|
|
|
if (!warned++)
|
if (!warned++)
|
inform ((flag_guess_branch_prob
|
inform ((flag_guess_branch_prob
|
? "file %s not found, execution counts estimated"
|
? "file %s not found, execution counts estimated"
|
: "file %s not found, execution counts assumed to be zero"),
|
: "file %s not found, execution counts assumed to be zero"),
|
da_file_name);
|
da_file_name);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
elt.ident = current_function_funcdef_no + 1;
|
elt.ident = current_function_funcdef_no + 1;
|
elt.ctr = counter;
|
elt.ctr = counter;
|
entry = htab_find (counts_hash, &elt);
|
entry = htab_find (counts_hash, &elt);
|
if (!entry)
|
if (!entry)
|
{
|
{
|
warning (0, "no coverage for function %qs found", IDENTIFIER_POINTER
|
warning (0, "no coverage for function %qs found", IDENTIFIER_POINTER
|
(DECL_ASSEMBLER_NAME (current_function_decl)));
|
(DECL_ASSEMBLER_NAME (current_function_decl)));
|
return 0;
|
return 0;
|
}
|
}
|
|
|
checksum = compute_checksum ();
|
checksum = compute_checksum ();
|
if (entry->checksum != checksum)
|
if (entry->checksum != checksum)
|
{
|
{
|
error ("coverage mismatch for function %qs while reading counter %qs",
|
error ("coverage mismatch for function %qs while reading counter %qs",
|
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
|
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
|
ctr_names[counter]);
|
ctr_names[counter]);
|
error ("checksum is %x instead of %x", entry->checksum, checksum);
|
error ("checksum is %x instead of %x", entry->checksum, checksum);
|
return 0;
|
return 0;
|
}
|
}
|
else if (entry->summary.num != expected)
|
else if (entry->summary.num != expected)
|
{
|
{
|
error ("coverage mismatch for function %qs while reading counter %qs",
|
error ("coverage mismatch for function %qs while reading counter %qs",
|
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
|
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)),
|
ctr_names[counter]);
|
ctr_names[counter]);
|
error ("number of counters is %d instead of %d", entry->summary.num, expected);
|
error ("number of counters is %d instead of %d", entry->summary.num, expected);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
if (summary)
|
if (summary)
|
*summary = &entry->summary;
|
*summary = &entry->summary;
|
|
|
return entry->counts;
|
return entry->counts;
|
}
|
}
|
|
|
/* Allocate NUM counters of type COUNTER. Returns nonzero if the
|
/* Allocate NUM counters of type COUNTER. Returns nonzero if the
|
allocation succeeded. */
|
allocation succeeded. */
|
|
|
int
|
int
|
coverage_counter_alloc (unsigned counter, unsigned num)
|
coverage_counter_alloc (unsigned counter, unsigned num)
|
{
|
{
|
if (no_coverage)
|
if (no_coverage)
|
return 0;
|
return 0;
|
|
|
if (!num)
|
if (!num)
|
return 1;
|
return 1;
|
|
|
if (!tree_ctr_tables[counter])
|
if (!tree_ctr_tables[counter])
|
{
|
{
|
/* Generate and save a copy of this so it can be shared. Leave
|
/* 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
|
the index type unspecified for now; it will be set after all
|
functions have been compiled. */
|
functions have been compiled. */
|
char buf[20];
|
char buf[20];
|
tree gcov_type_node = get_gcov_type ();
|
tree gcov_type_node = get_gcov_type ();
|
tree gcov_type_array_type
|
tree gcov_type_array_type
|
= build_array_type (gcov_type_node, NULL_TREE);
|
= build_array_type (gcov_type_node, NULL_TREE);
|
tree_ctr_tables[counter]
|
tree_ctr_tables[counter]
|
= build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
|
= build_decl (VAR_DECL, NULL_TREE, gcov_type_array_type);
|
TREE_STATIC (tree_ctr_tables[counter]) = 1;
|
TREE_STATIC (tree_ctr_tables[counter]) = 1;
|
ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
|
ASM_GENERATE_INTERNAL_LABEL (buf, "LPBX", counter + 1);
|
DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
|
DECL_NAME (tree_ctr_tables[counter]) = get_identifier (buf);
|
DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
|
DECL_ALIGN (tree_ctr_tables[counter]) = TYPE_ALIGN (gcov_type_node);
|
}
|
}
|
fn_b_ctrs[counter] = fn_n_ctrs[counter];
|
fn_b_ctrs[counter] = fn_n_ctrs[counter];
|
fn_n_ctrs[counter] += num;
|
fn_n_ctrs[counter] += num;
|
fn_ctr_mask |= 1 << counter;
|
fn_ctr_mask |= 1 << counter;
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* Generate a tree to access COUNTER NO. */
|
/* Generate a tree to access COUNTER NO. */
|
|
|
tree
|
tree
|
tree_coverage_counter_ref (unsigned counter, unsigned no)
|
tree_coverage_counter_ref (unsigned counter, unsigned no)
|
{
|
{
|
tree gcov_type_node = get_gcov_type ();
|
tree gcov_type_node = get_gcov_type ();
|
|
|
gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
|
gcc_assert (no < fn_n_ctrs[counter] - fn_b_ctrs[counter]);
|
no += prg_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. */
|
/* "no" here is an array index, scaled to bytes later. */
|
return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
|
return build4 (ARRAY_REF, gcov_type_node, tree_ctr_tables[counter],
|
build_int_cst (NULL_TREE, no), NULL, NULL);
|
build_int_cst (NULL_TREE, no), NULL, NULL);
|
}
|
}
|
|
|
/* Generate a checksum for a string. CHKSUM is the current
|
/* Generate a checksum for a string. CHKSUM is the current
|
checksum. */
|
checksum. */
|
|
|
static unsigned
|
static unsigned
|
coverage_checksum_string (unsigned chksum, const char *string)
|
coverage_checksum_string (unsigned chksum, const char *string)
|
{
|
{
|
int i;
|
int i;
|
char *dup = NULL;
|
char *dup = NULL;
|
|
|
/* Look for everything that looks if it were produced by
|
/* Look for everything that looks if it were produced by
|
get_file_function_name_long and zero out the second part
|
get_file_function_name_long and zero out the second part
|
that may result from flag_random_seed. This is not critical
|
that may result from flag_random_seed. This is not critical
|
as the checksums are used only for sanity checking. */
|
as the checksums are used only for sanity checking. */
|
for (i = 0; string[i]; i++)
|
for (i = 0; string[i]; i++)
|
{
|
{
|
int offset = 0;
|
int offset = 0;
|
if (!strncmp (string + i, "_GLOBAL__N_", 11))
|
if (!strncmp (string + i, "_GLOBAL__N_", 11))
|
offset = 11;
|
offset = 11;
|
if (!strncmp (string + i, "_GLOBAL__", 9))
|
if (!strncmp (string + i, "_GLOBAL__", 9))
|
offset = 9;
|
offset = 9;
|
|
|
/* C++ namespaces do have scheme:
|
/* C++ namespaces do have scheme:
|
_GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
|
_GLOBAL__N_<filename>_<wrongmagicnumber>_<magicnumber>functionname
|
since filename might contain extra underscores there seems
|
since filename might contain extra underscores there seems
|
to be no better chance then walk all possible offsets looking
|
to be no better chance then walk all possible offsets looking
|
for magicnuber. */
|
for magicnuber. */
|
if (offset)
|
if (offset)
|
{
|
{
|
for (i = i + offset; string[i]; i++)
|
for (i = i + offset; string[i]; i++)
|
if (string[i]=='_')
|
if (string[i]=='_')
|
{
|
{
|
int y;
|
int y;
|
|
|
for (y = 1; y < 9; y++)
|
for (y = 1; y < 9; y++)
|
if (!(string[i + y] >= '0' && string[i + y] <= '9')
|
if (!(string[i + y] >= '0' && string[i + y] <= '9')
|
&& !(string[i + y] >= 'A' && string[i + y] <= 'F'))
|
&& !(string[i + y] >= 'A' && string[i + y] <= 'F'))
|
break;
|
break;
|
if (y != 9 || string[i + 9] != '_')
|
if (y != 9 || string[i + 9] != '_')
|
continue;
|
continue;
|
for (y = 10; y < 18; y++)
|
for (y = 10; y < 18; y++)
|
if (!(string[i + y] >= '0' && string[i + y] <= '9')
|
if (!(string[i + y] >= '0' && string[i + y] <= '9')
|
&& !(string[i + y] >= 'A' && string[i + y] <= 'F'))
|
&& !(string[i + y] >= 'A' && string[i + y] <= 'F'))
|
break;
|
break;
|
if (y != 18)
|
if (y != 18)
|
continue;
|
continue;
|
if (!dup)
|
if (!dup)
|
string = dup = xstrdup (string);
|
string = dup = xstrdup (string);
|
for (y = 10; y < 18; y++)
|
for (y = 10; y < 18; y++)
|
dup[i + y] = '0';
|
dup[i + y] = '0';
|
}
|
}
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
chksum = crc32_string (chksum, string);
|
chksum = crc32_string (chksum, string);
|
if (dup)
|
if (dup)
|
free (dup);
|
free (dup);
|
|
|
return chksum;
|
return chksum;
|
}
|
}
|
|
|
/* Compute checksum for the current function. We generate a CRC32. */
|
/* Compute checksum for the current function. We generate a CRC32. */
|
|
|
static unsigned
|
static unsigned
|
compute_checksum (void)
|
compute_checksum (void)
|
{
|
{
|
expanded_location xloc
|
expanded_location xloc
|
= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
|
= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
|
unsigned chksum = xloc.line;
|
unsigned chksum = xloc.line;
|
|
|
chksum = coverage_checksum_string (chksum, xloc.file);
|
chksum = coverage_checksum_string (chksum, xloc.file);
|
chksum = coverage_checksum_string
|
chksum = coverage_checksum_string
|
(chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
|
(chksum, IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (current_function_decl)));
|
|
|
return chksum;
|
return chksum;
|
}
|
}
|
|
|
/* Begin output to the graph file for the current function.
|
/* Begin output to the graph file for the current function.
|
Opens the output file, if not already done. Writes the
|
Opens the output file, if not already done. Writes the
|
function header, if not already done. Returns nonzero if data
|
function header, if not already done. Returns nonzero if data
|
should be output. */
|
should be output. */
|
|
|
int
|
int
|
coverage_begin_output (void)
|
coverage_begin_output (void)
|
{
|
{
|
if (no_coverage)
|
if (no_coverage)
|
return 0;
|
return 0;
|
|
|
if (!bbg_function_announced)
|
if (!bbg_function_announced)
|
{
|
{
|
expanded_location xloc
|
expanded_location xloc
|
= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
|
= expand_location (DECL_SOURCE_LOCATION (current_function_decl));
|
unsigned long offset;
|
unsigned long offset;
|
|
|
if (!bbg_file_opened)
|
if (!bbg_file_opened)
|
{
|
{
|
if (!gcov_open (bbg_file_name, -1))
|
if (!gcov_open (bbg_file_name, -1))
|
error ("cannot open %s", bbg_file_name);
|
error ("cannot open %s", bbg_file_name);
|
else
|
else
|
{
|
{
|
gcov_write_unsigned (GCOV_NOTE_MAGIC);
|
gcov_write_unsigned (GCOV_NOTE_MAGIC);
|
gcov_write_unsigned (GCOV_VERSION);
|
gcov_write_unsigned (GCOV_VERSION);
|
gcov_write_unsigned (local_tick);
|
gcov_write_unsigned (local_tick);
|
}
|
}
|
bbg_file_opened = 1;
|
bbg_file_opened = 1;
|
}
|
}
|
|
|
/* Announce function */
|
/* Announce function */
|
offset = gcov_write_tag (GCOV_TAG_FUNCTION);
|
offset = gcov_write_tag (GCOV_TAG_FUNCTION);
|
gcov_write_unsigned (current_function_funcdef_no + 1);
|
gcov_write_unsigned (current_function_funcdef_no + 1);
|
gcov_write_unsigned (compute_checksum ());
|
gcov_write_unsigned (compute_checksum ());
|
gcov_write_string (IDENTIFIER_POINTER
|
gcov_write_string (IDENTIFIER_POINTER
|
(DECL_ASSEMBLER_NAME (current_function_decl)));
|
(DECL_ASSEMBLER_NAME (current_function_decl)));
|
gcov_write_string (xloc.file);
|
gcov_write_string (xloc.file);
|
gcov_write_unsigned (xloc.line);
|
gcov_write_unsigned (xloc.line);
|
gcov_write_length (offset);
|
gcov_write_length (offset);
|
|
|
bbg_function_announced = 1;
|
bbg_function_announced = 1;
|
}
|
}
|
return !gcov_is_error ();
|
return !gcov_is_error ();
|
}
|
}
|
|
|
/* Finish coverage data for the current function. Verify no output
|
/* Finish coverage data for the current function. Verify no output
|
error has occurred. Save function coverage counts. */
|
error has occurred. Save function coverage counts. */
|
|
|
void
|
void
|
coverage_end_function (void)
|
coverage_end_function (void)
|
{
|
{
|
unsigned i;
|
unsigned i;
|
|
|
if (bbg_file_opened > 1 && gcov_is_error ())
|
if (bbg_file_opened > 1 && gcov_is_error ())
|
{
|
{
|
warning (0, "error writing %qs", bbg_file_name);
|
warning (0, "error writing %qs", bbg_file_name);
|
bbg_file_opened = -1;
|
bbg_file_opened = -1;
|
}
|
}
|
|
|
if (fn_ctr_mask)
|
if (fn_ctr_mask)
|
{
|
{
|
struct function_list *item;
|
struct function_list *item;
|
|
|
item = XNEW (struct function_list);
|
item = XNEW (struct function_list);
|
|
|
*functions_tail = item;
|
*functions_tail = item;
|
functions_tail = &item->next;
|
functions_tail = &item->next;
|
|
|
item->next = 0;
|
item->next = 0;
|
item->ident = current_function_funcdef_no + 1;
|
item->ident = current_function_funcdef_no + 1;
|
item->checksum = compute_checksum ();
|
item->checksum = compute_checksum ();
|
for (i = 0; i != GCOV_COUNTERS; i++)
|
for (i = 0; i != GCOV_COUNTERS; i++)
|
{
|
{
|
item->n_ctrs[i] = fn_n_ctrs[i];
|
item->n_ctrs[i] = fn_n_ctrs[i];
|
prg_n_ctrs[i] += fn_n_ctrs[i];
|
prg_n_ctrs[i] += fn_n_ctrs[i];
|
fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
|
fn_n_ctrs[i] = fn_b_ctrs[i] = 0;
|
}
|
}
|
prg_ctr_mask |= fn_ctr_mask;
|
prg_ctr_mask |= fn_ctr_mask;
|
fn_ctr_mask = 0;
|
fn_ctr_mask = 0;
|
}
|
}
|
bbg_function_announced = 0;
|
bbg_function_announced = 0;
|
}
|
}
|
|
|
/* Creates the gcov_fn_info RECORD_TYPE. */
|
/* Creates the gcov_fn_info RECORD_TYPE. */
|
|
|
static tree
|
static tree
|
build_fn_info_type (unsigned int 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 field, fields;
|
tree array_type;
|
tree array_type;
|
|
|
/* ident */
|
/* ident */
|
fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
fields = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
|
|
/* checksum */
|
/* checksum */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
|
|
array_type = build_int_cst (NULL_TREE, counters - 1);
|
array_type = build_int_cst (NULL_TREE, counters - 1);
|
array_type = build_index_type (array_type);
|
array_type = build_index_type (array_type);
|
array_type = build_array_type (get_gcov_unsigned_t (), array_type);
|
array_type = build_array_type (get_gcov_unsigned_t (), array_type);
|
|
|
/* counters */
|
/* counters */
|
field = build_decl (FIELD_DECL, NULL_TREE, array_type);
|
field = build_decl (FIELD_DECL, NULL_TREE, array_type);
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
|
|
finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
|
finish_builtin_struct (type, "__gcov_fn_info", fields, NULL_TREE);
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
/* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
|
/* Creates a CONSTRUCTOR for a gcov_fn_info. FUNCTION is
|
the function being processed and TYPE is the gcov_fn_info
|
the function being processed and TYPE is the gcov_fn_info
|
RECORD_TYPE. */
|
RECORD_TYPE. */
|
|
|
static tree
|
static tree
|
build_fn_info_value (const struct function_list *function, tree type)
|
build_fn_info_value (const struct function_list *function, tree type)
|
{
|
{
|
tree value = NULL_TREE;
|
tree value = NULL_TREE;
|
tree fields = TYPE_FIELDS (type);
|
tree fields = TYPE_FIELDS (type);
|
unsigned ix;
|
unsigned ix;
|
tree array_value = NULL_TREE;
|
tree array_value = NULL_TREE;
|
|
|
/* ident */
|
/* ident */
|
value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
|
value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
|
function->ident), value);
|
function->ident), value);
|
fields = TREE_CHAIN (fields);
|
fields = TREE_CHAIN (fields);
|
|
|
/* checksum */
|
/* checksum */
|
value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
|
value = tree_cons (fields, build_int_cstu (get_gcov_unsigned_t (),
|
function->checksum), value);
|
function->checksum), value);
|
fields = TREE_CHAIN (fields);
|
fields = TREE_CHAIN (fields);
|
|
|
/* counters */
|
/* counters */
|
for (ix = 0; ix != GCOV_COUNTERS; ix++)
|
for (ix = 0; ix != GCOV_COUNTERS; ix++)
|
if (prg_ctr_mask & (1 << ix))
|
if (prg_ctr_mask & (1 << ix))
|
{
|
{
|
tree counters = build_int_cstu (get_gcov_unsigned_t (),
|
tree counters = build_int_cstu (get_gcov_unsigned_t (),
|
function->n_ctrs[ix]);
|
function->n_ctrs[ix]);
|
|
|
array_value = tree_cons (NULL_TREE, counters, array_value);
|
array_value = tree_cons (NULL_TREE, counters, array_value);
|
}
|
}
|
|
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
array_value = build_constructor_from_list (TREE_TYPE (fields),
|
array_value = build_constructor_from_list (TREE_TYPE (fields),
|
nreverse (array_value));
|
nreverse (array_value));
|
value = tree_cons (fields, array_value, value);
|
value = tree_cons (fields, array_value, value);
|
|
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
value = build_constructor_from_list (type, nreverse (value));
|
value = build_constructor_from_list (type, nreverse (value));
|
|
|
return value;
|
return value;
|
}
|
}
|
|
|
/* Creates the gcov_ctr_info RECORD_TYPE. */
|
/* Creates the gcov_ctr_info RECORD_TYPE. */
|
|
|
static tree
|
static tree
|
build_ctr_info_type (void)
|
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 field, fields = NULL_TREE;
|
tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
|
tree gcov_ptr_type = build_pointer_type (get_gcov_type ());
|
tree gcov_merge_fn_type;
|
tree gcov_merge_fn_type;
|
|
|
/* counters */
|
/* counters */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
|
|
/* values */
|
/* values */
|
field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
|
field = build_decl (FIELD_DECL, NULL_TREE, gcov_ptr_type);
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
|
|
/* merge */
|
/* merge */
|
gcov_merge_fn_type =
|
gcov_merge_fn_type =
|
build_function_type_list (void_type_node,
|
build_function_type_list (void_type_node,
|
gcov_ptr_type, get_gcov_unsigned_t (),
|
gcov_ptr_type, get_gcov_unsigned_t (),
|
NULL_TREE);
|
NULL_TREE);
|
field = build_decl (FIELD_DECL, NULL_TREE,
|
field = build_decl (FIELD_DECL, NULL_TREE,
|
build_pointer_type (gcov_merge_fn_type));
|
build_pointer_type (gcov_merge_fn_type));
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
|
|
finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
|
finish_builtin_struct (type, "__gcov_ctr_info", fields, NULL_TREE);
|
|
|
return type;
|
return type;
|
}
|
}
|
|
|
/* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
|
/* Creates a CONSTRUCTOR for a gcov_ctr_info. COUNTER is
|
the counter being processed and TYPE is the gcov_ctr_info
|
the counter being processed and TYPE is the gcov_ctr_info
|
RECORD_TYPE. */
|
RECORD_TYPE. */
|
|
|
static tree
|
static tree
|
build_ctr_info_value (unsigned int counter, tree type)
|
build_ctr_info_value (unsigned int counter, tree type)
|
{
|
{
|
tree value = NULL_TREE;
|
tree value = NULL_TREE;
|
tree fields = TYPE_FIELDS (type);
|
tree fields = TYPE_FIELDS (type);
|
tree fn;
|
tree fn;
|
|
|
/* counters */
|
/* counters */
|
value = tree_cons (fields,
|
value = tree_cons (fields,
|
build_int_cstu (get_gcov_unsigned_t (),
|
build_int_cstu (get_gcov_unsigned_t (),
|
prg_n_ctrs[counter]),
|
prg_n_ctrs[counter]),
|
value);
|
value);
|
fields = TREE_CHAIN (fields);
|
fields = TREE_CHAIN (fields);
|
|
|
if (prg_n_ctrs[counter])
|
if (prg_n_ctrs[counter])
|
{
|
{
|
tree array_type;
|
tree array_type;
|
|
|
array_type = build_int_cstu (get_gcov_unsigned_t (),
|
array_type = build_int_cstu (get_gcov_unsigned_t (),
|
prg_n_ctrs[counter] - 1);
|
prg_n_ctrs[counter] - 1);
|
array_type = build_index_type (array_type);
|
array_type = build_index_type (array_type);
|
array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
|
array_type = build_array_type (TREE_TYPE (TREE_TYPE (fields)),
|
array_type);
|
array_type);
|
|
|
TREE_TYPE (tree_ctr_tables[counter]) = array_type;
|
TREE_TYPE (tree_ctr_tables[counter]) = array_type;
|
DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
|
DECL_SIZE (tree_ctr_tables[counter]) = TYPE_SIZE (array_type);
|
DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
|
DECL_SIZE_UNIT (tree_ctr_tables[counter]) = TYPE_SIZE_UNIT (array_type);
|
assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
|
assemble_variable (tree_ctr_tables[counter], 0, 0, 0);
|
|
|
value = tree_cons (fields,
|
value = tree_cons (fields,
|
build1 (ADDR_EXPR, TREE_TYPE (fields),
|
build1 (ADDR_EXPR, TREE_TYPE (fields),
|
tree_ctr_tables[counter]),
|
tree_ctr_tables[counter]),
|
value);
|
value);
|
}
|
}
|
else
|
else
|
value = tree_cons (fields, null_pointer_node, value);
|
value = tree_cons (fields, null_pointer_node, value);
|
fields = TREE_CHAIN (fields);
|
fields = TREE_CHAIN (fields);
|
|
|
fn = build_decl (FUNCTION_DECL,
|
fn = build_decl (FUNCTION_DECL,
|
get_identifier (ctr_merge_functions[counter]),
|
get_identifier (ctr_merge_functions[counter]),
|
TREE_TYPE (TREE_TYPE (fields)));
|
TREE_TYPE (TREE_TYPE (fields)));
|
DECL_EXTERNAL (fn) = 1;
|
DECL_EXTERNAL (fn) = 1;
|
TREE_PUBLIC (fn) = 1;
|
TREE_PUBLIC (fn) = 1;
|
DECL_ARTIFICIAL (fn) = 1;
|
DECL_ARTIFICIAL (fn) = 1;
|
TREE_NOTHROW (fn) = 1;
|
TREE_NOTHROW (fn) = 1;
|
value = tree_cons (fields,
|
value = tree_cons (fields,
|
build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
|
build1 (ADDR_EXPR, TREE_TYPE (fields), fn),
|
value);
|
value);
|
|
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
value = build_constructor_from_list (type, nreverse (value));
|
value = build_constructor_from_list (type, nreverse (value));
|
|
|
return value;
|
return value;
|
}
|
}
|
|
|
/* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
|
/* Creates the gcov_info RECORD_TYPE and initializer for it. Returns a
|
CONSTRUCTOR. */
|
CONSTRUCTOR. */
|
|
|
static tree
|
static tree
|
build_gcov_info (void)
|
build_gcov_info (void)
|
{
|
{
|
unsigned n_ctr_types, ix;
|
unsigned n_ctr_types, ix;
|
tree type, const_type;
|
tree type, const_type;
|
tree fn_info_type, fn_info_value = NULL_TREE;
|
tree fn_info_type, fn_info_value = NULL_TREE;
|
tree fn_info_ptr_type;
|
tree fn_info_ptr_type;
|
tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
|
tree ctr_info_type, ctr_info_ary_type, ctr_info_value = NULL_TREE;
|
tree field, fields = NULL_TREE;
|
tree field, fields = NULL_TREE;
|
tree value = NULL_TREE;
|
tree value = NULL_TREE;
|
tree filename_string;
|
tree filename_string;
|
char *filename;
|
char *filename;
|
int filename_len;
|
int filename_len;
|
unsigned n_fns;
|
unsigned n_fns;
|
const struct function_list *fn;
|
const struct function_list *fn;
|
tree string_type;
|
tree string_type;
|
|
|
/* Count the number of active counters. */
|
/* Count the number of active counters. */
|
for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
|
for (n_ctr_types = 0, ix = 0; ix != GCOV_COUNTERS; ix++)
|
if (prg_ctr_mask & (1 << ix))
|
if (prg_ctr_mask & (1 << ix))
|
n_ctr_types++;
|
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);
|
const_type = build_qualified_type (type, TYPE_QUAL_CONST);
|
|
|
/* Version ident */
|
/* Version ident */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
|
value = tree_cons (field, build_int_cstu (TREE_TYPE (field), GCOV_VERSION),
|
value);
|
value);
|
|
|
/* next -- NULL */
|
/* next -- NULL */
|
field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
|
field = build_decl (FIELD_DECL, NULL_TREE, build_pointer_type (const_type));
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field, null_pointer_node, value);
|
value = tree_cons (field, null_pointer_node, value);
|
|
|
/* stamp */
|
/* stamp */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
|
value = tree_cons (field, build_int_cstu (TREE_TYPE (field), local_tick),
|
value);
|
value);
|
|
|
/* Filename */
|
/* Filename */
|
string_type = build_pointer_type (build_qualified_type (char_type_node,
|
string_type = build_pointer_type (build_qualified_type (char_type_node,
|
TYPE_QUAL_CONST));
|
TYPE_QUAL_CONST));
|
field = build_decl (FIELD_DECL, NULL_TREE, string_type);
|
field = build_decl (FIELD_DECL, NULL_TREE, string_type);
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
filename = getpwd ();
|
filename = getpwd ();
|
filename = (filename && da_file_name[0] != '/'
|
filename = (filename && da_file_name[0] != '/'
|
? concat (filename, "/", da_file_name, NULL)
|
? concat (filename, "/", da_file_name, NULL)
|
: da_file_name);
|
: da_file_name);
|
filename_len = strlen (filename);
|
filename_len = strlen (filename);
|
filename_string = build_string (filename_len + 1, filename);
|
filename_string = build_string (filename_len + 1, filename);
|
if (filename != da_file_name)
|
if (filename != da_file_name)
|
free (filename);
|
free (filename);
|
TREE_TYPE (filename_string) = build_array_type
|
TREE_TYPE (filename_string) = build_array_type
|
(char_type_node, build_index_type
|
(char_type_node, build_index_type
|
(build_int_cst (NULL_TREE, filename_len)));
|
(build_int_cst (NULL_TREE, filename_len)));
|
value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
|
value = tree_cons (field, build1 (ADDR_EXPR, string_type, filename_string),
|
value);
|
value);
|
|
|
/* Build the fn_info type and initializer. */
|
/* Build the fn_info type and initializer. */
|
fn_info_type = build_fn_info_type (n_ctr_types);
|
fn_info_type = build_fn_info_type (n_ctr_types);
|
fn_info_ptr_type = build_pointer_type (build_qualified_type
|
fn_info_ptr_type = build_pointer_type (build_qualified_type
|
(fn_info_type, TYPE_QUAL_CONST));
|
(fn_info_type, TYPE_QUAL_CONST));
|
for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
|
for (fn = functions_head, n_fns = 0; fn; fn = fn->next, n_fns++)
|
fn_info_value = tree_cons (NULL_TREE,
|
fn_info_value = tree_cons (NULL_TREE,
|
build_fn_info_value (fn, fn_info_type),
|
build_fn_info_value (fn, fn_info_type),
|
fn_info_value);
|
fn_info_value);
|
if (n_fns)
|
if (n_fns)
|
{
|
{
|
tree array_type;
|
tree array_type;
|
|
|
array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
|
array_type = build_index_type (build_int_cst (NULL_TREE, n_fns - 1));
|
array_type = build_array_type (fn_info_type, array_type);
|
array_type = build_array_type (fn_info_type, array_type);
|
|
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
fn_info_value = build_constructor_from_list (array_type,
|
fn_info_value = build_constructor_from_list (array_type,
|
nreverse (fn_info_value));
|
nreverse (fn_info_value));
|
fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
|
fn_info_value = build1 (ADDR_EXPR, fn_info_ptr_type, fn_info_value);
|
}
|
}
|
else
|
else
|
fn_info_value = null_pointer_node;
|
fn_info_value = null_pointer_node;
|
|
|
/* number of functions */
|
/* number of functions */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field,
|
value = tree_cons (field,
|
build_int_cstu (get_gcov_unsigned_t (), n_fns),
|
build_int_cstu (get_gcov_unsigned_t (), n_fns),
|
value);
|
value);
|
|
|
/* fn_info table */
|
/* fn_info table */
|
field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
|
field = build_decl (FIELD_DECL, NULL_TREE, fn_info_ptr_type);
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field, fn_info_value, value);
|
value = tree_cons (field, fn_info_value, value);
|
|
|
/* counter_mask */
|
/* counter_mask */
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
field = build_decl (FIELD_DECL, NULL_TREE, get_gcov_unsigned_t ());
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field,
|
value = tree_cons (field,
|
build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask),
|
build_int_cstu (get_gcov_unsigned_t (), prg_ctr_mask),
|
value);
|
value);
|
|
|
/* counters */
|
/* counters */
|
ctr_info_type = build_ctr_info_type ();
|
ctr_info_type = build_ctr_info_type ();
|
ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
|
ctr_info_ary_type = build_index_type (build_int_cst (NULL_TREE,
|
n_ctr_types));
|
n_ctr_types));
|
ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
|
ctr_info_ary_type = build_array_type (ctr_info_type, ctr_info_ary_type);
|
for (ix = 0; ix != GCOV_COUNTERS; ix++)
|
for (ix = 0; ix != GCOV_COUNTERS; ix++)
|
if (prg_ctr_mask & (1 << ix))
|
if (prg_ctr_mask & (1 << ix))
|
ctr_info_value = tree_cons (NULL_TREE,
|
ctr_info_value = tree_cons (NULL_TREE,
|
build_ctr_info_value (ix, ctr_info_type),
|
build_ctr_info_value (ix, ctr_info_type),
|
ctr_info_value);
|
ctr_info_value);
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
|
ctr_info_value = build_constructor_from_list (ctr_info_ary_type,
|
nreverse (ctr_info_value));
|
nreverse (ctr_info_value));
|
|
|
field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
|
field = build_decl (FIELD_DECL, NULL_TREE, ctr_info_ary_type);
|
TREE_CHAIN (field) = fields;
|
TREE_CHAIN (field) = fields;
|
fields = field;
|
fields = field;
|
value = tree_cons (field, ctr_info_value, value);
|
value = tree_cons (field, ctr_info_value, value);
|
|
|
finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
|
finish_builtin_struct (type, "__gcov_info", fields, NULL_TREE);
|
|
|
/* FIXME: use build_constructor directly. */
|
/* FIXME: use build_constructor directly. */
|
value = build_constructor_from_list (type, nreverse (value));
|
value = build_constructor_from_list (type, nreverse (value));
|
|
|
return value;
|
return value;
|
}
|
}
|
|
|
/* Write out the structure which libgcov uses to locate all the
|
/* Write out the structure which libgcov uses to locate all the
|
counters. The structures used here must match those defined in
|
counters. The structures used here must match those defined in
|
gcov-io.h. Write out the constructor to call __gcov_init. */
|
gcov-io.h. Write out the constructor to call __gcov_init. */
|
|
|
static void
|
static void
|
create_coverage (void)
|
create_coverage (void)
|
{
|
{
|
tree gcov_info, gcov_init, body, t;
|
tree gcov_info, gcov_init, body, t;
|
char name_buf[32];
|
char name_buf[32];
|
|
|
no_coverage = 1; /* Disable any further coverage. */
|
no_coverage = 1; /* Disable any further coverage. */
|
|
|
if (!prg_ctr_mask)
|
if (!prg_ctr_mask)
|
return;
|
return;
|
|
|
t = build_gcov_info ();
|
t = build_gcov_info ();
|
|
|
gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
|
gcov_info = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (t));
|
TREE_STATIC (gcov_info) = 1;
|
TREE_STATIC (gcov_info) = 1;
|
ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
|
ASM_GENERATE_INTERNAL_LABEL (name_buf, "LPBX", 0);
|
DECL_NAME (gcov_info) = get_identifier (name_buf);
|
DECL_NAME (gcov_info) = get_identifier (name_buf);
|
DECL_INITIAL (gcov_info) = t;
|
DECL_INITIAL (gcov_info) = t;
|
|
|
/* Build structure. */
|
/* Build structure. */
|
assemble_variable (gcov_info, 0, 0, 0);
|
assemble_variable (gcov_info, 0, 0, 0);
|
|
|
/* Build a decl for __gcov_init. */
|
/* Build a decl for __gcov_init. */
|
t = build_pointer_type (TREE_TYPE (gcov_info));
|
t = build_pointer_type (TREE_TYPE (gcov_info));
|
t = build_function_type_list (void_type_node, t, NULL);
|
t = build_function_type_list (void_type_node, t, NULL);
|
t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
|
t = build_decl (FUNCTION_DECL, get_identifier ("__gcov_init"), t);
|
TREE_PUBLIC (t) = 1;
|
TREE_PUBLIC (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
DECL_EXTERNAL (t) = 1;
|
gcov_init = t;
|
gcov_init = t;
|
|
|
/* Generate a call to __gcov_init(&gcov_info). */
|
/* Generate a call to __gcov_init(&gcov_info). */
|
body = NULL;
|
body = NULL;
|
t = build_fold_addr_expr (gcov_info);
|
t = build_fold_addr_expr (gcov_info);
|
t = tree_cons (NULL, t, NULL);
|
t = tree_cons (NULL, t, NULL);
|
t = build_function_call_expr (gcov_init, t);
|
t = build_function_call_expr (gcov_init, t);
|
append_to_statement_list (t, &body);
|
append_to_statement_list (t, &body);
|
|
|
/* Generate a constructor to run it. */
|
/* Generate a constructor to run it. */
|
cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
|
cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
|
}
|
}
|
|
|
/* Perform file-level initialization. Read in data file, generate name
|
/* Perform file-level initialization. Read in data file, generate name
|
of graph file. */
|
of graph file. */
|
|
|
void
|
void
|
coverage_init (const char *filename)
|
coverage_init (const char *filename)
|
{
|
{
|
int len = strlen (filename);
|
int len = strlen (filename);
|
|
|
/* Name of da file. */
|
/* Name of da file. */
|
da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) + 1);
|
da_file_name = XNEWVEC (char, len + strlen (GCOV_DATA_SUFFIX) + 1);
|
strcpy (da_file_name, filename);
|
strcpy (da_file_name, filename);
|
strcat (da_file_name, GCOV_DATA_SUFFIX);
|
strcat (da_file_name, GCOV_DATA_SUFFIX);
|
|
|
/* Name of bbg file. */
|
/* Name of bbg file. */
|
bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
|
bbg_file_name = XNEWVEC (char, len + strlen (GCOV_NOTE_SUFFIX) + 1);
|
strcpy (bbg_file_name, filename);
|
strcpy (bbg_file_name, filename);
|
strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
|
strcat (bbg_file_name, GCOV_NOTE_SUFFIX);
|
|
|
read_counts_file ();
|
read_counts_file ();
|
}
|
}
|
|
|
/* Performs file-level cleanup. Close graph file, generate coverage
|
/* Performs file-level cleanup. Close graph file, generate coverage
|
variables and constructor. */
|
variables and constructor. */
|
|
|
void
|
void
|
coverage_finish (void)
|
coverage_finish (void)
|
{
|
{
|
create_coverage ();
|
create_coverage ();
|
if (bbg_file_opened)
|
if (bbg_file_opened)
|
{
|
{
|
int error = gcov_close ();
|
int error = gcov_close ();
|
|
|
if (error)
|
if (error)
|
unlink (bbg_file_name);
|
unlink (bbg_file_name);
|
if (!local_tick)
|
if (!local_tick)
|
/* Only remove the da file, if we cannot stamp it. If we can
|
/* Only remove the da file, if we cannot stamp it. If we can
|
stamp it, libgcov will DTRT. */
|
stamp it, libgcov will DTRT. */
|
unlink (da_file_name);
|
unlink (da_file_name);
|
}
|
}
|
}
|
}
|
|
|
#include "gt-coverage.h"
|
#include "gt-coverage.h"
|
|
|
