1 /* Gcov.c: prepend line execution counts and branch probabilities to a
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998, 1999,
4 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
6 Contributed by James E. Wilson of Cygnus Support.
7 Mangled by Bob Manson of Cygnus Support.
8 Mangled further by Nathan Sidwell <nathan@codesourcery.com>
10 Gcov is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3, or (at your option)
15 Gcov is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with Gcov; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* ??? Print a list of the ten blocks with the highest execution counts,
25 and list the line numbers corresponding to those blocks. Also, perhaps
26 list the line numbers with the highest execution counts, only printing
27 the first if there are several which are all listed in the same block. */
29 /* ??? Should have an option to print the number of basic blocks, and the
30 percent of them that are covered. */
32 /* Need an option to show individual block counts, and show
33 probabilities of fall through arcs. */
37 #include "coretypes.h"
40 #include "diagnostic.h"
49 /* The gcno file is generated by -ftest-coverage option. The gcda file is
50 generated by a program compiled with -fprofile-arcs. Their formats
51 are documented in gcov-io.h. */
53 /* The functions in this file for creating and solution program flow graphs
54 are very similar to functions in the gcc source file profile.c. In
55 some places we make use of the knowledge of how profile.c works to
56 select particular algorithms here. */
58 /* The code validates that the profile information read in corresponds
59 to the code currently being compiled. Rather than checking for
60 identical files, the code below computes a checksum on the CFG
61 (based on the order of basic blocks and the arcs in the CFG). If
62 the CFG checksum in the gcda file match the CFG checksum for the
63 code currently being compiled, the profile data will be used. */
65 /* This is the size of the buffer used to read in source file lines. */
67 #define STRING_SIZE 200
73 /* Describes an arc between two basic blocks. */
75 typedef struct arc_info
77 /* source and destination blocks. */
78 struct block_info *src;
79 struct block_info *dst;
81 /* transition counts. */
83 /* used in cycle search, so that we do not clobber original counts. */
86 unsigned int count_valid : 1;
87 unsigned int on_tree : 1;
88 unsigned int fake : 1;
89 unsigned int fall_through : 1;
91 /* Arc is for a function that abnormally returns. */
92 unsigned int is_call_non_return : 1;
94 /* Arc is for catch/setjmp. */
95 unsigned int is_nonlocal_return : 1;
97 /* Is an unconditional branch. */
98 unsigned int is_unconditional : 1;
100 /* Loop making arc. */
101 unsigned int cycle : 1;
103 /* Next branch on line. */
104 struct arc_info *line_next;
106 /* Links to next arc on src and dst lists. */
107 struct arc_info *succ_next;
108 struct arc_info *pred_next;
111 /* Describes a basic block. Contains lists of arcs to successor and
112 predecessor blocks. */
114 typedef struct block_info
116 /* Chain of exit and entry arcs. */
120 /* Number of unprocessed exit and entry arcs. */
124 /* Block execution count. */
127 unsigned count_valid : 1;
128 unsigned valid_chain : 1;
129 unsigned invalid_chain : 1;
131 /* Block is a call instrumenting site. */
132 unsigned is_call_site : 1; /* Does the call. */
133 unsigned is_call_return : 1; /* Is the return. */
135 /* Block is a landing pad for longjmp or throw. */
136 unsigned is_nonlocal_return : 1;
142 /* Array of line numbers and source files. source files are
143 introduced by a linenumber of zero, the next 'line number' is
144 the number of the source file. Always starts with a source
148 } line; /* Valid until blocks are linked onto lines */
151 /* Single line graph cycle workspace. Used for all-blocks
155 } cycle; /* Used in all-blocks mode, after blocks are linked onto
159 /* Temporary chain for solving graph, and for chaining blocks on one
161 struct block_info *chain;
165 /* Describes a single function. Contains an array of basic blocks. */
167 typedef struct function_info
169 /* Name of function. */
172 unsigned lineno_checksum;
173 unsigned cfg_checksum;
175 /* Array of basic blocks. */
178 unsigned blocks_executed;
180 /* Raw arc coverage counts. */
184 /* First line number & file. */
188 /* Next function in same source file. */
189 struct function_info *line_next;
192 struct function_info *next;
195 /* Describes coverage of a file or function. */
197 typedef struct coverage_info
203 int branches_executed;
212 /* Describes a single line of source. Contains a chain of basic blocks
215 typedef struct line_info
217 gcov_type count; /* execution count */
220 arc_t *branches; /* branches from blocks that end on this
221 line. Used for branch-counts when not
223 block_t *blocks; /* blocks which start on this line. Used
224 in all-blocks mode. */
229 /* Describes a file mentioned in the block graph. Contains an array
232 typedef struct source_info
234 /* Canonical name of source file. */
238 /* Array of line information. */
244 /* Functions in this source file. These are in ascending line
246 function_t *functions;
249 typedef struct name_map
251 char *name; /* Source file name */
252 unsigned src; /* Source file */
255 /* Holds a list of function basic block graphs. */
257 static function_t *functions;
258 static function_t **fn_end = &functions;
260 static source_t *sources; /* Array of source files */
261 static unsigned n_sources; /* Number of sources */
262 static unsigned a_sources; /* Allocated sources */
264 static name_map_t *names; /* Mapping of file names to sources */
265 static unsigned n_names; /* Number of names */
266 static unsigned a_names; /* Allocated names */
268 /* This holds data summary information. */
270 static unsigned object_runs;
271 static unsigned program_count;
273 /* Modification time of graph file. */
275 static time_t bbg_file_time;
277 /* Name and file pointer of the input file for the basic block graph. */
279 static char *bbg_file_name;
281 /* Stamp of the bbg file */
282 static unsigned bbg_stamp;
284 /* Name and file pointer of the input file for the arc count data. */
286 static char *da_file_name;
288 /* Data file is missing. */
290 static int no_data_file;
292 /* If there is several input files, compute and display results after
293 reading all data files. This way if two or more gcda file refer to
294 the same source file (eg inline subprograms in a .h file), the
297 static int multiple_files = 0;
299 /* Output branch probabilities. */
301 static int flag_branches = 0;
303 /* Show unconditional branches too. */
304 static int flag_unconditional = 0;
306 /* Output a gcov file if this is true. This is on by default, and can
307 be turned off by the -n option. */
309 static int flag_gcov_file = 1;
311 /* Output progress indication if this is true. This is off by default
312 and can be turned on by the -d option. */
314 static int flag_display_progress = 0;
316 /* For included files, make the gcov output file name include the name
317 of the input source file. For example, if x.h is included in a.c,
318 then the output file name is a.c##x.h.gcov instead of x.h.gcov. */
320 static int flag_long_names = 0;
322 /* Output count information for every basic block, not merely those
323 that contain line number information. */
325 static int flag_all_blocks = 0;
327 /* Output summary info for each function. */
329 static int flag_function_summary = 0;
331 /* Object directory file prefix. This is the directory/file where the
332 graph and data files are looked for, if nonzero. */
334 static char *object_directory = 0;
336 /* Source directory prefix. This is removed from source pathnames
337 that match, when generating the output file name. */
339 static char *source_prefix = 0;
340 static size_t source_length = 0;
342 /* Only show data for sources with relative pathnames. Absolute ones
343 usually indicate a system header file, which although it may
344 contain inline functions, is usually uninteresting. */
345 static int flag_relative_only = 0;
347 /* Preserve all pathname components. Needed when object files and
348 source files are in subdirectories. '/' is mangled as '#', '.' is
349 elided and '..' mangled to '^'. */
351 static int flag_preserve_paths = 0;
353 /* Output the number of times a branch was taken as opposed to the percentage
354 of times it was taken. */
356 static int flag_counts = 0;
358 /* Forward declarations. */
359 static int process_args (int, char **);
360 static void print_usage (int) ATTRIBUTE_NORETURN;
361 static void print_version (void) ATTRIBUTE_NORETURN;
362 static void process_file (const char *);
363 static void generate_results (const char *);
364 static void create_file_names (const char *);
365 static int name_search (const void *, const void *);
366 static int name_sort (const void *, const void *);
367 static char *canonicalize_name (const char *);
368 static unsigned find_source (const char *);
369 static function_t *read_graph_file (void);
370 static int read_count_file (function_t *);
371 static void solve_flow_graph (function_t *);
372 static void add_branch_counts (coverage_t *, const arc_t *);
373 static void add_line_counts (coverage_t *, function_t *);
374 static void function_summary (const coverage_t *, const char *);
375 static const char *format_gcov (gcov_type, gcov_type, int);
376 static void accumulate_line_counts (source_t *);
377 static int output_branch_count (FILE *, int, const arc_t *);
378 static void output_lines (FILE *, const source_t *);
379 static char *make_gcov_file_name (const char *, const char *);
380 static char *mangle_name (const char *, char *);
381 static void release_structures (void);
382 static void release_function (function_t *);
383 extern int main (int, char **);
386 main (int argc, char **argv)
392 p = argv[0] + strlen (argv[0]);
393 while (p != argv[0] && !IS_DIR_SEPARATOR (p[-1]))
397 xmalloc_set_program_name (progname);
399 /* Unlock the stdio streams. */
400 unlock_std_streams ();
404 diagnostic_initialize (global_dc, 0);
406 /* Handle response files. */
407 expandargv (&argc, &argv);
409 argno = process_args (argc, argv);
413 if (argc - argno > 1)
418 for (; argno != argc; argno++)
420 if (flag_display_progress)
421 printf("Processing file %d out of %d\n",
422 argno - first_arg + 1, argc - first_arg);
423 process_file (argv[argno]);
426 generate_results (multiple_files ? NULL : argv[argc - 1]);
428 release_structures ();
433 /* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
434 otherwise the output of --help. */
437 print_usage (int error_p)
439 FILE *file = error_p ? stderr : stdout;
440 int status = error_p ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE;
442 fnotice (file, "Usage: gcov [OPTION]... SOURCE|OBJ...\n\n");
443 fnotice (file, "Print code coverage information.\n\n");
444 fnotice (file, " -h, --help Print this help, then exit\n");
445 fnotice (file, " -v, --version Print version number, then exit\n");
446 fnotice (file, " -a, --all-blocks Show information for every basic block\n");
447 fnotice (file, " -b, --branch-probabilities Include branch probabilities in output\n");
448 fnotice (file, " -c, --branch-counts Given counts of branches taken\n\
449 rather than percentages\n");
450 fnotice (file, " -n, --no-output Do not create an output file\n");
451 fnotice (file, " -l, --long-file-names Use long output file names for included\n\
453 fnotice (file, " -f, --function-summaries Output summaries for each function\n");
454 fnotice (file, " -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n");
455 fnotice (file, " -s, --source-prefix DIR Source prefix to elide\n");
456 fnotice (file, " -r, --relative-only Only show data for relative sources\n");
457 fnotice (file, " -p, --preserve-paths Preserve all pathname components\n");
458 fnotice (file, " -u, --unconditional-branches Show unconditional branch counts too\n");
459 fnotice (file, " -d, --display-progress Display progress information\n");
460 fnotice (file, "\nFor bug reporting instructions, please see:\n%s.\n",
465 /* Print version information and exit. */
470 fnotice (stdout, "gcov %s%s\n", pkgversion_string, version_string);
471 fprintf (stdout, "Copyright %s 2011 Free Software Foundation, Inc.\n",
474 _("This is free software; see the source for copying conditions.\n"
475 "There is NO warranty; not even for MERCHANTABILITY or \n"
476 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
477 exit (SUCCESS_EXIT_CODE);
480 static const struct option options[] =
482 { "help", no_argument, NULL, 'h' },
483 { "version", no_argument, NULL, 'v' },
484 { "all-blocks", no_argument, NULL, 'a' },
485 { "branch-probabilities", no_argument, NULL, 'b' },
486 { "branch-counts", no_argument, NULL, 'c' },
487 { "no-output", no_argument, NULL, 'n' },
488 { "long-file-names", no_argument, NULL, 'l' },
489 { "function-summaries", no_argument, NULL, 'f' },
490 { "preserve-paths", no_argument, NULL, 'p' },
491 { "relative-only", no_argument, NULL, 'r' },
492 { "object-directory", required_argument, NULL, 'o' },
493 { "object-file", required_argument, NULL, 'o' },
494 { "source-prefix", required_argument, NULL, 's' },
495 { "unconditional-branches", no_argument, NULL, 'u' },
496 { "display-progress", no_argument, NULL, 'd' },
500 /* Process args, return index to first non-arg. */
503 process_args (int argc, char **argv)
507 while ((opt = getopt_long (argc, argv, "abcdfhlno:s:pruv", options, NULL)) != -1)
521 flag_function_summary = 1;
525 /* print_usage will exit. */
533 object_directory = optarg;
536 source_prefix = optarg;
537 source_length = strlen (source_prefix);
540 flag_relative_only = 1;
543 flag_preserve_paths = 1;
546 flag_unconditional = 1;
549 flag_display_progress = 1;
553 /* print_version will exit. */
556 /* print_usage will exit. */
563 /* Process a single input file. */
566 process_file (const char *file_name)
570 create_file_names (file_name);
571 fns = read_graph_file ();
575 read_count_file (fns);
578 function_t *fn = fns;
584 unsigned src = fn->src;
585 unsigned line = fn->line;
587 function_t *probe, **prev;
589 /* Now insert it into the source file's list of
590 functions. Normally functions will be encountered in
591 ascending order, so a simple scan is quick. Note we're
592 building this list in reverse order. */
593 for (prev = &sources[src].functions;
594 (probe = *prev); prev = &probe->line_next)
595 if (probe->line <= line)
597 fn->line_next = probe;
600 /* Mark last line in files touched by function. */
601 for (block_no = 0; block_no != fn->num_blocks; block_no++)
603 unsigned *enc = fn->blocks[block_no].u.line.encoding;
604 unsigned num = fn->blocks[block_no].u.line.num;
611 if (line >= sources[src].num_lines)
612 sources[src].num_lines = line + 1;
619 else if (*enc > line)
622 if (line >= sources[src].num_lines)
623 sources[src].num_lines = line + 1;
625 solve_flow_graph (fn);
630 /* The function was not in the executable -- some other
631 instance must have been selected. */
632 release_function (fn);
637 generate_results (const char *file_name)
643 for (ix = n_sources, src = sources; ix--; src++)
645 src->lines = XCNEWVEC (line_t, src->num_lines);
647 for (fn = functions; fn; fn = fn->next)
651 memset (&coverage, 0, sizeof (coverage));
652 coverage.name = fn->name;
653 add_line_counts (flag_function_summary ? &coverage : NULL, fn);
654 if (flag_function_summary)
656 function_summary (&coverage, "Function");
657 fnotice (stdout, "\n");
663 name_map_t *name_map = (name_map_t *)bsearch
664 (file_name, names, n_names, sizeof (*names), name_search);
666 file_name = sources[name_map->src].coverage.name;
668 file_name = canonicalize_name (file_name);
671 for (ix = n_sources, src = sources; ix--; src++)
673 if (flag_relative_only)
675 /* Ignore this source, if it is an absolute path (after
676 source prefix removal). */
677 char first = src->coverage.name[0];
679 #if HAVE_DOS_BASED_FILE_SYSTEM
680 if (first && src->coverage.name[1] == ':')
681 first = src->coverage.name[2];
683 if (IS_DIR_SEPARATOR (first))
687 accumulate_line_counts (src);
688 function_summary (&src->coverage, "File");
689 if (flag_gcov_file && src->coverage.lines)
692 = make_gcov_file_name (file_name, src->coverage.name);
693 FILE *gcov_file = fopen (gcov_file_name, "w");
697 fnotice (stdout, "Creating '%s'\n", gcov_file_name);
698 output_lines (gcov_file, src);
699 if (ferror (gcov_file))
700 fnotice (stderr, "Error writing output file '%s'\n",
705 fnotice (stderr, "Could not open output file '%s'\n",
707 free (gcov_file_name);
709 fnotice (stdout, "\n");
713 /* Release a function structure */
716 release_function (function_t *fn)
721 for (ix = fn->num_blocks, block = fn->blocks; ix--; block++)
725 for (arc = block->succ; arc; arc = arc_n)
727 arc_n = arc->succ_next;
735 /* Release all memory used. */
738 release_structures (void)
743 for (ix = n_sources; ix--;)
744 free (sources[ix].lines);
747 for (ix = n_names; ix--;)
748 free (names[ix].name);
751 while ((fn = functions))
753 functions = fn->next;
754 release_function (fn);
758 /* Generate the names of the graph and data files. If OBJECT_DIRECTORY
759 is not specified, these are named from FILE_NAME sans extension. If
760 OBJECT_DIRECTORY is specified and is a directory, the files are in that
761 directory, but named from the basename of the FILE_NAME, sans extension.
762 Otherwise OBJECT_DIRECTORY is taken to be the name of the object *file*
763 and the data files are named from that. */
766 create_file_names (const char *file_name)
770 int length = strlen (file_name);
773 /* Free previous file names. */
774 free (bbg_file_name);
776 da_file_name = bbg_file_name = NULL;
780 if (object_directory && object_directory[0])
784 length += strlen (object_directory) + 2;
785 name = XNEWVEC (char, length);
788 base = !stat (object_directory, &status) && S_ISDIR (status.st_mode);
789 strcat (name, object_directory);
790 if (base && (! IS_DIR_SEPARATOR (name[strlen (name) - 1])))
795 name = XNEWVEC (char, length + 1);
796 strcpy (name, file_name);
802 /* Append source file name. */
803 const char *cptr = lbasename (file_name);
804 strcat (name, cptr ? cptr : file_name);
807 /* Remove the extension. */
808 cptr = strrchr (name, '.');
812 length = strlen (name);
814 bbg_file_name = XNEWVEC (char, length + strlen (GCOV_NOTE_SUFFIX) + 1);
815 strcpy (bbg_file_name, name);
816 strcpy (bbg_file_name + length, GCOV_NOTE_SUFFIX);
818 da_file_name = XNEWVEC (char, length + strlen (GCOV_DATA_SUFFIX) + 1);
819 strcpy (da_file_name, name);
820 strcpy (da_file_name + length, GCOV_DATA_SUFFIX);
826 /* A is a string and B is a pointer to name_map_t. Compare for file
827 name orderability. */
830 name_search (const void *a_, const void *b_)
832 const char *a = (const char *)a_;
833 const name_map_t *b = (const name_map_t *)b_;
835 #if HAVE_DOS_BASED_FILE_SYSTEM
836 return strcasecmp (a, b->name);
838 return strcmp (a, b->name);
842 /* A and B are a pointer to name_map_t. Compare for file name
846 name_sort (const void *a_, const void *b_)
848 const name_map_t *a = (const name_map_t *)a_;
849 return name_search (a->name, b_);
852 /* Find or create a source file structure for FILE_NAME. Copies
853 FILE_NAME on creation */
856 find_source (const char *file_name)
858 name_map_t *name_map;
864 file_name = "<unknown>";
865 name_map = (name_map_t *)bsearch
866 (file_name, names, n_names, sizeof (*names), name_search);
873 if (n_names + 2 > a_names)
875 /* Extend the name map array -- we'll be inserting one or two
880 name_map = XNEWVEC (name_map_t, a_names);
881 memcpy (name_map, names, n_names * sizeof (*names));
886 /* Not found, try the canonical name. */
887 canon = canonicalize_name (file_name);
888 name_map = (name_map_t *)bsearch
889 (canon, names, n_names, sizeof (*names), name_search);
892 /* Not found with canonical name, create a new source. */
895 if (n_sources == a_sources)
900 src = XNEWVEC (source_t, a_sources);
901 memcpy (src, sources, n_sources * sizeof (*sources));
908 name_map = &names[n_names++];
909 name_map->name = canon;
912 src = &sources[n_sources++];
913 memset (src, 0, sizeof (*src));
915 src->coverage.name = src->name;
917 #if HAVE_DOS_BASED_FILE_SYSTEM
918 /* You lose if separators don't match exactly in the
920 && !strncasecmp (source_prefix, src->coverage.name, source_length)
922 && !strncmp (source_prefix, src->coverage.name, source_length)
924 && IS_DIR_SEPARATOR (src->coverage.name[source_length]))
925 src->coverage.name += source_length + 1;
926 if (!stat (src->name, &status))
927 src->file_time = status.st_mtime;
932 if (name_search (file_name, name_map))
934 /* Append the non-canonical name. */
935 name_map = &names[n_names++];
936 name_map->name = xstrdup (file_name);
940 /* Resort the name map. */
941 qsort (names, n_names, sizeof (*names), name_sort);
944 if (sources[idx].file_time > bbg_file_time)
946 static int info_emitted;
948 fnotice (stderr, "%s:source file is newer than graph file '%s'\n",
949 file_name, bbg_file_name);
953 "(the message is only displayed one per source file)\n");
956 sources[idx].file_time = 0;
962 /* Read the graph file. Return list of functions read -- in reverse order. */
965 read_graph_file (void)
968 unsigned current_tag = 0;
969 function_t *fn = NULL;
970 function_t *fns = NULL;
971 function_t **fns_end = &fns;
972 unsigned src_idx = 0;
976 if (!gcov_open (bbg_file_name, 1))
978 fnotice (stderr, "%s:cannot open graph file\n", bbg_file_name);
981 bbg_file_time = gcov_time ();
982 if (!gcov_magic (gcov_read_unsigned (), GCOV_NOTE_MAGIC))
984 fnotice (stderr, "%s:not a gcov graph file\n", bbg_file_name);
989 version = gcov_read_unsigned ();
990 if (version != GCOV_VERSION)
994 GCOV_UNSIGNED2STRING (v, version);
995 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
997 fnotice (stderr, "%s:version '%.4s', prefer '%.4s'\n",
998 bbg_file_name, v, e);
1000 bbg_stamp = gcov_read_unsigned ();
1002 while ((tag = gcov_read_unsigned ()))
1004 unsigned length = gcov_read_unsigned ();
1005 gcov_position_t base = gcov_position ();
1007 if (tag == GCOV_TAG_FUNCTION)
1009 char *function_name;
1010 unsigned ident, lineno;
1011 unsigned lineno_checksum, cfg_checksum;
1013 ident = gcov_read_unsigned ();
1014 lineno_checksum = gcov_read_unsigned ();
1015 cfg_checksum = gcov_read_unsigned ();
1016 function_name = xstrdup (gcov_read_string ());
1017 src_idx = find_source (gcov_read_string ());
1018 lineno = gcov_read_unsigned ();
1020 fn = XCNEW (function_t);
1021 fn->name = function_name;
1023 fn->lineno_checksum = lineno_checksum;
1024 fn->cfg_checksum = cfg_checksum;
1028 fn->line_next = NULL;
1031 fns_end = &fn->next;
1034 else if (fn && tag == GCOV_TAG_BLOCKS)
1037 fnotice (stderr, "%s:already seen blocks for '%s'\n",
1038 bbg_file_name, fn->name);
1041 unsigned ix, num_blocks = GCOV_TAG_BLOCKS_NUM (length);
1042 fn->num_blocks = num_blocks;
1044 fn->blocks = XCNEWVEC (block_t, fn->num_blocks);
1045 for (ix = 0; ix != num_blocks; ix++)
1046 fn->blocks[ix].flags = gcov_read_unsigned ();
1049 else if (fn && tag == GCOV_TAG_ARCS)
1051 unsigned src = gcov_read_unsigned ();
1052 unsigned num_dests = GCOV_TAG_ARCS_NUM (length);
1054 if (src >= fn->num_blocks || fn->blocks[src].succ)
1059 struct arc_info *arc;
1060 unsigned dest = gcov_read_unsigned ();
1061 unsigned flags = gcov_read_unsigned ();
1063 if (dest >= fn->num_blocks)
1065 arc = XCNEW (arc_t);
1067 arc->dst = &fn->blocks[dest];
1068 arc->src = &fn->blocks[src];
1071 arc->count_valid = 0;
1072 arc->on_tree = !!(flags & GCOV_ARC_ON_TREE);
1073 arc->fake = !!(flags & GCOV_ARC_FAKE);
1074 arc->fall_through = !!(flags & GCOV_ARC_FALLTHROUGH);
1076 arc->succ_next = fn->blocks[src].succ;
1077 fn->blocks[src].succ = arc;
1078 fn->blocks[src].num_succ++;
1080 arc->pred_next = fn->blocks[dest].pred;
1081 fn->blocks[dest].pred = arc;
1082 fn->blocks[dest].num_pred++;
1088 /* Exceptional exit from this function, the
1089 source block must be a call. */
1090 fn->blocks[src].is_call_site = 1;
1091 arc->is_call_non_return = 1;
1095 /* Non-local return from a callee of this
1096 function. The destination block is a catch or
1098 arc->is_nonlocal_return = 1;
1099 fn->blocks[dest].is_nonlocal_return = 1;
1107 else if (fn && tag == GCOV_TAG_LINES)
1109 unsigned blockno = gcov_read_unsigned ();
1110 unsigned *line_nos = XCNEWVEC (unsigned, length - 1);
1112 if (blockno >= fn->num_blocks || fn->blocks[blockno].u.line.encoding)
1117 unsigned lineno = gcov_read_unsigned ();
1124 line_nos[ix++] = src_idx;
1126 line_nos[ix++] = lineno;
1130 const char *file_name = gcov_read_string ();
1134 src_idx = find_source (file_name);
1136 line_nos[ix++] = src_idx;
1140 fn->blocks[blockno].u.line.encoding = line_nos;
1141 fn->blocks[blockno].u.line.num = ix;
1143 else if (current_tag && !GCOV_TAG_IS_SUBTAG (current_tag, tag))
1148 gcov_sync (base, length);
1149 if (gcov_is_error ())
1152 fnotice (stderr, "%s:corrupted\n", bbg_file_name);
1159 fnotice (stderr, "%s:no functions found\n", bbg_file_name);
1164 /* Reads profiles from the count file and attach to each
1165 function. Return nonzero if fatal error. */
1168 read_count_file (function_t *fns)
1173 function_t *fn = NULL;
1176 if (!gcov_open (da_file_name, 1))
1178 fnotice (stderr, "%s:cannot open data file, assuming not executed\n",
1183 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC))
1185 fnotice (stderr, "%s:not a gcov data file\n", da_file_name);
1190 version = gcov_read_unsigned ();
1191 if (version != GCOV_VERSION)
1195 GCOV_UNSIGNED2STRING (v, version);
1196 GCOV_UNSIGNED2STRING (e, GCOV_VERSION);
1198 fnotice (stderr, "%s:version '%.4s', prefer version '%.4s'\n",
1199 da_file_name, v, e);
1201 tag = gcov_read_unsigned ();
1202 if (tag != bbg_stamp)
1204 fnotice (stderr, "%s:stamp mismatch with graph file\n", da_file_name);
1208 while ((tag = gcov_read_unsigned ()))
1210 unsigned length = gcov_read_unsigned ();
1211 unsigned long base = gcov_position ();
1213 if (tag == GCOV_TAG_PROGRAM_SUMMARY)
1215 struct gcov_summary summary;
1216 gcov_read_summary (&summary);
1217 object_runs += summary.ctrs[GCOV_COUNTER_ARCS].runs;
1220 else if (tag == GCOV_TAG_FUNCTION && !length)
1222 else if (tag == GCOV_TAG_FUNCTION && length == GCOV_TAG_FUNCTION_LENGTH)
1225 struct function_info *fn_n;
1227 /* Try to find the function in the list. To speed up the
1228 search, first start from the last function found. */
1229 ident = gcov_read_unsigned ();
1231 for (fn = fn ? fn->next : NULL; ; fn = fn->next)
1235 else if ((fn = fn_n))
1239 fnotice (stderr, "%s:unknown function '%u'\n",
1240 da_file_name, ident);
1243 if (fn->ident == ident)
1249 else if (gcov_read_unsigned () != fn->lineno_checksum
1250 || gcov_read_unsigned () != fn->cfg_checksum)
1253 fnotice (stderr, "%s:profile mismatch for '%s'\n",
1254 da_file_name, fn->name);
1258 else if (tag == GCOV_TAG_FOR_COUNTER (GCOV_COUNTER_ARCS) && fn)
1260 if (length != GCOV_TAG_COUNTER_LENGTH (fn->num_counts))
1264 fn->counts = XCNEWVEC (gcov_type, fn->num_counts);
1266 for (ix = 0; ix != fn->num_counts; ix++)
1267 fn->counts[ix] += gcov_read_counter ();
1269 gcov_sync (base, length);
1270 if ((error = gcov_is_error ()))
1272 fnotice (stderr, error < 0 ? "%s:overflowed\n" : "%s:corrupted\n",
1282 /* Solve the flow graph. Propagate counts from the instrumented arcs
1283 to the blocks and the uninstrumented arcs. */
1286 solve_flow_graph (function_t *fn)
1290 gcov_type *count_ptr = fn->counts;
1292 block_t *valid_blocks = NULL; /* valid, but unpropagated blocks. */
1293 block_t *invalid_blocks = NULL; /* invalid, but inferable blocks. */
1295 /* The arcs were built in reverse order. Fix that now. */
1296 for (ix = fn->num_blocks; ix--;)
1298 arc_t *arc_p, *arc_n;
1300 for (arc_p = NULL, arc = fn->blocks[ix].succ; arc;
1301 arc_p = arc, arc = arc_n)
1303 arc_n = arc->succ_next;
1304 arc->succ_next = arc_p;
1306 fn->blocks[ix].succ = arc_p;
1308 for (arc_p = NULL, arc = fn->blocks[ix].pred; arc;
1309 arc_p = arc, arc = arc_n)
1311 arc_n = arc->pred_next;
1312 arc->pred_next = arc_p;
1314 fn->blocks[ix].pred = arc_p;
1317 if (fn->num_blocks < 2)
1318 fnotice (stderr, "%s:'%s' lacks entry and/or exit blocks\n",
1319 bbg_file_name, fn->name);
1322 if (fn->blocks[0].num_pred)
1323 fnotice (stderr, "%s:'%s' has arcs to entry block\n",
1324 bbg_file_name, fn->name);
1326 /* We can't deduce the entry block counts from the lack of
1328 fn->blocks[0].num_pred = ~(unsigned)0;
1330 if (fn->blocks[fn->num_blocks - 1].num_succ)
1331 fnotice (stderr, "%s:'%s' has arcs from exit block\n",
1332 bbg_file_name, fn->name);
1334 /* Likewise, we can't deduce exit block counts from the lack
1335 of its successors. */
1336 fn->blocks[fn->num_blocks - 1].num_succ = ~(unsigned)0;
1339 /* Propagate the measured counts, this must be done in the same
1340 order as the code in profile.c */
1341 for (ix = 0, blk = fn->blocks; ix != fn->num_blocks; ix++, blk++)
1343 block_t const *prev_dst = NULL;
1344 int out_of_order = 0;
1345 int non_fake_succ = 0;
1347 for (arc = blk->succ; arc; arc = arc->succ_next)
1355 arc->count = *count_ptr++;
1356 arc->count_valid = 1;
1358 arc->dst->num_pred--;
1360 if (prev_dst && prev_dst > arc->dst)
1362 prev_dst = arc->dst;
1364 if (non_fake_succ == 1)
1366 /* If there is only one non-fake exit, it is an
1367 unconditional branch. */
1368 for (arc = blk->succ; arc; arc = arc->succ_next)
1371 arc->is_unconditional = 1;
1372 /* If this block is instrumenting a call, it might be
1373 an artificial block. It is not artificial if it has
1374 a non-fallthrough exit, or the destination of this
1375 arc has more than one entry. Mark the destination
1376 block as a return site, if none of those conditions
1378 if (blk->is_call_site && arc->fall_through
1379 && arc->dst->pred == arc && !arc->pred_next)
1380 arc->dst->is_call_return = 1;
1384 /* Sort the successor arcs into ascending dst order. profile.c
1385 normally produces arcs in the right order, but sometimes with
1386 one or two out of order. We're not using a particularly
1390 arc_t *start = blk->succ;
1391 unsigned changes = 1;
1395 arc_t *arc, *arc_p, *arc_n;
1398 for (arc_p = NULL, arc = start; (arc_n = arc->succ_next);)
1400 if (arc->dst > arc_n->dst)
1404 arc_p->succ_next = arc_n;
1407 arc->succ_next = arc_n->succ_next;
1408 arc_n->succ_next = arc;
1421 /* Place it on the invalid chain, it will be ignored if that's
1423 blk->invalid_chain = 1;
1424 blk->chain = invalid_blocks;
1425 invalid_blocks = blk;
1428 while (invalid_blocks || valid_blocks)
1430 while ((blk = invalid_blocks))
1432 gcov_type total = 0;
1435 invalid_blocks = blk->chain;
1436 blk->invalid_chain = 0;
1438 for (arc = blk->succ; arc; arc = arc->succ_next)
1439 total += arc->count;
1440 else if (!blk->num_pred)
1441 for (arc = blk->pred; arc; arc = arc->pred_next)
1442 total += arc->count;
1447 blk->count_valid = 1;
1448 blk->chain = valid_blocks;
1449 blk->valid_chain = 1;
1452 while ((blk = valid_blocks))
1455 arc_t *arc, *inv_arc;
1457 valid_blocks = blk->chain;
1458 blk->valid_chain = 0;
1459 if (blk->num_succ == 1)
1465 for (arc = blk->succ; arc; arc = arc->succ_next)
1467 total -= arc->count;
1468 if (!arc->count_valid)
1472 inv_arc->count_valid = 1;
1473 inv_arc->count = total;
1476 if (dst->count_valid)
1478 if (dst->num_pred == 1 && !dst->valid_chain)
1480 dst->chain = valid_blocks;
1481 dst->valid_chain = 1;
1487 if (!dst->num_pred && !dst->invalid_chain)
1489 dst->chain = invalid_blocks;
1490 dst->invalid_chain = 1;
1491 invalid_blocks = dst;
1495 if (blk->num_pred == 1)
1501 for (arc = blk->pred; arc; arc = arc->pred_next)
1503 total -= arc->count;
1504 if (!arc->count_valid)
1508 inv_arc->count_valid = 1;
1509 inv_arc->count = total;
1512 if (src->count_valid)
1514 if (src->num_succ == 1 && !src->valid_chain)
1516 src->chain = valid_blocks;
1517 src->valid_chain = 1;
1523 if (!src->num_succ && !src->invalid_chain)
1525 src->chain = invalid_blocks;
1526 src->invalid_chain = 1;
1527 invalid_blocks = src;
1534 /* If the graph has been correctly solved, every block will have a
1536 for (ix = 0; ix < fn->num_blocks; ix++)
1537 if (!fn->blocks[ix].count_valid)
1539 fnotice (stderr, "%s:graph is unsolvable for '%s'\n",
1540 bbg_file_name, fn->name);
1547 /* Increment totals in COVERAGE according to arc ARC. */
1550 add_branch_counts (coverage_t *coverage, const arc_t *arc)
1552 if (arc->is_call_non_return)
1555 if (arc->src->count)
1556 coverage->calls_executed++;
1558 else if (!arc->is_unconditional)
1560 coverage->branches++;
1561 if (arc->src->count)
1562 coverage->branches_executed++;
1564 coverage->branches_taken++;
1568 /* Format a HOST_WIDE_INT as either a percent ratio, or absolute
1569 count. If dp >= 0, format TOP/BOTTOM * 100 to DP decimal places.
1570 If DP is zero, no decimal point is printed. Only print 100% when
1571 TOP==BOTTOM and only print 0% when TOP=0. If dp < 0, then simply
1572 format TOP. Return pointer to a static string. */
1575 format_gcov (gcov_type top, gcov_type bottom, int dp)
1577 static char buffer[20];
1581 float ratio = bottom ? (float)top / bottom : 0;
1583 unsigned limit = 100;
1586 for (ix = dp; ix--; )
1589 percent = (unsigned) (ratio * limit + (float)0.5);
1590 if (percent <= 0 && top)
1592 else if (percent >= limit && top != bottom)
1593 percent = limit - 1;
1594 ix = sprintf (buffer, "%.*u%%", dp + 1, percent);
1600 buffer[ix+1] = buffer[ix];
1604 buffer[ix + 1] = '.';
1608 sprintf (buffer, HOST_WIDEST_INT_PRINT_DEC, (HOST_WIDEST_INT)top);
1614 /* Output summary info for a function. */
1617 function_summary (const coverage_t *coverage, const char *title)
1619 fnotice (stdout, "%s '%s'\n", title, coverage->name);
1621 if (coverage->lines)
1622 fnotice (stdout, "Lines executed:%s of %d\n",
1623 format_gcov (coverage->lines_executed, coverage->lines, 2),
1626 fnotice (stdout, "No executable lines\n");
1630 if (coverage->branches)
1632 fnotice (stdout, "Branches executed:%s of %d\n",
1633 format_gcov (coverage->branches_executed,
1634 coverage->branches, 2),
1635 coverage->branches);
1636 fnotice (stdout, "Taken at least once:%s of %d\n",
1637 format_gcov (coverage->branches_taken,
1638 coverage->branches, 2),
1639 coverage->branches);
1642 fnotice (stdout, "No branches\n");
1643 if (coverage->calls)
1644 fnotice (stdout, "Calls executed:%s of %d\n",
1645 format_gcov (coverage->calls_executed, coverage->calls, 2),
1648 fnotice (stdout, "No calls\n");
1652 /* Canonicalize the filename NAME by canonicalizing directory
1653 separators, eliding . components and resolving .. components
1654 appropriately. Always returns a unique string. */
1657 canonicalize_name (const char *name)
1659 /* The canonical name cannot be longer than the incoming name. */
1660 char *result = XNEWVEC (char, strlen (name) + 1);
1661 const char *base = name, *probe;
1666 #if HAVE_DOS_BASED_FILE_SYSTEM
1667 if (base[0] && base[1] == ':')
1669 result[0] = base[0];
1675 for (dd_base = ptr; *base; base = probe)
1679 for (probe = base; *probe; probe++)
1680 if (IS_DIR_SEPARATOR (*probe))
1684 if (len == 1 && base[0] == '.')
1685 /* Elide a '.' directory */
1687 else if (len == 2 && base[0] == '.' && base[1] == '.')
1689 /* '..', we can only elide it and the previous directory, if
1690 we're not a symlink. */
1691 struct stat ATTRIBUTE_UNUSED buf;
1695 #if defined (S_ISLNK)
1696 /* S_ISLNK is not POSIX.1-1996. */
1697 || stat (result, &buf) || S_ISLNK (buf.st_mode)
1701 /* Cannot elide, or unreadable or a symlink. */
1702 dd_base = ptr + 2 + slash;
1705 while (ptr != dd_base && *ptr != '/')
1707 slash = ptr != result;
1712 /* Regular pathname component. */
1715 memcpy (ptr, base, len);
1720 for (; IS_DIR_SEPARATOR (*probe); probe++)
1728 /* Generate an output file name. INPUT_NAME is the canonicalized main
1729 input file and SRC_NAME is the canonicalized file name.
1730 LONG_OUTPUT_NAMES and PRESERVE_PATHS affect name generation. With
1731 long_output_names we prepend the processed name of the input file
1732 to each output name (except when the current source file is the
1733 input file, so you don't get a double concatenation). The two
1734 components are separated by '##'. With preserve_paths we create a
1735 filename from all path components of the source file, replacing '/'
1736 with '#', and .. with '^', without it we simply take the basename
1737 component. (Remember, the canonicalized name will already have
1738 elided '.' components and converted \\ separators.) */
1741 make_gcov_file_name (const char *input_name, const char *src_name)
1746 if (flag_long_names && input_name && strcmp (src_name, input_name))
1748 /* Generate the input filename part. */
1749 result = XNEWVEC (char, strlen (input_name) + strlen (src_name) + 10);
1752 ptr = mangle_name (input_name, ptr);
1753 ptr[0] = ptr[1] = '#';
1758 result = XNEWVEC (char, strlen (src_name) + 10);
1762 ptr = mangle_name (src_name, ptr);
1763 strcpy (ptr, ".gcov");
1769 mangle_name (char const *base, char *ptr)
1773 /* Generate the source filename part. */
1774 if (!flag_preserve_paths)
1776 base = lbasename (base);
1777 len = strlen (base);
1778 memcpy (ptr, base, len);
1783 /* Convert '/' to '#', convert '..' to '^',
1784 convert ':' to '~' on DOS based file system. */
1787 #if HAVE_DOS_BASED_FILE_SYSTEM
1788 if (base[0] && base[1] == ':')
1796 for (; *base; base = probe)
1800 for (probe = base; *probe; probe++)
1804 if (len == 2 && base[0] == '.' && base[1] == '.')
1808 memcpy (ptr, base, len);
1822 /* Scan through the bb_data for each line in the block, increment
1823 the line number execution count indicated by the execution count of
1824 the appropriate basic block. */
1827 add_line_counts (coverage_t *coverage, function_t *fn)
1830 line_t *line = NULL; /* This is propagated from one iteration to the
1833 /* Scan each basic block. */
1834 for (ix = 0; ix != fn->num_blocks; ix++)
1836 block_t *block = &fn->blocks[ix];
1838 const source_t *src = NULL;
1841 if (block->count && ix && ix + 1 != fn->num_blocks)
1842 fn->blocks_executed++;
1843 for (jx = 0, encoding = block->u.line.encoding;
1844 jx != block->u.line.num; jx++, encoding++)
1847 src = &sources[*++encoding];
1852 line = &src->lines[*encoding];
1858 if (!line->count && block->count)
1859 coverage->lines_executed++;
1862 line->count += block->count;
1864 free (block->u.line.encoding);
1865 block->u.cycle.arc = NULL;
1866 block->u.cycle.ident = ~0U;
1868 if (!ix || ix + 1 == fn->num_blocks)
1869 /* Entry or exit block */;
1870 else if (flag_all_blocks)
1872 line_t *block_line = line;
1875 block_line = &sources[fn->src].lines[fn->line];
1877 block->chain = block_line->u.blocks;
1878 block_line->u.blocks = block;
1880 else if (flag_branches)
1884 for (arc = block->succ; arc; arc = arc->succ_next)
1886 arc->line_next = line->u.branches;
1887 line->u.branches = arc;
1888 if (coverage && !arc->is_unconditional)
1889 add_branch_counts (coverage, arc);
1894 fnotice (stderr, "%s:no lines for '%s'\n", bbg_file_name, fn->name);
1897 /* Accumulate the line counts of a file. */
1900 accumulate_line_counts (source_t *src)
1903 function_t *fn, *fn_p, *fn_n;
1906 /* Reverse the function order. */
1907 for (fn = src->functions, fn_p = NULL; fn;
1908 fn_p = fn, fn = fn_n)
1910 fn_n = fn->line_next;
1911 fn->line_next = fn_p;
1913 src->functions = fn_p;
1915 for (ix = src->num_lines, line = src->lines; ix--; line++)
1917 if (!flag_all_blocks)
1919 arc_t *arc, *arc_p, *arc_n;
1921 /* Total and reverse the branch information. */
1922 for (arc = line->u.branches, arc_p = NULL; arc;
1923 arc_p = arc, arc = arc_n)
1925 arc_n = arc->line_next;
1926 arc->line_next = arc_p;
1928 add_branch_counts (&src->coverage, arc);
1930 line->u.branches = arc_p;
1932 else if (line->u.blocks)
1934 /* The user expects the line count to be the number of times
1935 a line has been executed. Simply summing the block count
1936 will give an artificially high number. The Right Thing
1937 is to sum the entry counts to the graph of blocks on this
1938 line, then find the elementary cycles of the local graph
1939 and add the transition counts of those cycles. */
1940 block_t *block, *block_p, *block_n;
1941 gcov_type count = 0;
1943 /* Reverse the block information. */
1944 for (block = line->u.blocks, block_p = NULL; block;
1945 block_p = block, block = block_n)
1947 block_n = block->chain;
1948 block->chain = block_p;
1949 block->u.cycle.ident = ix;
1951 line->u.blocks = block_p;
1953 /* Sum the entry arcs. */
1954 for (block = line->u.blocks; block; block = block->chain)
1958 for (arc = block->pred; arc; arc = arc->pred_next)
1960 if (arc->src->u.cycle.ident != ix)
1961 count += arc->count;
1963 add_branch_counts (&src->coverage, arc);
1966 /* Initialize the cs_count. */
1967 for (arc = block->succ; arc; arc = arc->succ_next)
1968 arc->cs_count = arc->count;
1971 /* Find the loops. This uses the algorithm described in
1972 Tiernan 'An Efficient Search Algorithm to Find the
1973 Elementary Circuits of a Graph', CACM Dec 1970. We hold
1974 the P array by having each block point to the arc that
1975 connects to the previous block. The H array is implicitly
1976 held because of the arc ordering, and the block's
1977 previous arc pointer.
1979 Although the algorithm is O(N^3) for highly connected
1980 graphs, at worst we'll have O(N^2), as most blocks have
1981 only one or two exits. Most graphs will be small.
1983 For each loop we find, locate the arc with the smallest
1984 transition count, and add that to the cumulative
1985 count. Decrease flow over the cycle and remove the arc
1986 from consideration. */
1987 for (block = line->u.blocks; block; block = block->chain)
1989 block_t *head = block;
1997 block_t *dst = arc->dst;
1998 if (/* Already used that arc. */
2000 /* Not to same graph, or before first vertex. */
2001 || dst->u.cycle.ident != ix
2002 /* Already in path. */
2003 || dst->u.cycle.arc)
2005 arc = arc->succ_next;
2011 /* Found a closing arc. */
2012 gcov_type cycle_count = arc->cs_count;
2013 arc_t *cycle_arc = arc;
2016 /* Locate the smallest arc count of the loop. */
2017 for (dst = head; (probe_arc = dst->u.cycle.arc);
2018 dst = probe_arc->src)
2019 if (cycle_count > probe_arc->cs_count)
2021 cycle_count = probe_arc->cs_count;
2022 cycle_arc = probe_arc;
2025 count += cycle_count;
2026 cycle_arc->cycle = 1;
2028 /* Remove the flow from the cycle. */
2029 arc->cs_count -= cycle_count;
2030 for (dst = head; (probe_arc = dst->u.cycle.arc);
2031 dst = probe_arc->src)
2032 probe_arc->cs_count -= cycle_count;
2034 /* Unwind to the cyclic arc. */
2035 while (head != cycle_arc->src)
2037 arc = head->u.cycle.arc;
2038 head->u.cycle.arc = NULL;
2042 arc = arc->succ_next;
2046 /* Add new block to chain. */
2047 dst->u.cycle.arc = arc;
2051 /* We could not add another vertex to the path. Remove
2052 the last vertex from the list. */
2053 arc = head->u.cycle.arc;
2056 /* It was not the first vertex. Move onto next arc. */
2057 head->u.cycle.arc = NULL;
2059 arc = arc->succ_next;
2060 goto current_vertex;
2062 /* Mark this block as unusable. */
2063 block->u.cycle.ident = ~0U;
2066 line->count = count;
2071 src->coverage.lines++;
2073 src->coverage.lines_executed++;
2078 /* Output information about ARC number IX. Returns nonzero if
2079 anything is output. */
2082 output_branch_count (FILE *gcov_file, int ix, const arc_t *arc)
2085 if (arc->is_call_non_return)
2087 if (arc->src->count)
2089 fnotice (gcov_file, "call %2d returned %s\n", ix,
2090 format_gcov (arc->src->count - arc->count,
2091 arc->src->count, -flag_counts));
2094 fnotice (gcov_file, "call %2d never executed\n", ix);
2096 else if (!arc->is_unconditional)
2098 if (arc->src->count)
2099 fnotice (gcov_file, "branch %2d taken %s%s\n", ix,
2100 format_gcov (arc->count, arc->src->count, -flag_counts),
2101 arc->fall_through ? " (fallthrough)" : "");
2103 fnotice (gcov_file, "branch %2d never executed\n", ix);
2105 else if (flag_unconditional && !arc->dst->is_call_return)
2107 if (arc->src->count)
2108 fnotice (gcov_file, "unconditional %2d taken %s\n", ix,
2109 format_gcov (arc->count, arc->src->count, -flag_counts));
2111 fnotice (gcov_file, "unconditional %2d never executed\n", ix);
2119 /* Read in the source file one line at a time, and output that line to
2120 the gcov file preceded by its execution count and other
2124 output_lines (FILE *gcov_file, const source_t *src)
2127 unsigned line_num; /* current line number. */
2128 const line_t *line; /* current line info ptr. */
2129 char string[STRING_SIZE]; /* line buffer. */
2130 char const *retval = ""; /* status of source file reading. */
2131 function_t *fn = NULL;
2133 fprintf (gcov_file, "%9s:%5d:Source:%s\n", "-", 0, src->coverage.name);
2134 if (!multiple_files)
2136 fprintf (gcov_file, "%9s:%5d:Graph:%s\n", "-", 0, bbg_file_name);
2137 fprintf (gcov_file, "%9s:%5d:Data:%s\n", "-", 0,
2138 no_data_file ? "-" : da_file_name);
2139 fprintf (gcov_file, "%9s:%5d:Runs:%u\n", "-", 0, object_runs);
2141 fprintf (gcov_file, "%9s:%5d:Programs:%u\n", "-", 0, program_count);
2143 source_file = fopen (src->name, "r");
2146 fnotice (stderr, "Cannot open source file %s\n", src->name);
2149 else if (src->file_time == 0)
2150 fprintf (gcov_file, "%9s:%5d:Source is newer than graph\n", "-", 0);
2153 fn = src->functions;
2155 for (line_num = 1, line = &src->lines[line_num];
2156 line_num < src->num_lines; line_num++, line++)
2158 for (; fn && fn->line == line_num; fn = fn->line_next)
2160 arc_t *arc = fn->blocks[fn->num_blocks - 1].pred;
2161 gcov_type return_count = fn->blocks[fn->num_blocks - 1].count;
2163 for (; arc; arc = arc->pred_next)
2165 return_count -= arc->count;
2167 fprintf (gcov_file, "function %s", fn->name);
2168 fprintf (gcov_file, " called %s",
2169 format_gcov (fn->blocks[0].count, 0, -1));
2170 fprintf (gcov_file, " returned %s",
2171 format_gcov (return_count, fn->blocks[0].count, 0));
2172 fprintf (gcov_file, " blocks executed %s",
2173 format_gcov (fn->blocks_executed, fn->num_blocks - 2, 0));
2174 fprintf (gcov_file, "\n");
2177 /* For lines which don't exist in the .bb file, print '-' before
2178 the source line. For lines which exist but were never
2179 executed, print '#####' before the source line. Otherwise,
2180 print the execution count before the source line. There are
2181 16 spaces of indentation added before the source line so that
2182 tabs won't be messed up. */
2183 fprintf (gcov_file, "%9s:%5u:",
2184 !line->exists ? "-" : !line->count ? "#####"
2185 : format_gcov (line->count, 0, -1), line_num);
2189 /* Copy source line. */
2192 retval = fgets (string, STRING_SIZE, source_file);
2195 fputs (retval, gcov_file);
2197 while (!retval[0] || retval[strlen (retval) - 1] != '\n');
2200 fputs ("/*EOF*/\n", gcov_file);
2202 if (flag_all_blocks)
2208 for (ix = jx = 0, block = line->u.blocks; block;
2209 block = block->chain)
2211 if (!block->is_call_return)
2212 fprintf (gcov_file, "%9s:%5u-block %2d\n",
2213 !line->exists ? "-" : !block->count ? "$$$$$"
2214 : format_gcov (block->count, 0, -1),
2217 for (arc = block->succ; arc; arc = arc->succ_next)
2218 jx += output_branch_count (gcov_file, jx, arc);
2221 else if (flag_branches)
2226 for (ix = 0, arc = line->u.branches; arc; arc = arc->line_next)
2227 ix += output_branch_count (gcov_file, ix, arc);
2231 /* Handle all remaining source lines. There may be lines after the
2232 last line of code. */
2235 for (; (retval = fgets (string, STRING_SIZE, source_file)); line_num++)
2237 fprintf (gcov_file, "%9s:%5u:%s", "-", line_num, retval);
2239 while (!retval[0] || retval[strlen (retval) - 1] != '\n')
2241 retval = fgets (string, STRING_SIZE, source_file);
2244 fputs (retval, gcov_file);
2250 fclose (source_file);