1999, 2000, 2001, 2002 Free Software Foundation, Inc.
Contributed by James E. Wilson of Cygnus Support.
Mangled by Bob Manson of Cygnus Support.
+ Mangled further by Nathan Sidwell <nathan@codesourcery.com>
Gcov 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 Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* ??? The code in final.c that produces the struct bb assumes that there is
- no padding between the fields. This is not necessary true. The current
- code can only be trusted if longs and pointers are the same size. */
-
-/* ??? No need to print an execution count on every line, could just print
- it on the first line of each block, and only print it on a subsequent
- line in the same block if the count changes. */
-
/* ??? Print a list of the ten blocks with the highest execution counts,
and list the line numbers corresponding to those blocks. Also, perhaps
list the line numbers with the highest execution counts, only printing
/* ??? Should have an option to print the number of basic blocks, and the
percent of them that are covered. */
-/* ??? Does not correctly handle the case where two .bb files refer to the
- same included source file. For example, if one has a short file containing
- only inline functions, which is then included in two other files, then
- there will be two .bb files which refer to the include file, but there
- is no way to get the total execution counts for the included file, can
- only get execution counts for one or the other of the including files. */
+/* ??? Does not correctly handle the case where two .bb files refer to
+ the same included source file. For example, if one has a short
+ file containing only inline functions, which is then included in
+ two other files, then there will be two .bb files which refer to
+ the include file, but there is no way to get the total execution
+ counts for the included file, can only get execution counts for one
+ or the other of the including files. this can be fixed by --ratios
+ --long-file-names --preserve-paths and perl. */
+
+/* Need an option to show individual block counts, and show
+ probabilities of fall through arcs. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "intl.h"
#include "version.h"
#undef abort
typedef HOST_WIDEST_INT gcov_type;
#include "gcov-io.h"
-/* The .bb file format consists of several lists of 4-byte integers
- which are the line numbers of each basic block in the file. Each
- list is terminated by a zero. These lists correspond to the basic
- blocks in the reconstructed program flow graph.
-
- A line number of -1 indicates that a source file name (padded to a
- long boundary) follows. The padded file name is followed by
- another -1 to make it easy to scan past file names. A -2 indicates
- that a function name (padded to a long boundary) follows; the name
- is followed by another -2 to make it easy to scan past the function
- name.
-
- The .bbg file contains enough info to enable gcov to reconstruct the
- program flow graph. The first word is the number of basic blocks,
- the second word is the number of arcs, followed by the list of arcs
- (source bb, dest bb pairs), then a -1, then the number of instrumented
- arcs followed by the instrumented arcs, followed by another -1. This
- is repeated for each function.
-
- The .da file contains the execution count for each instrumented branch.
-
- The .bb and .bbg files are created by giving GCC the -ftest-coverage option,
- and the .da files are created when an executable compiled with
- -fprofile-arcs is run. */
+/* The bbg file is generated by -ftest-coverage option. The da file is
+ generated by a program compiled with -fprofile-arcs. Their formats
+ are documented in gcov-io.h. */
/* The functions in this file for creating and solution program flow graphs
- are very similar to functions in the gcc source file profile.c. */
+ are very similar to functions in the gcc source file profile.c. In
+ some places we make use of the knowledge of how profile.c works to
+ select particular algorithms here. */
/* This is the size of the buffer used to read in source file lines. */
#define STRING_SIZE 200
-/* One copy of this structure is created for each source file mentioned in the
- .bb file. */
+struct function_info;
+struct block_info;
-struct sourcefile
-{
- char *name;
- int maxlineno;
- struct sourcefile *next;
-};
+/* Describes an arc between two basic blocks. */
-/* This points to the head of the sourcefile structure list. */
-
-struct sourcefile *sources;
+typedef struct arc_info
+{
+ /* source and destination blocks. */
+ struct block_info *src;
+ struct block_info *dst;
-/* One of these is dynamically created whenever we identify an arc in the
- function. */
+ /* transition counts. */
+ gcov_type count;
-struct adj_list
-{
- int source;
- int target;
- gcov_type arc_count;
unsigned int count_valid : 1;
unsigned int on_tree : 1;
unsigned int fake : 1;
unsigned int fall_through : 1;
-#if 0
- /* Not needed for gcov, but defined in profile.c. */
- rtx branch_insn;
-#endif
- struct adj_list *pred_next;
- struct adj_list *succ_next;
-};
-/* Count the number of basic blocks, and create an array of these structures,
- one for each bb in the function. */
-
-struct bb_info
-{
- struct adj_list *succ;
- struct adj_list *pred;
- gcov_type succ_count;
- gcov_type pred_count;
- gcov_type exec_count;
- unsigned int count_valid : 1;
- unsigned int on_tree : 1;
-#if 0
- /* Not needed for gcov, but defined in profile.c. */
- rtx first_insn;
-#endif
-};
+ /* Arc to a call. */
+ unsigned int is_call : 1;
+
+ /* Next branch on line. */
+ struct arc_info *line_next;
+
+ /* Links to next arc on src and dst lists. */
+ struct arc_info *succ_next;
+ struct arc_info *pred_next;
+} arc_t;
-/* When outputting branch probabilities, one of these structures is created
- for each branch/call. */
+/* Describes a basic block. Contains lists of arcs to successor and
+ predecessor blocks. */
-struct arcdata
+typedef struct block_info
{
- gcov_type hits;
- gcov_type total;
- int call_insn;
- struct arcdata *next;
-};
+ /* Chain of exit and entry arcs. */
+ arc_t *succ;
+ arc_t *pred;
+
+ /* Number of unprocessed exit and entry arcs. */
+ gcov_type num_succ;
+ gcov_type num_pred;
+
+ /* Block execution count. */
+ gcov_type count;
+ unsigned count_valid : 1;
+ unsigned valid_chain : 1;
+ unsigned invalid_chain : 1;
+
+ /* Array of line numbers and source files. source files are
+ introduced by a linenumber of zero, the next 'line number' is the
+ number of the source file. Always starts with a source file. */
+ unsigned *encoding;
+ unsigned num_encodings;
+
+ /* Temporary chain for solving graph. */
+ struct block_info *chain;
+
+} block_t;
-/* Used to save the list of bb_graphs, one per function. */
+/* Describes a single function. Contains an array of basic blocks. */
-struct bb_info_list
+typedef struct function_info
{
- /* Indexed by block number, holds the basic block graph for one function. */
- struct bb_info *bb_graph;
- int num_blocks;
- struct bb_info_list *next;
-};
+ /* Name of function. */
+ char *name;
+ unsigned checksum;
-/* Used to hold information about each line. */
-struct line_info
-{
- gcov_type count; /* execution count */
- struct arcdata *branches; /* list of branch probabilities for line. */
- unsigned exists : 1; /* has code associated with it. */
-};
+ /* Array of basic blocks. */
+ block_t *blocks;
+ unsigned num_blocks;
+
+ /* Raw arc coverage counts. */
+ gcov_type *counts;
+ unsigned num_counts;
-struct coverage
+ /* Next function. */
+ struct function_info *next;
+} function_t;
+
+/* Describes coverage of a file or function. */
+
+typedef struct coverage_info
{
int lines;
int lines_executed;
int calls_executed;
char *name;
-};
+} coverage_t;
-/* Holds a list of function basic block graphs. */
+/* Describes a single line of source. Contains a chain of basic blocks
+ with code on it. */
-static struct bb_info_list *bb_graph_list = 0;
+typedef struct line_info
+{
+ gcov_type count; /* execution count */
+ arc_t *branches; /* branches from blocks that end on this
+ line. */
+ unsigned exists : 1;
+} line_t;
-/* Modification time of data files. */
+/* Describes a file mentioned in the block graph. Contains an array
+ of line info. */
-static time_t bb_file_time;
+typedef struct source_info
+{
+ /* Name of source file. */
+ char *name;
+ unsigned index;
-/* Name and file pointer of the input file for the basic block graph. */
+ /* Array of line information. */
+ line_t *lines;
+ unsigned num_lines;
-static char *bbg_file_name;
-static FILE *bbg_file;
+ coverage_t coverage;
+
+ /* Next source file. */
+ struct source_info *next;
+} source_t;
-/* Name and file pointer of the input file for the arc count data. */
+/* Holds a list of function basic block graphs. */
-static char *da_file_name;
-static FILE *da_file;
+static function_t *functions;
-/* Name and file pointer of the input file for the basic block line counts. */
+/* This points to the head of the sourcefile structure list. */
-static char *bb_file_name;
-static FILE *bb_file;
+static source_t *sources;
-/* Holds the entire contents of the bb_file read into memory. */
+/* Modification time of graph file. */
-static char *bb_data;
+static time_t bbg_file_time;
-/* Size of bb_data array in longs. */
+/* Name and file pointer of the input file for the basic block graph. */
-static long bb_data_size;
+static char *bbg_file_name;
-/* Name of the file mentioned on the command line. */
+/* Name and file pointer of the input file for the arc count data. */
-static char *input_file_name = 0;
+static char *da_file_name;
-/* Output branch probabilities if true. */
+/* Output branch probabilities. */
-static int output_branch_probs = 0;
+static int flag_branches = 0;
/* Output a gcov file if this is true. This is on by default, and can
be turned off by the -n option. */
-static int output_gcov_file = 1;
+static int flag_gcov_file = 1;
-/* For included files, make the gcov output file name include the name of
- the input source file. For example, if x.h is included in a.c, then the
- output file name is a.c.x.h.gcov instead of x.h.gcov. This works only
- when a single source file is specified. */
+/* For included files, make the gcov output file name include the name
+ of the input source file. For example, if x.h is included in a.c,
+ then the output file name is a.c##x.h.gcov instead of x.h.gcov. */
-static int output_long_names = 0;
+static int flag_long_names = 0;
/* Output summary info for each function. */
-static int output_function_summary = 0;
+static int flag_function_summary = 0;
-/* Object directory file prefix. This is the directory/file
- where .bb and .bbg files are looked for, if nonzero. */
+/* Object directory file prefix. This is the directory/file where the
+ graph and data files are looked for, if nonzero. */
static char *object_directory = 0;
/* Preserve all pathname components. Needed when object files and
- source files are in subdirectories. */
-static int preserve_paths = 0;
+ source files are in subdirectories. '/' is mangled as '#', '.' is
+ elided and '..' mangled to '^'. */
+
+static int flag_preserve_paths = 0;
/* Output the number of times a branch was taken as opposed to the percentage
- of times it was taken. Turned on by the -c option */
+ of times it was taken. */
-static int output_branch_counts = 0;
+static int flag_counts = 0;
/* Forward declarations. */
-static void process_args PARAMS ((int, char **));
-static void open_files PARAMS ((void));
-static void read_files PARAMS ((void));
-static void scan_for_source_files PARAMS ((void));
-static void output_data PARAMS ((struct sourcefile *));
+static void fnotice PARAMS ((FILE *, const char *, ...)) ATTRIBUTE_PRINTF_2;
+static int process_args PARAMS ((int, char **));
static void print_usage PARAMS ((int)) ATTRIBUTE_NORETURN;
static void print_version PARAMS ((void)) ATTRIBUTE_NORETURN;
-static void init_arc PARAMS ((struct adj_list *, int, int, struct bb_info *));
-static struct adj_list *reverse_arcs PARAMS ((struct adj_list *));
-static gcov_type *read_profile PARAMS ((char *, long, int));
-static void create_program_flow_graph PARAMS ((struct bb_info_list *));
-static void solve_program_flow_graph PARAMS ((struct bb_info_list *));
-static void accumulate_branch_counts PARAMS ((struct coverage *,
- struct arcdata *));
-static void calculate_branch_probs PARAMS ((struct bb_info *,
- struct line_info *,
- struct coverage *));
-static void function_summary PARAMS ((struct coverage *, const char *));
-static void init_line_info PARAMS ((struct line_info *,
- struct coverage *, long));
-static void output_line_info PARAMS ((FILE *, const struct line_info *,
- const struct coverage *, long));
-static char *make_gcov_file_name PARAMS ((char *));
-static const char *format_hwint PARAMS ((HOST_WIDEST_INT, HOST_WIDEST_INT,
- int));
-
+static void process_file PARAMS ((const char *));
+static void create_file_names PARAMS ((const char *));
+static int read_graph_file PARAMS ((void));
+static int read_count_file PARAMS ((void));
+static void solve_flow_graph PARAMS ((function_t *));
+static void add_branch_counts PARAMS ((coverage_t *, const arc_t *));
+static void add_line_counts PARAMS ((coverage_t *, const function_t *));
+static void function_summary PARAMS ((const coverage_t *, const char *));
+static const char *format_gcov PARAMS ((gcov_type, gcov_type, int));
+static void accumulate_line_counts PARAMS ((source_t *));
+static void output_lines PARAMS ((FILE *, const source_t *));
+static char *make_gcov_file_name PARAMS ((const char *, const char *));
+static void release_structures PARAMS ((void));
extern int main PARAMS ((int, char **));
int
int argc;
char **argv;
{
- struct sourcefile *s_ptr;
+ int argno;
gcc_init_libintl ();
- process_args (argc, argv);
-
- open_files ();
-
- read_files ();
-
- scan_for_source_files ();
-
- for (s_ptr = sources; s_ptr; s_ptr = s_ptr->next)
- output_data (s_ptr);
+ argno = process_args (argc, argv);
+ if (optind == argc)
+ print_usage (true);
+ for (; argno != argc; argno++)
+ {
+ release_structures ();
+
+ process_file (argv[argno]);
+ }
+
return 0;
}
-static void fnotice PARAMS ((FILE *, const char *, ...)) ATTRIBUTE_PRINTF_2;
static void
fnotice VPARAMS ((FILE *file, const char *msgid, ...))
{
{
FILE *file = error_p ? stderr : stdout;
int status = error_p ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
+
fnotice (file, "Usage: gcov [OPTION]... SOURCEFILE\n\n");
fnotice (file, "Print code coverage information.\n\n");
fnotice (file, " -h, --help Print this help, then exit\n");
static void
print_version ()
{
- fnotice (stdout, "gcov (GCC) %s\n", version_string);
- fnotice (stdout, "Copyright (C) 2001 Free Software Foundation, Inc.\n");
+ char v[4];
+ unsigned version = GCOV_VERSION;
+ unsigned ix;
+
+ for (ix = 4; ix--; version >>= 8)
+ v[ix] = version;
+ fnotice (stdout, "gcov %.4s (GCC %s)\n", v, version_string);
+ fnotice (stdout, "Copyright (C) 2002 Free Software Foundation, Inc.\n");
fnotice (stdout,
"This is free software; see the source for copying conditions. There is NO\n\
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\n");
{ "object-file", required_argument, NULL, 'o' },
};
-/* Parse the command line. */
+/* Process args, return index to first non-arg. */
-static void
+static int
process_args (argc, argv)
int argc;
char **argv;
print_version ();
/* print_version will exit. */
case 'b':
- output_branch_probs = 1;
+ flag_branches = 1;
break;
case 'c':
- output_branch_counts = 1;
+ flag_counts = 1;
break;
case 'n':
- output_gcov_file = 0;
+ flag_gcov_file = 0;
break;
case 'l':
- output_long_names = 1;
+ flag_long_names = 1;
break;
case 'f':
- output_function_summary = 1;
+ flag_function_summary = 1;
break;
case 'o':
object_directory = optarg;
break;
case 'p':
- preserve_paths = 1;
+ flag_preserve_paths = 1;
break;
default:
print_usage (true);
}
}
- if (optind != argc - 1)
- print_usage (true);
+ return optind;
+}
+
+/* Process a single source file. */
- input_file_name = argv[optind];
+static void
+process_file (file_name)
+ const char *file_name;
+{
+ source_t *src;
+ function_t *fn;
+
+ create_file_names (file_name);
+ if (read_graph_file ())
+ return;
+
+ if (!functions)
+ {
+ fnotice (stderr, "%s:no functions found\n", bbg_file_name);
+ return;
+ }
+
+ if (read_count_file ())
+ return;
+
+ for (fn = functions; fn; fn = fn->next)
+ solve_flow_graph (fn);
+ for (src = sources; src; src = src->next)
+ src->lines = (line_t *) xcalloc (src->num_lines, sizeof (line_t));
+ for (fn = functions; fn; fn = fn->next)
+ {
+ coverage_t coverage;
+
+ memset (&coverage, 0, sizeof (coverage));
+ coverage.name = fn->name;
+ add_line_counts (flag_function_summary ? &coverage : NULL, fn);
+ if (flag_function_summary)
+ {
+ function_summary (&coverage, "Function");
+ fnotice (stdout, "\n");
+ }
+ }
+
+ for (src = sources; src; src = src->next)
+ {
+ accumulate_line_counts (src);
+ function_summary (&src->coverage, "File");
+ if (flag_gcov_file)
+ {
+ char *gcov_file_name = make_gcov_file_name (file_name, src->name);
+ FILE *gcov_file = fopen (gcov_file_name, "w");
+
+ if (gcov_file)
+ {
+ fnotice (stdout, "%s:creating `%s'\n",
+ src->name, gcov_file_name);
+ output_lines (gcov_file, src);
+ if (ferror (gcov_file))
+ fnotice (stderr, "%s:error writing output file `%s'\n",
+ src->name, gcov_file_name);
+ fclose (gcov_file);
+ }
+ else
+ fnotice (stderr, "%s:could not open output file `%s'\n",
+ src->name, gcov_file_name);
+ free (gcov_file_name);
+ }
+ fnotice (stdout, "\n");
+ }
}
+/* Release all memory used. */
-/* Find and open the .bb, .da, and .bbg files. If OBJECT_DIRECTORY is
- not specified, these are looked for in the current directory, and
- named from the basename of the input_file_name sans extension. If
+static void
+release_structures ()
+{
+ function_t *fn;
+ source_t *src;
+
+ free (bbg_file_name);
+ free (da_file_name);
+ da_file_name = bbg_file_name = NULL;
+ bbg_file_time = 0;
+
+ while ((src = sources))
+ {
+ sources = src->next;
+
+ free (src->name);
+ free (src->lines);
+ }
+
+ while ((fn = functions))
+ {
+ unsigned ix;
+ block_t *block;
+
+ functions = fn->next;
+ for (ix = fn->num_blocks, block = fn->blocks; ix--; block++)
+ {
+ arc_t *arc, *arc_n;
+
+ for (arc = block->succ; arc; arc = arc_n)
+ {
+ arc_n = arc->succ_next;
+ free (arc);
+ }
+ free (block->encoding);
+ }
+ free (fn->blocks);
+ free (fn->counts);
+ }
+}
+
+/* Generate the names of the graph and data files. If OBJECT_DIRECTORY
+ is not specified, these are looked for in the current directory,
+ and named from the basename of the FILE_NAME sans extension. If
OBJECT_DIRECTORY is specified and is a directory, the files are in
- that directory, but named from the basename of the input_file_name,
- sans extension. Otherwise OBJECT_DIRECTORY is taken to be the name
- of the object *file*, and the data files are named from that. */
+ that directory, but named from the basename of the FILE_NAME, sans
+ extension. Otherwise OBJECT_DIRECTORY is taken to be the name of
+ the object *file*, and the data files are named from that. */
static void
-open_files ()
+create_file_names (file_name)
+ const char *file_name;
{
char *cptr;
char *name;
- int length = strlen (input_file_name);
+ int length = strlen (file_name);
int base;
if (object_directory && object_directory[0])
if (base)
{
/* Append source file name */
- cptr = strrchr (input_file_name, '/');
- cptr = cptr ? cptr + 1 : input_file_name;
-
- strcat (name, cptr);
+ cptr = strrchr (file_name, '/');
+ strcat (name, cptr ? cptr + 1 : file_name);
}
+
/* Remove the extension. */
cptr = strrchr (name, '.');
if (cptr)
*cptr = 0;
length = strlen (name);
- da_file_name = xmalloc (length + 4);
- bb_file_name = xmalloc (length + 4);
- bbg_file_name = xmalloc (length + 5);
-
- strcpy (da_file_name, name);
- strcpy (bb_file_name, name);
- strcpy (bbg_file_name, name);
- strcpy (da_file_name + length, ".da");
- strcpy (bb_file_name + length, ".bb");
- strcpy (bbg_file_name + length, ".bbg");
-
- bb_file = fopen (bb_file_name, "rb");
- if (bb_file == NULL)
- {
- fnotice (stderr, "Could not open basic block file %s.\n", bb_file_name);
- exit (FATAL_EXIT_CODE);
- }
-
- bbg_file = fopen (bbg_file_name, "rb");
- if (bbg_file == NULL)
- {
- fnotice (stderr, "Could not open program flow graph file %s.\n",
- bbg_file_name);
- exit (FATAL_EXIT_CODE);
- }
- {
- struct stat status;
+ bbg_file_name = xmalloc (length + strlen (GCOV_GRAPH_SUFFIX) + 1);
+ strcpy (bbg_file_name, name);
+ strcpy (bbg_file_name + length, GCOV_GRAPH_SUFFIX);
- if (!fstat (fileno (bb_file), &status))
- bb_file_time = status.st_mtime;
- }
+ da_file_name = xmalloc (length + strlen (GCOV_DATA_SUFFIX) + 1);
+ strcpy (da_file_name, name);
+ strcpy (da_file_name + length, GCOV_DATA_SUFFIX);
- /* If none of the functions in the file were executed, then there won't
- be a .da file. Just assume that all counts are zero in this case. */
- da_file = fopen (da_file_name, "rb");
- if (da_file == NULL)
- {
- fnotice (stderr, "Could not open data file %s.\n", da_file_name);
- fnotice (stderr, "Assuming that all execution counts are zero.\n");
- }
-
- /* Check for empty .bbg file. This indicates that there is no executable
- code in this source file. */
- /* Set the EOF condition if at the end of file. */
- ungetc (getc (bbg_file), bbg_file);
- if (feof (bbg_file))
- {
- fnotice (stderr, "No executable code associated with file %s.\n",
- input_file_name);
- exit (FATAL_EXIT_CODE);
- }
+ return;
}
-\f
-/* Initialize a new arc. */
-static void
-init_arc (arcptr, source, target, bb_graph)
- struct adj_list *arcptr;
- int source, target;
- struct bb_info *bb_graph;
-{
- arcptr->target = target;
- arcptr->source = source;
-
- arcptr->arc_count = 0;
- arcptr->count_valid = 0;
- arcptr->on_tree = 0;
- arcptr->fake = 0;
- arcptr->fall_through = 0;
-
- arcptr->succ_next = bb_graph[source].succ;
- bb_graph[source].succ = arcptr;
- bb_graph[source].succ_count++;
-
- arcptr->pred_next = bb_graph[target].pred;
- bb_graph[target].pred = arcptr;
- bb_graph[target].pred_count++;
-}
+/* Read the graph file. Return non-zero on fatal error. */
-/* Reverse the arcs on an arc list. */
-
-static struct adj_list *
-reverse_arcs (arcptr)
- struct adj_list *arcptr;
+static int
+read_graph_file ()
{
- struct adj_list *prev = 0;
- struct adj_list *next;
-
- for ( ; arcptr; arcptr = next)
+ FILE *file;
+ struct stat status;
+ unsigned magic, version;
+ unsigned current_tag = 0;
+ unsigned tag;
+ struct function_info *fn = NULL;
+ source_t *src = NULL;
+ unsigned ix;
+
+ file = fopen (bbg_file_name, "rb");
+ if (!file)
{
- next = arcptr->succ_next;
- arcptr->succ_next = prev;
- prev = arcptr;
+ fnotice (stderr, "%s:cannot open graph file\n", bbg_file_name);
+ return 1;
}
-
- return prev;
-}
-
-/* Reads profiles from the .da file and compute a hybrid profile. */
-
-static gcov_type *
-read_profile (function_name, cfg_checksum, instr_arcs)
- char *function_name;
- long cfg_checksum;
- int instr_arcs;
-{
- int i;
- int okay = 1;
- gcov_type *profile;
- char *function_name_buffer;
- int function_name_buffer_len;
-
- profile = xmalloc (sizeof (gcov_type) * instr_arcs);
- function_name_buffer_len = strlen (function_name) + 1;
- function_name_buffer = xmalloc (function_name_buffer_len + 1);
-
- for (i = 0; i < instr_arcs; i++)
- profile[i] = 0;
-
- if (!da_file)
- return profile;
-
- rewind (da_file);
- while (1)
+ if (!fstat (fileno (file), &status))
+ bbg_file_time = status.st_mtime;
+ if (gcov_read_unsigned (file, &magic) || magic != GCOV_GRAPH_MAGIC)
{
- long magic, extra_bytes;
- long func_count;
- int i;
+ fnotice (stderr, "%s:not a gcov graph file\n", bbg_file_name);
+ fclose (file);
+ return 1;
+ }
- if (__read_long (&magic, da_file, 4) != 0)
- break;
+ if (gcov_read_unsigned (file, &version) || version != GCOV_VERSION)
+ {
+ char v[4], e[4];
- if (magic != -123)
+ magic = GCOV_VERSION;
+
+ for (ix = 4; ix--; magic >>= 8, version >>= 8)
{
- okay = 0;
- break;
+ v[ix] = version;
+ e[ix] = magic;
}
+ fnotice (stderr, "%s:version `%.4s', prefer `%.4s'\n",
+ bbg_file_name, v, e);
+ }
+
+ while (!gcov_read_unsigned (file, &tag))
+ {
+ unsigned length;
+ long base;
- if (__read_long (&func_count, da_file, 4) != 0)
- {
- okay = 0;
- break;
- }
+ if (gcov_read_unsigned (file, &length))
+ goto corrupt;
- if (__read_long (&extra_bytes, da_file, 4) != 0)
+ base = gcov_save_position (file);
+
+ if (tag == GCOV_TAG_FUNCTION)
{
- okay = 0;
- break;
+ char *function_name = NULL;
+ unsigned checksum;
+
+ if (gcov_read_string (file, &function_name, NULL)
+ || gcov_read_unsigned (file, &checksum))
+ goto corrupt;
+ fn = (function_t *)xcalloc (1, sizeof (function_t));
+ fn->name = function_name;
+ fn->checksum = checksum;
+
+ fn->next = functions;
+ functions = fn;
+ current_tag = tag;
}
-
- /* skip extra data emited by __bb_exit_func. */
- fseek (da_file, extra_bytes, SEEK_CUR);
-
- for (i = 0; i < func_count; i++)
+ else if (fn && tag == GCOV_TAG_BLOCKS)
{
- long arc_count;
- long chksum;
- int j;
-
- if (__read_gcov_string
- (function_name_buffer, function_name_buffer_len, da_file,
- -1) != 0)
- {
- okay = 0;
- break;
- }
-
- if (__read_long (&chksum, da_file, 4) != 0)
+ if (fn->blocks)
+ fnotice (stderr, "%s:already seen blocks for `%s'\n",
+ bbg_file_name, fn->name);
+ else
{
- okay = 0;
- break;
+ fn->num_blocks = length / 4;
+ fn->blocks
+ = (block_t *)xcalloc (fn->num_blocks, sizeof (block_t));
}
-
- if (__read_long (&arc_count, da_file, 4) != 0)
+ }
+ else if (fn && tag == GCOV_TAG_ARCS)
+ {
+ unsigned src;
+ unsigned num_dests = (length - 4) / 8;
+ unsigned dest, flags;
+
+ if (gcov_read_unsigned (file, &src)
+ || src >= fn->num_blocks
+ || fn->blocks[src].succ)
+ goto corrupt;
+
+ while (num_dests--)
{
- okay = 0;
- break;
+ struct arc_info *arc;
+
+ if (gcov_read_unsigned (file, &dest)
+ || gcov_read_unsigned (file, &flags)
+ || dest >= fn->num_blocks)
+ goto corrupt;
+ arc = (arc_t *) xcalloc (1, sizeof (arc_t));
+
+ arc->dst = &fn->blocks[dest];
+ arc->src = &fn->blocks[src];
+
+ arc->count = 0;
+ arc->count_valid = 0;
+ arc->on_tree = !!(flags & GCOV_ARC_ON_TREE);
+ arc->fake = !!(flags & GCOV_ARC_FAKE);
+ arc->fall_through = !!(flags & GCOV_ARC_FALLTHROUGH);
+
+ arc->succ_next = fn->blocks[src].succ;
+ fn->blocks[src].succ = arc;
+ fn->blocks[src].num_succ++;
+
+ arc->pred_next = fn->blocks[dest].pred;
+ fn->blocks[dest].pred = arc;
+ fn->blocks[dest].num_pred++;
+
+ arc->is_call = arc->fake;
+
+ if (!arc->on_tree)
+ fn->num_counts++;
}
-
- if (strcmp (function_name_buffer, function_name) != 0
- || arc_count != instr_arcs || chksum != cfg_checksum)
+ }
+ else if (fn && tag == GCOV_TAG_LINES)
+ {
+ unsigned blockno;
+ unsigned *line_nos
+ = (unsigned *)xcalloc ((length - 4) / 4, sizeof (unsigned));
+
+ if (gcov_read_unsigned (file, &blockno)
+ || blockno >= fn->num_blocks
+ || fn->blocks[blockno].encoding)
+ goto corrupt;
+
+ for (ix = 0; ; )
{
- /* skip */
- if (fseek (da_file, arc_count * 8, SEEK_CUR) < 0)
+ unsigned lineno;
+
+ if (gcov_read_unsigned (file, &lineno))
+ goto corrupt;
+ if (lineno)
{
- okay = 0;
- break;
+ if (!ix)
+ {
+ line_nos[ix++] = 0;
+ line_nos[ix++] = src->index;
+ }
+ line_nos[ix++] = lineno;
+ if (lineno >= src->num_lines)
+ src->num_lines = lineno + 1;
}
- }
- else
- {
- gcov_type tmp;
-
- for (j = 0; j < arc_count; j++)
- if (__read_gcov_type (&tmp, da_file, 8) != 0)
- {
- okay = 0;
+ else
+ {
+ char *file_name = NULL;
+
+ if (gcov_read_string (file, &file_name, NULL))
+ goto corrupt;
+ if (!file_name)
break;
- }
- else
- {
- profile[j] += tmp;
- }
+ for (src = sources; src; src = src->next)
+ if (!strcmp (file_name, src->name))
+ {
+ free (file_name);
+ break;
+ }
+ if (!src)
+ {
+ src = (source_t *)xcalloc (1, sizeof (source_t));
+ src->name = file_name;
+ src->coverage.name = file_name;
+ src->index = sources ? sources->index + 1 : 1;
+ src->next = sources;
+ sources = src;
+ }
+ line_nos[ix++] = 0;
+ line_nos[ix++] = src->index;
+ }
}
+
+ fn->blocks[blockno].encoding = line_nos;
+ fn->blocks[blockno].num_encodings = ix;
+ }
+ else if (current_tag && !GCOV_TAG_IS_SUBTAG (current_tag, tag))
+ {
+ fn = NULL;
+ current_tag = 0;
+ }
+ if (gcov_resync (file, base, length))
+ {
+ corrupt:;
+ fnotice (stderr, "%s:corrupted\n", bbg_file_name);
+ fclose (file);
+ return 1;
}
-
- if (!okay)
- break;
-
}
+ fclose (file);
+
+ /* We built everything backwards, so nreverse them all */
+
+ /* Reverse sources. Not strictly necessary, but we'll then process
+ them in the 'expected' order. */
+ {
+ source_t *src, *src_p, *src_n;
+
+ for (src_p = NULL, src = sources; src; src_p = src, src = src_n)
+ {
+ src_n = src->next;
+ src->next = src_p;
+ }
+ sources = src_p;
+ }
- free (function_name_buffer);
+ /* Reverse functions. */
+ {
+ function_t *fn, *fn_p, *fn_n;
- if (!okay)
- {
- fprintf (stderr, ".da file corrupted!\n");
- free (profile);
- abort ();
- }
+ for (fn_p = NULL, fn = functions; fn; fn_p = fn, fn = fn_n)
+ {
+ unsigned ix;
+
+ fn_n = fn->next;
+ fn->next = fn_p;
- return profile;
+ /* Reverse the arcs */
+ for (ix = fn->num_blocks; ix--;)
+ {
+ arc_t *arc, *arc_p, *arc_n;
+
+ for (arc_p = NULL, arc = fn->blocks[ix].succ; arc;
+ arc_p = arc, arc = arc_n)
+ {
+ arc_n = arc->succ_next;
+ arc->succ_next = arc_p;
+ }
+ fn->blocks[ix].succ = arc_p;
+
+ for (arc_p = NULL, arc = fn->blocks[ix].pred; arc;
+ arc_p = arc, arc = arc_n)
+ {
+ arc_n = arc->pred_next;
+ arc->pred_next = arc_p;
+ }
+ fn->blocks[ix].pred = arc_p;
+ }
+ }
+ functions = fn_p;
+ }
+ return 0;
}
-/* Construct the program flow graph from the .bbg file, and read in the data
- in the .da file. */
+/* Reads profiles from the count file and attach to each
+ function. Return non-zero if fatal error. */
-static void
-create_program_flow_graph (bptr)
- struct bb_info_list *bptr;
+static int
+read_count_file ()
{
- long num_blocks, number_arcs, src, dest, flag_bits, num_arcs_per_block;
- int i;
- struct adj_list *arcptr;
- struct bb_info *bb_graph;
- long cfg_checksum;
- long instr_arcs = 0;
- gcov_type *profile;
- int profile_pos = 0;
- char *function_name;
- long function_name_len, tmp;
-
- /* Read function name. */
- __read_long (&tmp, bbg_file, 4); /* ignore -1. */
- __read_long (&function_name_len, bbg_file, 4);
- function_name = xmalloc (function_name_len + 1);
- fread (function_name, 1, function_name_len + 1, bbg_file);
-
- /* Skip padding. */
- tmp = (function_name_len + 1) % 4;
-
- if (tmp)
- fseek (bbg_file, 4 - tmp, SEEK_CUR);
-
- __read_long (&tmp, bbg_file, 4); /* ignore -1. */
-
- /* Read the cfg checksum. */
- __read_long (&cfg_checksum, bbg_file, 4);
-
- /* Read the number of blocks. */
- __read_long (&num_blocks, bbg_file, 4);
-
- /* Create an array of size bb number of bb_info structs. */
- bb_graph = (struct bb_info *) xcalloc (num_blocks, sizeof (struct bb_info));
-
- bptr->bb_graph = bb_graph;
- bptr->num_blocks = num_blocks;
-
- /* Read and create each arc from the .bbg file. */
- __read_long (&number_arcs, bbg_file, 4);
- for (i = 0; i < num_blocks; i++)
+ FILE *file;
+ unsigned ix;
+ char *function_name_buffer = NULL;
+ unsigned magic, version;
+ function_t *fn = NULL;
+
+ file = fopen (da_file_name, "rb");
+ if (!file)
{
- int j;
-
- __read_long (&num_arcs_per_block, bbg_file, 4);
- for (j = 0; j < num_arcs_per_block; j++)
+ fnotice (stderr, "%s:cannot open data file\n", da_file_name);
+ return 1;
+ }
+ if (gcov_read_unsigned (file, &magic) || magic != GCOV_DATA_MAGIC)
+ {
+ fnotice (stderr, "%s:not a gcov data file\n", da_file_name);
+ cleanup:;
+ free (function_name_buffer);
+ fclose (file);
+ return 1;
+ }
+ if (gcov_read_unsigned (file, &version) || version != GCOV_VERSION)
+ {
+ char v[4], e[4];
+
+ magic = GCOV_VERSION;
+ for (ix = 4; ix--; magic >>= 8, version >>= 8)
{
- if (number_arcs-- < 0)
- abort ();
-
- src = i;
- __read_long (&dest, bbg_file, 4);
-
- arcptr = (struct adj_list *) xmalloc (sizeof (struct adj_list));
- init_arc (arcptr, src, dest, bb_graph);
-
- __read_long (&flag_bits, bbg_file, 4);
- if (flag_bits & 0x1)
- arcptr->on_tree++;
- else
- instr_arcs++;
- arcptr->fake = !! (flag_bits & 0x2);
- arcptr->fall_through = !! (flag_bits & 0x4);
+ v[ix] = version;
+ e[ix] = magic;
}
+ fnotice (stderr, "%s:version `%.4s', prefer version `%.4s'\n",
+ da_file_name, v, e);
}
-
- if (number_arcs)
- abort ();
-
- /* Read and ignore the -1 separating the arc list from the arc list of the
- next function. */
- __read_long (&src, bbg_file, 4);
- if (src != -1)
- abort ();
-
- /* Must reverse the order of all succ arcs, to ensure that they match
- the order of the data in the .da file. */
-
- for (i = 0; i < num_blocks; i++)
- if (bb_graph[i].succ)
- bb_graph[i].succ = reverse_arcs (bb_graph[i].succ);
-
- /* Read profile from the .da file. */
-
- profile = read_profile (function_name, cfg_checksum, instr_arcs);
-
- /* For each arc not on the spanning tree, set its execution count from
- the .da file. */
-
- /* The first count in the .da file is the number of times that the function
- was entered. This is the exec_count for block zero. */
-
- /* This duplicates code in branch_prob in profile.c. */
-
- for (i = 0; i < num_blocks; i++)
- for (arcptr = bb_graph[i].succ; arcptr; arcptr = arcptr->succ_next)
- if (! arcptr->on_tree)
+
+ while (1)
+ {
+ unsigned tag, length;
+ long base;
+
+ if (gcov_read_unsigned (file, &tag)
+ || gcov_read_unsigned (file, &length))
{
- arcptr->arc_count = profile[profile_pos++];
- arcptr->count_valid = 1;
- bb_graph[i].succ_count--;
- bb_graph[arcptr->target].pred_count--;
+ if (feof (file))
+ break;
+
+ corrupt:;
+ fnotice (stderr, "%s:corrupted\n", da_file_name);
+ goto cleanup;
}
- free (profile);
- free (function_name);
-}
-
-static void
-solve_program_flow_graph (bptr)
- struct bb_info_list *bptr;
-{
- int passes, changes;
- gcov_type total;
- int i;
- struct adj_list *arcptr;
- struct bb_info *bb_graph;
- int num_blocks;
-
- num_blocks = bptr->num_blocks;
- bb_graph = bptr->bb_graph;
-
- /* For every block in the file,
- - if every exit/entrance arc has a known count, then set the block count
- - if the block count is known, and every exit/entrance arc but one has
- a known execution count, then set the count of the remaining arc
-
- As arc counts are set, decrement the succ/pred count, but don't delete
- the arc, that way we can easily tell when all arcs are known, or only
- one arc is unknown. */
-
- /* The order that the basic blocks are iterated through is important.
- Since the code that finds spanning trees starts with block 0, low numbered
- arcs are put on the spanning tree in preference to high numbered arcs.
- Hence, most instrumented arcs are at the end. Graph solving works much
- faster if we propagate numbers from the end to the start.
-
- This takes an average of slightly more than 3 passes. */
-
- changes = 1;
- passes = 0;
- while (changes)
- {
- passes++;
- changes = 0;
-
- for (i = num_blocks - 1; i >= 0; i--)
+ base = gcov_save_position (file);
+ if (tag == GCOV_TAG_FUNCTION)
{
- if (! bb_graph[i].count_valid)
+ unsigned checksum;
+ struct function_info *fn_n = functions;
+
+ if (gcov_read_string (file, &function_name_buffer, NULL)
+ || gcov_read_unsigned (file, &checksum))
+ goto corrupt;
+
+ for (fn = fn ? fn->next : NULL; ; fn = fn->next)
{
- if (bb_graph[i].succ_count == 0)
- {
- total = 0;
- for (arcptr = bb_graph[i].succ; arcptr;
- arcptr = arcptr->succ_next)
- total += arcptr->arc_count;
- bb_graph[i].exec_count = total;
- bb_graph[i].count_valid = 1;
- changes = 1;
- }
- else if (bb_graph[i].pred_count == 0)
+ if (fn)
+ ;
+ else if ((fn = fn_n))
+ fn_n = NULL;
+ else
{
- total = 0;
- for (arcptr = bb_graph[i].pred; arcptr;
- arcptr = arcptr->pred_next)
- total += arcptr->arc_count;
- bb_graph[i].exec_count = total;
- bb_graph[i].count_valid = 1;
- changes = 1;
+ fnotice (stderr, "%s:unknown function `%s'\n",
+ da_file_name, function_name_buffer);
+ break;
}
+ if (!strcmp (fn->name, function_name_buffer))
+ break;
}
- if (bb_graph[i].count_valid)
+
+ if (!fn)
+ ;
+ else if (checksum != fn->checksum)
{
- if (bb_graph[i].succ_count == 1)
- {
- total = 0;
- /* One of the counts will be invalid, but it is zero,
- so adding it in also doesn't hurt. */
- for (arcptr = bb_graph[i].succ; arcptr;
- arcptr = arcptr->succ_next)
- total += arcptr->arc_count;
- /* Calculate count for remaining arc by conservation. */
- total = bb_graph[i].exec_count - total;
- /* Search for the invalid arc, and set its count. */
- for (arcptr = bb_graph[i].succ; arcptr;
- arcptr = arcptr->succ_next)
- if (! arcptr->count_valid)
- break;
- if (! arcptr)
- abort ();
- arcptr->count_valid = 1;
- arcptr->arc_count = total;
- bb_graph[i].succ_count--;
-
- bb_graph[arcptr->target].pred_count--;
- changes = 1;
- }
- if (bb_graph[i].pred_count == 1)
- {
- total = 0;
- /* One of the counts will be invalid, but it is zero,
- so adding it in also doesn't hurt. */
- for (arcptr = bb_graph[i].pred; arcptr;
- arcptr = arcptr->pred_next)
- total += arcptr->arc_count;
- /* Calculate count for remaining arc by conservation. */
- total = bb_graph[i].exec_count - total;
- /* Search for the invalid arc, and set its count. */
- for (arcptr = bb_graph[i].pred; arcptr;
- arcptr = arcptr->pred_next)
- if (! arcptr->count_valid)
- break;
- if (! arcptr)
- abort ();
- arcptr->count_valid = 1;
- arcptr->arc_count = total;
- bb_graph[i].pred_count--;
-
- bb_graph[arcptr->source].succ_count--;
- changes = 1;
- }
+ mismatch:;
+ fnotice (stderr, "%s:profile mismatch for `%s'\n",
+ da_file_name, function_name_buffer);
+ goto cleanup;
+ }
+ }
+ else if (tag == GCOV_TAG_ARC_COUNTS && fn)
+ {
+ if (length != 8 * fn->num_counts)
+ goto mismatch;
+
+ if (!fn->counts)
+ fn->counts
+ = (gcov_type *)xcalloc (fn->num_counts, sizeof (gcov_type));
+
+ for (ix = 0; ix != fn->num_counts; ix++)
+ {
+ gcov_type count;
+
+ if (gcov_read_counter (file, &count))
+ goto corrupt;
+ fn->counts[ix] += count;
}
}
+ gcov_resync (file, base, length);
}
- /* If the graph has been correctly solved, every block will have a
- succ and pred count of zero. */
- for (i = 0; i < num_blocks; i++)
- if (bb_graph[i].succ_count || bb_graph[i].pred_count)
- abort ();
+ fclose (file);
+ free (function_name_buffer);
+ return 0;
}
+/* Solve the flow graph. Propagate counts from the instrumented arcs
+ to the blocks and the uninstrumented arcs. */
static void
-read_files ()
+solve_flow_graph (fn)
+ function_t *fn;
{
- struct stat buf;
- struct bb_info_list *list_end = 0;
- struct bb_info_list *b_ptr;
-
- while (! feof (bbg_file))
+ unsigned ix;
+ arc_t *arc;
+ gcov_type *count_ptr = fn->counts;
+ block_t *valid_blocks = NULL; /* valid, but unpropagated blocks. */
+ block_t *invalid_blocks = NULL; /* invalid, but inferable blocks. */
+
+ if (fn->num_blocks < 2)
+ fnotice (stderr, "%s:`%s' lacks entry and/or exit blocks\n",
+ bbg_file_name, fn->name);
+ else
{
- b_ptr = (struct bb_info_list *) xmalloc (sizeof (struct bb_info_list));
-
- b_ptr->next = 0;
- if (list_end)
- list_end->next = b_ptr;
+ if (fn->blocks[0].num_pred)
+ fnotice (stderr, "%s:`%s' has arcs to entry block\n",
+ bbg_file_name, fn->name);
else
- bb_graph_list = b_ptr;
- list_end = b_ptr;
-
- /* Read in the data in the .bbg file and reconstruct the program flow
- graph for one function. */
- create_program_flow_graph (b_ptr);
-
- /* Set the EOF condition if at the end of file. */
- ungetc (getc (bbg_file), bbg_file);
+ /* We can't deduce the entry block counts from the lack of
+ predecessors. */
+ fn->blocks[0].num_pred = ~(unsigned)0;
+
+ if (fn->blocks[fn->num_blocks - 1].num_succ)
+ fnotice (stderr, "%s:`%s' has arcs from exit block\n",
+ bbg_file_name, fn->name);
+ else
+ /* Likewise, we can't deduce exit block counts from the lack
+ of its successors. */
+ fn->blocks[fn->num_blocks - 1].num_succ = ~(unsigned)0;
}
- /* Calculate all of the basic block execution counts and branch
- taken probabilities. */
-
- for (b_ptr = bb_graph_list; b_ptr; b_ptr = b_ptr->next)
- solve_program_flow_graph (b_ptr);
-
- /* Read in all of the data from the .bb file. This info will be accessed
- sequentially twice. */
- stat (bb_file_name, &buf);
- bb_data_size = buf.st_size / 4;
-
- bb_data = (char *) xmalloc ((unsigned) buf.st_size);
- fread (bb_data, sizeof (char), buf.st_size, bb_file);
-
- fclose (bb_file);
- if (da_file)
- fclose (da_file);
- fclose (bbg_file);
-}
-
-
-/* Scan the data in the .bb file to find all source files referenced,
- and the largest line number mentioned in each one. */
-
-static void
-scan_for_source_files ()
-{
- struct sourcefile *s_ptr = NULL;
- char *ptr;
- long count;
- long line_num;
-
- /* Search the bb_data to find:
- 1) The number of sources files contained herein, and
- 2) The largest line number for each source file. */
-
- ptr = bb_data;
- sources = 0;
- for (count = 0; count < bb_data_size; count++)
+ /* Propagate the measured counts, this must be done in the same
+ order as the code in profile.c */
+ for (ix = 0; ix != fn->num_blocks; ix++)
{
- __fetch_long (&line_num, ptr, 4);
- ptr += 4;
- if (line_num == -1)
+ block_t const *prev_dst = NULL;
+ int out_of_order = 0;
+
+ for (arc = fn->blocks[ix].succ; arc; arc = arc->succ_next)
{
- /* A source file name follows. Check to see if we already have
- a sourcefile structure for this file. */
- s_ptr = sources;
- while (s_ptr && strcmp (s_ptr->name, ptr))
- s_ptr = s_ptr->next;
-
- if (s_ptr == 0)
+ if (!arc->on_tree)
{
- /* No sourcefile structure for this file name exists, create
- a new one, and append it to the front of the sources list. */
- s_ptr = (struct sourcefile *) xmalloc (sizeof(struct sourcefile));
- s_ptr->name = xstrdup (ptr);
- s_ptr->maxlineno = 0;
- s_ptr->next = sources;
- sources = s_ptr;
+ if (count_ptr)
+ arc->count = *count_ptr++;
+ arc->count_valid = 1;
+ fn->blocks[ix].num_succ--;
+ arc->dst->num_pred--;
}
-
- /* Scan past the file name. */
- {
- long delim;
- do {
- count++;
- __fetch_long (&delim, ptr, 4);
- ptr += 4;
- } while (delim != line_num);
- }
+ if (prev_dst && prev_dst > arc->dst)
+ out_of_order = 1;
+ prev_dst = arc->dst;
}
- else if (line_num == -2)
+
+ /* Sort the successor arcs into ascending dst order. profile.c
+ normally produces arcs in the right order, but sometimes with
+ one or two out of order. We're not using a particularly
+ smart sort. */
+ if (out_of_order)
{
- long delim;
-
- /* A function name follows. Ignore it. */
- do {
- count++;
- __fetch_long (&delim, ptr, 4);
- ptr += 4;
- } while (delim != line_num);
+ arc_t *start = fn->blocks[ix].succ;
+ unsigned changes = 1;
+
+ while (changes)
+ {
+ arc_t *arc, *arc_p, *arc_n;
+
+ changes = 0;
+ for (arc_p = NULL, arc = start; (arc_n = arc->succ_next);)
+ {
+ if (arc->dst > arc_n->dst)
+ {
+ changes = 1;
+ if (arc_p)
+ arc_p->succ_next = arc_n;
+ else
+ start = arc_n;
+ arc->succ_next = arc_n->succ_next;
+ arc_n->succ_next = arc;
+ arc_p = arc_n;
+ }
+ else
+ {
+ arc_p = arc;
+ arc = arc_n;
+ }
+ }
+ }
+ fn->blocks[ix].succ = start;
}
- /* There will be a zero before the first file name, in which case s_ptr
- will still be uninitialized. So, only try to set the maxlineno
- field if line_num is nonzero. */
- else if (line_num > 0)
+
+ /* Place it on the invalid chain, it will be ignored if that's
+ wrong. */
+ fn->blocks[ix].invalid_chain = 1;
+ fn->blocks[ix].chain = invalid_blocks;
+ invalid_blocks = &fn->blocks[ix];
+ }
+
+ while (invalid_blocks || valid_blocks)
+ {
+ block_t *blk;
+
+ while ((blk = invalid_blocks))
{
- if (s_ptr->maxlineno <= line_num)
- s_ptr->maxlineno = line_num + 1;
+ gcov_type total = 0;
+ const arc_t *arc;
+
+ invalid_blocks = blk->chain;
+ blk->invalid_chain = 0;
+ if (!blk->num_succ)
+ for (arc = blk->succ; arc; arc = arc->succ_next)
+ total += arc->count;
+ else if (!blk->num_pred)
+ for (arc = blk->pred; arc; arc = arc->pred_next)
+ total += arc->count;
+ else
+ continue;
+
+ blk->count = total;
+ blk->count_valid = 1;
+ blk->chain = valid_blocks;
+ blk->valid_chain = 1;
+ valid_blocks = blk;
}
- else if (line_num < 0)
+ while ((blk = valid_blocks))
{
- /* Don't know what this is, but it's garbage. */
- abort ();
+ gcov_type total;
+ arc_t *arc, *inv_arc;
+
+ valid_blocks = blk->chain;
+ blk->valid_chain = 0;
+ if (blk->num_succ == 1)
+ {
+ block_t *dst;
+
+ total = blk->count;
+ inv_arc = NULL;
+ for (arc = blk->succ; arc; arc = arc->succ_next)
+ {
+ total -= arc->count;
+ if (!arc->count_valid)
+ inv_arc = arc;
+ }
+ dst = inv_arc->dst;
+ inv_arc->count_valid = 1;
+ inv_arc->count = total;
+ blk->num_succ--;
+ dst->num_pred--;
+ if (dst->count_valid)
+ {
+ if (dst->num_pred == 1 && !dst->valid_chain)
+ {
+ dst->chain = valid_blocks;
+ dst->valid_chain = 1;
+ valid_blocks = dst;
+ }
+ }
+ else
+ {
+ if (!dst->num_pred && !dst->invalid_chain)
+ {
+ dst->chain = invalid_blocks;
+ dst->invalid_chain = 1;
+ invalid_blocks = dst;
+ }
+ }
+ }
+ if (blk->num_pred == 1)
+ {
+ block_t *src;
+
+ total = blk->count;
+ inv_arc = NULL;
+ for (arc = blk->pred; arc; arc = arc->pred_next)
+ {
+ total -= arc->count;
+ if (!arc->count_valid)
+ inv_arc = arc;
+ }
+ src = inv_arc->src;
+ inv_arc->count_valid = 1;
+ inv_arc->count = total;
+ blk->num_pred--;
+ src->num_succ--;
+ if (src->count_valid)
+ {
+ if (src->num_succ == 1 && !src->valid_chain)
+ {
+ src->chain = valid_blocks;
+ src->valid_chain = 1;
+ valid_blocks = src;
+ }
+ }
+ else
+ {
+ if (!src->num_succ && !src->invalid_chain)
+ {
+ src->chain = invalid_blocks;
+ src->invalid_chain = 1;
+ invalid_blocks = src;
+ }
+ }
+ }
}
}
+
+ /* If the graph has been correctly solved, every block will have a
+ valid count. */
+ for (ix = 0; ix < fn->num_blocks; ix++)
+ if (!fn->blocks[ix].count_valid)
+ {
+ fnotice (stderr, "%s:graph is unsolvable for `%s'\n",
+ bbg_file_name, fn->name);
+ break;
+ }
}
+
\f
-/* Increment totals in FUNCTION according to arc A_PTR. */
+/* Increment totals in COVERAGE according to arc ARC. */
static void
-accumulate_branch_counts (function, a_ptr)
- struct coverage *function;
- struct arcdata *a_ptr;
+add_branch_counts (coverage, arc)
+ coverage_t *coverage;
+ const arc_t *arc;
{
- if (a_ptr->call_insn)
+ if (arc->is_call)
{
- function->calls++;
- if (a_ptr->total)
- function->calls_executed++;
+ coverage->calls++;
+ if (arc->src->count)
+ coverage->calls_executed++;
}
else
{
- function->branches++;
- if (a_ptr->total)
- function->branches_executed++;
- if (a_ptr->hits)
- function->branches_taken++;
- }
-}
-
-/* Calculate the branch taken probabilities for all arcs branches at the
- end of this block. */
-
-static void
-calculate_branch_probs (block_ptr, line_info, function)
- struct bb_info *block_ptr;
- struct line_info *line_info;
- struct coverage *function;
-{
- gcov_type total;
- struct adj_list *arcptr;
-
- total = block_ptr->exec_count;
- for (arcptr = block_ptr->succ; arcptr; arcptr = arcptr->succ_next)
- {
- struct arcdata *a_ptr;
-
- /* Ignore fall through arcs as they aren't really branches. */
- if (arcptr->fall_through)
- continue;
-
- a_ptr = (struct arcdata *) xmalloc (sizeof (struct arcdata));
- a_ptr->total = total;
- a_ptr->hits = total ? arcptr->arc_count : 0;
- a_ptr->call_insn = arcptr->fake;
-
- if (function)
- accumulate_branch_counts (function, a_ptr);
- /* Prepend the new branch to the list. */
- a_ptr->next = line_info->branches;
- line_info->branches = a_ptr;
+ coverage->branches++;
+ if (arc->src->count)
+ coverage->branches_executed++;
+ if (arc->count)
+ coverage->branches_taken++;
}
}
format TOP. Return pointer to a static string. */
static char const *
-format_hwint (top, bottom, dp)
- HOST_WIDEST_INT top, bottom;
+format_gcov (top, bottom, dp)
+ gcov_type top, bottom;
int dp;
{
static char buffer[20];
}
}
else
- sprintf (buffer, HOST_WIDEST_INT_PRINT_DEC, top);
+ sprintf (buffer, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT)top);
return buffer;
}
/* Output summary info for a function. */
static void
-function_summary (function, title)
- struct coverage *function;
+function_summary (coverage, title)
+ const coverage_t *coverage;
const char *title;
{
- if (function->lines)
- fnotice (stdout, "%s of %d lines executed in %s %s\n",
- format_hwint (function->lines_executed,
- function->lines, 2),
- function->lines, title, function->name);
+ fnotice (stdout, "%s `%s'\n", title, coverage->name);
+
+ if (coverage->lines)
+ fnotice (stdout, "Lines executed:%s of %d\n",
+ format_gcov (coverage->lines_executed, coverage->lines, 2),
+ coverage->lines);
else
- fnotice (stdout, "No executable lines in %s %s\n",
- title, function->name);
+ fnotice (stdout, "No executable lines");
- if (output_branch_probs)
+ if (flag_branches)
{
- if (function->branches)
+ if (coverage->branches)
{
- fnotice (stdout, "%s of %d branches executed in %s %s\n",
- format_hwint (function->branches_executed,
- function->branches, 2),
- function->branches, title, function->name);
- fnotice (stdout,
- "%s of %d branches taken at least once in %s %s\n",
- format_hwint (function->branches_taken,
- function->branches, 2),
- function->branches, title, function->name);
+ fnotice (stdout, "Branches executed:%s of %d\n",
+ format_gcov (coverage->branches_executed,
+ coverage->branches, 2),
+ coverage->branches);
+ fnotice (stdout, "Taken at least once:%s of %d\n",
+ format_gcov (coverage->branches_taken,
+ coverage->branches, 2),
+ coverage->branches);
}
else
- fnotice (stdout, "No branches in %s %s\n", title, function->name);
- if (function->calls)
- fnotice (stdout, "%s of %d calls executed in %s %s\n",
- format_hwint (function->calls_executed,
- function->calls, 2),
- function->calls, title, function->name);
+ fnotice (stdout, "No branches\n");
+ if (coverage->calls)
+ fnotice (stdout, "Calls executed:%s of %d\n",
+ format_gcov (coverage->calls_executed, coverage->calls, 2),
+ coverage->calls);
else
- fnotice (stdout, "No calls in %s %s\n", title, function->name);
+ fnotice (stdout, "No calls\n");
}
}
removed and '..' components are renamed to '^'. */
static char *
-make_gcov_file_name (src_name)
- char *src_name;
+make_gcov_file_name (input_name, src_name)
+ const char *input_name;
+ const char *src_name;
{
char *cptr;
- char *name = xmalloc (strlen (src_name) + strlen (input_file_name) + 10);
+ char *name = xmalloc (strlen (src_name) + strlen (input_name) + 10);
name[0] = 0;
- if (output_long_names && strcmp (src_name, input_file_name))
+ if (flag_long_names && strcmp (src_name, input_name))
{
/* Generate the input filename part. */
- cptr = preserve_paths ? NULL : strrchr (input_file_name, '/');
- cptr = cptr ? cptr + 1 : input_file_name;
- strcat (name, cptr);
+ cptr = flag_preserve_paths ? NULL : strrchr (input_name, '/');
+ strcat (name, cptr ? cptr + 1 : input_name);
strcat (name, "##");
}
/* Generate the source filename part. */
- cptr = preserve_paths ? NULL : strrchr (src_name, '/');
- cptr = cptr ? cptr + 1 : src_name;
- strcat (name, cptr);
+ cptr = flag_preserve_paths ? NULL : strrchr (src_name, '/');
+ strcat (name, cptr ? cptr + 1 : src_name);
- if (preserve_paths)
+ if (flag_preserve_paths)
{
/* Convert '/' to '#', remove '/./', convert '/../' to '/^/' */
char *prev;
}
}
- /* Don't strip off the ending for compatibility with tcov, since
- this results in confusion if there is more than one file with the
- same basename, e.g. tmp.c and tmp.h. */
strcat (name, ".gcov");
return name;
}
-/* Scan through the bb_data, and when the file name matches the
- source file name, then for each following line number, increment
+/* Scan through the bb_data for each line in the block, increment
the line number execution count indicated by the execution count of
the appropriate basic block. */
static void
-init_line_info (line_info, total, maxlineno)
- struct line_info *line_info;
- struct coverage *total;
- long maxlineno;
+add_line_counts (coverage, fn)
+ coverage_t *coverage;
+ const function_t *fn;
{
- long block_num = 0; /* current block number */
- struct bb_info *block_ptr = NULL; /* current block ptr */
- struct coverage function;
- struct coverage *func_ptr = NULL;
- struct bb_info_list *current_graph = NULL; /* Graph for current function. */
- int is_this_file = 0; /* We're scanning a block from the desired file. */
- char *ptr = bb_data;
- long count;
- long line_num;
- struct line_info *line_ptr = 0; /* line info ptr. */
-
- memset (&function, 0, sizeof (function));
- if (output_function_summary)
- func_ptr = &function;
-
- for (count = 0; count < bb_data_size; count++)
+ unsigned ix;
+ line_t *line = NULL; /* this is propagated from one iteration to the
+ next. */
+
+ /* Scan each basic block. */
+ for (ix = 0; ix != fn->num_blocks; ix++)
{
- __fetch_long (&line_num, ptr, 4);
- ptr += 4;
- if (line_num < 0)
- {
- long delim;
-
- if (line_num == -1)
- {
- /* Marks the beginning of a file name. Check to see
- whether this is the filename we are currently
- collecting data for. */
- is_this_file = !strcmp (total->name, ptr);
- }
- else if (line_num == -2)
- {
- /* Marks the start of a new function. Advance to the
- next program flow graph. */
- if (!current_graph)
- current_graph = bb_graph_list;
- else
- {
- if (block_num == current_graph->num_blocks - 1)
- /* Last block falls through to exit. */
- ;
- else if (block_num == current_graph->num_blocks - 2)
- {
- if (output_branch_probs && is_this_file)
- calculate_branch_probs (block_ptr, line_ptr, func_ptr);
- }
- else
- {
- fnotice (stderr,
- "didn't use all bb entries of graph, function %s\n",
- function.name);
- fnotice (stderr, "block_num = %ld, num_blocks = %d\n",
- block_num, current_graph->num_blocks);
- }
- if (func_ptr && is_this_file)
- function_summary (func_ptr, "function");
- current_graph = current_graph->next;
- }
- block_num = 0;
- block_ptr = current_graph->bb_graph;
- memset (&function, 0, sizeof (function));
- function.name = ptr;
- }
- else
- {
- fnotice (stderr, "ERROR: unexpected line number %ld\n", line_num);
- abort ();
- }
+ const block_t *block = &fn->blocks[ix];
+ unsigned *encoding;
+ const source_t *src = NULL;
+ unsigned jx;
+
+ for (jx = 0, encoding = block->encoding;
+ jx != block->num_encodings; jx++, encoding++)
+ if (!*encoding)
+ {
+ unsigned src_n = *++encoding;
- /* Scan past the string. */
- for (delim = 0; delim != line_num; count++)
- {
- __fetch_long (&delim, ptr, 4);
- ptr += 4;
- }
- }
- else if (!line_num)
+ for (src = sources; src->index != src_n; src = src->next)
+ continue;
+ jx++;
+ }
+ else
+ {
+ line = &src->lines[*encoding];
+
+ if (coverage)
+ {
+ if (!line->exists)
+ coverage->lines++;
+ if (!line->count && block->count)
+ coverage->lines_executed++;
+ }
+ line->exists = 1;
+ line->count += block->count;
+ }
+
+ if (line && flag_branches)
{
- /* Marks the end of a block. */
- if (block_num >= current_graph->num_blocks)
- {
- fnotice (stderr, "ERROR: too many basic blocks in function %s\n",
- function.name);
- abort ();
- }
-
- if (output_branch_probs && is_this_file)
- calculate_branch_probs (block_ptr, line_ptr, func_ptr);
+ arc_t *arc;
- block_num++;
- block_ptr++;
- }
- else if (is_this_file)
- {
- if (line_num >= maxlineno)
- {
- fnotice (stderr, "ERROR: out of range line number in function %s\n",
- function.name);
- abort ();
- }
-
- line_ptr = &line_info[line_num];
- if (func_ptr)
+ for (arc = block->succ; arc; arc = arc->succ_next)
{
- if (!line_ptr->exists)
- func_ptr->lines++;
- if (!line_ptr->count && block_ptr->exec_count)
- func_ptr->lines_executed++;
+ /* Ignore fall through arcs as they aren't really branches. */
+ if (arc->fall_through)
+ continue;
+
+ arc->line_next = line->branches;
+ line->branches = arc;
+ if (coverage)
+ add_branch_counts (coverage, arc);
}
-
- /* Accumulate execution data for this line number. */
- line_ptr->count += block_ptr->exec_count;
- line_ptr->exists = 1;
}
}
+ if (!line)
+ fnotice (stderr, "%s:no lines for `%s'\n", bbg_file_name, fn->name);
+}
+
+/* Accumulate the line counts of a file. */
+
+static void
+accumulate_line_counts (src)
+ source_t *src;
+{
+ line_t *line;
+ unsigned ix;
- if (func_ptr && is_this_file)
- function_summary (func_ptr, "function");
-
- /* Calculate summary test coverage statistics. */
- for (line_num = 1, line_ptr = &line_info[line_num];
- line_num < maxlineno; line_num++, line_ptr++)
+ for (ix = src->num_lines, line = src->lines; ix--; line++)
{
- struct arcdata *a_ptr, *prev, *next;
+ arc_t *arc, *arc_p, *arc_n;
- if (line_ptr->exists)
+ /* Total and reverse the branch information. */
+ for (arc = line->branches, arc_p = NULL; arc; arc_p = arc, arc = arc_n)
{
- total->lines++;
- if (line_ptr->count)
- total->lines_executed++;
+ arc_n = arc->line_next;
+ arc->line_next = arc_p;
+
+ add_branch_counts (&src->coverage, arc);
}
+ line->branches = arc_p;
- /* Total and reverse the branch information. */
- for (a_ptr = line_ptr->branches, prev = NULL; a_ptr; a_ptr = next)
+ if (line->exists)
{
- next = a_ptr->next;
- a_ptr->next = prev;
- prev = a_ptr;
-
- accumulate_branch_counts (total, a_ptr);
+ src->coverage.lines++;
+ if (line->count)
+ src->coverage.lines_executed++;
}
- line_ptr->branches = prev;
}
}
information. */
static void
-output_line_info (gcov_file, line_info, total, maxlineno)
+output_lines (gcov_file, src)
FILE *gcov_file;
- const struct line_info *line_info;
- const struct coverage *total;
- long maxlineno;
+ const source_t *src;
{
FILE *source_file;
- long line_num; /* current line number */
- const struct line_info *line_ptr; /* current line info ptr. */
- char string[STRING_SIZE]; /* line buffer. */
- char const *retval = ""; /* status of source file reading. */
-
- fprintf (gcov_file, "%9s:%5d:Source:%s\n", "-", 0, total->name);
- fprintf (gcov_file, "%9s:%5d:Object:%s\n", "-", 0, bb_file_name);
+ unsigned line_num; /* current line number. */
+ const line_t *line; /* current line info ptr. */
+ char string[STRING_SIZE]; /* line buffer. */
+ char const *retval = ""; /* status of source file reading. */
+
+ fprintf (gcov_file, "%9s:%5d:Source:%s\n", "-", 0, src->name);
+ fprintf (gcov_file, "%9s:%5d:Graph:%s\n", "-", 0, bbg_file_name);
+ fprintf (gcov_file, "%9s:%5d:Data:%s\n", "-", 0, da_file_name);
- source_file = fopen (total->name, "r");
+ source_file = fopen (src->name, "r");
if (!source_file)
{
- fnotice (stderr, "Could not open source file %s.\n", total->name);
+ fnotice (stderr, "%s:cannot open source file\n", src->name);
retval = NULL;
}
else
struct stat status;
if (!fstat (fileno (source_file), &status)
- && status.st_mtime > bb_file_time)
+ && status.st_mtime > bbg_file_time)
{
- fnotice (stderr, "Warning: source file %s is newer than %s\n",
- total->name, bb_file_name);
- fprintf (gcov_file, "%9s:%5d:Source is newer than compiler output\n",
+ fnotice (stderr, "%s:source file is newer than graph file `%s'\n",
+ src->name, bbg_file_name);
+ fprintf (gcov_file, "%9s:%5d:Source is newer than graph\n",
"-", 0);
}
}
- for (line_num = 1, line_ptr = &line_info[line_num];
- line_num < maxlineno; line_num++, line_ptr++)
+ for (line_num = 1, line = &src->lines[line_num];
+ line_num < src->num_lines; line_num++, line++)
{
/* For lines which don't exist in the .bb file, print '-' before
the source line. For lines which exist but were never
print the execution count before the source line. There are
16 spaces of indentation added before the source line so that
tabs won't be messed up. */
- fprintf (gcov_file, "%9s:%5ld:",
- !line_ptr->exists ? "-"
- : !line_ptr->count ? "#####"
- : format_hwint (line_ptr->count, 0, -1), line_num);
+ fprintf (gcov_file, "%9s:%5u:",
+ !line->exists ? "-" : !line->count ? "#####"
+ : format_gcov (line->count, 0, -1), line_num);
if (retval)
{
retval = fgets (string, STRING_SIZE, source_file);
if (!retval)
{
- fnotice (stderr,
- "Unexpected EOF while reading source file %s.\n",
- total->name);
+ fnotice (stderr, "%s:unexpected EOF\n", src->name);
break;
}
fputs (retval, gcov_file);
if (!retval)
fputs ("??\n", gcov_file);
- if (output_branch_probs)
+ if (flag_branches)
{
- int i;
- struct arcdata *a_ptr;
+ int ix;
+ arc_t *arc;
- for (i = 0, a_ptr = line_ptr->branches; a_ptr;
- a_ptr = a_ptr->next, i++)
+ for (ix = 0, arc = line->branches; arc; arc = arc->line_next, ix++)
{
- if (a_ptr->call_insn)
+ if (arc->is_call)
{
- if (a_ptr->total == 0)
- fnotice (gcov_file, "call %2d never executed\n", i);
- else
+ if (arc->src->count)
fnotice
- (gcov_file, "call %2d returns %s\n", i,
- format_hwint (a_ptr->total - a_ptr->hits,
- a_ptr->total,
- -output_branch_counts));
+ (gcov_file, "call %2d returns %s\n", ix,
+ format_gcov (arc->src->count - arc->count,
+ arc->src->count,
+ -flag_counts));
+ else
+ fnotice (gcov_file, "call %2d never executed\n", ix);
}
else
{
- if (a_ptr->total == 0)
- fnotice (gcov_file, "branch %2d never executed\n", i);
- else
+ if (arc->src->count)
fnotice
- (gcov_file, "branch %2d taken %s\n", i,
- format_hwint (a_ptr->hits, a_ptr->total,
- -output_branch_counts));
+ (gcov_file, "branch %2d taken %s\n", ix,
+ format_gcov (arc->count, arc->src->count,
+ -flag_counts));
+ else
+ fnotice (gcov_file, "branch %2d never executed\n", ix);
}
}
}
{
for (; (retval = fgets (string, STRING_SIZE, source_file)); line_num++)
{
- fprintf (gcov_file, "%9s:%5ld:%s", "-", line_num, retval);
+ fprintf (gcov_file, "%9s:%5u:%s", "-", line_num, retval);
while (!retval[0] || retval[strlen (retval) - 1] != '\n')
{
if (source_file)
fclose (source_file);
}
-
-/* Calculate line execution counts, and output a .gcov file for source
- file S_PTR. Allocate an array big enough to hold a count for each
- line. Scan through the bb_data, and when the file name matches the
- current file name, then for each following line number, increment
- the line number execution count indicated by the execution count of
- the appropriate basic block. */
-
-static void
-output_data (s_ptr)
- struct sourcefile *s_ptr;
-{
- struct line_info *line_info /* line info data */
- = (struct line_info *) xcalloc (s_ptr->maxlineno,
- sizeof (struct line_info));
- long line_num;
- struct coverage total;
-
- memset (&total, 0, sizeof (total));
- total.name = s_ptr->name;
-
- init_line_info (line_info, &total, s_ptr->maxlineno);
- function_summary (&total, "file");
-
- if (output_gcov_file)
- {
- /* Now the statistics are ready. Read in the source file one
- line at a time, and output that line to the gcov file
- preceded by its execution information. */
-
- char *gcov_file_name = make_gcov_file_name (total.name);
- FILE *gcov_file = fopen (gcov_file_name, "w");
-
- if (gcov_file)
- {
- fnotice (stdout, "Creating %s.\n", gcov_file_name);
- output_line_info (gcov_file, line_info, &total, s_ptr->maxlineno);
- if (ferror (gcov_file))
- fnotice (stderr, "Error writing output file %s.\n",
- gcov_file_name);
- fclose (gcov_file);
- }
- else
- fnotice (stderr, "Could not open output file %s.\n", gcov_file_name);
- free (gcov_file_name);
- }
-
- /* Free data. */
- for (line_num = 1; line_num != s_ptr->maxlineno; line_num++)
- {
- struct arcdata *branch, *next;
-
- for (branch = line_info[line_num].branches; branch; branch = next)
- {
- next = branch->next;
- free (branch);
- }
- }
- free (line_info);
-}
OSDN Git Service
