1 /* Gcov.c: prepend line execution counts and branch probabilities to a
3 Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 Contributed by James E. Wilson of Cygnus Support.
6 Mangled by Bob Manson of Cygnus Support.
7 Mangled further by Nathan Sidwell <nathan@codesourcery.com>
9 Gcov is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 Gcov is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with Gcov; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
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 /* ??? Does not correctly handle the case where two .bb files refer to
33 the same included source file. For example, if one has a short
34 file containing only inline functions, which is then included in
35 two other files, then there will be two .bb files which refer to
36 the include file, but there is no way to get the total execution
37 counts for the included file, can only get execution counts for one
38 or the other of the including files. this can be fixed by --ratios
39 --long-file-names --preserve-paths and perl. */
41 /* Need an option to show individual block counts, and show
42 probabilities of fall through arcs. */
46 #include "coretypes.h"
58 /* The bbg file is generated by -ftest-coverage option. The da file is
59 generated by a program compiled with -fprofile-arcs. Their formats
60 are documented in gcov-io.h. */
62 /* The functions in this file for creating and solution program flow graphs
63 are very similar to functions in the gcc source file profile.c. In
64 some places we make use of the knowledge of how profile.c works to
65 select particular algorithms here. */
67 /* This is the size of the buffer used to read in source file lines. */
69 #define STRING_SIZE 200
75 /* Describes an arc between two basic blocks. */
77 typedef struct arc_info
79 /* source and destination blocks. */
80 struct block_info
*src
;
81 struct block_info
*dst
;
83 /* transition counts. */
85 /* used in cycle search, so that we do not clobber original counts. */
88 unsigned int count_valid
: 1;
89 unsigned int on_tree
: 1;
90 unsigned int fake
: 1;
91 unsigned int fall_through
: 1;
93 /* Arc is for a function that abnormally returns. */
94 unsigned int is_call_non_return
: 1;
96 /* Arc is for catch/setjump. */
97 unsigned int is_nonlocal_return
: 1;
99 /* Is an unconditional branch. */
100 unsigned int is_unconditional
: 1;
102 /* Loop making arc. */
103 unsigned int cycle
: 1;
105 /* Next branch on line. */
106 struct arc_info
*line_next
;
108 /* Links to next arc on src and dst lists. */
109 struct arc_info
*succ_next
;
110 struct arc_info
*pred_next
;
113 /* Describes a basic block. Contains lists of arcs to successor and
114 predecessor blocks. */
116 typedef struct block_info
118 /* Chain of exit and entry arcs. */
122 /* Number of unprocessed exit and entry arcs. */
126 /* Block execution count. */
129 unsigned count_valid
: 1;
130 unsigned valid_chain
: 1;
131 unsigned invalid_chain
: 1;
133 /* Block is a call instrumenting site. */
134 unsigned is_call_site
: 1; /* Does the call. */
135 unsigned is_call_return
: 1; /* Is the return. */
137 /* Block is a landing pad for longjmp or throw. */
138 unsigned is_nonlocal_return
: 1;
144 /* Array of line numbers and source files. source files are
145 introduced by a linenumber of zero, the next 'line number' is
146 the number of the source file. Always starts with a source
150 } line
; /* Valid until blocks are linked onto lines */
153 /* Single line graph cycle workspace. Used for all-blocks
157 } cycle
; /* Used in all-blocks mode, after blocks are linked onto
161 /* Temporary chain for solving graph, and for chaining blocks on one
163 struct block_info
*chain
;
167 /* Describes a single function. Contains an array of basic blocks. */
169 typedef struct function_info
171 /* Name of function. */
176 /* Array of basic blocks. */
179 unsigned blocks_executed
;
181 /* Raw arc coverage counts. */
185 /* First line number. */
187 struct source_info
*src
;
189 /* Next function in same source file. */
190 struct function_info
*line_next
;
193 struct function_info
*next
;
196 /* Describes coverage of a file or function. */
198 typedef struct coverage_info
204 int branches_executed
;
213 /* Describes a single line of source. Contains a chain of basic blocks
216 typedef struct line_info
218 gcov_type count
; /* execution count */
221 arc_t
*branches
; /* branches from blocks that end on this
222 line. Used for branch-counts when not
224 block_t
*blocks
; /* blocks which start on this line. Used
225 in all-blocks mode. */
230 /* Describes a file mentioned in the block graph. Contains an array
233 typedef struct source_info
235 /* Name of source file. */
239 /* Array of line information. */
245 /* Functions in this source file. These are in ascending line
247 function_t
*functions
;
249 /* Next source file. */
250 struct source_info
*next
;
253 /* Holds a list of function basic block graphs. */
255 static function_t
*functions
;
257 /* This points to the head of the sourcefile structure list. */
259 static source_t
*sources
;
261 /* This holds data summary information. */
263 static struct gcov_summary object_summary
;
264 static unsigned program_count
;
266 /* Modification time of graph file. */
268 static time_t bbg_file_time
;
270 /* Name and file pointer of the input file for the basic block graph. */
272 static char *bbg_file_name
;
274 /* Stamp of the bbg file */
275 static unsigned bbg_stamp
;
277 /* Name and file pointer of the input file for the arc count data. */
279 static char *da_file_name
;
281 /* Output branch probabilities. */
283 static int flag_branches
= 0;
285 /* Show unconditional branches too. */
286 static int flag_unconditional
= 0;
288 /* Output a gcov file if this is true. This is on by default, and can
289 be turned off by the -n option. */
291 static int flag_gcov_file
= 1;
293 /* For included files, make the gcov output file name include the name
294 of the input source file. For example, if x.h is included in a.c,
295 then the output file name is a.c##x.h.gcov instead of x.h.gcov. */
297 static int flag_long_names
= 0;
299 /* Output count information for every basic block, not merely those
300 that contain line number information. */
302 static int flag_all_blocks
= 0;
304 /* Output summary info for each function. */
306 static int flag_function_summary
= 0;
308 /* Object directory file prefix. This is the directory/file where the
309 graph and data files are looked for, if nonzero. */
311 static char *object_directory
= 0;
313 /* Preserve all pathname components. Needed when object files and
314 source files are in subdirectories. '/' is mangled as '#', '.' is
315 elided and '..' mangled to '^'. */
317 static int flag_preserve_paths
= 0;
319 /* Output the number of times a branch was taken as opposed to the percentage
320 of times it was taken. */
322 static int flag_counts
= 0;
324 /* Forward declarations. */
325 static void fnotice (FILE *, const char *, ...) ATTRIBUTE_PRINTF_2
;
326 static int process_args (int, char **);
327 static void print_usage (int) ATTRIBUTE_NORETURN
;
328 static void print_version (void) ATTRIBUTE_NORETURN
;
329 static void process_file (const char *);
330 static void create_file_names (const char *);
331 static source_t
*find_source (const char *);
332 static int read_graph_file (void);
333 static int read_count_file (void);
334 static void solve_flow_graph (function_t
*);
335 static void add_branch_counts (coverage_t
*, const arc_t
*);
336 static void add_line_counts (coverage_t
*, function_t
*);
337 static void function_summary (const coverage_t
*, const char *);
338 static const char *format_gcov (gcov_type
, gcov_type
, int);
339 static void accumulate_line_counts (source_t
*);
340 static int output_branch_count (FILE *, int, const arc_t
*);
341 static void output_lines (FILE *, const source_t
*);
342 static char *make_gcov_file_name (const char *, const char *);
343 static void release_structures (void);
344 extern int main (int, char **);
347 main (int argc
, char **argv
)
353 argno
= process_args (argc
, argv
);
357 for (; argno
!= argc
; argno
++)
359 release_structures ();
361 process_file (argv
[argno
]);
368 fnotice (FILE *file
, const char *msgid
, ...)
372 va_start (ap
, msgid
);
373 vfprintf (file
, _(msgid
), ap
);
377 /* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
378 otherwise the output of --help. */
381 print_usage (int error_p
)
383 FILE *file
= error_p
? stderr
: stdout
;
384 int status
= error_p
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
386 fnotice (file
, "Usage: gcov [OPTION]... SOURCEFILE\n\n");
387 fnotice (file
, "Print code coverage information.\n\n");
388 fnotice (file
, " -h, --help Print this help, then exit\n");
389 fnotice (file
, " -v, --version Print version number, then exit\n");
390 fnotice (file
, " -a, --all-blocks Show information for every basic block\n");
391 fnotice (file
, " -b, --branch-probabilities Include branch probabilities in output\n");
392 fnotice (file
, " -c, --branch-counts Given counts of branches taken\n\
393 rather than percentages\n");
394 fnotice (file
, " -n, --no-output Do not create an output file\n");
395 fnotice (file
, " -l, --long-file-names Use long output file names for included\n\
397 fnotice (file
, " -f, --function-summaries Output summaries for each function\n");
398 fnotice (file
, " -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n");
399 fnotice (file
, " -p, --preserve-paths Preserve all pathname components\n");
400 fnotice (file
, " -u, --unconditional-branches Show unconditional branch counts too\n");
401 fnotice (file
, "\nFor bug reporting instructions, please see:\n%s.\n",
406 /* Print version information and exit. */
411 fnotice (stdout
, "gcov (GCC) %s\n", version_string
);
412 fprintf (stdout
, "Copyright %s 2004 Free Software Foundation, Inc.\n",
415 _("This is free software; see the source for copying conditions.\n"
416 "There is NO warranty; not even for MERCHANTABILITY or \n"
417 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
418 exit (SUCCESS_EXIT_CODE
);
421 static const struct option options
[] =
423 { "help", no_argument
, NULL
, 'h' },
424 { "version", no_argument
, NULL
, 'v' },
425 { "all-blocks", no_argument
, NULL
, 'a' },
426 { "branch-probabilities", no_argument
, NULL
, 'b' },
427 { "branch-counts", no_argument
, NULL
, 'c' },
428 { "no-output", no_argument
, NULL
, 'n' },
429 { "long-file-names", no_argument
, NULL
, 'l' },
430 { "function-summaries", no_argument
, NULL
, 'f' },
431 { "preserve-paths", no_argument
, NULL
, 'p' },
432 { "object-directory", required_argument
, NULL
, 'o' },
433 { "object-file", required_argument
, NULL
, 'o' },
434 { "unconditional-branches", no_argument
, NULL
, 'u' },
438 /* Process args, return index to first non-arg. */
441 process_args (int argc
, char **argv
)
445 while ((opt
= getopt_long (argc
, argv
, "abcfhlno:puv", options
, NULL
)) != -1)
459 flag_function_summary
= 1;
463 /* print_usage will exit. */
471 object_directory
= optarg
;
474 flag_preserve_paths
= 1;
477 flag_unconditional
= 1;
481 /* print_version will exit. */
484 /* print_usage will exit. */
491 /* Process a single source file. */
494 process_file (const char *file_name
)
499 create_file_names (file_name
);
500 if (read_graph_file ())
505 fnotice (stderr
, "%s:no functions found\n", bbg_file_name
);
509 if (read_count_file ())
512 for (fn
= functions
; fn
; fn
= fn
->next
)
513 solve_flow_graph (fn
);
514 for (src
= sources
; src
; src
= src
->next
)
515 src
->lines
= xcalloc (src
->num_lines
, sizeof (line_t
));
516 for (fn
= functions
; fn
; fn
= fn
->next
)
520 memset (&coverage
, 0, sizeof (coverage
));
521 coverage
.name
= fn
->name
;
522 add_line_counts (flag_function_summary
? &coverage
: NULL
, fn
);
523 if (flag_function_summary
)
525 function_summary (&coverage
, "Function");
526 fnotice (stdout
, "\n");
530 for (src
= sources
; src
; src
= src
->next
)
532 accumulate_line_counts (src
);
533 function_summary (&src
->coverage
, "File");
536 char *gcov_file_name
= make_gcov_file_name (file_name
, src
->name
);
537 FILE *gcov_file
= fopen (gcov_file_name
, "w");
541 fnotice (stdout
, "%s:creating `%s'\n",
542 src
->name
, gcov_file_name
);
543 output_lines (gcov_file
, src
);
544 if (ferror (gcov_file
))
545 fnotice (stderr
, "%s:error writing output file `%s'\n",
546 src
->name
, gcov_file_name
);
550 fnotice (stderr
, "%s:could not open output file `%s'\n",
551 src
->name
, gcov_file_name
);
552 free (gcov_file_name
);
554 fnotice (stdout
, "\n");
558 /* Release all memory used. */
561 release_structures (void)
566 free (bbg_file_name
);
568 da_file_name
= bbg_file_name
= NULL
;
572 while ((src
= sources
))
580 while ((fn
= functions
))
585 functions
= fn
->next
;
586 for (ix
= fn
->num_blocks
, block
= fn
->blocks
; ix
--; block
++)
590 for (arc
= block
->succ
; arc
; arc
= arc_n
)
592 arc_n
= arc
->succ_next
;
601 /* Generate the names of the graph and data files. If OBJECT_DIRECTORY
602 is not specified, these are looked for in the current directory,
603 and named from the basename of the FILE_NAME sans extension. If
604 OBJECT_DIRECTORY is specified and is a directory, the files are in
605 that directory, but named from the basename of the FILE_NAME, sans
606 extension. Otherwise OBJECT_DIRECTORY is taken to be the name of
607 the object *file*, and the data files are named from that. */
610 create_file_names (const char *file_name
)
614 int length
= strlen (file_name
);
617 if (object_directory
&& object_directory
[0])
621 length
+= strlen (object_directory
) + 2;
622 name
= xmalloc (length
);
625 base
= !stat (object_directory
, &status
) && S_ISDIR (status
.st_mode
);
626 strcat (name
, object_directory
);
627 if (base
&& name
[strlen (name
) - 1] != '/')
632 name
= xmalloc (length
+ 1);
639 /* Append source file name. */
640 cptr
= strrchr (file_name
, '/');
641 strcat (name
, cptr
? cptr
+ 1 : file_name
);
644 /* Remove the extension. */
645 cptr
= strrchr (name
, '.');
649 length
= strlen (name
);
651 bbg_file_name
= xmalloc (length
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
652 strcpy (bbg_file_name
, name
);
653 strcpy (bbg_file_name
+ length
, GCOV_NOTE_SUFFIX
);
655 da_file_name
= xmalloc (length
+ strlen (GCOV_DATA_SUFFIX
) + 1);
656 strcpy (da_file_name
, name
);
657 strcpy (da_file_name
+ length
, GCOV_DATA_SUFFIX
);
662 /* Find or create a source file structure for FILE_NAME. Copies
663 FILE_NAME on creation */
666 find_source (const char *file_name
)
671 file_name
= "<unknown>";
673 for (src
= sources
; src
; src
= src
->next
)
674 if (!strcmp (file_name
, src
->name
))
677 src
= xcalloc (1, sizeof (source_t
));
678 src
->name
= xstrdup (file_name
);
679 src
->coverage
.name
= src
->name
;
680 src
->index
= sources
? sources
->index
+ 1 : 1;
687 /* Read the graph file. Return nonzero on fatal error. */
690 read_graph_file (void)
693 unsigned current_tag
= 0;
694 struct function_info
*fn
= NULL
;
695 source_t
*src
= NULL
;
699 if (!gcov_open (bbg_file_name
, 1))
701 fnotice (stderr
, "%s:cannot open graph file\n", bbg_file_name
);
704 bbg_file_time
= gcov_time ();
705 if (!gcov_magic (gcov_read_unsigned (), GCOV_NOTE_MAGIC
))
707 fnotice (stderr
, "%s:not a gcov graph file\n", bbg_file_name
);
712 version
= gcov_read_unsigned ();
713 if (version
!= GCOV_VERSION
)
717 GCOV_UNSIGNED2STRING (v
, version
);
718 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
720 fnotice (stderr
, "%s:version `%.4s', prefer `%.4s'\n",
721 bbg_file_name
, v
, e
);
723 bbg_stamp
= gcov_read_unsigned ();
725 while ((tag
= gcov_read_unsigned ()))
727 unsigned length
= gcov_read_unsigned ();
728 gcov_position_t base
= gcov_position ();
730 if (tag
== GCOV_TAG_FUNCTION
)
733 unsigned ident
, checksum
, lineno
;
735 function_t
*probe
, *prev
;
737 ident
= gcov_read_unsigned ();
738 checksum
= gcov_read_unsigned ();
739 function_name
= xstrdup (gcov_read_string ());
740 src
= find_source (gcov_read_string ());
741 lineno
= gcov_read_unsigned ();
743 fn
= xcalloc (1, sizeof (function_t
));
744 fn
->name
= function_name
;
746 fn
->checksum
= checksum
;
750 fn
->next
= functions
;
754 if (lineno
>= src
->num_lines
)
755 src
->num_lines
= lineno
+ 1;
756 /* Now insert it into the source file's list of
757 functions. Normally functions will be encountered in
758 ascending order, so a simple scan is quick. */
759 for (probe
= src
->functions
, prev
= NULL
;
760 probe
&& probe
->line
> lineno
;
761 prev
= probe
, probe
= probe
->line_next
)
763 fn
->line_next
= probe
;
765 prev
->line_next
= fn
;
769 else if (fn
&& tag
== GCOV_TAG_BLOCKS
)
772 fnotice (stderr
, "%s:already seen blocks for `%s'\n",
773 bbg_file_name
, fn
->name
);
776 unsigned ix
, num_blocks
= GCOV_TAG_BLOCKS_NUM (length
);
777 fn
->num_blocks
= num_blocks
;
779 fn
->blocks
= xcalloc (fn
->num_blocks
, sizeof (block_t
));
780 for (ix
= 0; ix
!= num_blocks
; ix
++)
781 fn
->blocks
[ix
].flags
= gcov_read_unsigned ();
784 else if (fn
&& tag
== GCOV_TAG_ARCS
)
786 unsigned src
= gcov_read_unsigned ();
787 unsigned num_dests
= GCOV_TAG_ARCS_NUM (length
);
789 if (src
>= fn
->num_blocks
|| fn
->blocks
[src
].succ
)
794 struct arc_info
*arc
;
795 unsigned dest
= gcov_read_unsigned ();
796 unsigned flags
= gcov_read_unsigned ();
798 if (dest
>= fn
->num_blocks
)
800 arc
= xcalloc (1, sizeof (arc_t
));
802 arc
->dst
= &fn
->blocks
[dest
];
803 arc
->src
= &fn
->blocks
[src
];
806 arc
->count_valid
= 0;
807 arc
->on_tree
= !!(flags
& GCOV_ARC_ON_TREE
);
808 arc
->fake
= !!(flags
& GCOV_ARC_FAKE
);
809 arc
->fall_through
= !!(flags
& GCOV_ARC_FALLTHROUGH
);
811 arc
->succ_next
= fn
->blocks
[src
].succ
;
812 fn
->blocks
[src
].succ
= arc
;
813 fn
->blocks
[src
].num_succ
++;
815 arc
->pred_next
= fn
->blocks
[dest
].pred
;
816 fn
->blocks
[dest
].pred
= arc
;
817 fn
->blocks
[dest
].num_pred
++;
823 /* Exceptional exit from this function, the
824 source block must be a call. */
825 fn
->blocks
[src
].is_call_site
= 1;
826 arc
->is_call_non_return
= 1;
830 /* Non-local return from a callee of this
831 function. The destination block is a catch or
833 arc
->is_nonlocal_return
= 1;
834 fn
->blocks
[dest
].is_nonlocal_return
= 1;
842 else if (fn
&& tag
== GCOV_TAG_LINES
)
844 unsigned blockno
= gcov_read_unsigned ();
845 unsigned *line_nos
= xcalloc (length
- 1, sizeof (unsigned));
847 if (blockno
>= fn
->num_blocks
|| fn
->blocks
[blockno
].u
.line
.encoding
)
852 unsigned lineno
= gcov_read_unsigned ();
859 line_nos
[ix
++] = src
->index
;
861 line_nos
[ix
++] = lineno
;
862 if (lineno
>= src
->num_lines
)
863 src
->num_lines
= lineno
+ 1;
867 const char *file_name
= gcov_read_string ();
871 src
= find_source (file_name
);
874 line_nos
[ix
++] = src
->index
;
878 fn
->blocks
[blockno
].u
.line
.encoding
= line_nos
;
879 fn
->blocks
[blockno
].u
.line
.num
= ix
;
881 else if (current_tag
&& !GCOV_TAG_IS_SUBTAG (current_tag
, tag
))
886 gcov_sync (base
, length
);
887 if (gcov_is_error ())
890 fnotice (stderr
, "%s:corrupted\n", bbg_file_name
);
897 /* We built everything backwards, so nreverse them all. */
899 /* Reverse sources. Not strictly necessary, but we'll then process
900 them in the 'expected' order. */
902 source_t
*src
, *src_p
, *src_n
;
904 for (src_p
= NULL
, src
= sources
; src
; src_p
= src
, src
= src_n
)
912 /* Reverse functions. */
914 function_t
*fn
, *fn_p
, *fn_n
;
916 for (fn_p
= NULL
, fn
= functions
; fn
; fn_p
= fn
, fn
= fn_n
)
923 /* Reverse the arcs. */
924 for (ix
= fn
->num_blocks
; ix
--;)
926 arc_t
*arc
, *arc_p
, *arc_n
;
928 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].succ
; arc
;
929 arc_p
= arc
, arc
= arc_n
)
931 arc_n
= arc
->succ_next
;
932 arc
->succ_next
= arc_p
;
934 fn
->blocks
[ix
].succ
= arc_p
;
936 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].pred
; arc
;
937 arc_p
= arc
, arc
= arc_n
)
939 arc_n
= arc
->pred_next
;
940 arc
->pred_next
= arc_p
;
942 fn
->blocks
[ix
].pred
= arc_p
;
950 /* Reads profiles from the count file and attach to each
951 function. Return nonzero if fatal error. */
954 read_count_file (void)
959 function_t
*fn
= NULL
;
962 if (!gcov_open (da_file_name
, 1))
964 fnotice (stderr
, "%s:cannot open data file\n", da_file_name
);
967 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
969 fnotice (stderr
, "%s:not a gcov data file\n", da_file_name
);
974 version
= gcov_read_unsigned ();
975 if (version
!= GCOV_VERSION
)
979 GCOV_UNSIGNED2STRING (v
, version
);
980 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
982 fnotice (stderr
, "%s:version `%.4s', prefer version `%.4s'\n",
985 tag
= gcov_read_unsigned ();
986 if (tag
!= bbg_stamp
)
988 fnotice (stderr
, "%s:stamp mismatch with graph file\n", da_file_name
);
992 while ((tag
= gcov_read_unsigned ()))
994 unsigned length
= gcov_read_unsigned ();
995 unsigned long base
= gcov_position ();
997 if (tag
== GCOV_TAG_OBJECT_SUMMARY
)
998 gcov_read_summary (&object_summary
);
999 else if (tag
== GCOV_TAG_PROGRAM_SUMMARY
)
1001 else if (tag
== GCOV_TAG_FUNCTION
)
1003 unsigned ident
= gcov_read_unsigned ();
1004 struct function_info
*fn_n
= functions
;
1006 for (fn
= fn
? fn
->next
: NULL
; ; fn
= fn
->next
)
1010 else if ((fn
= fn_n
))
1014 fnotice (stderr
, "%s:unknown function `%u'\n",
1015 da_file_name
, ident
);
1018 if (fn
->ident
== ident
)
1024 else if (gcov_read_unsigned () != fn
->checksum
)
1027 fnotice (stderr
, "%s:profile mismatch for `%s'\n",
1028 da_file_name
, fn
->name
);
1032 else if (tag
== GCOV_TAG_FOR_COUNTER (GCOV_COUNTER_ARCS
) && fn
)
1034 if (length
!= GCOV_TAG_COUNTER_LENGTH (fn
->num_counts
))
1038 fn
->counts
= xcalloc (fn
->num_counts
, sizeof (gcov_type
));
1040 for (ix
= 0; ix
!= fn
->num_counts
; ix
++)
1041 fn
->counts
[ix
] += gcov_read_counter ();
1043 gcov_sync (base
, length
);
1044 if ((error
= gcov_is_error ()))
1046 fnotice (stderr
, error
< 0 ? "%s:overflowed\n" : "%s:corrupted\n",
1056 /* Solve the flow graph. Propagate counts from the instrumented arcs
1057 to the blocks and the uninstrumented arcs. */
1060 solve_flow_graph (function_t
*fn
)
1064 gcov_type
*count_ptr
= fn
->counts
;
1066 block_t
*valid_blocks
= NULL
; /* valid, but unpropagated blocks. */
1067 block_t
*invalid_blocks
= NULL
; /* invalid, but inferable blocks. */
1069 if (fn
->num_blocks
< 2)
1070 fnotice (stderr
, "%s:`%s' lacks entry and/or exit blocks\n",
1071 bbg_file_name
, fn
->name
);
1074 if (fn
->blocks
[0].num_pred
)
1075 fnotice (stderr
, "%s:`%s' has arcs to entry block\n",
1076 bbg_file_name
, fn
->name
);
1078 /* We can't deduce the entry block counts from the lack of
1080 fn
->blocks
[0].num_pred
= ~(unsigned)0;
1082 if (fn
->blocks
[fn
->num_blocks
- 1].num_succ
)
1083 fnotice (stderr
, "%s:`%s' has arcs from exit block\n",
1084 bbg_file_name
, fn
->name
);
1086 /* Likewise, we can't deduce exit block counts from the lack
1087 of its successors. */
1088 fn
->blocks
[fn
->num_blocks
- 1].num_succ
= ~(unsigned)0;
1091 /* Propagate the measured counts, this must be done in the same
1092 order as the code in profile.c */
1093 for (ix
= 0, blk
= fn
->blocks
; ix
!= fn
->num_blocks
; ix
++, blk
++)
1095 block_t
const *prev_dst
= NULL
;
1096 int out_of_order
= 0;
1097 int non_fake_succ
= 0;
1099 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1107 arc
->count
= *count_ptr
++;
1108 arc
->count_valid
= 1;
1110 arc
->dst
->num_pred
--;
1112 if (prev_dst
&& prev_dst
> arc
->dst
)
1114 prev_dst
= arc
->dst
;
1116 if (non_fake_succ
== 1)
1118 /* If there is only one non-fake exit, it is an
1119 unconditional branch. */
1120 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1123 arc
->is_unconditional
= 1;
1124 /* If this block is instrumenting a call, it might be
1125 an artificial block. It is not artificial if it has
1126 a non-fallthrough exit, or the destination of this
1127 arc has more than one entry. Mark the destination
1128 block as a return site, if none of those conditions
1130 if (blk
->is_call_site
&& arc
->fall_through
1131 && arc
->dst
->pred
== arc
&& !arc
->pred_next
)
1132 arc
->dst
->is_call_return
= 1;
1136 /* Sort the successor arcs into ascending dst order. profile.c
1137 normally produces arcs in the right order, but sometimes with
1138 one or two out of order. We're not using a particularly
1142 arc_t
*start
= blk
->succ
;
1143 unsigned changes
= 1;
1147 arc_t
*arc
, *arc_p
, *arc_n
;
1150 for (arc_p
= NULL
, arc
= start
; (arc_n
= arc
->succ_next
);)
1152 if (arc
->dst
> arc_n
->dst
)
1156 arc_p
->succ_next
= arc_n
;
1159 arc
->succ_next
= arc_n
->succ_next
;
1160 arc_n
->succ_next
= arc
;
1173 /* Place it on the invalid chain, it will be ignored if that's
1175 blk
->invalid_chain
= 1;
1176 blk
->chain
= invalid_blocks
;
1177 invalid_blocks
= blk
;
1180 while (invalid_blocks
|| valid_blocks
)
1182 while ((blk
= invalid_blocks
))
1184 gcov_type total
= 0;
1187 invalid_blocks
= blk
->chain
;
1188 blk
->invalid_chain
= 0;
1190 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1191 total
+= arc
->count
;
1192 else if (!blk
->num_pred
)
1193 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
1194 total
+= arc
->count
;
1199 blk
->count_valid
= 1;
1200 blk
->chain
= valid_blocks
;
1201 blk
->valid_chain
= 1;
1204 while ((blk
= valid_blocks
))
1207 arc_t
*arc
, *inv_arc
;
1209 valid_blocks
= blk
->chain
;
1210 blk
->valid_chain
= 0;
1211 if (blk
->num_succ
== 1)
1217 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1219 total
-= arc
->count
;
1220 if (!arc
->count_valid
)
1224 inv_arc
->count_valid
= 1;
1225 inv_arc
->count
= total
;
1228 if (dst
->count_valid
)
1230 if (dst
->num_pred
== 1 && !dst
->valid_chain
)
1232 dst
->chain
= valid_blocks
;
1233 dst
->valid_chain
= 1;
1239 if (!dst
->num_pred
&& !dst
->invalid_chain
)
1241 dst
->chain
= invalid_blocks
;
1242 dst
->invalid_chain
= 1;
1243 invalid_blocks
= dst
;
1247 if (blk
->num_pred
== 1)
1253 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
1255 total
-= arc
->count
;
1256 if (!arc
->count_valid
)
1260 inv_arc
->count_valid
= 1;
1261 inv_arc
->count
= total
;
1264 if (src
->count_valid
)
1266 if (src
->num_succ
== 1 && !src
->valid_chain
)
1268 src
->chain
= valid_blocks
;
1269 src
->valid_chain
= 1;
1275 if (!src
->num_succ
&& !src
->invalid_chain
)
1277 src
->chain
= invalid_blocks
;
1278 src
->invalid_chain
= 1;
1279 invalid_blocks
= src
;
1286 /* If the graph has been correctly solved, every block will have a
1288 for (ix
= 0; ix
< fn
->num_blocks
; ix
++)
1289 if (!fn
->blocks
[ix
].count_valid
)
1291 fnotice (stderr
, "%s:graph is unsolvable for `%s'\n",
1292 bbg_file_name
, fn
->name
);
1299 /* Increment totals in COVERAGE according to arc ARC. */
1302 add_branch_counts (coverage_t
*coverage
, const arc_t
*arc
)
1304 if (arc
->is_call_non_return
)
1307 if (arc
->src
->count
)
1308 coverage
->calls_executed
++;
1310 else if (!arc
->is_unconditional
)
1312 coverage
->branches
++;
1313 if (arc
->src
->count
)
1314 coverage
->branches_executed
++;
1316 coverage
->branches_taken
++;
1320 /* Format a HOST_WIDE_INT as either a percent ratio, or absolute
1321 count. If dp >= 0, format TOP/BOTTOM * 100 to DP decimal places.
1322 If DP is zero, no decimal point is printed. Only print 100% when
1323 TOP==BOTTOM and only print 0% when TOP=0. If dp < 0, then simply
1324 format TOP. Return pointer to a static string. */
1327 format_gcov (gcov_type top
, gcov_type bottom
, int dp
)
1329 static char buffer
[20];
1333 float ratio
= bottom
? (float)top
/ bottom
: 0;
1335 unsigned limit
= 100;
1338 for (ix
= dp
; ix
--; )
1341 percent
= (unsigned) (ratio
* limit
+ (float)0.5);
1342 if (percent
<= 0 && top
)
1344 else if (percent
>= limit
&& top
!= bottom
)
1345 percent
= limit
- 1;
1346 ix
= sprintf (buffer
, "%.*u%%", dp
+ 1, percent
);
1352 buffer
[ix
+1] = buffer
[ix
];
1356 buffer
[ix
+ 1] = '.';
1360 sprintf (buffer
, HOST_WIDEST_INT_PRINT_DEC
, (HOST_WIDEST_INT
)top
);
1366 /* Output summary info for a function. */
1369 function_summary (const coverage_t
*coverage
, const char *title
)
1371 fnotice (stdout
, "%s `%s'\n", title
, coverage
->name
);
1373 if (coverage
->lines
)
1374 fnotice (stdout
, "Lines executed:%s of %d\n",
1375 format_gcov (coverage
->lines_executed
, coverage
->lines
, 2),
1378 fnotice (stdout
, "No executable lines\n");
1382 if (coverage
->branches
)
1384 fnotice (stdout
, "Branches executed:%s of %d\n",
1385 format_gcov (coverage
->branches_executed
,
1386 coverage
->branches
, 2),
1387 coverage
->branches
);
1388 fnotice (stdout
, "Taken at least once:%s of %d\n",
1389 format_gcov (coverage
->branches_taken
,
1390 coverage
->branches
, 2),
1391 coverage
->branches
);
1394 fnotice (stdout
, "No branches\n");
1395 if (coverage
->calls
)
1396 fnotice (stdout
, "Calls executed:%s of %d\n",
1397 format_gcov (coverage
->calls_executed
, coverage
->calls
, 2),
1400 fnotice (stdout
, "No calls\n");
1404 /* Generate an output file name. LONG_OUTPUT_NAMES and PRESERVE_PATHS
1405 affect name generation. With preserve_paths we create a filename
1406 from all path components of the source file, replacing '/' with
1407 '#', without it we simply take the basename component. With
1408 long_output_names we prepend the processed name of the input file
1409 to each output name (except when the current source file is the
1410 input file, so you don't get a double concatenation). The two
1411 components are separated by '##'. Also '.' filename components are
1412 removed and '..' components are renamed to '^'. */
1415 make_gcov_file_name (const char *input_name
, const char *src_name
)
1418 char *name
= xmalloc (strlen (src_name
) + strlen (input_name
) + 10);
1421 if (flag_long_names
&& strcmp (src_name
, input_name
))
1423 /* Generate the input filename part. */
1424 cptr
= flag_preserve_paths
? NULL
: strrchr (input_name
, '/');
1425 strcat (name
, cptr
? cptr
+ 1 : input_name
);
1426 strcat (name
, "##");
1429 /* Generate the source filename part. */
1430 cptr
= flag_preserve_paths
? NULL
: strrchr (src_name
, '/');
1431 strcat (name
, cptr
? cptr
+ 1 : src_name
);
1433 if (flag_preserve_paths
)
1435 /* Convert '/' to '#', remove '/./', convert '/../' to '/^/' */
1438 for (cptr
= name
; (cptr
= strchr ((prev
= cptr
), '/'));)
1442 if (prev
+ 1 == cptr
&& prev
[0] == '.')
1447 else if (prev
+ 2 == cptr
&& prev
[0] == '.' && prev
[1] == '.')
1459 prev
[0] = prev
[shift
];
1465 strcat (name
, ".gcov");
1469 /* Scan through the bb_data for each line in the block, increment
1470 the line number execution count indicated by the execution count of
1471 the appropriate basic block. */
1474 add_line_counts (coverage_t
*coverage
, function_t
*fn
)
1477 line_t
*line
= NULL
; /* This is propagated from one iteration to the
1480 /* Scan each basic block. */
1481 for (ix
= 0; ix
!= fn
->num_blocks
; ix
++)
1483 block_t
*block
= &fn
->blocks
[ix
];
1485 const source_t
*src
= NULL
;
1488 if (block
->count
&& ix
&& ix
+ 1 != fn
->num_blocks
)
1489 fn
->blocks_executed
++;
1490 for (jx
= 0, encoding
= block
->u
.line
.encoding
;
1491 jx
!= block
->u
.line
.num
; jx
++, encoding
++)
1494 unsigned src_n
= *++encoding
;
1496 for (src
= sources
; src
->index
!= src_n
; src
= src
->next
)
1502 line
= &src
->lines
[*encoding
];
1508 if (!line
->count
&& block
->count
)
1509 coverage
->lines_executed
++;
1512 line
->count
+= block
->count
;
1514 free (block
->u
.line
.encoding
);
1515 block
->u
.cycle
.arc
= NULL
;
1516 block
->u
.cycle
.ident
= ~0U;
1518 if (!ix
|| ix
+ 1 == fn
->num_blocks
)
1519 /* Entry or exit block */;
1520 else if (flag_all_blocks
)
1522 line_t
*block_line
= line
? line
: &fn
->src
->lines
[fn
->line
];
1524 block
->chain
= block_line
->u
.blocks
;
1525 block_line
->u
.blocks
= block
;
1527 else if (flag_branches
)
1531 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
1533 arc
->line_next
= line
->u
.branches
;
1534 line
->u
.branches
= arc
;
1535 if (coverage
&& !arc
->is_unconditional
)
1536 add_branch_counts (coverage
, arc
);
1541 fnotice (stderr
, "%s:no lines for `%s'\n", bbg_file_name
, fn
->name
);
1544 /* Accumulate the line counts of a file. */
1547 accumulate_line_counts (source_t
*src
)
1550 function_t
*fn
, *fn_p
, *fn_n
;
1553 /* Reverse the function order. */
1554 for (fn
= src
->functions
, fn_p
= NULL
; fn
;
1555 fn_p
= fn
, fn
= fn_n
)
1557 fn_n
= fn
->line_next
;
1558 fn
->line_next
= fn_p
;
1560 src
->functions
= fn_p
;
1562 for (ix
= src
->num_lines
, line
= src
->lines
; ix
--; line
++)
1564 if (!flag_all_blocks
)
1566 arc_t
*arc
, *arc_p
, *arc_n
;
1568 /* Total and reverse the branch information. */
1569 for (arc
= line
->u
.branches
, arc_p
= NULL
; arc
;
1570 arc_p
= arc
, arc
= arc_n
)
1572 arc_n
= arc
->line_next
;
1573 arc
->line_next
= arc_p
;
1575 add_branch_counts (&src
->coverage
, arc
);
1577 line
->u
.branches
= arc_p
;
1579 else if (line
->u
.blocks
)
1581 /* The user expects the line count to be the number of times
1582 a line has been executed. Simply summing the block count
1583 will give an artificially high number. The Right Thing
1584 is to sum the entry counts to the graph of blocks on this
1585 line, then find the elementary cycles of the local graph
1586 and add the transition counts of those cycles. */
1587 block_t
*block
, *block_p
, *block_n
;
1588 gcov_type count
= 0;
1590 /* Reverse the block information. */
1591 for (block
= line
->u
.blocks
, block_p
= NULL
; block
;
1592 block_p
= block
, block
= block_n
)
1594 block_n
= block
->chain
;
1595 block
->chain
= block_p
;
1596 block
->u
.cycle
.ident
= ix
;
1598 line
->u
.blocks
= block_p
;
1600 /* Sum the entry arcs. */
1601 for (block
= line
->u
.blocks
; block
; block
= block
->chain
)
1605 for (arc
= block
->pred
; arc
; arc
= arc
->pred_next
)
1607 if (arc
->src
->u
.cycle
.ident
!= ix
)
1608 count
+= arc
->count
;
1610 add_branch_counts (&src
->coverage
, arc
);
1613 /* Initialize the cs_count. */
1614 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
1615 arc
->cs_count
= arc
->count
;
1618 /* Find the loops. This uses the algorithm described in
1619 Tiernan 'An Efficient Search Algorithm to Find the
1620 Elementary Circuits of a Graph', CACM Dec 1970. We hold
1621 the P array by having each block point to the arc that
1622 connects to the previous block. The H array is implicitly
1623 held because of the arc ordering, and the block's
1624 previous arc pointer.
1626 Although the algorithm is O(N^3) for highly connected
1627 graphs, at worst we'll have O(N^2), as most blocks have
1628 only one or two exits. Most graphs will be small.
1630 For each loop we find, locate the arc with the smallest
1631 transition count, and add that to the cumulative
1632 count. Decrease flow over the cycle and remove the arc
1633 from consideration. */
1634 for (block
= line
->u
.blocks
; block
; block
= block
->chain
)
1636 block_t
*head
= block
;
1644 block_t
*dst
= arc
->dst
;
1645 if (/* Already used that arc. */
1647 /* Not to same graph, or before first vertex. */
1648 || dst
->u
.cycle
.ident
!= ix
1649 /* Already in path. */
1650 || dst
->u
.cycle
.arc
)
1652 arc
= arc
->succ_next
;
1658 /* Found a closing arc. */
1659 gcov_type cycle_count
= arc
->cs_count
;
1660 arc_t
*cycle_arc
= arc
;
1663 /* Locate the smallest arc count of the loop. */
1664 for (dst
= head
; (probe_arc
= dst
->u
.cycle
.arc
);
1665 dst
= probe_arc
->src
)
1666 if (cycle_count
> probe_arc
->cs_count
)
1668 cycle_count
= probe_arc
->cs_count
;
1669 cycle_arc
= probe_arc
;
1672 count
+= cycle_count
;
1673 cycle_arc
->cycle
= 1;
1675 /* Remove the flow from the cycle. */
1676 arc
->cs_count
-= cycle_count
;
1677 for (dst
= head
; (probe_arc
= dst
->u
.cycle
.arc
);
1678 dst
= probe_arc
->src
)
1679 probe_arc
->cs_count
-= cycle_count
;
1681 /* Unwind to the cyclic arc. */
1682 while (head
!= cycle_arc
->src
)
1684 arc
= head
->u
.cycle
.arc
;
1685 head
->u
.cycle
.arc
= NULL
;
1689 arc
= arc
->succ_next
;
1693 /* Add new block to chain. */
1694 dst
->u
.cycle
.arc
= arc
;
1698 /* We could not add another vertex to the path. Remove
1699 the last vertex from the list. */
1700 arc
= head
->u
.cycle
.arc
;
1703 /* It was not the first vertex. Move onto next arc. */
1704 head
->u
.cycle
.arc
= NULL
;
1706 arc
= arc
->succ_next
;
1707 goto current_vertex
;
1709 /* Mark this block as unusable. */
1710 block
->u
.cycle
.ident
= ~0U;
1713 line
->count
= count
;
1718 src
->coverage
.lines
++;
1720 src
->coverage
.lines_executed
++;
1725 /* Output information about ARC number IX. Returns nonzero if
1726 anything is output. */
1729 output_branch_count (FILE *gcov_file
, int ix
, const arc_t
*arc
)
1732 if (arc
->is_call_non_return
)
1734 if (arc
->src
->count
)
1736 fnotice (gcov_file
, "call %2d returned %s\n", ix
,
1737 format_gcov (arc
->src
->count
- arc
->count
,
1738 arc
->src
->count
, -flag_counts
));
1741 fnotice (gcov_file
, "call %2d never executed\n", ix
);
1743 else if (!arc
->is_unconditional
)
1745 if (arc
->src
->count
)
1746 fnotice (gcov_file
, "branch %2d taken %s%s\n", ix
,
1747 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
),
1748 arc
->fall_through
? " (fallthrough)" : "");
1750 fnotice (gcov_file
, "branch %2d never executed\n", ix
);
1752 else if (flag_unconditional
&& !arc
->dst
->is_call_return
)
1754 if (arc
->src
->count
)
1755 fnotice (gcov_file
, "unconditional %2d taken %s\n", ix
,
1756 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
));
1758 fnotice (gcov_file
, "unconditional %2d never executed\n", ix
);
1766 /* Read in the source file one line at a time, and output that line to
1767 the gcov file preceded by its execution count and other
1771 output_lines (FILE *gcov_file
, const source_t
*src
)
1774 unsigned line_num
; /* current line number. */
1775 const line_t
*line
; /* current line info ptr. */
1776 char string
[STRING_SIZE
]; /* line buffer. */
1777 char const *retval
= ""; /* status of source file reading. */
1778 function_t
*fn
= src
->functions
;
1780 fprintf (gcov_file
, "%9s:%5d:Source:%s\n", "-", 0, src
->name
);
1781 fprintf (gcov_file
, "%9s:%5d:Graph:%s\n", "-", 0, bbg_file_name
);
1782 fprintf (gcov_file
, "%9s:%5d:Data:%s\n", "-", 0, da_file_name
);
1783 fprintf (gcov_file
, "%9s:%5d:Runs:%u\n", "-", 0,
1784 object_summary
.ctrs
[GCOV_COUNTER_ARCS
].runs
);
1785 fprintf (gcov_file
, "%9s:%5d:Programs:%u\n", "-", 0, program_count
);
1787 source_file
= fopen (src
->name
, "r");
1790 fnotice (stderr
, "%s:cannot open source file\n", src
->name
);
1797 if (!fstat (fileno (source_file
), &status
)
1798 && status
.st_mtime
> bbg_file_time
)
1800 fnotice (stderr
, "%s:source file is newer than graph file `%s'\n",
1801 src
->name
, bbg_file_name
);
1802 fprintf (gcov_file
, "%9s:%5d:Source is newer than graph\n",
1807 for (line_num
= 1, line
= &src
->lines
[line_num
];
1808 line_num
< src
->num_lines
; line_num
++, line
++)
1810 for (; fn
&& fn
->line
== line_num
; fn
= fn
->line_next
)
1812 arc_t
*arc
= fn
->blocks
[fn
->num_blocks
- 1].pred
;
1813 gcov_type return_count
= fn
->blocks
[fn
->num_blocks
- 1].count
;
1815 for (; arc
; arc
= arc
->pred_next
)
1817 return_count
-= arc
->count
;
1819 fprintf (gcov_file
, "function %s", fn
->name
);
1820 fprintf (gcov_file
, " called %s",
1821 format_gcov (fn
->blocks
[0].count
, 0, -1));
1822 fprintf (gcov_file
, " returned %s",
1823 format_gcov (return_count
, fn
->blocks
[0].count
, 0));
1824 fprintf (gcov_file
, " blocks executed %s",
1825 format_gcov (fn
->blocks_executed
, fn
->num_blocks
- 2, 0));
1826 fprintf (gcov_file
, "\n");
1829 /* For lines which don't exist in the .bb file, print '-' before
1830 the source line. For lines which exist but were never
1831 executed, print '#####' before the source line. Otherwise,
1832 print the execution count before the source line. There are
1833 16 spaces of indentation added before the source line so that
1834 tabs won't be messed up. */
1835 fprintf (gcov_file
, "%9s:%5u:",
1836 !line
->exists
? "-" : !line
->count
? "#####"
1837 : format_gcov (line
->count
, 0, -1), line_num
);
1841 /* Copy source line. */
1844 retval
= fgets (string
, STRING_SIZE
, source_file
);
1847 fputs (retval
, gcov_file
);
1849 while (!retval
[0] || retval
[strlen (retval
) - 1] != '\n');
1852 fputs ("/*EOF*/\n", gcov_file
);
1854 if (flag_all_blocks
)
1860 for (ix
= jx
= 0, block
= line
->u
.blocks
; block
;
1861 block
= block
->chain
)
1863 if (!block
->is_call_return
)
1864 fprintf (gcov_file
, "%9s:%5u-block %2d\n",
1865 !line
->exists
? "-" : !block
->count
? "$$$$$"
1866 : format_gcov (block
->count
, 0, -1),
1869 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
1870 jx
+= output_branch_count (gcov_file
, jx
, arc
);
1873 else if (flag_branches
)
1878 for (ix
= 0, arc
= line
->u
.branches
; arc
; arc
= arc
->line_next
)
1879 ix
+= output_branch_count (gcov_file
, ix
, arc
);
1883 /* Handle all remaining source lines. There may be lines after the
1884 last line of code. */
1887 for (; (retval
= fgets (string
, STRING_SIZE
, source_file
)); line_num
++)
1889 fprintf (gcov_file
, "%9s:%5u:%s", "-", line_num
, retval
);
1891 while (!retval
[0] || retval
[strlen (retval
) - 1] != '\n')
1893 retval
= fgets (string
, STRING_SIZE
, source_file
);
1896 fputs (retval
, gcov_file
);
1902 fclose (source_file
);