1 /* Gcov.c: prepend line execution counts and branch probabilities to a
3 Copyright (C) 1990-2017 Free Software Foundation, Inc.
4 Contributed by James E. Wilson of Cygnus Support.
5 Mangled by Bob Manson of Cygnus Support.
6 Mangled further by Nathan Sidwell <nathan@codesourcery.com>
8 Gcov is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 Gcov is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Gcov; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 /* ??? Print a list of the ten blocks with the highest execution counts,
23 and list the line numbers corresponding to those blocks. Also, perhaps
24 list the line numbers with the highest execution counts, only printing
25 the first if there are several which are all listed in the same block. */
27 /* ??? Should have an option to print the number of basic blocks, and the
28 percent of them that are covered. */
30 /* Need an option to show individual block counts, and show
31 probabilities of fall through arcs. */
34 #define INCLUDE_ALGORITHM
35 #define INCLUDE_VECTOR
37 #include "coretypes.h"
40 #include "diagnostic.h"
54 /* The gcno file is generated by -ftest-coverage option. The gcda file is
55 generated by a program compiled with -fprofile-arcs. Their formats
56 are documented in gcov-io.h. */
58 /* The functions in this file for creating and solution program flow graphs
59 are very similar to functions in the gcc source file profile.c. In
60 some places we make use of the knowledge of how profile.c works to
61 select particular algorithms here. */
63 /* The code validates that the profile information read in corresponds
64 to the code currently being compiled. Rather than checking for
65 identical files, the code below compares a checksum on the CFG
66 (based on the order of basic blocks and the arcs in the CFG). If
67 the CFG checksum in the gcda file match the CFG checksum in the
68 gcno file, the profile data will be used. */
70 /* This is the size of the buffer used to read in source file lines. */
76 /* Describes an arc between two basic blocks. */
78 typedef struct arc_info
80 /* source and destination blocks. */
81 struct block_info
*src
;
82 struct block_info
*dst
;
84 /* transition counts. */
86 /* used in cycle search, so that we do not clobber original counts. */
89 unsigned int count_valid
: 1;
90 unsigned int on_tree
: 1;
91 unsigned int fake
: 1;
92 unsigned int fall_through
: 1;
94 /* Arc to a catch handler. */
95 unsigned int is_throw
: 1;
97 /* Arc is for a function that abnormally returns. */
98 unsigned int is_call_non_return
: 1;
100 /* Arc is for catch/setjmp. */
101 unsigned int is_nonlocal_return
: 1;
103 /* Is an unconditional branch. */
104 unsigned int is_unconditional
: 1;
106 /* Loop making arc. */
107 unsigned int cycle
: 1;
109 /* Next branch on line. */
110 struct arc_info
*line_next
;
112 /* Links to next arc on src and dst lists. */
113 struct arc_info
*succ_next
;
114 struct arc_info
*pred_next
;
117 /* Describes which locations (lines and files) are associated with
120 struct block_location_info
122 block_location_info (unsigned _source_file_idx
):
123 source_file_idx (_source_file_idx
)
126 unsigned source_file_idx
;
127 vector
<unsigned> lines
;
130 /* Describes a basic block. Contains lists of arcs to successor and
131 predecessor blocks. */
133 typedef struct block_info
135 /* Chain of exit and entry arcs. */
139 /* Number of unprocessed exit and entry arcs. */
145 /* Block execution count. */
147 unsigned count_valid
: 1;
148 unsigned valid_chain
: 1;
149 unsigned invalid_chain
: 1;
150 unsigned exceptional
: 1;
152 /* Block is a call instrumenting site. */
153 unsigned is_call_site
: 1; /* Does the call. */
154 unsigned is_call_return
: 1; /* Is the return. */
156 /* Block is a landing pad for longjmp or throw. */
157 unsigned is_nonlocal_return
: 1;
159 vector
<block_location_info
> locations
;
163 /* Single line graph cycle workspace. Used for all-blocks
167 } cycle
; /* Used in all-blocks mode, after blocks are linked onto
170 /* Temporary chain for solving graph, and for chaining blocks on one
172 struct block_info
*chain
;
176 /* Describes a single function. Contains an array of basic blocks. */
178 typedef struct function_info
183 /* Name of function. */
185 char *demangled_name
;
187 unsigned lineno_checksum
;
188 unsigned cfg_checksum
;
190 /* The graph contains at least one fake incoming edge. */
191 unsigned has_catch
: 1;
193 /* Array of basic blocks. Like in GCC, the entry block is
194 at blocks[0] and the exit block is at blocks[1]. */
195 #define ENTRY_BLOCK (0)
196 #define EXIT_BLOCK (1)
197 vector
<block_t
> blocks
;
198 unsigned blocks_executed
;
200 /* Raw arc coverage counts. */
204 /* First line number & file. */
208 /* Next function in same source file. */
209 struct function_info
*next_file_fn
;
212 struct function_info
*next
;
215 /* Describes coverage of a file or function. */
217 typedef struct coverage_info
223 int branches_executed
;
232 /* Describes a single line of source. Contains a chain of basic blocks
235 typedef struct line_info
237 /* Return true when NEEDLE is one of basic blocks the line belongs to. */
238 bool has_block (block_t
*needle
);
240 gcov_type count
; /* execution count */
243 arc_t
*branches
; /* branches from blocks that end on this
244 line. Used for branch-counts when not
246 block_t
*blocks
; /* blocks which start on this line. Used
247 in all-blocks mode. */
250 unsigned unexceptional
: 1;
254 line_t::has_block (block_t
*needle
)
256 for (block_t
*n
= u
.blocks
; n
; n
= n
->chain
)
263 /* Describes a file mentioned in the block graph. Contains an array
266 typedef struct source_info
268 /* Canonical name of source file. */
272 /* Array of line information. */
278 /* Functions in this source file. These are in ascending line
280 function_t
*functions
;
283 typedef struct name_map
285 char *name
; /* Source file name */
286 unsigned src
; /* Source file */
289 /* Holds a list of function basic block graphs. */
291 static function_t
*functions
;
292 static function_t
**fn_end
= &functions
;
294 static source_t
*sources
; /* Array of source files */
295 static unsigned n_sources
; /* Number of sources */
296 static unsigned a_sources
; /* Allocated sources */
298 static name_map_t
*names
; /* Mapping of file names to sources */
299 static unsigned n_names
; /* Number of names */
300 static unsigned a_names
; /* Allocated names */
302 /* This holds data summary information. */
304 static unsigned object_runs
;
305 static unsigned program_count
;
307 static unsigned total_lines
;
308 static unsigned total_executed
;
310 /* Modification time of graph file. */
312 static time_t bbg_file_time
;
314 /* Name of the notes (gcno) output file. The "bbg" prefix is for
315 historical reasons, when the notes file contained only the
316 basic block graph notes. */
318 static char *bbg_file_name
;
320 /* Stamp of the bbg file */
321 static unsigned bbg_stamp
;
323 /* Name and file pointer of the input file for the count data (gcda). */
325 static char *da_file_name
;
327 /* Data file is missing. */
329 static int no_data_file
;
331 /* If there is several input files, compute and display results after
332 reading all data files. This way if two or more gcda file refer to
333 the same source file (eg inline subprograms in a .h file), the
336 static int multiple_files
= 0;
338 /* Output branch probabilities. */
340 static int flag_branches
= 0;
342 /* Show unconditional branches too. */
343 static int flag_unconditional
= 0;
345 /* Output a gcov file if this is true. This is on by default, and can
346 be turned off by the -n option. */
348 static int flag_gcov_file
= 1;
350 /* Output progress indication if this is true. This is off by default
351 and can be turned on by the -d option. */
353 static int flag_display_progress
= 0;
355 /* Output *.gcov file in intermediate format used by 'lcov'. */
357 static int flag_intermediate_format
= 0;
359 /* Output demangled function names. */
361 static int flag_demangled_names
= 0;
363 /* For included files, make the gcov output file name include the name
364 of the input source file. For example, if x.h is included in a.c,
365 then the output file name is a.c##x.h.gcov instead of x.h.gcov. */
367 static int flag_long_names
= 0;
369 /* For situations when a long name can potentially hit filesystem path limit,
370 let's calculate md5sum of the path and append it to a file name. */
372 static int flag_hash_filenames
= 0;
374 /* Print verbose informations. */
376 static int flag_verbose
= 0;
378 /* Output count information for every basic block, not merely those
379 that contain line number information. */
381 static int flag_all_blocks
= 0;
383 /* Output summary info for each function. */
385 static int flag_function_summary
= 0;
387 /* Object directory file prefix. This is the directory/file where the
388 graph and data files are looked for, if nonzero. */
390 static char *object_directory
= 0;
392 /* Source directory prefix. This is removed from source pathnames
393 that match, when generating the output file name. */
395 static char *source_prefix
= 0;
396 static size_t source_length
= 0;
398 /* Only show data for sources with relative pathnames. Absolute ones
399 usually indicate a system header file, which although it may
400 contain inline functions, is usually uninteresting. */
401 static int flag_relative_only
= 0;
403 /* Preserve all pathname components. Needed when object files and
404 source files are in subdirectories. '/' is mangled as '#', '.' is
405 elided and '..' mangled to '^'. */
407 static int flag_preserve_paths
= 0;
409 /* Output the number of times a branch was taken as opposed to the percentage
410 of times it was taken. */
412 static int flag_counts
= 0;
414 /* Forward declarations. */
415 static int process_args (int, char **);
416 static void print_usage (int) ATTRIBUTE_NORETURN
;
417 static void print_version (void) ATTRIBUTE_NORETURN
;
418 static void process_file (const char *);
419 static void generate_results (const char *);
420 static void create_file_names (const char *);
421 static int name_search (const void *, const void *);
422 static int name_sort (const void *, const void *);
423 static char *canonicalize_name (const char *);
424 static unsigned find_source (const char *);
425 static function_t
*read_graph_file (void);
426 static int read_count_file (function_t
*);
427 static void solve_flow_graph (function_t
*);
428 static void find_exception_blocks (function_t
*);
429 static void add_branch_counts (coverage_t
*, const arc_t
*);
430 static void add_line_counts (coverage_t
*, function_t
*);
431 static void executed_summary (unsigned, unsigned);
432 static void function_summary (const coverage_t
*, const char *);
433 static const char *format_gcov (gcov_type
, gcov_type
, int);
434 static void accumulate_line_counts (source_t
*);
435 static void output_gcov_file (const char *, source_t
*);
436 static int output_branch_count (FILE *, int, const arc_t
*);
437 static void output_lines (FILE *, const source_t
*);
438 static char *make_gcov_file_name (const char *, const char *);
439 static char *mangle_name (const char *, char *);
440 static void release_structures (void);
441 extern int main (int, char **);
443 function_info::function_info ()
445 /* The type is POD, so that we can use memset. */
446 memset (this, 0, sizeof (*this));
449 function_info::~function_info ()
451 for (int i
= blocks
.size () - 1; i
>= 0; i
--)
455 for (arc
= blocks
[i
].succ
; arc
; arc
= arc_n
)
457 arc_n
= arc
->succ_next
;
462 if (flag_demangled_names
&& demangled_name
!= name
)
463 free (demangled_name
);
468 There are a bajillion algorithms that do this. Boost's function is named
469 hawick_cycles, so I used the algorithm by K. A. Hawick and H. A. James in
470 "Enumerating Circuits and Loops in Graphs with Self-Arcs and Multiple-Arcs"
471 (url at <http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf>).
473 The basic algorithm is simple: effectively, we're finding all simple paths
474 in a subgraph (that shrinks every iteration). Duplicates are filtered by
475 "blocking" a path when a node is added to the path (this also prevents non-
476 simple paths)--the node is unblocked only when it participates in a cycle.
479 typedef vector
<arc_t
*> arc_vector_t
;
480 typedef vector
<const block_t
*> block_vector_t
;
482 /* Enum with types of loop in CFG. */
491 /* Loop_type operator that merges two values: A and B. */
493 inline loop_type
& operator |= (loop_type
& a
, loop_type b
)
495 return a
= static_cast<loop_type
> (a
| b
);
498 /* Handle cycle identified by EDGES, where the function finds minimum cs_count
499 and subtract the value from all counts. The subtracted value is added
500 to COUNT. Returns type of loop. */
503 handle_cycle (const arc_vector_t
&edges
, int64_t &count
)
505 /* Find the minimum edge of the cycle, and reduce all nodes in the cycle by
507 int64_t cycle_count
= INTTYPE_MAXIMUM (int64_t);
508 for (unsigned i
= 0; i
< edges
.size (); i
++)
510 int64_t ecount
= edges
[i
]->cs_count
;
511 if (cycle_count
> ecount
)
512 cycle_count
= ecount
;
514 count
+= cycle_count
;
515 for (unsigned i
= 0; i
< edges
.size (); i
++)
516 edges
[i
]->cs_count
-= cycle_count
;
518 return cycle_count
< 0 ? NEGATIVE_LOOP
: LOOP
;
521 /* Unblock a block U from BLOCKED. Apart from that, iterate all blocks
522 blocked by U in BLOCK_LISTS. */
525 unblock (const block_t
*u
, block_vector_t
&blocked
,
526 vector
<block_vector_t
> &block_lists
)
528 block_vector_t::iterator it
= find (blocked
.begin (), blocked
.end (), u
);
529 if (it
== blocked
.end ())
532 unsigned index
= it
- blocked
.begin ();
535 for (block_vector_t::iterator it2
= block_lists
[index
].begin ();
536 it2
!= block_lists
[index
].end (); it2
++)
537 unblock (*it2
, blocked
, block_lists
);
538 for (unsigned j
= 0; j
< block_lists
[index
].size (); j
++)
539 unblock (u
, blocked
, block_lists
);
541 block_lists
.erase (block_lists
.begin () + index
);
544 /* Find circuit going to block V, PATH is provisional seen cycle.
545 BLOCKED is vector of blocked vertices, BLOCK_LISTS contains vertices
546 blocked by a block. COUNT is accumulated count of the current LINE.
547 Returns what type of loop it contains. */
550 circuit (block_t
*v
, arc_vector_t
&path
, block_t
*start
,
551 block_vector_t
&blocked
, vector
<block_vector_t
> &block_lists
,
552 line_t
&linfo
, int64_t &count
)
554 loop_type result
= NO_LOOP
;
556 /* Add v to the block list. */
557 gcc_assert (find (blocked
.begin (), blocked
.end (), v
) == blocked
.end ());
558 blocked
.push_back (v
);
559 block_lists
.push_back (block_vector_t ());
561 for (arc_t
*arc
= v
->succ
; arc
; arc
= arc
->succ_next
)
563 block_t
*w
= arc
->dst
;
564 if (w
< start
|| !linfo
.has_block (w
))
567 path
.push_back (arc
);
569 /* Cycle has been found. */
570 result
|= handle_cycle (path
, count
);
571 else if (find (blocked
.begin (), blocked
.end (), w
) == blocked
.end ())
572 result
|= circuit (w
, path
, start
, blocked
, block_lists
, linfo
, count
);
577 if (result
!= NO_LOOP
)
578 unblock (v
, blocked
, block_lists
);
580 for (arc_t
*arc
= v
->succ
; arc
; arc
= arc
->succ_next
)
582 block_t
*w
= arc
->dst
;
583 if (w
< start
|| !linfo
.has_block (w
))
587 = find (blocked
.begin (), blocked
.end (), w
) - blocked
.begin ();
588 gcc_assert (index
< blocked
.size ());
589 block_vector_t
&list
= block_lists
[index
];
590 if (find (list
.begin (), list
.end (), v
) == list
.end ())
597 /* Find cycles for a LINFO. If HANDLE_NEGATIVE_CYCLES is set and the line
598 contains a negative loop, then perform the same function once again. */
601 get_cycles_count (line_t
&linfo
, bool handle_negative_cycles
= true)
603 /* Note that this algorithm works even if blocks aren't in sorted order.
604 Each iteration of the circuit detection is completely independent
605 (except for reducing counts, but that shouldn't matter anyways).
606 Therefore, operating on a permuted order (i.e., non-sorted) only
607 has the effect of permuting the output cycles. */
609 loop_type result
= NO_LOOP
;
611 for (block_t
*block
= linfo
.u
.blocks
; block
; block
= block
->chain
)
614 block_vector_t blocked
;
615 vector
<block_vector_t
> block_lists
;
616 result
|= circuit (block
, path
, block
, blocked
, block_lists
, linfo
,
620 /* If we have a negative cycle, repeat the find_cycles routine. */
621 if (result
== NEGATIVE_LOOP
&& handle_negative_cycles
)
622 count
+= get_cycles_count (linfo
, false);
628 main (int argc
, char **argv
)
634 p
= argv
[0] + strlen (argv
[0]);
635 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
639 xmalloc_set_program_name (progname
);
641 /* Unlock the stdio streams. */
642 unlock_std_streams ();
646 diagnostic_initialize (global_dc
, 0);
648 /* Handle response files. */
649 expandargv (&argc
, &argv
);
652 names
= XNEWVEC (name_map_t
, a_names
);
654 sources
= XNEWVEC (source_t
, a_sources
);
656 argno
= process_args (argc
, argv
);
660 if (argc
- argno
> 1)
665 for (; argno
!= argc
; argno
++)
667 if (flag_display_progress
)
668 printf ("Processing file %d out of %d\n", argno
- first_arg
+ 1,
670 process_file (argv
[argno
]);
673 generate_results (multiple_files
? NULL
: argv
[argc
- 1]);
675 release_structures ();
680 /* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
681 otherwise the output of --help. */
684 print_usage (int error_p
)
686 FILE *file
= error_p
? stderr
: stdout
;
687 int status
= error_p
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
689 fnotice (file
, "Usage: gcov [OPTION...] SOURCE|OBJ...\n\n");
690 fnotice (file
, "Print code coverage information.\n\n");
691 fnotice (file
, " -h, --help Print this help, then exit\n");
692 fnotice (file
, " -a, --all-blocks Show information for every basic block\n");
693 fnotice (file
, " -b, --branch-probabilities Include branch probabilities in output\n");
694 fnotice (file
, " -c, --branch-counts Output counts of branches taken\n\
695 rather than percentages\n");
696 fnotice (file
, " -d, --display-progress Display progress information\n");
697 fnotice (file
, " -f, --function-summaries Output summaries for each function\n");
698 fnotice (file
, " -i, --intermediate-format Output .gcov file in intermediate text format\n");
699 fnotice (file
, " -l, --long-file-names Use long output file names for included\n\
701 fnotice (file
, " -m, --demangled-names Output demangled function names\n");
702 fnotice (file
, " -n, --no-output Do not create an output file\n");
703 fnotice (file
, " -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n");
704 fnotice (file
, " -p, --preserve-paths Preserve all pathname components\n");
705 fnotice (file
, " -r, --relative-only Only show data for relative sources\n");
706 fnotice (file
, " -s, --source-prefix DIR Source prefix to elide\n");
707 fnotice (file
, " -u, --unconditional-branches Show unconditional branch counts too\n");
708 fnotice (file
, " -v, --version Print version number, then exit\n");
709 fnotice (file
, " -w, --verbose Print verbose informations\n");
710 fnotice (file
, " -x, --hash-filenames Hash long pathnames\n");
711 fnotice (file
, "\nFor bug reporting instructions, please see:\n%s.\n",
716 /* Print version information and exit. */
721 fnotice (stdout
, "gcov %s%s\n", pkgversion_string
, version_string
);
722 fprintf (stdout
, "Copyright %s 2017 Free Software Foundation, Inc.\n",
725 _("This is free software; see the source for copying conditions.\n"
726 "There is NO warranty; not even for MERCHANTABILITY or \n"
727 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
728 exit (SUCCESS_EXIT_CODE
);
731 static const struct option options
[] =
733 { "help", no_argument
, NULL
, 'h' },
734 { "version", no_argument
, NULL
, 'v' },
735 { "verbose", no_argument
, NULL
, 'w' },
736 { "all-blocks", no_argument
, NULL
, 'a' },
737 { "branch-probabilities", no_argument
, NULL
, 'b' },
738 { "branch-counts", no_argument
, NULL
, 'c' },
739 { "intermediate-format", no_argument
, NULL
, 'i' },
740 { "no-output", no_argument
, NULL
, 'n' },
741 { "long-file-names", no_argument
, NULL
, 'l' },
742 { "function-summaries", no_argument
, NULL
, 'f' },
743 { "demangled-names", no_argument
, NULL
, 'm' },
744 { "preserve-paths", no_argument
, NULL
, 'p' },
745 { "relative-only", no_argument
, NULL
, 'r' },
746 { "object-directory", required_argument
, NULL
, 'o' },
747 { "object-file", required_argument
, NULL
, 'o' },
748 { "source-prefix", required_argument
, NULL
, 's' },
749 { "unconditional-branches", no_argument
, NULL
, 'u' },
750 { "display-progress", no_argument
, NULL
, 'd' },
751 { "hash-filenames", no_argument
, NULL
, 'x' },
755 /* Process args, return index to first non-arg. */
758 process_args (int argc
, char **argv
)
762 const char *opts
= "abcdfhilmno:prs:uvwx";
763 while ((opt
= getopt_long (argc
, argv
, opts
, options
, NULL
)) != -1)
777 flag_function_summary
= 1;
781 /* print_usage will exit. */
786 flag_demangled_names
= 1;
792 object_directory
= optarg
;
795 source_prefix
= optarg
;
796 source_length
= strlen (source_prefix
);
799 flag_relative_only
= 1;
802 flag_preserve_paths
= 1;
805 flag_unconditional
= 1;
808 flag_intermediate_format
= 1;
812 flag_display_progress
= 1;
815 flag_hash_filenames
= 1;
822 /* print_version will exit. */
825 /* print_usage will exit. */
832 /* Output the result in intermediate format used by 'lcov'.
834 The intermediate format contains a single file named 'foo.cc.gcov',
835 with no source code included. A sample output is
840 function:19,1,_GLOBAL__sub_I__Z3foov
841 function:19,1,_Z41__static_initialization_and_destruction_0ii
848 file:/.../basic_ios.h
851 function:157,0,_ZStorSt12_Ios_IostateS_
853 file:/.../char_traits.h
854 function:258,0,_ZNSt11char_traitsIcE6lengthEPKc
858 The default gcov outputs multiple files: 'foo.cc.gcov',
859 'iostream.gcov', 'ios_base.h.gcov', etc. with source code
860 included. Instead the intermediate format here outputs only a single
861 file 'foo.cc.gcov' similar to the above example. */
864 output_intermediate_file (FILE *gcov_file
, source_t
*src
)
866 unsigned line_num
; /* current line number. */
867 const line_t
*line
; /* current line info ptr. */
868 function_t
*fn
; /* current function info ptr. */
870 fprintf (gcov_file
, "file:%s\n", src
->name
); /* source file name */
872 for (fn
= src
->functions
; fn
; fn
= fn
->next_file_fn
)
874 /* function:<name>,<line_number>,<execution_count> */
875 fprintf (gcov_file
, "function:%d,%s,%s\n", fn
->line
,
876 format_gcov (fn
->blocks
[0].count
, 0, -1),
877 flag_demangled_names
? fn
->demangled_name
: fn
->name
);
880 for (line_num
= 1, line
= &src
->lines
[line_num
];
881 line_num
< src
->num_lines
;
886 fprintf (gcov_file
, "lcount:%u,%s\n", line_num
,
887 format_gcov (line
->count
, 0, -1));
889 for (arc
= line
->u
.branches
; arc
; arc
= arc
->line_next
)
891 if (!arc
->is_unconditional
&& !arc
->is_call_non_return
)
893 const char *branch_type
;
894 /* branch:<line_num>,<branch_coverage_type>
896 : notexec (Branch not executed)
897 : taken (Branch executed and taken)
898 : nottaken (Branch executed, but not taken)
901 branch_type
= (arc
->count
> 0) ? "taken" : "nottaken";
903 branch_type
= "notexec";
904 fprintf (gcov_file
, "branch:%d,%s\n", line_num
, branch_type
);
910 /* Process a single input file. */
913 process_file (const char *file_name
)
917 create_file_names (file_name
);
918 fns
= read_graph_file ();
922 read_count_file (fns
);
925 function_t
*fn
= fns
;
929 if (fn
->counts
|| no_data_file
)
931 unsigned src
= fn
->src
;
932 unsigned line
= fn
->line
;
934 function_t
*probe
, **prev
;
936 /* Now insert it into the source file's list of
937 functions. Normally functions will be encountered in
938 ascending order, so a simple scan is quick. Note we're
939 building this list in reverse order. */
940 for (prev
= &sources
[src
].functions
;
941 (probe
= *prev
); prev
= &probe
->next_file_fn
)
942 if (probe
->line
<= line
)
944 fn
->next_file_fn
= probe
;
947 /* Mark last line in files touched by function. */
948 for (block_no
= 0; block_no
!= fn
->blocks
.size (); block_no
++)
950 block_t
*block
= &fn
->blocks
[block_no
];
951 for (unsigned i
= 0; i
< block
->locations
.size (); i
++)
953 unsigned s
= block
->locations
[i
].source_file_idx
;
955 /* Sort lines of locations. */
956 sort (block
->locations
[i
].lines
.begin (),
957 block
->locations
[i
].lines
.end ());
959 if (!block
->locations
[i
].lines
.empty ())
962 = block
->locations
[i
].lines
.back () + 1;
963 if (last_line
> sources
[s
].num_lines
)
964 sources
[s
].num_lines
= last_line
;
969 solve_flow_graph (fn
);
971 find_exception_blocks (fn
);
976 /* The function was not in the executable -- some other
977 instance must have been selected. */
983 output_gcov_file (const char *file_name
, source_t
*src
)
985 char *gcov_file_name
= make_gcov_file_name (file_name
, src
->coverage
.name
);
987 if (src
->coverage
.lines
)
989 FILE *gcov_file
= fopen (gcov_file_name
, "w");
992 fnotice (stdout
, "Creating '%s'\n", gcov_file_name
);
994 if (flag_intermediate_format
)
995 output_intermediate_file (gcov_file
, src
);
997 output_lines (gcov_file
, src
);
998 if (ferror (gcov_file
))
999 fnotice (stderr
, "Error writing output file '%s'\n", gcov_file_name
);
1003 fnotice (stderr
, "Could not open output file '%s'\n", gcov_file_name
);
1007 unlink (gcov_file_name
);
1008 fnotice (stdout
, "Removing '%s'\n", gcov_file_name
);
1010 free (gcov_file_name
);
1014 generate_results (const char *file_name
)
1020 for (ix
= n_sources
, src
= sources
; ix
--; src
++)
1022 src
->lines
= XCNEWVEC (line_t
, src
->num_lines
);
1024 for (fn
= functions
; fn
; fn
= fn
->next
)
1026 coverage_t coverage
;
1028 memset (&coverage
, 0, sizeof (coverage
));
1029 coverage
.name
= flag_demangled_names
? fn
->demangled_name
: fn
->name
;
1030 add_line_counts (flag_function_summary
? &coverage
: NULL
, fn
);
1031 if (flag_function_summary
)
1033 function_summary (&coverage
, "Function");
1034 fnotice (stdout
, "\n");
1040 name_map_t
*name_map
= (name_map_t
*)bsearch
1041 (file_name
, names
, n_names
, sizeof (*names
), name_search
);
1043 file_name
= sources
[name_map
->src
].coverage
.name
;
1045 file_name
= canonicalize_name (file_name
);
1048 for (ix
= n_sources
, src
= sources
; ix
--; src
++)
1050 if (flag_relative_only
)
1052 /* Ignore this source, if it is an absolute path (after
1053 source prefix removal). */
1054 char first
= src
->coverage
.name
[0];
1056 #if HAVE_DOS_BASED_FILE_SYSTEM
1057 if (first
&& src
->coverage
.name
[1] == ':')
1058 first
= src
->coverage
.name
[2];
1060 if (IS_DIR_SEPARATOR (first
))
1064 accumulate_line_counts (src
);
1065 function_summary (&src
->coverage
, "File");
1066 total_lines
+= src
->coverage
.lines
;
1067 total_executed
+= src
->coverage
.lines_executed
;
1070 output_gcov_file (file_name
, src
);
1071 fnotice (stdout
, "\n");
1076 executed_summary (total_lines
, total_executed
);
1079 /* Release all memory used. */
1082 release_structures (void)
1087 for (ix
= n_sources
; ix
--;)
1088 free (sources
[ix
].lines
);
1091 for (ix
= n_names
; ix
--;)
1092 free (names
[ix
].name
);
1095 while ((fn
= functions
))
1097 functions
= fn
->next
;
1102 /* Generate the names of the graph and data files. If OBJECT_DIRECTORY
1103 is not specified, these are named from FILE_NAME sans extension. If
1104 OBJECT_DIRECTORY is specified and is a directory, the files are in that
1105 directory, but named from the basename of the FILE_NAME, sans extension.
1106 Otherwise OBJECT_DIRECTORY is taken to be the name of the object *file*
1107 and the data files are named from that. */
1110 create_file_names (const char *file_name
)
1114 int length
= strlen (file_name
);
1117 /* Free previous file names. */
1118 free (bbg_file_name
);
1119 free (da_file_name
);
1120 da_file_name
= bbg_file_name
= NULL
;
1124 if (object_directory
&& object_directory
[0])
1128 length
+= strlen (object_directory
) + 2;
1129 name
= XNEWVEC (char, length
);
1132 base
= !stat (object_directory
, &status
) && S_ISDIR (status
.st_mode
);
1133 strcat (name
, object_directory
);
1134 if (base
&& (!IS_DIR_SEPARATOR (name
[strlen (name
) - 1])))
1139 name
= XNEWVEC (char, length
+ 1);
1140 strcpy (name
, file_name
);
1146 /* Append source file name. */
1147 const char *cptr
= lbasename (file_name
);
1148 strcat (name
, cptr
? cptr
: file_name
);
1151 /* Remove the extension. */
1152 cptr
= strrchr (CONST_CAST (char *, lbasename (name
)), '.');
1156 length
= strlen (name
);
1158 bbg_file_name
= XNEWVEC (char, length
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1159 strcpy (bbg_file_name
, name
);
1160 strcpy (bbg_file_name
+ length
, GCOV_NOTE_SUFFIX
);
1162 da_file_name
= XNEWVEC (char, length
+ strlen (GCOV_DATA_SUFFIX
) + 1);
1163 strcpy (da_file_name
, name
);
1164 strcpy (da_file_name
+ length
, GCOV_DATA_SUFFIX
);
1170 /* A is a string and B is a pointer to name_map_t. Compare for file
1171 name orderability. */
1174 name_search (const void *a_
, const void *b_
)
1176 const char *a
= (const char *)a_
;
1177 const name_map_t
*b
= (const name_map_t
*)b_
;
1179 #if HAVE_DOS_BASED_FILE_SYSTEM
1180 return strcasecmp (a
, b
->name
);
1182 return strcmp (a
, b
->name
);
1186 /* A and B are a pointer to name_map_t. Compare for file name
1190 name_sort (const void *a_
, const void *b_
)
1192 const name_map_t
*a
= (const name_map_t
*)a_
;
1193 return name_search (a
->name
, b_
);
1196 /* Find or create a source file structure for FILE_NAME. Copies
1197 FILE_NAME on creation */
1200 find_source (const char *file_name
)
1202 name_map_t
*name_map
;
1208 file_name
= "<unknown>";
1209 name_map
= (name_map_t
*)bsearch
1210 (file_name
, names
, n_names
, sizeof (*names
), name_search
);
1213 idx
= name_map
->src
;
1217 if (n_names
+ 2 > a_names
)
1219 /* Extend the name map array -- we'll be inserting one or two
1222 name_map
= XNEWVEC (name_map_t
, a_names
);
1223 memcpy (name_map
, names
, n_names
* sizeof (*names
));
1228 /* Not found, try the canonical name. */
1229 canon
= canonicalize_name (file_name
);
1230 name_map
= (name_map_t
*) bsearch (canon
, names
, n_names
, sizeof (*names
),
1234 /* Not found with canonical name, create a new source. */
1237 if (n_sources
== a_sources
)
1240 src
= XNEWVEC (source_t
, a_sources
);
1241 memcpy (src
, sources
, n_sources
* sizeof (*sources
));
1248 name_map
= &names
[n_names
++];
1249 name_map
->name
= canon
;
1250 name_map
->src
= idx
;
1252 src
= &sources
[n_sources
++];
1253 memset (src
, 0, sizeof (*src
));
1255 src
->coverage
.name
= src
->name
;
1257 #if HAVE_DOS_BASED_FILE_SYSTEM
1258 /* You lose if separators don't match exactly in the
1260 && !strncasecmp (source_prefix
, src
->coverage
.name
, source_length
)
1262 && !strncmp (source_prefix
, src
->coverage
.name
, source_length
)
1264 && IS_DIR_SEPARATOR (src
->coverage
.name
[source_length
]))
1265 src
->coverage
.name
+= source_length
+ 1;
1266 if (!stat (src
->name
, &status
))
1267 src
->file_time
= status
.st_mtime
;
1270 idx
= name_map
->src
;
1272 if (name_search (file_name
, name_map
))
1274 /* Append the non-canonical name. */
1275 name_map
= &names
[n_names
++];
1276 name_map
->name
= xstrdup (file_name
);
1277 name_map
->src
= idx
;
1280 /* Resort the name map. */
1281 qsort (names
, n_names
, sizeof (*names
), name_sort
);
1284 if (sources
[idx
].file_time
> bbg_file_time
)
1286 static int info_emitted
;
1288 fnotice (stderr
, "%s:source file is newer than notes file '%s'\n",
1289 file_name
, bbg_file_name
);
1293 "(the message is displayed only once per source file)\n");
1296 sources
[idx
].file_time
= 0;
1302 /* Read the notes file. Return list of functions read -- in reverse order. */
1305 read_graph_file (void)
1308 unsigned current_tag
= 0;
1309 function_t
*fn
= NULL
;
1310 function_t
*fns
= NULL
;
1311 function_t
**fns_end
= &fns
;
1314 if (!gcov_open (bbg_file_name
, 1))
1316 fnotice (stderr
, "%s:cannot open notes file\n", bbg_file_name
);
1319 bbg_file_time
= gcov_time ();
1320 if (!gcov_magic (gcov_read_unsigned (), GCOV_NOTE_MAGIC
))
1322 fnotice (stderr
, "%s:not a gcov notes file\n", bbg_file_name
);
1327 version
= gcov_read_unsigned ();
1328 if (version
!= GCOV_VERSION
)
1332 GCOV_UNSIGNED2STRING (v
, version
);
1333 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
1335 fnotice (stderr
, "%s:version '%.4s', prefer '%.4s'\n",
1336 bbg_file_name
, v
, e
);
1338 bbg_stamp
= gcov_read_unsigned ();
1340 while ((tag
= gcov_read_unsigned ()))
1342 unsigned length
= gcov_read_unsigned ();
1343 gcov_position_t base
= gcov_position ();
1345 if (tag
== GCOV_TAG_FUNCTION
)
1347 char *function_name
;
1348 unsigned ident
, lineno
;
1349 unsigned lineno_checksum
, cfg_checksum
;
1351 ident
= gcov_read_unsigned ();
1352 lineno_checksum
= gcov_read_unsigned ();
1353 cfg_checksum
= gcov_read_unsigned ();
1354 function_name
= xstrdup (gcov_read_string ());
1355 unsigned src_idx
= find_source (gcov_read_string ());
1356 lineno
= gcov_read_unsigned ();
1358 fn
= new function_t
;
1359 fn
->name
= function_name
;
1360 if (flag_demangled_names
)
1362 fn
->demangled_name
= cplus_demangle (fn
->name
, DMGL_PARAMS
);
1363 if (!fn
->demangled_name
)
1364 fn
->demangled_name
= fn
->name
;
1367 fn
->lineno_checksum
= lineno_checksum
;
1368 fn
->cfg_checksum
= cfg_checksum
;
1372 fn
->next_file_fn
= NULL
;
1375 fns_end
= &fn
->next
;
1378 else if (fn
&& tag
== GCOV_TAG_BLOCKS
)
1380 if (!fn
->blocks
.empty ())
1381 fnotice (stderr
, "%s:already seen blocks for '%s'\n",
1382 bbg_file_name
, fn
->name
);
1384 fn
->blocks
.resize (gcov_read_unsigned ());
1386 else if (fn
&& tag
== GCOV_TAG_ARCS
)
1388 unsigned src
= gcov_read_unsigned ();
1389 fn
->blocks
[src
].id
= src
;
1390 unsigned num_dests
= GCOV_TAG_ARCS_NUM (length
);
1391 block_t
*src_blk
= &fn
->blocks
[src
];
1392 unsigned mark_catches
= 0;
1393 struct arc_info
*arc
;
1395 if (src
>= fn
->blocks
.size () || fn
->blocks
[src
].succ
)
1400 unsigned dest
= gcov_read_unsigned ();
1401 unsigned flags
= gcov_read_unsigned ();
1403 if (dest
>= fn
->blocks
.size ())
1405 arc
= XCNEW (arc_t
);
1407 arc
->dst
= &fn
->blocks
[dest
];
1411 arc
->count_valid
= 0;
1412 arc
->on_tree
= !!(flags
& GCOV_ARC_ON_TREE
);
1413 arc
->fake
= !!(flags
& GCOV_ARC_FAKE
);
1414 arc
->fall_through
= !!(flags
& GCOV_ARC_FALLTHROUGH
);
1416 arc
->succ_next
= src_blk
->succ
;
1417 src_blk
->succ
= arc
;
1418 src_blk
->num_succ
++;
1420 arc
->pred_next
= fn
->blocks
[dest
].pred
;
1421 fn
->blocks
[dest
].pred
= arc
;
1422 fn
->blocks
[dest
].num_pred
++;
1428 /* Exceptional exit from this function, the
1429 source block must be a call. */
1430 fn
->blocks
[src
].is_call_site
= 1;
1431 arc
->is_call_non_return
= 1;
1436 /* Non-local return from a callee of this
1437 function. The destination block is a setjmp. */
1438 arc
->is_nonlocal_return
= 1;
1439 fn
->blocks
[dest
].is_nonlocal_return
= 1;
1449 /* We have a fake exit from this block. The other
1450 non-fall through exits must be to catch handlers.
1451 Mark them as catch arcs. */
1453 for (arc
= src_blk
->succ
; arc
; arc
= arc
->succ_next
)
1454 if (!arc
->fake
&& !arc
->fall_through
)
1461 else if (fn
&& tag
== GCOV_TAG_LINES
)
1463 unsigned blockno
= gcov_read_unsigned ();
1464 block_t
*block
= &fn
->blocks
[blockno
];
1466 if (blockno
>= fn
->blocks
.size ())
1471 unsigned lineno
= gcov_read_unsigned ();
1474 block
->locations
.back ().lines
.push_back (lineno
);
1477 const char *file_name
= gcov_read_string ();
1481 block
->locations
.push_back (block_location_info
1482 (find_source (file_name
)));
1486 else if (current_tag
&& !GCOV_TAG_IS_SUBTAG (current_tag
, tag
))
1491 gcov_sync (base
, length
);
1492 if (gcov_is_error ())
1495 fnotice (stderr
, "%s:corrupted\n", bbg_file_name
);
1502 fnotice (stderr
, "%s:no functions found\n", bbg_file_name
);
1507 /* Reads profiles from the count file and attach to each
1508 function. Return nonzero if fatal error. */
1511 read_count_file (function_t
*fns
)
1516 function_t
*fn
= NULL
;
1519 if (!gcov_open (da_file_name
, 1))
1521 fnotice (stderr
, "%s:cannot open data file, assuming not executed\n",
1526 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
1528 fnotice (stderr
, "%s:not a gcov data file\n", da_file_name
);
1533 version
= gcov_read_unsigned ();
1534 if (version
!= GCOV_VERSION
)
1538 GCOV_UNSIGNED2STRING (v
, version
);
1539 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
1541 fnotice (stderr
, "%s:version '%.4s', prefer version '%.4s'\n",
1542 da_file_name
, v
, e
);
1544 tag
= gcov_read_unsigned ();
1545 if (tag
!= bbg_stamp
)
1547 fnotice (stderr
, "%s:stamp mismatch with notes file\n", da_file_name
);
1551 while ((tag
= gcov_read_unsigned ()))
1553 unsigned length
= gcov_read_unsigned ();
1554 unsigned long base
= gcov_position ();
1556 if (tag
== GCOV_TAG_PROGRAM_SUMMARY
)
1558 struct gcov_summary summary
;
1559 gcov_read_summary (&summary
);
1560 object_runs
+= summary
.ctrs
[GCOV_COUNTER_ARCS
].runs
;
1563 else if (tag
== GCOV_TAG_FUNCTION
&& !length
)
1565 else if (tag
== GCOV_TAG_FUNCTION
&& length
== GCOV_TAG_FUNCTION_LENGTH
)
1568 struct function_info
*fn_n
;
1570 /* Try to find the function in the list. To speed up the
1571 search, first start from the last function found. */
1572 ident
= gcov_read_unsigned ();
1574 for (fn
= fn
? fn
->next
: NULL
; ; fn
= fn
->next
)
1578 else if ((fn
= fn_n
))
1582 fnotice (stderr
, "%s:unknown function '%u'\n",
1583 da_file_name
, ident
);
1586 if (fn
->ident
== ident
)
1592 else if (gcov_read_unsigned () != fn
->lineno_checksum
1593 || gcov_read_unsigned () != fn
->cfg_checksum
)
1596 fnotice (stderr
, "%s:profile mismatch for '%s'\n",
1597 da_file_name
, fn
->name
);
1601 else if (tag
== GCOV_TAG_FOR_COUNTER (GCOV_COUNTER_ARCS
) && fn
)
1603 if (length
!= GCOV_TAG_COUNTER_LENGTH (fn
->num_counts
))
1607 fn
->counts
= XCNEWVEC (gcov_type
, fn
->num_counts
);
1609 for (ix
= 0; ix
!= fn
->num_counts
; ix
++)
1610 fn
->counts
[ix
] += gcov_read_counter ();
1612 gcov_sync (base
, length
);
1613 if ((error
= gcov_is_error ()))
1617 ? N_("%s:overflowed\n")
1618 : N_("%s:corrupted\n"),
1628 /* Solve the flow graph. Propagate counts from the instrumented arcs
1629 to the blocks and the uninstrumented arcs. */
1632 solve_flow_graph (function_t
*fn
)
1636 gcov_type
*count_ptr
= fn
->counts
;
1638 block_t
*valid_blocks
= NULL
; /* valid, but unpropagated blocks. */
1639 block_t
*invalid_blocks
= NULL
; /* invalid, but inferable blocks. */
1641 /* The arcs were built in reverse order. Fix that now. */
1642 for (ix
= fn
->blocks
.size (); ix
--;)
1644 arc_t
*arc_p
, *arc_n
;
1646 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].succ
; arc
;
1647 arc_p
= arc
, arc
= arc_n
)
1649 arc_n
= arc
->succ_next
;
1650 arc
->succ_next
= arc_p
;
1652 fn
->blocks
[ix
].succ
= arc_p
;
1654 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].pred
; arc
;
1655 arc_p
= arc
, arc
= arc_n
)
1657 arc_n
= arc
->pred_next
;
1658 arc
->pred_next
= arc_p
;
1660 fn
->blocks
[ix
].pred
= arc_p
;
1663 if (fn
->blocks
.size () < 2)
1664 fnotice (stderr
, "%s:'%s' lacks entry and/or exit blocks\n",
1665 bbg_file_name
, fn
->name
);
1668 if (fn
->blocks
[ENTRY_BLOCK
].num_pred
)
1669 fnotice (stderr
, "%s:'%s' has arcs to entry block\n",
1670 bbg_file_name
, fn
->name
);
1672 /* We can't deduce the entry block counts from the lack of
1674 fn
->blocks
[ENTRY_BLOCK
].num_pred
= ~(unsigned)0;
1676 if (fn
->blocks
[EXIT_BLOCK
].num_succ
)
1677 fnotice (stderr
, "%s:'%s' has arcs from exit block\n",
1678 bbg_file_name
, fn
->name
);
1680 /* Likewise, we can't deduce exit block counts from the lack
1681 of its successors. */
1682 fn
->blocks
[EXIT_BLOCK
].num_succ
= ~(unsigned)0;
1685 /* Propagate the measured counts, this must be done in the same
1686 order as the code in profile.c */
1687 for (unsigned i
= 0; i
< fn
->blocks
.size (); i
++)
1689 blk
= &fn
->blocks
[i
];
1690 block_t
const *prev_dst
= NULL
;
1691 int out_of_order
= 0;
1692 int non_fake_succ
= 0;
1694 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1702 arc
->count
= *count_ptr
++;
1703 arc
->count_valid
= 1;
1705 arc
->dst
->num_pred
--;
1707 if (prev_dst
&& prev_dst
> arc
->dst
)
1709 prev_dst
= arc
->dst
;
1711 if (non_fake_succ
== 1)
1713 /* If there is only one non-fake exit, it is an
1714 unconditional branch. */
1715 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1718 arc
->is_unconditional
= 1;
1719 /* If this block is instrumenting a call, it might be
1720 an artificial block. It is not artificial if it has
1721 a non-fallthrough exit, or the destination of this
1722 arc has more than one entry. Mark the destination
1723 block as a return site, if none of those conditions
1725 if (blk
->is_call_site
&& arc
->fall_through
1726 && arc
->dst
->pred
== arc
&& !arc
->pred_next
)
1727 arc
->dst
->is_call_return
= 1;
1731 /* Sort the successor arcs into ascending dst order. profile.c
1732 normally produces arcs in the right order, but sometimes with
1733 one or two out of order. We're not using a particularly
1737 arc_t
*start
= blk
->succ
;
1738 unsigned changes
= 1;
1742 arc_t
*arc
, *arc_p
, *arc_n
;
1745 for (arc_p
= NULL
, arc
= start
; (arc_n
= arc
->succ_next
);)
1747 if (arc
->dst
> arc_n
->dst
)
1751 arc_p
->succ_next
= arc_n
;
1754 arc
->succ_next
= arc_n
->succ_next
;
1755 arc_n
->succ_next
= arc
;
1768 /* Place it on the invalid chain, it will be ignored if that's
1770 blk
->invalid_chain
= 1;
1771 blk
->chain
= invalid_blocks
;
1772 invalid_blocks
= blk
;
1775 while (invalid_blocks
|| valid_blocks
)
1777 while ((blk
= invalid_blocks
))
1779 gcov_type total
= 0;
1782 invalid_blocks
= blk
->chain
;
1783 blk
->invalid_chain
= 0;
1785 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1786 total
+= arc
->count
;
1787 else if (!blk
->num_pred
)
1788 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
1789 total
+= arc
->count
;
1794 blk
->count_valid
= 1;
1795 blk
->chain
= valid_blocks
;
1796 blk
->valid_chain
= 1;
1799 while ((blk
= valid_blocks
))
1802 arc_t
*arc
, *inv_arc
;
1804 valid_blocks
= blk
->chain
;
1805 blk
->valid_chain
= 0;
1806 if (blk
->num_succ
== 1)
1812 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
1814 total
-= arc
->count
;
1815 if (!arc
->count_valid
)
1819 inv_arc
->count_valid
= 1;
1820 inv_arc
->count
= total
;
1823 if (dst
->count_valid
)
1825 if (dst
->num_pred
== 1 && !dst
->valid_chain
)
1827 dst
->chain
= valid_blocks
;
1828 dst
->valid_chain
= 1;
1834 if (!dst
->num_pred
&& !dst
->invalid_chain
)
1836 dst
->chain
= invalid_blocks
;
1837 dst
->invalid_chain
= 1;
1838 invalid_blocks
= dst
;
1842 if (blk
->num_pred
== 1)
1848 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
1850 total
-= arc
->count
;
1851 if (!arc
->count_valid
)
1855 inv_arc
->count_valid
= 1;
1856 inv_arc
->count
= total
;
1859 if (src
->count_valid
)
1861 if (src
->num_succ
== 1 && !src
->valid_chain
)
1863 src
->chain
= valid_blocks
;
1864 src
->valid_chain
= 1;
1870 if (!src
->num_succ
&& !src
->invalid_chain
)
1872 src
->chain
= invalid_blocks
;
1873 src
->invalid_chain
= 1;
1874 invalid_blocks
= src
;
1881 /* If the graph has been correctly solved, every block will have a
1883 for (unsigned i
= 0; ix
< fn
->blocks
.size (); i
++)
1884 if (!fn
->blocks
[i
].count_valid
)
1886 fnotice (stderr
, "%s:graph is unsolvable for '%s'\n",
1887 bbg_file_name
, fn
->name
);
1892 /* Mark all the blocks only reachable via an incoming catch. */
1895 find_exception_blocks (function_t
*fn
)
1898 block_t
**queue
= XALLOCAVEC (block_t
*, fn
->blocks
.size ());
1900 /* First mark all blocks as exceptional. */
1901 for (ix
= fn
->blocks
.size (); ix
--;)
1902 fn
->blocks
[ix
].exceptional
= 1;
1904 /* Now mark all the blocks reachable via non-fake edges */
1905 queue
[0] = &fn
->blocks
[0];
1906 queue
[0]->exceptional
= 0;
1909 block_t
*block
= queue
[--ix
];
1912 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
1913 if (!arc
->fake
&& !arc
->is_throw
&& arc
->dst
->exceptional
)
1915 arc
->dst
->exceptional
= 0;
1916 queue
[ix
++] = arc
->dst
;
1922 /* Increment totals in COVERAGE according to arc ARC. */
1925 add_branch_counts (coverage_t
*coverage
, const arc_t
*arc
)
1927 if (arc
->is_call_non_return
)
1930 if (arc
->src
->count
)
1931 coverage
->calls_executed
++;
1933 else if (!arc
->is_unconditional
)
1935 coverage
->branches
++;
1936 if (arc
->src
->count
)
1937 coverage
->branches_executed
++;
1939 coverage
->branches_taken
++;
1943 /* Format a GCOV_TYPE integer as either a percent ratio, or absolute
1944 count. If dp >= 0, format TOP/BOTTOM * 100 to DP decimal places.
1945 If DP is zero, no decimal point is printed. Only print 100% when
1946 TOP==BOTTOM and only print 0% when TOP=0. If dp < 0, then simply
1947 format TOP. Return pointer to a static string. */
1950 format_gcov (gcov_type top
, gcov_type bottom
, int dp
)
1952 static char buffer
[20];
1956 float ratio
= bottom
? (float)top
/ bottom
: 0;
1958 unsigned limit
= 100;
1961 for (ix
= dp
; ix
--; )
1964 percent
= (unsigned) (ratio
* limit
+ (float)0.5);
1965 if (percent
<= 0 && top
)
1967 else if (percent
>= limit
&& top
!= bottom
)
1968 percent
= limit
- 1;
1969 ix
= sprintf (buffer
, "%.*u%%", dp
+ 1, percent
);
1975 buffer
[ix
+1] = buffer
[ix
];
1979 buffer
[ix
+ 1] = '.';
1983 sprintf (buffer
, "%" PRId64
, (int64_t)top
);
1988 /* Summary of execution */
1991 executed_summary (unsigned lines
, unsigned executed
)
1994 fnotice (stdout
, "Lines executed:%s of %d\n",
1995 format_gcov (executed
, lines
, 2), lines
);
1997 fnotice (stdout
, "No executable lines\n");
2000 /* Output summary info for a function or file. */
2003 function_summary (const coverage_t
*coverage
, const char *title
)
2005 fnotice (stdout
, "%s '%s'\n", title
, coverage
->name
);
2006 executed_summary (coverage
->lines
, coverage
->lines_executed
);
2010 if (coverage
->branches
)
2012 fnotice (stdout
, "Branches executed:%s of %d\n",
2013 format_gcov (coverage
->branches_executed
,
2014 coverage
->branches
, 2),
2015 coverage
->branches
);
2016 fnotice (stdout
, "Taken at least once:%s of %d\n",
2017 format_gcov (coverage
->branches_taken
,
2018 coverage
->branches
, 2),
2019 coverage
->branches
);
2022 fnotice (stdout
, "No branches\n");
2023 if (coverage
->calls
)
2024 fnotice (stdout
, "Calls executed:%s of %d\n",
2025 format_gcov (coverage
->calls_executed
, coverage
->calls
, 2),
2028 fnotice (stdout
, "No calls\n");
2032 /* Canonicalize the filename NAME by canonicalizing directory
2033 separators, eliding . components and resolving .. components
2034 appropriately. Always returns a unique string. */
2037 canonicalize_name (const char *name
)
2039 /* The canonical name cannot be longer than the incoming name. */
2040 char *result
= XNEWVEC (char, strlen (name
) + 1);
2041 const char *base
= name
, *probe
;
2046 #if HAVE_DOS_BASED_FILE_SYSTEM
2047 if (base
[0] && base
[1] == ':')
2049 result
[0] = base
[0];
2055 for (dd_base
= ptr
; *base
; base
= probe
)
2059 for (probe
= base
; *probe
; probe
++)
2060 if (IS_DIR_SEPARATOR (*probe
))
2064 if (len
== 1 && base
[0] == '.')
2065 /* Elide a '.' directory */
2067 else if (len
== 2 && base
[0] == '.' && base
[1] == '.')
2069 /* '..', we can only elide it and the previous directory, if
2070 we're not a symlink. */
2071 struct stat ATTRIBUTE_UNUSED buf
;
2075 #if defined (S_ISLNK)
2076 /* S_ISLNK is not POSIX.1-1996. */
2077 || stat (result
, &buf
) || S_ISLNK (buf
.st_mode
)
2081 /* Cannot elide, or unreadable or a symlink. */
2082 dd_base
= ptr
+ 2 + slash
;
2085 while (ptr
!= dd_base
&& *ptr
!= '/')
2087 slash
= ptr
!= result
;
2092 /* Regular pathname component. */
2095 memcpy (ptr
, base
, len
);
2100 for (; IS_DIR_SEPARATOR (*probe
); probe
++)
2108 /* Print hex representation of 16 bytes from SUM and write it to BUFFER. */
2111 md5sum_to_hex (const char *sum
, char *buffer
)
2113 for (unsigned i
= 0; i
< 16; i
++)
2114 sprintf (buffer
+ (2 * i
), "%02x", (unsigned char)sum
[i
]);
2117 /* Generate an output file name. INPUT_NAME is the canonicalized main
2118 input file and SRC_NAME is the canonicalized file name.
2119 LONG_OUTPUT_NAMES and PRESERVE_PATHS affect name generation. With
2120 long_output_names we prepend the processed name of the input file
2121 to each output name (except when the current source file is the
2122 input file, so you don't get a double concatenation). The two
2123 components are separated by '##'. With preserve_paths we create a
2124 filename from all path components of the source file, replacing '/'
2125 with '#', and .. with '^', without it we simply take the basename
2126 component. (Remember, the canonicalized name will already have
2127 elided '.' components and converted \\ separators.) */
2130 make_gcov_file_name (const char *input_name
, const char *src_name
)
2135 if (flag_long_names
&& input_name
&& strcmp (src_name
, input_name
))
2137 /* Generate the input filename part. */
2138 result
= XNEWVEC (char, strlen (input_name
) + strlen (src_name
) + 10);
2141 ptr
= mangle_name (input_name
, ptr
);
2142 ptr
[0] = ptr
[1] = '#';
2147 result
= XNEWVEC (char, strlen (src_name
) + 10);
2151 ptr
= mangle_name (src_name
, ptr
);
2152 strcpy (ptr
, ".gcov");
2154 /* When hashing filenames, we shorten them by only using the filename
2155 component and appending a hash of the full (mangled) pathname. */
2156 if (flag_hash_filenames
)
2160 char md5sum_hex
[33];
2162 md5_init_ctx (&ctx
);
2163 md5_process_bytes (src_name
, strlen (src_name
), &ctx
);
2164 md5_finish_ctx (&ctx
, md5sum
);
2165 md5sum_to_hex (md5sum
, md5sum_hex
);
2168 result
= XNEWVEC (char, strlen (src_name
) + 50);
2170 ptr
= mangle_name (src_name
, ptr
);
2171 ptr
[0] = ptr
[1] = '#';
2173 memcpy (ptr
, md5sum_hex
, 32);
2175 strcpy (ptr
, ".gcov");
2182 mangle_name (char const *base
, char *ptr
)
2186 /* Generate the source filename part. */
2187 if (!flag_preserve_paths
)
2189 base
= lbasename (base
);
2190 len
= strlen (base
);
2191 memcpy (ptr
, base
, len
);
2196 /* Convert '/' to '#', convert '..' to '^',
2197 convert ':' to '~' on DOS based file system. */
2200 #if HAVE_DOS_BASED_FILE_SYSTEM
2201 if (base
[0] && base
[1] == ':')
2209 for (; *base
; base
= probe
)
2213 for (probe
= base
; *probe
; probe
++)
2217 if (len
== 2 && base
[0] == '.' && base
[1] == '.')
2221 memcpy (ptr
, base
, len
);
2235 /* Scan through the bb_data for each line in the block, increment
2236 the line number execution count indicated by the execution count of
2237 the appropriate basic block. */
2240 add_line_counts (coverage_t
*coverage
, function_t
*fn
)
2243 line_t
*line
= NULL
; /* This is propagated from one iteration to the
2246 /* Scan each basic block. */
2247 for (ix
= 0; ix
!= fn
->blocks
.size (); ix
++)
2249 block_t
*block
= &fn
->blocks
[ix
];
2250 if (block
->count
&& ix
&& ix
+ 1 != fn
->blocks
.size ())
2251 fn
->blocks_executed
++;
2252 for (unsigned i
= 0; i
< block
->locations
.size (); i
++)
2254 const source_t
*src
= &sources
[block
->locations
[i
].source_file_idx
];
2256 vector
<unsigned> &lines
= block
->locations
[i
].lines
;
2257 for (unsigned j
= 0; j
< lines
.size (); j
++)
2259 line
= &src
->lines
[lines
[j
]];
2264 if (!line
->count
&& block
->count
)
2265 coverage
->lines_executed
++;
2268 if (!block
->exceptional
)
2269 line
->unexceptional
= 1;
2270 line
->count
+= block
->count
;
2273 block
->cycle
.arc
= NULL
;
2274 block
->cycle
.ident
= ~0U;
2276 if (!ix
|| ix
+ 1 == fn
->blocks
.size ())
2277 /* Entry or exit block */;
2278 else if (flag_all_blocks
)
2280 line_t
*block_line
= line
;
2283 block_line
= &sources
[fn
->src
].lines
[fn
->line
];
2285 block
->chain
= block_line
->u
.blocks
;
2286 block_line
->u
.blocks
= block
;
2288 else if (flag_branches
)
2292 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
2294 arc
->line_next
= line
->u
.branches
;
2295 line
->u
.branches
= arc
;
2296 if (coverage
&& !arc
->is_unconditional
)
2297 add_branch_counts (coverage
, arc
);
2302 fnotice (stderr
, "%s:no lines for '%s'\n", bbg_file_name
, fn
->name
);
2305 /* Accumulate the line counts of a file. */
2308 accumulate_line_counts (source_t
*src
)
2311 function_t
*fn
, *fn_p
, *fn_n
;
2314 /* Reverse the function order. */
2315 for (fn
= src
->functions
, fn_p
= NULL
; fn
; fn_p
= fn
, fn
= fn_n
)
2317 fn_n
= fn
->next_file_fn
;
2318 fn
->next_file_fn
= fn_p
;
2320 src
->functions
= fn_p
;
2322 for (ix
= src
->num_lines
, line
= src
->lines
; ix
--; line
++)
2324 if (!flag_all_blocks
)
2326 arc_t
*arc
, *arc_p
, *arc_n
;
2328 /* Total and reverse the branch information. */
2329 for (arc
= line
->u
.branches
, arc_p
= NULL
; arc
;
2330 arc_p
= arc
, arc
= arc_n
)
2332 arc_n
= arc
->line_next
;
2333 arc
->line_next
= arc_p
;
2335 add_branch_counts (&src
->coverage
, arc
);
2337 line
->u
.branches
= arc_p
;
2339 else if (line
->u
.blocks
)
2341 /* The user expects the line count to be the number of times
2342 a line has been executed. Simply summing the block count
2343 will give an artificially high number. The Right Thing
2344 is to sum the entry counts to the graph of blocks on this
2345 line, then find the elementary cycles of the local graph
2346 and add the transition counts of those cycles. */
2347 block_t
*block
, *block_p
, *block_n
;
2348 gcov_type count
= 0;
2350 /* Reverse the block information. */
2351 for (block
= line
->u
.blocks
, block_p
= NULL
; block
;
2352 block_p
= block
, block
= block_n
)
2354 block_n
= block
->chain
;
2355 block
->chain
= block_p
;
2356 block
->cycle
.ident
= ix
;
2358 line
->u
.blocks
= block_p
;
2360 /* Sum the entry arcs. */
2361 for (block
= line
->u
.blocks
; block
; block
= block
->chain
)
2365 for (arc
= block
->pred
; arc
; arc
= arc
->pred_next
)
2367 add_branch_counts (&src
->coverage
, arc
);
2370 /* Cycle detection. */
2371 for (block
= line
->u
.blocks
; block
; block
= block
->chain
)
2373 for (arc_t
*arc
= block
->pred
; arc
; arc
= arc
->pred_next
)
2374 if (!line
->has_block (arc
->src
))
2375 count
+= arc
->count
;
2376 for (arc_t
*arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
2377 arc
->cs_count
= arc
->count
;
2380 /* Now, add the count of loops entirely on this line. */
2381 count
+= get_cycles_count (*line
);
2382 line
->count
= count
;
2387 src
->coverage
.lines
++;
2389 src
->coverage
.lines_executed
++;
2394 /* Output information about ARC number IX. Returns nonzero if
2395 anything is output. */
2398 output_branch_count (FILE *gcov_file
, int ix
, const arc_t
*arc
)
2400 if (arc
->is_call_non_return
)
2402 if (arc
->src
->count
)
2404 fnotice (gcov_file
, "call %2d returned %s\n", ix
,
2405 format_gcov (arc
->src
->count
- arc
->count
,
2406 arc
->src
->count
, -flag_counts
));
2409 fnotice (gcov_file
, "call %2d never executed\n", ix
);
2411 else if (!arc
->is_unconditional
)
2413 if (arc
->src
->count
)
2414 fnotice (gcov_file
, "branch %2d taken %s%s", ix
,
2415 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
),
2416 arc
->fall_through
? " (fallthrough)"
2417 : arc
->is_throw
? " (throw)" : "");
2419 fnotice (gcov_file
, "branch %2d never executed", ix
);
2422 fnotice (gcov_file
, " (BB %d)", arc
->dst
->id
);
2424 fnotice (gcov_file
, "\n");
2426 else if (flag_unconditional
&& !arc
->dst
->is_call_return
)
2428 if (arc
->src
->count
)
2429 fnotice (gcov_file
, "unconditional %2d taken %s\n", ix
,
2430 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
));
2432 fnotice (gcov_file
, "unconditional %2d never executed\n", ix
);
2440 read_line (FILE *file
)
2442 static char *string
;
2443 static size_t string_len
;
2450 string
= XNEWVEC (char, string_len
);
2453 while ((ptr
= fgets (string
+ pos
, string_len
- pos
, file
)))
2455 size_t len
= strlen (string
+ pos
);
2457 if (len
&& string
[pos
+ len
- 1] == '\n')
2459 string
[pos
+ len
- 1] = 0;
2463 /* If the file contains NUL characters or an incomplete
2464 last line, which can happen more than once in one run,
2465 we have to avoid doubling the STRING_LEN unnecessarily. */
2466 if (pos
> string_len
/ 2)
2469 string
= XRESIZEVEC (char, string
, string_len
);
2473 return pos
? string
: NULL
;
2476 /* Read in the source file one line at a time, and output that line to
2477 the gcov file preceded by its execution count and other
2481 output_lines (FILE *gcov_file
, const source_t
*src
)
2484 unsigned line_num
; /* current line number. */
2485 const line_t
*line
; /* current line info ptr. */
2486 const char *retval
= ""; /* status of source file reading. */
2487 function_t
*fn
= NULL
;
2489 fprintf (gcov_file
, "%9s:%5d:Source:%s\n", "-", 0, src
->coverage
.name
);
2490 if (!multiple_files
)
2492 fprintf (gcov_file
, "%9s:%5d:Graph:%s\n", "-", 0, bbg_file_name
);
2493 fprintf (gcov_file
, "%9s:%5d:Data:%s\n", "-", 0,
2494 no_data_file
? "-" : da_file_name
);
2495 fprintf (gcov_file
, "%9s:%5d:Runs:%u\n", "-", 0, object_runs
);
2497 fprintf (gcov_file
, "%9s:%5d:Programs:%u\n", "-", 0, program_count
);
2499 source_file
= fopen (src
->name
, "r");
2502 fnotice (stderr
, "Cannot open source file %s\n", src
->name
);
2505 else if (src
->file_time
== 0)
2506 fprintf (gcov_file
, "%9s:%5d:Source is newer than graph\n", "-", 0);
2509 fn
= src
->functions
;
2511 for (line_num
= 1, line
= &src
->lines
[line_num
];
2512 line_num
< src
->num_lines
; line_num
++, line
++)
2514 for (; fn
&& fn
->line
== line_num
; fn
= fn
->next_file_fn
)
2516 arc_t
*arc
= fn
->blocks
[EXIT_BLOCK
].pred
;
2517 gcov_type return_count
= fn
->blocks
[EXIT_BLOCK
].count
;
2518 gcov_type called_count
= fn
->blocks
[ENTRY_BLOCK
].count
;
2520 for (; arc
; arc
= arc
->pred_next
)
2522 return_count
-= arc
->count
;
2524 fprintf (gcov_file
, "function %s", flag_demangled_names
?
2525 fn
->demangled_name
: fn
->name
);
2526 fprintf (gcov_file
, " called %s",
2527 format_gcov (called_count
, 0, -1));
2528 fprintf (gcov_file
, " returned %s",
2529 format_gcov (return_count
, called_count
, 0));
2530 fprintf (gcov_file
, " blocks executed %s",
2531 format_gcov (fn
->blocks_executed
, fn
->blocks
.size () - 2,
2533 fprintf (gcov_file
, "\n");
2537 retval
= read_line (source_file
);
2539 /* For lines which don't exist in the .bb file, print '-' before
2540 the source line. For lines which exist but were never
2541 executed, print '#####' or '=====' before the source line.
2542 Otherwise, print the execution count before the source line.
2543 There are 16 spaces of indentation added before the source
2544 line so that tabs won't be messed up. */
2545 fprintf (gcov_file
, "%9s:%5u:%s\n",
2546 !line
->exists
? "-" : line
->count
2547 ? format_gcov (line
->count
, 0, -1)
2548 : line
->unexceptional
? "#####" : "=====", line_num
,
2549 retval
? retval
: "/*EOF*/");
2551 if (flag_all_blocks
)
2557 for (ix
= jx
= 0, block
= line
->u
.blocks
; block
;
2558 block
= block
->chain
)
2560 if (!block
->is_call_return
)
2562 fprintf (gcov_file
, "%9s:%5u-block %2d",
2563 !line
->exists
? "-" : block
->count
2564 ? format_gcov (block
->count
, 0, -1)
2565 : block
->exceptional
? "%%%%%" : "$$$$$",
2568 fprintf (gcov_file
, " (BB %u)", block
->id
);
2569 fprintf (gcov_file
, "\n");
2572 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
2573 jx
+= output_branch_count (gcov_file
, jx
, arc
);
2576 else if (flag_branches
)
2581 for (ix
= 0, arc
= line
->u
.branches
; arc
; arc
= arc
->line_next
)
2582 ix
+= output_branch_count (gcov_file
, ix
, arc
);
2586 /* Handle all remaining source lines. There may be lines after the
2587 last line of code. */
2590 for (; (retval
= read_line (source_file
)); line_num
++)
2591 fprintf (gcov_file
, "%9s:%5u:%s\n", "-", line_num
, retval
);
2595 fclose (source_file
);