1 /* Gcov.c: prepend line execution counts and branch probabilities to a
3 Copyright (C) 1990-2018 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
36 #define INCLUDE_STRING
40 #include "coretypes.h"
43 #include "diagnostic.h"
46 #include "color-macros.h"
47 #include "pretty-print.h"
61 /* The gcno file is generated by -ftest-coverage option. The gcda file is
62 generated by a program compiled with -fprofile-arcs. Their formats
63 are documented in gcov-io.h. */
65 /* The functions in this file for creating and solution program flow graphs
66 are very similar to functions in the gcc source file profile.c. In
67 some places we make use of the knowledge of how profile.c works to
68 select particular algorithms here. */
70 /* The code validates that the profile information read in corresponds
71 to the code currently being compiled. Rather than checking for
72 identical files, the code below compares a checksum on the CFG
73 (based on the order of basic blocks and the arcs in the CFG). If
74 the CFG checksum in the gcda file match the CFG checksum in the
75 gcno file, the profile data will be used. */
77 /* This is the size of the buffer used to read in source file lines. */
83 /* Describes an arc between two basic blocks. */
87 /* source and destination blocks. */
88 struct block_info
*src
;
89 struct block_info
*dst
;
91 /* transition counts. */
93 /* used in cycle search, so that we do not clobber original counts. */
96 unsigned int count_valid
: 1;
97 unsigned int on_tree
: 1;
98 unsigned int fake
: 1;
99 unsigned int fall_through
: 1;
101 /* Arc to a catch handler. */
102 unsigned int is_throw
: 1;
104 /* Arc is for a function that abnormally returns. */
105 unsigned int is_call_non_return
: 1;
107 /* Arc is for catch/setjmp. */
108 unsigned int is_nonlocal_return
: 1;
110 /* Is an unconditional branch. */
111 unsigned int is_unconditional
: 1;
113 /* Loop making arc. */
114 unsigned int cycle
: 1;
116 /* Links to next arc on src and dst lists. */
117 struct arc_info
*succ_next
;
118 struct arc_info
*pred_next
;
121 /* Describes which locations (lines and files) are associated with
124 struct block_location_info
126 block_location_info (unsigned _source_file_idx
):
127 source_file_idx (_source_file_idx
)
130 unsigned source_file_idx
;
131 vector
<unsigned> lines
;
134 /* Describes a basic block. Contains lists of arcs to successor and
135 predecessor blocks. */
142 /* Chain of exit and entry arcs. */
146 /* Number of unprocessed exit and entry arcs. */
152 /* Block execution count. */
154 unsigned count_valid
: 1;
155 unsigned valid_chain
: 1;
156 unsigned invalid_chain
: 1;
157 unsigned exceptional
: 1;
159 /* Block is a call instrumenting site. */
160 unsigned is_call_site
: 1; /* Does the call. */
161 unsigned is_call_return
: 1; /* Is the return. */
163 /* Block is a landing pad for longjmp or throw. */
164 unsigned is_nonlocal_return
: 1;
166 vector
<block_location_info
> locations
;
170 /* Single line graph cycle workspace. Used for all-blocks
174 } cycle
; /* Used in all-blocks mode, after blocks are linked onto
177 /* Temporary chain for solving graph, and for chaining blocks on one
179 struct block_info
*chain
;
183 block_info::block_info (): succ (NULL
), pred (NULL
), num_succ (0), num_pred (0),
184 id (0), count (0), count_valid (0), valid_chain (0), invalid_chain (0),
185 exceptional (0), is_call_site (0), is_call_return (0), is_nonlocal_return (0),
186 locations (), chain (NULL
)
191 /* Describes a single line of source. Contains a chain of basic blocks
196 /* Default constructor. */
199 /* Return true when NEEDLE is one of basic blocks the line belongs to. */
200 bool has_block (block_info
*needle
);
202 /* Execution count. */
205 /* Branches from blocks that end on this line. */
206 vector
<arc_info
*> branches
;
208 /* blocks which start on this line. Used in all-blocks mode. */
209 vector
<block_info
*> blocks
;
212 unsigned unexceptional
: 1;
213 unsigned has_unexecuted_block
: 1;
216 line_info::line_info (): count (0), branches (), blocks (), exists (false),
217 unexceptional (0), has_unexecuted_block (0)
222 line_info::has_block (block_info
*needle
)
224 return std::find (blocks
.begin (), blocks
.end (), needle
) != blocks
.end ();
227 /* Output demangled function names. */
229 static int flag_demangled_names
= 0;
231 /* Describes a single function. Contains an array of basic blocks. */
238 /* Return true when line N belongs to the function in source file SRC_IDX.
239 The line must be defined in body of the function, can't be inlined. */
240 bool group_line_p (unsigned n
, unsigned src_idx
);
242 /* Function filter based on function_info::artificial variable. */
245 is_artificial (function_info
*fn
)
247 return fn
->artificial
;
250 /* Name of function. */
252 char *m_demangled_name
;
254 unsigned lineno_checksum
;
255 unsigned cfg_checksum
;
257 /* The graph contains at least one fake incoming edge. */
258 unsigned has_catch
: 1;
260 /* True when the function is artificial and does not exist
262 unsigned artificial
: 1;
264 /* True when multiple functions start at a line in a source file. */
265 unsigned is_group
: 1;
267 /* Array of basic blocks. Like in GCC, the entry block is
268 at blocks[0] and the exit block is at blocks[1]. */
269 #define ENTRY_BLOCK (0)
270 #define EXIT_BLOCK (1)
271 vector
<block_info
> blocks
;
272 unsigned blocks_executed
;
274 /* Raw arc coverage counts. */
275 vector
<gcov_type
> counts
;
277 /* First line number. */
280 /* First line column. */
281 unsigned start_column
;
283 /* Last line number. */
286 /* Index of source file where the function is defined. */
289 /* Vector of line information. */
290 vector
<line_info
> lines
;
293 struct function_info
*next
;
295 /* Get demangled name of a function. The demangled name
296 is converted when it is used for the first time. */
297 char *get_demangled_name ()
299 if (m_demangled_name
== NULL
)
301 m_demangled_name
= cplus_demangle (m_name
, DMGL_PARAMS
);
302 if (!m_demangled_name
)
303 m_demangled_name
= m_name
;
306 return m_demangled_name
;
309 /* Get name of the function based on flag_demangled_names. */
312 return flag_demangled_names
? get_demangled_name () : m_name
;
315 /* Return number of basic blocks (without entry and exit block). */
316 unsigned get_block_count ()
318 return blocks
.size () - 2;
322 /* Function info comparer that will sort functions according to starting
325 struct function_line_start_cmp
327 inline bool operator() (const function_info
*lhs
,
328 const function_info
*rhs
)
330 return (lhs
->start_line
== rhs
->start_line
331 ? lhs
->start_column
< rhs
->start_column
332 : lhs
->start_line
< rhs
->start_line
);
336 /* Describes coverage of a file or function. */
344 int branches_executed
;
353 /* Describes a file mentioned in the block graph. Contains an array
358 /* Default constructor. */
361 vector
<function_info
*> get_functions_at_location (unsigned line_num
) const;
363 /* Index of the source_info in sources vector. */
366 /* Canonical name of source file. */
370 /* Vector of line information. */
371 vector
<line_info
> lines
;
373 coverage_info coverage
;
375 /* Maximum line count in the source file. */
376 unsigned int maximum_count
;
378 /* Functions in this source file. These are in ascending line
380 vector
<function_info
*> functions
;
383 source_info::source_info (): index (0), name (NULL
), file_time (),
384 lines (), coverage (), maximum_count (0), functions ()
388 vector
<function_info
*>
389 source_info::get_functions_at_location (unsigned line_num
) const
391 vector
<function_info
*> r
;
393 for (vector
<function_info
*>::const_iterator it
= functions
.begin ();
394 it
!= functions
.end (); it
++)
396 if ((*it
)->start_line
== line_num
&& (*it
)->src
== index
)
400 std::sort (r
.begin (), r
.end (), function_line_start_cmp ());
412 name_map (char *_name
, unsigned _src
): name (_name
), src (_src
)
416 bool operator== (const name_map
&rhs
) const
418 #if HAVE_DOS_BASED_FILE_SYSTEM
419 return strcasecmp (this->name
, rhs
.name
) == 0;
421 return strcmp (this->name
, rhs
.name
) == 0;
425 bool operator< (const name_map
&rhs
) const
427 #if HAVE_DOS_BASED_FILE_SYSTEM
428 return strcasecmp (this->name
, rhs
.name
) < 0;
430 return strcmp (this->name
, rhs
.name
) < 0;
434 const char *name
; /* Source file name */
435 unsigned src
; /* Source file */
438 /* Vector of all functions. */
439 static vector
<function_info
*> functions
;
441 /* Vector of source files. */
442 static vector
<source_info
> sources
;
444 /* Mapping of file names to sources */
445 static vector
<name_map
> names
;
447 /* Record all processed files in order to warn about
448 a file being read multiple times. */
449 static vector
<char *> processed_files
;
451 /* This holds data summary information. */
453 static unsigned object_runs
;
455 static unsigned total_lines
;
456 static unsigned total_executed
;
458 /* Modification time of graph file. */
460 static time_t bbg_file_time
;
462 /* Name of the notes (gcno) output file. The "bbg" prefix is for
463 historical reasons, when the notes file contained only the
464 basic block graph notes. */
466 static char *bbg_file_name
;
468 /* Stamp of the bbg file */
469 static unsigned bbg_stamp
;
471 /* Supports has_unexecuted_blocks functionality. */
472 static unsigned bbg_supports_has_unexecuted_blocks
;
474 /* Working directory in which a TU was compiled. */
475 static const char *bbg_cwd
;
477 /* Name and file pointer of the input file for the count data (gcda). */
479 static char *da_file_name
;
481 /* Data file is missing. */
483 static int no_data_file
;
485 /* If there is several input files, compute and display results after
486 reading all data files. This way if two or more gcda file refer to
487 the same source file (eg inline subprograms in a .h file), the
490 static int multiple_files
= 0;
492 /* Output branch probabilities. */
494 static int flag_branches
= 0;
496 /* Show unconditional branches too. */
497 static int flag_unconditional
= 0;
499 /* Output a gcov file if this is true. This is on by default, and can
500 be turned off by the -n option. */
502 static int flag_gcov_file
= 1;
504 /* Output to stdout instead to a gcov file. */
506 static int flag_use_stdout
= 0;
508 /* Output progress indication if this is true. This is off by default
509 and can be turned on by the -d option. */
511 static int flag_display_progress
= 0;
513 /* Output *.gcov file in JSON intermediate format used by consumers. */
515 static int flag_json_format
= 0;
517 /* For included files, make the gcov output file name include the name
518 of the input source file. For example, if x.h is included in a.c,
519 then the output file name is a.c##x.h.gcov instead of x.h.gcov. */
521 static int flag_long_names
= 0;
523 /* For situations when a long name can potentially hit filesystem path limit,
524 let's calculate md5sum of the path and append it to a file name. */
526 static int flag_hash_filenames
= 0;
528 /* Print verbose informations. */
530 static int flag_verbose
= 0;
532 /* Print colored output. */
534 static int flag_use_colors
= 0;
536 /* Use perf-like colors to indicate hot lines. */
538 static int flag_use_hotness_colors
= 0;
540 /* Output count information for every basic block, not merely those
541 that contain line number information. */
543 static int flag_all_blocks
= 0;
545 /* Output human readable numbers. */
547 static int flag_human_readable_numbers
= 0;
549 /* Output summary info for each function. */
551 static int flag_function_summary
= 0;
553 /* Object directory file prefix. This is the directory/file where the
554 graph and data files are looked for, if nonzero. */
556 static char *object_directory
= 0;
558 /* Source directory prefix. This is removed from source pathnames
559 that match, when generating the output file name. */
561 static char *source_prefix
= 0;
562 static size_t source_length
= 0;
564 /* Only show data for sources with relative pathnames. Absolute ones
565 usually indicate a system header file, which although it may
566 contain inline functions, is usually uninteresting. */
567 static int flag_relative_only
= 0;
569 /* Preserve all pathname components. Needed when object files and
570 source files are in subdirectories. '/' is mangled as '#', '.' is
571 elided and '..' mangled to '^'. */
573 static int flag_preserve_paths
= 0;
575 /* Output the number of times a branch was taken as opposed to the percentage
576 of times it was taken. */
578 static int flag_counts
= 0;
580 /* Forward declarations. */
581 static int process_args (int, char **);
582 static void print_usage (int) ATTRIBUTE_NORETURN
;
583 static void print_version (void) ATTRIBUTE_NORETURN
;
584 static void process_file (const char *);
585 static void process_all_functions (void);
586 static void generate_results (const char *);
587 static void create_file_names (const char *);
588 static char *canonicalize_name (const char *);
589 static unsigned find_source (const char *);
590 static void read_graph_file (void);
591 static int read_count_file (void);
592 static void solve_flow_graph (function_info
*);
593 static void find_exception_blocks (function_info
*);
594 static void add_branch_counts (coverage_info
*, const arc_info
*);
595 static void add_line_counts (coverage_info
*, function_info
*);
596 static void executed_summary (unsigned, unsigned);
597 static void function_summary (const coverage_info
*, const char *);
598 static const char *format_gcov (gcov_type
, gcov_type
, int);
599 static void accumulate_line_counts (source_info
*);
600 static void output_gcov_file (const char *, source_info
*);
601 static int output_branch_count (FILE *, int, const arc_info
*);
602 static void output_lines (FILE *, const source_info
*);
603 static char *make_gcov_file_name (const char *, const char *);
604 static char *mangle_name (const char *, char *);
605 static void release_structures (void);
606 extern int main (int, char **);
608 function_info::function_info (): m_name (NULL
), m_demangled_name (NULL
),
609 ident (0), lineno_checksum (0), cfg_checksum (0), has_catch (0),
610 artificial (0), is_group (0),
611 blocks (), blocks_executed (0), counts (),
612 start_line (0), start_column (), end_line (0), src (0), lines (), next (NULL
)
616 function_info::~function_info ()
618 for (int i
= blocks
.size () - 1; i
>= 0; i
--)
620 arc_info
*arc
, *arc_n
;
622 for (arc
= blocks
[i
].succ
; arc
; arc
= arc_n
)
624 arc_n
= arc
->succ_next
;
628 if (m_demangled_name
!= m_name
)
629 free (m_demangled_name
);
633 bool function_info::group_line_p (unsigned n
, unsigned src_idx
)
635 return is_group
&& src
== src_idx
&& start_line
<= n
&& n
<= end_line
;
639 There are a bajillion algorithms that do this. Boost's function is named
640 hawick_cycles, so I used the algorithm by K. A. Hawick and H. A. James in
641 "Enumerating Circuits and Loops in Graphs with Self-Arcs and Multiple-Arcs"
642 (url at <http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf>).
644 The basic algorithm is simple: effectively, we're finding all simple paths
645 in a subgraph (that shrinks every iteration). Duplicates are filtered by
646 "blocking" a path when a node is added to the path (this also prevents non-
647 simple paths)--the node is unblocked only when it participates in a cycle.
650 typedef vector
<arc_info
*> arc_vector_t
;
651 typedef vector
<const block_info
*> block_vector_t
;
653 /* Enum with types of loop in CFG. */
662 /* Loop_type operator that merges two values: A and B. */
664 inline loop_type
& operator |= (loop_type
& a
, loop_type b
)
666 return a
= static_cast<loop_type
> (a
| b
);
669 /* Handle cycle identified by EDGES, where the function finds minimum cs_count
670 and subtract the value from all counts. The subtracted value is added
671 to COUNT. Returns type of loop. */
674 handle_cycle (const arc_vector_t
&edges
, int64_t &count
)
676 /* Find the minimum edge of the cycle, and reduce all nodes in the cycle by
678 int64_t cycle_count
= INTTYPE_MAXIMUM (int64_t);
679 for (unsigned i
= 0; i
< edges
.size (); i
++)
681 int64_t ecount
= edges
[i
]->cs_count
;
682 if (cycle_count
> ecount
)
683 cycle_count
= ecount
;
685 count
+= cycle_count
;
686 for (unsigned i
= 0; i
< edges
.size (); i
++)
687 edges
[i
]->cs_count
-= cycle_count
;
689 return cycle_count
< 0 ? NEGATIVE_LOOP
: LOOP
;
692 /* Unblock a block U from BLOCKED. Apart from that, iterate all blocks
693 blocked by U in BLOCK_LISTS. */
696 unblock (const block_info
*u
, block_vector_t
&blocked
,
697 vector
<block_vector_t
> &block_lists
)
699 block_vector_t::iterator it
= find (blocked
.begin (), blocked
.end (), u
);
700 if (it
== blocked
.end ())
703 unsigned index
= it
- blocked
.begin ();
706 block_vector_t
to_unblock (block_lists
[index
]);
708 block_lists
.erase (block_lists
.begin () + index
);
710 for (block_vector_t::iterator it
= to_unblock
.begin ();
711 it
!= to_unblock
.end (); it
++)
712 unblock (*it
, blocked
, block_lists
);
715 /* Find circuit going to block V, PATH is provisional seen cycle.
716 BLOCKED is vector of blocked vertices, BLOCK_LISTS contains vertices
717 blocked by a block. COUNT is accumulated count of the current LINE.
718 Returns what type of loop it contains. */
721 circuit (block_info
*v
, arc_vector_t
&path
, block_info
*start
,
722 block_vector_t
&blocked
, vector
<block_vector_t
> &block_lists
,
723 line_info
&linfo
, int64_t &count
)
725 loop_type result
= NO_LOOP
;
727 /* Add v to the block list. */
728 gcc_assert (find (blocked
.begin (), blocked
.end (), v
) == blocked
.end ());
729 blocked
.push_back (v
);
730 block_lists
.push_back (block_vector_t ());
732 for (arc_info
*arc
= v
->succ
; arc
; arc
= arc
->succ_next
)
734 block_info
*w
= arc
->dst
;
735 if (w
< start
|| !linfo
.has_block (w
))
738 path
.push_back (arc
);
740 /* Cycle has been found. */
741 result
|= handle_cycle (path
, count
);
742 else if (find (blocked
.begin (), blocked
.end (), w
) == blocked
.end ())
743 result
|= circuit (w
, path
, start
, blocked
, block_lists
, linfo
, count
);
748 if (result
!= NO_LOOP
)
749 unblock (v
, blocked
, block_lists
);
751 for (arc_info
*arc
= v
->succ
; arc
; arc
= arc
->succ_next
)
753 block_info
*w
= arc
->dst
;
754 if (w
< start
|| !linfo
.has_block (w
))
758 = find (blocked
.begin (), blocked
.end (), w
) - blocked
.begin ();
759 gcc_assert (index
< blocked
.size ());
760 block_vector_t
&list
= block_lists
[index
];
761 if (find (list
.begin (), list
.end (), v
) == list
.end ())
768 /* Find cycles for a LINFO. If HANDLE_NEGATIVE_CYCLES is set and the line
769 contains a negative loop, then perform the same function once again. */
772 get_cycles_count (line_info
&linfo
, bool handle_negative_cycles
= true)
774 /* Note that this algorithm works even if blocks aren't in sorted order.
775 Each iteration of the circuit detection is completely independent
776 (except for reducing counts, but that shouldn't matter anyways).
777 Therefore, operating on a permuted order (i.e., non-sorted) only
778 has the effect of permuting the output cycles. */
780 loop_type result
= NO_LOOP
;
782 for (vector
<block_info
*>::iterator it
= linfo
.blocks
.begin ();
783 it
!= linfo
.blocks
.end (); it
++)
786 block_vector_t blocked
;
787 vector
<block_vector_t
> block_lists
;
788 result
|= circuit (*it
, path
, *it
, blocked
, block_lists
, linfo
,
792 /* If we have a negative cycle, repeat the find_cycles routine. */
793 if (result
== NEGATIVE_LOOP
&& handle_negative_cycles
)
794 count
+= get_cycles_count (linfo
, false);
800 main (int argc
, char **argv
)
806 p
= argv
[0] + strlen (argv
[0]);
807 while (p
!= argv
[0] && !IS_DIR_SEPARATOR (p
[-1]))
811 xmalloc_set_program_name (progname
);
813 /* Unlock the stdio streams. */
814 unlock_std_streams ();
818 diagnostic_initialize (global_dc
, 0);
820 /* Handle response files. */
821 expandargv (&argc
, &argv
);
823 argno
= process_args (argc
, argv
);
827 if (argc
- argno
> 1)
832 for (; argno
!= argc
; argno
++)
834 if (flag_display_progress
)
835 printf ("Processing file %d out of %d\n", argno
- first_arg
+ 1,
837 process_file (argv
[argno
]);
839 if (flag_json_format
|| argno
== argc
- 1)
841 process_all_functions ();
842 generate_results (argv
[argno
]);
843 release_structures ();
850 /* Print a usage message and exit. If ERROR_P is nonzero, this is an error,
851 otherwise the output of --help. */
854 print_usage (int error_p
)
856 FILE *file
= error_p
? stderr
: stdout
;
857 int status
= error_p
? FATAL_EXIT_CODE
: SUCCESS_EXIT_CODE
;
859 fnotice (file
, "Usage: gcov [OPTION...] SOURCE|OBJ...\n\n");
860 fnotice (file
, "Print code coverage information.\n\n");
861 fnotice (file
, " -a, --all-blocks Show information for every basic block\n");
862 fnotice (file
, " -b, --branch-probabilities Include branch probabilities in output\n");
863 fnotice (file
, " -c, --branch-counts Output counts of branches taken\n\
864 rather than percentages\n");
865 fnotice (file
, " -d, --display-progress Display progress information\n");
866 fnotice (file
, " -f, --function-summaries Output summaries for each function\n");
867 fnotice (file
, " -h, --help Print this help, then exit\n");
868 fnotice (file
, " -i, --json-format Output JSON intermediate format into .gcov.json.gz file\n");
869 fnotice (file
, " -j, --human-readable Output human readable numbers\n");
870 fnotice (file
, " -k, --use-colors Emit colored output\n");
871 fnotice (file
, " -l, --long-file-names Use long output file names for included\n\
873 fnotice (file
, " -m, --demangled-names Output demangled function names\n");
874 fnotice (file
, " -n, --no-output Do not create an output file\n");
875 fnotice (file
, " -o, --object-directory DIR|FILE Search for object files in DIR or called FILE\n");
876 fnotice (file
, " -p, --preserve-paths Preserve all pathname components\n");
877 fnotice (file
, " -q, --use-hotness-colors Emit perf-like colored output for hot lines\n");
878 fnotice (file
, " -r, --relative-only Only show data for relative sources\n");
879 fnotice (file
, " -s, --source-prefix DIR Source prefix to elide\n");
880 fnotice (file
, " -t, --stdout Output to stdout instead of a file\n");
881 fnotice (file
, " -u, --unconditional-branches Show unconditional branch counts too\n");
882 fnotice (file
, " -v, --version Print version number, then exit\n");
883 fnotice (file
, " -w, --verbose Print verbose informations\n");
884 fnotice (file
, " -x, --hash-filenames Hash long pathnames\n");
885 fnotice (file
, "\nFor bug reporting instructions, please see:\n%s.\n",
890 /* Print version information and exit. */
895 fnotice (stdout
, "gcov %s%s\n", pkgversion_string
, version_string
);
896 fprintf (stdout
, "Copyright %s 2018 Free Software Foundation, Inc.\n",
899 _("This is free software; see the source for copying conditions.\n"
900 "There is NO warranty; not even for MERCHANTABILITY or \n"
901 "FITNESS FOR A PARTICULAR PURPOSE.\n\n"));
902 exit (SUCCESS_EXIT_CODE
);
905 static const struct option options
[] =
907 { "help", no_argument
, NULL
, 'h' },
908 { "version", no_argument
, NULL
, 'v' },
909 { "verbose", no_argument
, NULL
, 'w' },
910 { "all-blocks", no_argument
, NULL
, 'a' },
911 { "branch-probabilities", no_argument
, NULL
, 'b' },
912 { "branch-counts", no_argument
, NULL
, 'c' },
913 { "json-format", no_argument
, NULL
, 'i' },
914 { "human-readable", no_argument
, NULL
, 'j' },
915 { "no-output", no_argument
, NULL
, 'n' },
916 { "long-file-names", no_argument
, NULL
, 'l' },
917 { "function-summaries", no_argument
, NULL
, 'f' },
918 { "demangled-names", no_argument
, NULL
, 'm' },
919 { "preserve-paths", no_argument
, NULL
, 'p' },
920 { "relative-only", no_argument
, NULL
, 'r' },
921 { "object-directory", required_argument
, NULL
, 'o' },
922 { "object-file", required_argument
, NULL
, 'o' },
923 { "source-prefix", required_argument
, NULL
, 's' },
924 { "stdout", no_argument
, NULL
, 't' },
925 { "unconditional-branches", no_argument
, NULL
, 'u' },
926 { "display-progress", no_argument
, NULL
, 'd' },
927 { "hash-filenames", no_argument
, NULL
, 'x' },
928 { "use-colors", no_argument
, NULL
, 'k' },
929 { "use-hotness-colors", no_argument
, NULL
, 'q' },
933 /* Process args, return index to first non-arg. */
936 process_args (int argc
, char **argv
)
940 const char *opts
= "abcdfhijklmno:pqrs:tuvwx";
941 while ((opt
= getopt_long (argc
, argv
, opts
, options
, NULL
)) != -1)
955 flag_function_summary
= 1;
959 /* print_usage will exit. */
964 flag_human_readable_numbers
= 1;
970 flag_use_hotness_colors
= 1;
973 flag_demangled_names
= 1;
979 object_directory
= optarg
;
982 source_prefix
= optarg
;
983 source_length
= strlen (source_prefix
);
986 flag_relative_only
= 1;
989 flag_preserve_paths
= 1;
992 flag_unconditional
= 1;
995 flag_json_format
= 1;
999 flag_display_progress
= 1;
1002 flag_hash_filenames
= 1;
1008 flag_use_stdout
= 1;
1012 /* print_version will exit. */
1015 /* print_usage will exit. */
1022 /* Output intermediate LINE sitting on LINE_NUM to JSON OBJECT. */
1025 output_intermediate_json_line (json::array
*object
,
1026 line_info
*line
, unsigned line_num
)
1031 json::object
*lineo
= new json::object ();
1032 lineo
->set ("line_number", new json::number (line_num
));
1033 lineo
->set ("count", new json::number (line
->count
));
1034 lineo
->set ("unexecuted_block",
1035 new json::literal (line
->has_unexecuted_block
));
1037 json::array
*branches
= new json::array ();
1038 lineo
->set ("branches", branches
);
1040 vector
<arc_info
*>::const_iterator it
;
1042 for (it
= line
->branches
.begin (); it
!= line
->branches
.end ();
1045 if (!(*it
)->is_unconditional
&& !(*it
)->is_call_non_return
)
1047 json::object
*branch
= new json::object ();
1048 branch
->set ("count", new json::number ((*it
)->count
));
1049 branch
->set ("throw", new json::literal ((*it
)->is_throw
));
1050 branch
->set ("fallthrough",
1051 new json::literal ((*it
)->fall_through
));
1052 branches
->append (branch
);
1056 object
->append (lineo
);
1059 /* Get the name of the gcov file. The return value must be free'd.
1061 It appends the '.gcov' extension to the *basename* of the file.
1062 The resulting file name will be in PWD.
1065 input: foo.da, output: foo.da.gcov
1066 input: a/b/foo.cc, output: foo.cc.gcov */
1069 get_gcov_intermediate_filename (const char *file_name
)
1071 const char *gcov
= ".gcov.json.gz";
1075 /* Find the 'basename'. */
1076 cptr
= lbasename (file_name
);
1078 result
= XNEWVEC (char, strlen (cptr
) + strlen (gcov
) + 1);
1079 sprintf (result
, "%s%s", cptr
, gcov
);
1084 /* Output the result in JSON intermediate format.
1085 Source info SRC is dumped into JSON_FILES which is JSON array. */
1088 output_json_intermediate_file (json::array
*json_files
, source_info
*src
)
1090 json::object
*root
= new json::object ();
1091 json_files
->append (root
);
1093 root
->set ("file", new json::string (src
->name
));
1095 json::array
*functions
= new json::array ();
1096 root
->set ("functions", functions
);
1098 std::sort (src
->functions
.begin (), src
->functions
.end (),
1099 function_line_start_cmp ());
1100 for (vector
<function_info
*>::iterator it
= src
->functions
.begin ();
1101 it
!= src
->functions
.end (); it
++)
1103 json::object
*function
= new json::object ();
1104 function
->set ("name", new json::string ((*it
)->m_name
));
1105 function
->set ("demangled_name",
1106 new json::string ((*it
)->get_demangled_name ()));
1107 function
->set ("start_line", new json::number ((*it
)->start_line
));
1108 function
->set ("end_line", new json::number ((*it
)->end_line
));
1109 function
->set ("blocks",
1110 new json::number ((*it
)->get_block_count ()));
1111 function
->set ("blocks_executed",
1112 new json::number ((*it
)->blocks_executed
));
1113 function
->set ("execution_count",
1114 new json::number ((*it
)->blocks
[0].count
));
1116 functions
->append (function
);
1119 json::array
*lineso
= new json::array ();
1120 root
->set ("lines", lineso
);
1122 for (unsigned line_num
= 1; line_num
<= src
->lines
.size (); line_num
++)
1124 vector
<function_info
*> fns
= src
->get_functions_at_location (line_num
);
1126 /* Print first group functions that begin on the line. */
1127 for (vector
<function_info
*>::iterator it2
= fns
.begin ();
1128 it2
!= fns
.end (); it2
++)
1130 vector
<line_info
> &lines
= (*it2
)->lines
;
1131 for (unsigned i
= 0; i
< lines
.size (); i
++)
1133 line_info
*line
= &lines
[i
];
1134 output_intermediate_json_line (lineso
, line
, line_num
+ i
);
1138 /* Follow with lines associated with the source file. */
1139 if (line_num
< src
->lines
.size ())
1140 output_intermediate_json_line (lineso
, &src
->lines
[line_num
], line_num
);
1144 /* Function start pair. */
1145 struct function_start
1147 unsigned source_file_idx
;
1148 unsigned start_line
;
1151 /* Traits class for function start hash maps below. */
1153 struct function_start_pair_hash
: typed_noop_remove
<function_start
>
1155 typedef function_start value_type
;
1156 typedef function_start compare_type
;
1159 hash (const function_start
&ref
)
1161 inchash::hash
hstate (0);
1162 hstate
.add_int (ref
.source_file_idx
);
1163 hstate
.add_int (ref
.start_line
);
1164 return hstate
.end ();
1168 equal (const function_start
&ref1
, const function_start
&ref2
)
1170 return (ref1
.source_file_idx
== ref2
.source_file_idx
1171 && ref1
.start_line
== ref2
.start_line
);
1175 mark_deleted (function_start
&ref
)
1177 ref
.start_line
= ~1U;
1181 mark_empty (function_start
&ref
)
1183 ref
.start_line
= ~2U;
1187 is_deleted (const function_start
&ref
)
1189 return ref
.start_line
== ~1U;
1193 is_empty (const function_start
&ref
)
1195 return ref
.start_line
== ~2U;
1199 /* Process a single input file. */
1202 process_file (const char *file_name
)
1204 create_file_names (file_name
);
1206 for (unsigned i
= 0; i
< processed_files
.size (); i
++)
1207 if (strcmp (da_file_name
, processed_files
[i
]) == 0)
1209 fnotice (stderr
, "'%s' file is already processed\n",
1214 processed_files
.push_back (xstrdup (da_file_name
));
1220 /* Process all functions in all files. */
1223 process_all_functions (void)
1225 hash_map
<function_start_pair_hash
, function_info
*> fn_map
;
1227 /* Identify group functions. */
1228 for (vector
<function_info
*>::iterator it
= functions
.begin ();
1229 it
!= functions
.end (); it
++)
1230 if (!(*it
)->artificial
)
1232 function_start needle
;
1233 needle
.source_file_idx
= (*it
)->src
;
1234 needle
.start_line
= (*it
)->start_line
;
1236 function_info
**slot
= fn_map
.get (needle
);
1239 (*slot
)->is_group
= 1;
1240 (*it
)->is_group
= 1;
1243 fn_map
.put (needle
, *it
);
1246 /* Remove all artificial function. */
1247 functions
.erase (remove_if (functions
.begin (), functions
.end (),
1248 function_info::is_artificial
), functions
.end ());
1250 for (vector
<function_info
*>::iterator it
= functions
.begin ();
1251 it
!= functions
.end (); it
++)
1253 function_info
*fn
= *it
;
1254 unsigned src
= fn
->src
;
1256 if (!fn
->counts
.empty () || no_data_file
)
1258 source_info
*s
= &sources
[src
];
1259 s
->functions
.push_back (fn
);
1261 /* Mark last line in files touched by function. */
1262 for (unsigned block_no
= 0; block_no
!= fn
->blocks
.size ();
1265 block_info
*block
= &fn
->blocks
[block_no
];
1266 for (unsigned i
= 0; i
< block
->locations
.size (); i
++)
1268 /* Sort lines of locations. */
1269 sort (block
->locations
[i
].lines
.begin (),
1270 block
->locations
[i
].lines
.end ());
1272 if (!block
->locations
[i
].lines
.empty ())
1274 s
= &sources
[block
->locations
[i
].source_file_idx
];
1276 = block
->locations
[i
].lines
.back ();
1278 /* Record new lines for the function. */
1279 if (last_line
>= s
->lines
.size ())
1281 s
= &sources
[block
->locations
[i
].source_file_idx
];
1283 = block
->locations
[i
].lines
.back ();
1285 /* Record new lines for the function. */
1286 if (last_line
>= s
->lines
.size ())
1288 /* Record new lines for a source file. */
1289 s
->lines
.resize (last_line
+ 1);
1296 /* Allocate lines for group function, following start_line
1297 and end_line information of the function. */
1299 fn
->lines
.resize (fn
->end_line
- fn
->start_line
+ 1);
1301 solve_flow_graph (fn
);
1303 find_exception_blocks (fn
);
1307 /* The function was not in the executable -- some other
1308 instance must have been selected. */
1314 output_gcov_file (const char *file_name
, source_info
*src
)
1316 char *gcov_file_name
= make_gcov_file_name (file_name
, src
->coverage
.name
);
1318 if (src
->coverage
.lines
)
1320 FILE *gcov_file
= fopen (gcov_file_name
, "w");
1323 fnotice (stdout
, "Creating '%s'\n", gcov_file_name
);
1324 output_lines (gcov_file
, src
);
1325 if (ferror (gcov_file
))
1326 fnotice (stderr
, "Error writing output file '%s'\n",
1331 fnotice (stderr
, "Could not open output file '%s'\n", gcov_file_name
);
1335 unlink (gcov_file_name
);
1336 fnotice (stdout
, "Removing '%s'\n", gcov_file_name
);
1338 free (gcov_file_name
);
1342 generate_results (const char *file_name
)
1344 char *gcov_intermediate_filename
;
1346 for (vector
<function_info
*>::iterator it
= functions
.begin ();
1347 it
!= functions
.end (); it
++)
1349 function_info
*fn
= *it
;
1350 coverage_info coverage
;
1352 memset (&coverage
, 0, sizeof (coverage
));
1353 coverage
.name
= fn
->get_name ();
1354 add_line_counts (flag_function_summary
? &coverage
: NULL
, fn
);
1355 if (flag_function_summary
)
1357 function_summary (&coverage
, "Function");
1358 fnotice (stdout
, "\n");
1366 needle
.name
= file_name
;
1367 vector
<name_map
>::iterator it
= std::find (names
.begin (), names
.end (),
1369 if (it
!= names
.end ())
1370 file_name
= sources
[it
->src
].coverage
.name
;
1372 file_name
= canonicalize_name (file_name
);
1375 gcov_intermediate_filename
= get_gcov_intermediate_filename (file_name
);
1377 json::object
*root
= new json::object ();
1378 root
->set ("format_version", new json::string ("1"));
1379 root
->set ("gcc_version", new json::string (version_string
));
1380 root
->set ("current_working_directory", new json::string (bbg_cwd
));
1382 json::array
*json_files
= new json::array ();
1383 root
->set ("files", json_files
);
1385 for (vector
<source_info
>::iterator it
= sources
.begin ();
1386 it
!= sources
.end (); it
++)
1388 source_info
*src
= &(*it
);
1389 if (flag_relative_only
)
1391 /* Ignore this source, if it is an absolute path (after
1392 source prefix removal). */
1393 char first
= src
->coverage
.name
[0];
1395 #if HAVE_DOS_BASED_FILE_SYSTEM
1396 if (first
&& src
->coverage
.name
[1] == ':')
1397 first
= src
->coverage
.name
[2];
1399 if (IS_DIR_SEPARATOR (first
))
1403 accumulate_line_counts (src
);
1405 if (!flag_use_stdout
)
1406 function_summary (&src
->coverage
, "File");
1407 total_lines
+= src
->coverage
.lines
;
1408 total_executed
+= src
->coverage
.lines_executed
;
1411 if (flag_json_format
)
1412 output_json_intermediate_file (json_files
, src
);
1415 if (flag_use_stdout
)
1417 if (src
->coverage
.lines
)
1418 output_lines (stdout
, src
);
1422 output_gcov_file (file_name
, src
);
1423 fnotice (stdout
, "\n");
1429 if (flag_gcov_file
&& flag_json_format
)
1431 if (flag_use_stdout
)
1433 root
->dump (stdout
);
1440 pp_formatted_text (&pp
);
1442 gzFile output
= gzopen (gcov_intermediate_filename
, "w");
1445 fnotice (stderr
, "Cannot open JSON output file %s\n",
1446 gcov_intermediate_filename
);
1450 if (gzputs (output
, pp_formatted_text (&pp
)) == EOF
1451 || gzclose (output
))
1453 fnotice (stderr
, "Error writing JSON output file %s\n",
1454 gcov_intermediate_filename
);
1461 executed_summary (total_lines
, total_executed
);
1464 /* Release all memory used. */
1467 release_structures (void)
1469 for (vector
<function_info
*>::iterator it
= functions
.begin ();
1470 it
!= functions
.end (); it
++)
1475 functions
.resize (0);
1478 /* Generate the names of the graph and data files. If OBJECT_DIRECTORY
1479 is not specified, these are named from FILE_NAME sans extension. If
1480 OBJECT_DIRECTORY is specified and is a directory, the files are in that
1481 directory, but named from the basename of the FILE_NAME, sans extension.
1482 Otherwise OBJECT_DIRECTORY is taken to be the name of the object *file*
1483 and the data files are named from that. */
1486 create_file_names (const char *file_name
)
1490 int length
= strlen (file_name
);
1493 /* Free previous file names. */
1494 free (bbg_file_name
);
1495 free (da_file_name
);
1496 da_file_name
= bbg_file_name
= NULL
;
1500 if (object_directory
&& object_directory
[0])
1504 length
+= strlen (object_directory
) + 2;
1505 name
= XNEWVEC (char, length
);
1508 base
= !stat (object_directory
, &status
) && S_ISDIR (status
.st_mode
);
1509 strcat (name
, object_directory
);
1510 if (base
&& (!IS_DIR_SEPARATOR (name
[strlen (name
) - 1])))
1515 name
= XNEWVEC (char, length
+ 1);
1516 strcpy (name
, file_name
);
1522 /* Append source file name. */
1523 const char *cptr
= lbasename (file_name
);
1524 strcat (name
, cptr
? cptr
: file_name
);
1527 /* Remove the extension. */
1528 cptr
= strrchr (CONST_CAST (char *, lbasename (name
)), '.');
1532 length
= strlen (name
);
1534 bbg_file_name
= XNEWVEC (char, length
+ strlen (GCOV_NOTE_SUFFIX
) + 1);
1535 strcpy (bbg_file_name
, name
);
1536 strcpy (bbg_file_name
+ length
, GCOV_NOTE_SUFFIX
);
1538 da_file_name
= XNEWVEC (char, length
+ strlen (GCOV_DATA_SUFFIX
) + 1);
1539 strcpy (da_file_name
, name
);
1540 strcpy (da_file_name
+ length
, GCOV_DATA_SUFFIX
);
1546 /* Find or create a source file structure for FILE_NAME. Copies
1547 FILE_NAME on creation */
1550 find_source (const char *file_name
)
1557 file_name
= "<unknown>";
1560 needle
.name
= file_name
;
1562 vector
<name_map
>::iterator it
= std::find (names
.begin (), names
.end (),
1564 if (it
!= names
.end ())
1570 /* Not found, try the canonical name. */
1571 canon
= canonicalize_name (file_name
);
1572 needle
.name
= canon
;
1573 it
= std::find (names
.begin (), names
.end (), needle
);
1574 if (it
== names
.end ())
1576 /* Not found with canonical name, create a new source. */
1579 idx
= sources
.size ();
1580 needle
= name_map (canon
, idx
);
1581 names
.push_back (needle
);
1583 sources
.push_back (source_info ());
1584 src
= &sources
.back ();
1586 src
->coverage
.name
= src
->name
;
1589 #if HAVE_DOS_BASED_FILE_SYSTEM
1590 /* You lose if separators don't match exactly in the
1592 && !strncasecmp (source_prefix
, src
->coverage
.name
, source_length
)
1594 && !strncmp (source_prefix
, src
->coverage
.name
, source_length
)
1596 && IS_DIR_SEPARATOR (src
->coverage
.name
[source_length
]))
1597 src
->coverage
.name
+= source_length
+ 1;
1598 if (!stat (src
->name
, &status
))
1599 src
->file_time
= status
.st_mtime
;
1604 needle
.name
= file_name
;
1605 if (std::find (names
.begin (), names
.end (), needle
) == names
.end ())
1607 /* Append the non-canonical name. */
1608 names
.push_back (name_map (xstrdup (file_name
), idx
));
1611 /* Resort the name map. */
1612 std::sort (names
.begin (), names
.end ());
1615 if (sources
[idx
].file_time
> bbg_file_time
)
1617 static int info_emitted
;
1619 fnotice (stderr
, "%s:source file is newer than notes file '%s'\n",
1620 file_name
, bbg_file_name
);
1624 "(the message is displayed only once per source file)\n");
1627 sources
[idx
].file_time
= 0;
1633 /* Read the notes file. Save functions to FUNCTIONS global vector. */
1636 read_graph_file (void)
1639 unsigned current_tag
= 0;
1642 if (!gcov_open (bbg_file_name
, 1))
1644 fnotice (stderr
, "%s:cannot open notes file\n", bbg_file_name
);
1647 bbg_file_time
= gcov_time ();
1648 if (!gcov_magic (gcov_read_unsigned (), GCOV_NOTE_MAGIC
))
1650 fnotice (stderr
, "%s:not a gcov notes file\n", bbg_file_name
);
1655 version
= gcov_read_unsigned ();
1656 if (version
!= GCOV_VERSION
)
1660 GCOV_UNSIGNED2STRING (v
, version
);
1661 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
1663 fnotice (stderr
, "%s:version '%.4s', prefer '%.4s'\n",
1664 bbg_file_name
, v
, e
);
1666 bbg_stamp
= gcov_read_unsigned ();
1667 bbg_cwd
= xstrdup (gcov_read_string ());
1668 bbg_supports_has_unexecuted_blocks
= gcov_read_unsigned ();
1670 function_info
*fn
= NULL
;
1671 while ((tag
= gcov_read_unsigned ()))
1673 unsigned length
= gcov_read_unsigned ();
1674 gcov_position_t base
= gcov_position ();
1676 if (tag
== GCOV_TAG_FUNCTION
)
1678 char *function_name
;
1680 unsigned lineno_checksum
, cfg_checksum
;
1682 ident
= gcov_read_unsigned ();
1683 lineno_checksum
= gcov_read_unsigned ();
1684 cfg_checksum
= gcov_read_unsigned ();
1685 function_name
= xstrdup (gcov_read_string ());
1686 unsigned artificial
= gcov_read_unsigned ();
1687 unsigned src_idx
= find_source (gcov_read_string ());
1688 unsigned start_line
= gcov_read_unsigned ();
1689 unsigned start_column
= gcov_read_unsigned ();
1690 unsigned end_line
= gcov_read_unsigned ();
1692 fn
= new function_info ();
1693 functions
.push_back (fn
);
1694 fn
->m_name
= function_name
;
1696 fn
->lineno_checksum
= lineno_checksum
;
1697 fn
->cfg_checksum
= cfg_checksum
;
1699 fn
->start_line
= start_line
;
1700 fn
->start_column
= start_column
;
1701 fn
->end_line
= end_line
;
1702 fn
->artificial
= artificial
;
1706 else if (fn
&& tag
== GCOV_TAG_BLOCKS
)
1708 if (!fn
->blocks
.empty ())
1709 fnotice (stderr
, "%s:already seen blocks for '%s'\n",
1710 bbg_file_name
, fn
->get_name ());
1712 fn
->blocks
.resize (gcov_read_unsigned ());
1714 else if (fn
&& tag
== GCOV_TAG_ARCS
)
1716 unsigned src
= gcov_read_unsigned ();
1717 fn
->blocks
[src
].id
= src
;
1718 unsigned num_dests
= GCOV_TAG_ARCS_NUM (length
);
1719 block_info
*src_blk
= &fn
->blocks
[src
];
1720 unsigned mark_catches
= 0;
1721 struct arc_info
*arc
;
1723 if (src
>= fn
->blocks
.size () || fn
->blocks
[src
].succ
)
1728 unsigned dest
= gcov_read_unsigned ();
1729 unsigned flags
= gcov_read_unsigned ();
1731 if (dest
>= fn
->blocks
.size ())
1733 arc
= XCNEW (arc_info
);
1735 arc
->dst
= &fn
->blocks
[dest
];
1739 arc
->count_valid
= 0;
1740 arc
->on_tree
= !!(flags
& GCOV_ARC_ON_TREE
);
1741 arc
->fake
= !!(flags
& GCOV_ARC_FAKE
);
1742 arc
->fall_through
= !!(flags
& GCOV_ARC_FALLTHROUGH
);
1744 arc
->succ_next
= src_blk
->succ
;
1745 src_blk
->succ
= arc
;
1746 src_blk
->num_succ
++;
1748 arc
->pred_next
= fn
->blocks
[dest
].pred
;
1749 fn
->blocks
[dest
].pred
= arc
;
1750 fn
->blocks
[dest
].num_pred
++;
1756 /* Exceptional exit from this function, the
1757 source block must be a call. */
1758 fn
->blocks
[src
].is_call_site
= 1;
1759 arc
->is_call_non_return
= 1;
1764 /* Non-local return from a callee of this
1765 function. The destination block is a setjmp. */
1766 arc
->is_nonlocal_return
= 1;
1767 fn
->blocks
[dest
].is_nonlocal_return
= 1;
1772 fn
->counts
.push_back (0);
1777 /* We have a fake exit from this block. The other
1778 non-fall through exits must be to catch handlers.
1779 Mark them as catch arcs. */
1781 for (arc
= src_blk
->succ
; arc
; arc
= arc
->succ_next
)
1782 if (!arc
->fake
&& !arc
->fall_through
)
1789 else if (fn
&& tag
== GCOV_TAG_LINES
)
1791 unsigned blockno
= gcov_read_unsigned ();
1792 block_info
*block
= &fn
->blocks
[blockno
];
1794 if (blockno
>= fn
->blocks
.size ())
1799 unsigned lineno
= gcov_read_unsigned ();
1802 block
->locations
.back ().lines
.push_back (lineno
);
1805 const char *file_name
= gcov_read_string ();
1809 block
->locations
.push_back (block_location_info
1810 (find_source (file_name
)));
1814 else if (current_tag
&& !GCOV_TAG_IS_SUBTAG (current_tag
, tag
))
1819 gcov_sync (base
, length
);
1820 if (gcov_is_error ())
1823 fnotice (stderr
, "%s:corrupted\n", bbg_file_name
);
1829 if (functions
.empty ())
1830 fnotice (stderr
, "%s:no functions found\n", bbg_file_name
);
1833 /* Reads profiles from the count file and attach to each
1834 function. Return nonzero if fatal error. */
1837 read_count_file (void)
1842 function_info
*fn
= NULL
;
1845 if (!gcov_open (da_file_name
, 1))
1847 fnotice (stderr
, "%s:cannot open data file, assuming not executed\n",
1852 if (!gcov_magic (gcov_read_unsigned (), GCOV_DATA_MAGIC
))
1854 fnotice (stderr
, "%s:not a gcov data file\n", da_file_name
);
1859 version
= gcov_read_unsigned ();
1860 if (version
!= GCOV_VERSION
)
1864 GCOV_UNSIGNED2STRING (v
, version
);
1865 GCOV_UNSIGNED2STRING (e
, GCOV_VERSION
);
1867 fnotice (stderr
, "%s:version '%.4s', prefer version '%.4s'\n",
1868 da_file_name
, v
, e
);
1870 tag
= gcov_read_unsigned ();
1871 if (tag
!= bbg_stamp
)
1873 fnotice (stderr
, "%s:stamp mismatch with notes file\n", da_file_name
);
1877 while ((tag
= gcov_read_unsigned ()))
1879 unsigned length
= gcov_read_unsigned ();
1880 unsigned long base
= gcov_position ();
1882 if (tag
== GCOV_TAG_OBJECT_SUMMARY
)
1884 struct gcov_summary summary
;
1885 gcov_read_summary (&summary
);
1886 object_runs
= summary
.runs
;
1888 else if (tag
== GCOV_TAG_FUNCTION
&& !length
)
1890 else if (tag
== GCOV_TAG_FUNCTION
&& length
== GCOV_TAG_FUNCTION_LENGTH
)
1894 /* Try to find the function in the list. To speed up the
1895 search, first start from the last function found. */
1896 ident
= gcov_read_unsigned ();
1899 for (vector
<function_info
*>::reverse_iterator it
1900 = functions
.rbegin (); it
!= functions
.rend (); it
++)
1902 if ((*it
)->ident
== ident
)
1911 else if (gcov_read_unsigned () != fn
->lineno_checksum
1912 || gcov_read_unsigned () != fn
->cfg_checksum
)
1915 fnotice (stderr
, "%s:profile mismatch for '%s'\n",
1916 da_file_name
, fn
->get_name ());
1920 else if (tag
== GCOV_TAG_FOR_COUNTER (GCOV_COUNTER_ARCS
) && fn
)
1922 if (length
!= GCOV_TAG_COUNTER_LENGTH (fn
->counts
.size ()))
1925 for (ix
= 0; ix
!= fn
->counts
.size (); ix
++)
1926 fn
->counts
[ix
] += gcov_read_counter ();
1928 gcov_sync (base
, length
);
1929 if ((error
= gcov_is_error ()))
1933 ? N_("%s:overflowed\n")
1934 : N_("%s:corrupted\n"),
1944 /* Solve the flow graph. Propagate counts from the instrumented arcs
1945 to the blocks and the uninstrumented arcs. */
1948 solve_flow_graph (function_info
*fn
)
1952 gcov_type
*count_ptr
= &fn
->counts
.front ();
1954 block_info
*valid_blocks
= NULL
; /* valid, but unpropagated blocks. */
1955 block_info
*invalid_blocks
= NULL
; /* invalid, but inferable blocks. */
1957 /* The arcs were built in reverse order. Fix that now. */
1958 for (ix
= fn
->blocks
.size (); ix
--;)
1960 arc_info
*arc_p
, *arc_n
;
1962 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].succ
; arc
;
1963 arc_p
= arc
, arc
= arc_n
)
1965 arc_n
= arc
->succ_next
;
1966 arc
->succ_next
= arc_p
;
1968 fn
->blocks
[ix
].succ
= arc_p
;
1970 for (arc_p
= NULL
, arc
= fn
->blocks
[ix
].pred
; arc
;
1971 arc_p
= arc
, arc
= arc_n
)
1973 arc_n
= arc
->pred_next
;
1974 arc
->pred_next
= arc_p
;
1976 fn
->blocks
[ix
].pred
= arc_p
;
1979 if (fn
->blocks
.size () < 2)
1980 fnotice (stderr
, "%s:'%s' lacks entry and/or exit blocks\n",
1981 bbg_file_name
, fn
->get_name ());
1984 if (fn
->blocks
[ENTRY_BLOCK
].num_pred
)
1985 fnotice (stderr
, "%s:'%s' has arcs to entry block\n",
1986 bbg_file_name
, fn
->get_name ());
1988 /* We can't deduce the entry block counts from the lack of
1990 fn
->blocks
[ENTRY_BLOCK
].num_pred
= ~(unsigned)0;
1992 if (fn
->blocks
[EXIT_BLOCK
].num_succ
)
1993 fnotice (stderr
, "%s:'%s' has arcs from exit block\n",
1994 bbg_file_name
, fn
->get_name ());
1996 /* Likewise, we can't deduce exit block counts from the lack
1997 of its successors. */
1998 fn
->blocks
[EXIT_BLOCK
].num_succ
= ~(unsigned)0;
2001 /* Propagate the measured counts, this must be done in the same
2002 order as the code in profile.c */
2003 for (unsigned i
= 0; i
< fn
->blocks
.size (); i
++)
2005 blk
= &fn
->blocks
[i
];
2006 block_info
const *prev_dst
= NULL
;
2007 int out_of_order
= 0;
2008 int non_fake_succ
= 0;
2010 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
2018 arc
->count
= *count_ptr
++;
2019 arc
->count_valid
= 1;
2021 arc
->dst
->num_pred
--;
2023 if (prev_dst
&& prev_dst
> arc
->dst
)
2025 prev_dst
= arc
->dst
;
2027 if (non_fake_succ
== 1)
2029 /* If there is only one non-fake exit, it is an
2030 unconditional branch. */
2031 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
2034 arc
->is_unconditional
= 1;
2035 /* If this block is instrumenting a call, it might be
2036 an artificial block. It is not artificial if it has
2037 a non-fallthrough exit, or the destination of this
2038 arc has more than one entry. Mark the destination
2039 block as a return site, if none of those conditions
2041 if (blk
->is_call_site
&& arc
->fall_through
2042 && arc
->dst
->pred
== arc
&& !arc
->pred_next
)
2043 arc
->dst
->is_call_return
= 1;
2047 /* Sort the successor arcs into ascending dst order. profile.c
2048 normally produces arcs in the right order, but sometimes with
2049 one or two out of order. We're not using a particularly
2053 arc_info
*start
= blk
->succ
;
2054 unsigned changes
= 1;
2058 arc_info
*arc
, *arc_p
, *arc_n
;
2061 for (arc_p
= NULL
, arc
= start
; (arc_n
= arc
->succ_next
);)
2063 if (arc
->dst
> arc_n
->dst
)
2067 arc_p
->succ_next
= arc_n
;
2070 arc
->succ_next
= arc_n
->succ_next
;
2071 arc_n
->succ_next
= arc
;
2084 /* Place it on the invalid chain, it will be ignored if that's
2086 blk
->invalid_chain
= 1;
2087 blk
->chain
= invalid_blocks
;
2088 invalid_blocks
= blk
;
2091 while (invalid_blocks
|| valid_blocks
)
2093 while ((blk
= invalid_blocks
))
2095 gcov_type total
= 0;
2096 const arc_info
*arc
;
2098 invalid_blocks
= blk
->chain
;
2099 blk
->invalid_chain
= 0;
2101 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
2102 total
+= arc
->count
;
2103 else if (!blk
->num_pred
)
2104 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
2105 total
+= arc
->count
;
2110 blk
->count_valid
= 1;
2111 blk
->chain
= valid_blocks
;
2112 blk
->valid_chain
= 1;
2115 while ((blk
= valid_blocks
))
2118 arc_info
*arc
, *inv_arc
;
2120 valid_blocks
= blk
->chain
;
2121 blk
->valid_chain
= 0;
2122 if (blk
->num_succ
== 1)
2128 for (arc
= blk
->succ
; arc
; arc
= arc
->succ_next
)
2130 total
-= arc
->count
;
2131 if (!arc
->count_valid
)
2135 inv_arc
->count_valid
= 1;
2136 inv_arc
->count
= total
;
2139 if (dst
->count_valid
)
2141 if (dst
->num_pred
== 1 && !dst
->valid_chain
)
2143 dst
->chain
= valid_blocks
;
2144 dst
->valid_chain
= 1;
2150 if (!dst
->num_pred
&& !dst
->invalid_chain
)
2152 dst
->chain
= invalid_blocks
;
2153 dst
->invalid_chain
= 1;
2154 invalid_blocks
= dst
;
2158 if (blk
->num_pred
== 1)
2164 for (arc
= blk
->pred
; arc
; arc
= arc
->pred_next
)
2166 total
-= arc
->count
;
2167 if (!arc
->count_valid
)
2171 inv_arc
->count_valid
= 1;
2172 inv_arc
->count
= total
;
2175 if (src
->count_valid
)
2177 if (src
->num_succ
== 1 && !src
->valid_chain
)
2179 src
->chain
= valid_blocks
;
2180 src
->valid_chain
= 1;
2186 if (!src
->num_succ
&& !src
->invalid_chain
)
2188 src
->chain
= invalid_blocks
;
2189 src
->invalid_chain
= 1;
2190 invalid_blocks
= src
;
2197 /* If the graph has been correctly solved, every block will have a
2199 for (unsigned i
= 0; ix
< fn
->blocks
.size (); i
++)
2200 if (!fn
->blocks
[i
].count_valid
)
2202 fnotice (stderr
, "%s:graph is unsolvable for '%s'\n",
2203 bbg_file_name
, fn
->get_name ());
2208 /* Mark all the blocks only reachable via an incoming catch. */
2211 find_exception_blocks (function_info
*fn
)
2214 block_info
**queue
= XALLOCAVEC (block_info
*, fn
->blocks
.size ());
2216 /* First mark all blocks as exceptional. */
2217 for (ix
= fn
->blocks
.size (); ix
--;)
2218 fn
->blocks
[ix
].exceptional
= 1;
2220 /* Now mark all the blocks reachable via non-fake edges */
2221 queue
[0] = &fn
->blocks
[0];
2222 queue
[0]->exceptional
= 0;
2225 block_info
*block
= queue
[--ix
];
2226 const arc_info
*arc
;
2228 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
2229 if (!arc
->fake
&& !arc
->is_throw
&& arc
->dst
->exceptional
)
2231 arc
->dst
->exceptional
= 0;
2232 queue
[ix
++] = arc
->dst
;
2238 /* Increment totals in COVERAGE according to arc ARC. */
2241 add_branch_counts (coverage_info
*coverage
, const arc_info
*arc
)
2243 if (arc
->is_call_non_return
)
2246 if (arc
->src
->count
)
2247 coverage
->calls_executed
++;
2249 else if (!arc
->is_unconditional
)
2251 coverage
->branches
++;
2252 if (arc
->src
->count
)
2253 coverage
->branches_executed
++;
2255 coverage
->branches_taken
++;
2259 /* Format COUNT, if flag_human_readable_numbers is set, return it human
2263 format_count (gcov_type count
)
2265 static char buffer
[64];
2266 const char *units
= " kMGTPEZY";
2268 if (count
< 1000 || !flag_human_readable_numbers
)
2270 sprintf (buffer
, "%" PRId64
, count
);
2275 gcov_type divisor
= 1;
2276 for (i
= 0; units
[i
+1]; i
++, divisor
*= 1000)
2278 if (count
+ divisor
/ 2 < 1000 * divisor
)
2281 float r
= 1.0f
* count
/ divisor
;
2282 sprintf (buffer
, "%.1f%c", r
, units
[i
]);
2286 /* Format a GCOV_TYPE integer as either a percent ratio, or absolute
2287 count. If DECIMAL_PLACES >= 0, format TOP/BOTTOM * 100 to DECIMAL_PLACES.
2288 If DECIMAL_PLACES is zero, no decimal point is printed. Only print 100% when
2289 TOP==BOTTOM and only print 0% when TOP=0. If DECIMAL_PLACES < 0, then simply
2290 format TOP. Return pointer to a static string. */
2293 format_gcov (gcov_type top
, gcov_type bottom
, int decimal_places
)
2295 static char buffer
[20];
2297 if (decimal_places
>= 0)
2299 float ratio
= bottom
? 100.0f
* top
/ bottom
: 0;
2301 /* Round up to 1% if there's a small non-zero value. */
2302 if (ratio
> 0.0f
&& ratio
< 0.5f
&& decimal_places
== 0)
2304 sprintf (buffer
, "%.*f%%", decimal_places
, ratio
);
2307 return format_count (top
);
2312 /* Summary of execution */
2315 executed_summary (unsigned lines
, unsigned executed
)
2318 fnotice (stdout
, "Lines executed:%s of %d\n",
2319 format_gcov (executed
, lines
, 2), lines
);
2321 fnotice (stdout
, "No executable lines\n");
2324 /* Output summary info for a function or file. */
2327 function_summary (const coverage_info
*coverage
, const char *title
)
2329 fnotice (stdout
, "%s '%s'\n", title
, coverage
->name
);
2330 executed_summary (coverage
->lines
, coverage
->lines_executed
);
2334 if (coverage
->branches
)
2336 fnotice (stdout
, "Branches executed:%s of %d\n",
2337 format_gcov (coverage
->branches_executed
,
2338 coverage
->branches
, 2),
2339 coverage
->branches
);
2340 fnotice (stdout
, "Taken at least once:%s of %d\n",
2341 format_gcov (coverage
->branches_taken
,
2342 coverage
->branches
, 2),
2343 coverage
->branches
);
2346 fnotice (stdout
, "No branches\n");
2347 if (coverage
->calls
)
2348 fnotice (stdout
, "Calls executed:%s of %d\n",
2349 format_gcov (coverage
->calls_executed
, coverage
->calls
, 2),
2352 fnotice (stdout
, "No calls\n");
2356 /* Canonicalize the filename NAME by canonicalizing directory
2357 separators, eliding . components and resolving .. components
2358 appropriately. Always returns a unique string. */
2361 canonicalize_name (const char *name
)
2363 /* The canonical name cannot be longer than the incoming name. */
2364 char *result
= XNEWVEC (char, strlen (name
) + 1);
2365 const char *base
= name
, *probe
;
2370 #if HAVE_DOS_BASED_FILE_SYSTEM
2371 if (base
[0] && base
[1] == ':')
2373 result
[0] = base
[0];
2379 for (dd_base
= ptr
; *base
; base
= probe
)
2383 for (probe
= base
; *probe
; probe
++)
2384 if (IS_DIR_SEPARATOR (*probe
))
2388 if (len
== 1 && base
[0] == '.')
2389 /* Elide a '.' directory */
2391 else if (len
== 2 && base
[0] == '.' && base
[1] == '.')
2393 /* '..', we can only elide it and the previous directory, if
2394 we're not a symlink. */
2395 struct stat ATTRIBUTE_UNUSED buf
;
2399 #if defined (S_ISLNK)
2400 /* S_ISLNK is not POSIX.1-1996. */
2401 || stat (result
, &buf
) || S_ISLNK (buf
.st_mode
)
2405 /* Cannot elide, or unreadable or a symlink. */
2406 dd_base
= ptr
+ 2 + slash
;
2409 while (ptr
!= dd_base
&& *ptr
!= '/')
2411 slash
= ptr
!= result
;
2416 /* Regular pathname component. */
2419 memcpy (ptr
, base
, len
);
2424 for (; IS_DIR_SEPARATOR (*probe
); probe
++)
2432 /* Print hex representation of 16 bytes from SUM and write it to BUFFER. */
2435 md5sum_to_hex (const char *sum
, char *buffer
)
2437 for (unsigned i
= 0; i
< 16; i
++)
2438 sprintf (buffer
+ (2 * i
), "%02x", (unsigned char)sum
[i
]);
2441 /* Generate an output file name. INPUT_NAME is the canonicalized main
2442 input file and SRC_NAME is the canonicalized file name.
2443 LONG_OUTPUT_NAMES and PRESERVE_PATHS affect name generation. With
2444 long_output_names we prepend the processed name of the input file
2445 to each output name (except when the current source file is the
2446 input file, so you don't get a double concatenation). The two
2447 components are separated by '##'. With preserve_paths we create a
2448 filename from all path components of the source file, replacing '/'
2449 with '#', and .. with '^', without it we simply take the basename
2450 component. (Remember, the canonicalized name will already have
2451 elided '.' components and converted \\ separators.) */
2454 make_gcov_file_name (const char *input_name
, const char *src_name
)
2459 if (flag_long_names
&& input_name
&& strcmp (src_name
, input_name
))
2461 /* Generate the input filename part. */
2462 result
= XNEWVEC (char, strlen (input_name
) + strlen (src_name
) + 10);
2465 ptr
= mangle_name (input_name
, ptr
);
2466 ptr
[0] = ptr
[1] = '#';
2471 result
= XNEWVEC (char, strlen (src_name
) + 10);
2475 ptr
= mangle_name (src_name
, ptr
);
2476 strcpy (ptr
, ".gcov");
2478 /* When hashing filenames, we shorten them by only using the filename
2479 component and appending a hash of the full (mangled) pathname. */
2480 if (flag_hash_filenames
)
2484 char md5sum_hex
[33];
2486 md5_init_ctx (&ctx
);
2487 md5_process_bytes (src_name
, strlen (src_name
), &ctx
);
2488 md5_finish_ctx (&ctx
, md5sum
);
2489 md5sum_to_hex (md5sum
, md5sum_hex
);
2492 result
= XNEWVEC (char, strlen (src_name
) + 50);
2494 ptr
= mangle_name (src_name
, ptr
);
2495 ptr
[0] = ptr
[1] = '#';
2497 memcpy (ptr
, md5sum_hex
, 32);
2499 strcpy (ptr
, ".gcov");
2506 mangle_name (char const *base
, char *ptr
)
2510 /* Generate the source filename part. */
2511 if (!flag_preserve_paths
)
2513 base
= lbasename (base
);
2514 len
= strlen (base
);
2515 memcpy (ptr
, base
, len
);
2519 ptr
= mangle_path (base
);
2524 /* Scan through the bb_data for each line in the block, increment
2525 the line number execution count indicated by the execution count of
2526 the appropriate basic block. */
2529 add_line_counts (coverage_info
*coverage
, function_info
*fn
)
2531 bool has_any_line
= false;
2532 /* Scan each basic block. */
2533 for (unsigned ix
= 0; ix
!= fn
->blocks
.size (); ix
++)
2535 line_info
*line
= NULL
;
2536 block_info
*block
= &fn
->blocks
[ix
];
2537 if (block
->count
&& ix
&& ix
+ 1 != fn
->blocks
.size ())
2538 fn
->blocks_executed
++;
2539 for (unsigned i
= 0; i
< block
->locations
.size (); i
++)
2541 unsigned src_idx
= block
->locations
[i
].source_file_idx
;
2542 vector
<unsigned> &lines
= block
->locations
[i
].lines
;
2544 block
->cycle
.arc
= NULL
;
2545 block
->cycle
.ident
= ~0U;
2547 for (unsigned j
= 0; j
< lines
.size (); j
++)
2549 unsigned ln
= lines
[j
];
2551 /* Line belongs to a function that is in a group. */
2552 if (fn
->group_line_p (ln
, src_idx
))
2554 gcc_assert (lines
[j
] - fn
->start_line
< fn
->lines
.size ());
2555 line
= &(fn
->lines
[lines
[j
] - fn
->start_line
]);
2557 if (!block
->exceptional
)
2559 line
->unexceptional
= 1;
2560 if (block
->count
== 0)
2561 line
->has_unexecuted_block
= 1;
2563 line
->count
+= block
->count
;
2567 gcc_assert (ln
< sources
[src_idx
].lines
.size ());
2568 line
= &(sources
[src_idx
].lines
[ln
]);
2573 if (!line
->count
&& block
->count
)
2574 coverage
->lines_executed
++;
2577 if (!block
->exceptional
)
2579 line
->unexceptional
= 1;
2580 if (block
->count
== 0)
2581 line
->has_unexecuted_block
= 1;
2583 line
->count
+= block
->count
;
2587 has_any_line
= true;
2589 if (!ix
|| ix
+ 1 == fn
->blocks
.size ())
2590 /* Entry or exit block. */;
2591 else if (line
!= NULL
)
2593 line
->blocks
.push_back (block
);
2599 for (arc
= block
->succ
; arc
; arc
= arc
->succ_next
)
2600 line
->branches
.push_back (arc
);
2607 fnotice (stderr
, "%s:no lines for '%s'\n", bbg_file_name
,
2611 /* Accumulate info for LINE that belongs to SRC source file. If ADD_COVERAGE
2612 is set to true, update source file summary. */
2614 static void accumulate_line_info (line_info
*line
, source_info
*src
,
2618 for (vector
<arc_info
*>::iterator it
= line
->branches
.begin ();
2619 it
!= line
->branches
.end (); it
++)
2620 add_branch_counts (&src
->coverage
, *it
);
2622 if (!line
->blocks
.empty ())
2624 /* The user expects the line count to be the number of times
2625 a line has been executed. Simply summing the block count
2626 will give an artificially high number. The Right Thing
2627 is to sum the entry counts to the graph of blocks on this
2628 line, then find the elementary cycles of the local graph
2629 and add the transition counts of those cycles. */
2630 gcov_type count
= 0;
2632 /* Cycle detection. */
2633 for (vector
<block_info
*>::iterator it
= line
->blocks
.begin ();
2634 it
!= line
->blocks
.end (); it
++)
2636 for (arc_info
*arc
= (*it
)->pred
; arc
; arc
= arc
->pred_next
)
2637 if (!line
->has_block (arc
->src
))
2638 count
+= arc
->count
;
2639 for (arc_info
*arc
= (*it
)->succ
; arc
; arc
= arc
->succ_next
)
2640 arc
->cs_count
= arc
->count
;
2643 /* Now, add the count of loops entirely on this line. */
2644 count
+= get_cycles_count (*line
);
2645 line
->count
= count
;
2647 if (line
->count
> src
->maximum_count
)
2648 src
->maximum_count
= line
->count
;
2651 if (line
->exists
&& add_coverage
)
2653 src
->coverage
.lines
++;
2655 src
->coverage
.lines_executed
++;
2659 /* Accumulate the line counts of a file. */
2662 accumulate_line_counts (source_info
*src
)
2664 /* First work on group functions. */
2665 for (vector
<function_info
*>::iterator it
= src
->functions
.begin ();
2666 it
!= src
->functions
.end (); it
++)
2668 function_info
*fn
= *it
;
2670 if (fn
->src
!= src
->index
|| !fn
->is_group
)
2673 for (vector
<line_info
>::iterator it2
= fn
->lines
.begin ();
2674 it2
!= fn
->lines
.end (); it2
++)
2676 line_info
*line
= &(*it2
);
2677 accumulate_line_info (line
, src
, false);
2681 /* Work on global lines that line in source file SRC. */
2682 for (vector
<line_info
>::iterator it
= src
->lines
.begin ();
2683 it
!= src
->lines
.end (); it
++)
2684 accumulate_line_info (&(*it
), src
, true);
2686 /* If not using intermediate mode, sum lines of group functions and
2687 add them to lines that live in a source file. */
2688 if (!flag_json_format
)
2689 for (vector
<function_info
*>::iterator it
= src
->functions
.begin ();
2690 it
!= src
->functions
.end (); it
++)
2692 function_info
*fn
= *it
;
2694 if (fn
->src
!= src
->index
|| !fn
->is_group
)
2697 for (unsigned i
= 0; i
< fn
->lines
.size (); i
++)
2699 line_info
*fn_line
= &fn
->lines
[i
];
2700 if (fn_line
->exists
)
2702 unsigned ln
= fn
->start_line
+ i
;
2703 line_info
*src_line
= &src
->lines
[ln
];
2705 if (!src_line
->exists
)
2706 src
->coverage
.lines
++;
2707 if (!src_line
->count
&& fn_line
->count
)
2708 src
->coverage
.lines_executed
++;
2710 src_line
->count
+= fn_line
->count
;
2711 src_line
->exists
= 1;
2713 if (fn_line
->has_unexecuted_block
)
2714 src_line
->has_unexecuted_block
= 1;
2716 if (fn_line
->unexceptional
)
2717 src_line
->unexceptional
= 1;
2723 /* Output information about ARC number IX. Returns nonzero if
2724 anything is output. */
2727 output_branch_count (FILE *gcov_file
, int ix
, const arc_info
*arc
)
2729 if (arc
->is_call_non_return
)
2731 if (arc
->src
->count
)
2733 fnotice (gcov_file
, "call %2d returned %s\n", ix
,
2734 format_gcov (arc
->src
->count
- arc
->count
,
2735 arc
->src
->count
, -flag_counts
));
2738 fnotice (gcov_file
, "call %2d never executed\n", ix
);
2740 else if (!arc
->is_unconditional
)
2742 if (arc
->src
->count
)
2743 fnotice (gcov_file
, "branch %2d taken %s%s", ix
,
2744 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
),
2745 arc
->fall_through
? " (fallthrough)"
2746 : arc
->is_throw
? " (throw)" : "");
2748 fnotice (gcov_file
, "branch %2d never executed", ix
);
2751 fnotice (gcov_file
, " (BB %d)", arc
->dst
->id
);
2753 fnotice (gcov_file
, "\n");
2755 else if (flag_unconditional
&& !arc
->dst
->is_call_return
)
2757 if (arc
->src
->count
)
2758 fnotice (gcov_file
, "unconditional %2d taken %s\n", ix
,
2759 format_gcov (arc
->count
, arc
->src
->count
, -flag_counts
));
2761 fnotice (gcov_file
, "unconditional %2d never executed\n", ix
);
2769 read_line (FILE *file
)
2771 static char *string
;
2772 static size_t string_len
;
2779 string
= XNEWVEC (char, string_len
);
2782 while ((ptr
= fgets (string
+ pos
, string_len
- pos
, file
)))
2784 size_t len
= strlen (string
+ pos
);
2786 if (len
&& string
[pos
+ len
- 1] == '\n')
2788 string
[pos
+ len
- 1] = 0;
2792 /* If the file contains NUL characters or an incomplete
2793 last line, which can happen more than once in one run,
2794 we have to avoid doubling the STRING_LEN unnecessarily. */
2795 if (pos
> string_len
/ 2)
2798 string
= XRESIZEVEC (char, string
, string_len
);
2802 return pos
? string
: NULL
;
2805 /* Pad string S with spaces from left to have total width equal to 9. */
2808 pad_count_string (string
&s
)
2811 s
.insert (0, 9 - s
.size (), ' ');
2814 /* Print GCOV line beginning to F stream. If EXISTS is set to true, the
2815 line exists in source file. UNEXCEPTIONAL indicated that it's not in
2816 an exceptional statement. The output is printed for LINE_NUM of given
2817 COUNT of executions. EXCEPTIONAL_STRING and UNEXCEPTIONAL_STRING are
2818 used to indicate non-executed blocks. */
2821 output_line_beginning (FILE *f
, bool exists
, bool unexceptional
,
2822 bool has_unexecuted_block
,
2823 gcov_type count
, unsigned line_num
,
2824 const char *exceptional_string
,
2825 const char *unexceptional_string
,
2826 unsigned int maximum_count
)
2833 s
= format_gcov (count
, 0, -1);
2834 if (has_unexecuted_block
2835 && bbg_supports_has_unexecuted_blocks
)
2837 if (flag_use_colors
)
2839 pad_count_string (s
);
2840 s
.insert (0, SGR_SEQ (COLOR_BG_MAGENTA
2841 COLOR_SEPARATOR COLOR_FG_WHITE
));
2847 pad_count_string (s
);
2851 if (flag_use_colors
)
2854 pad_count_string (s
);
2856 s
.insert (0, SGR_SEQ (COLOR_BG_RED
2857 COLOR_SEPARATOR COLOR_FG_WHITE
));
2859 s
.insert (0, SGR_SEQ (COLOR_BG_CYAN
2860 COLOR_SEPARATOR COLOR_FG_WHITE
));
2865 s
= unexceptional
? unexceptional_string
: exceptional_string
;
2866 pad_count_string (s
);
2873 pad_count_string (s
);
2876 /* Format line number in output. */
2878 sprintf (buffer
, "%5u", line_num
);
2879 string
linestr (buffer
);
2881 if (flag_use_hotness_colors
&& maximum_count
)
2883 if (count
* 2 > maximum_count
) /* > 50%. */
2884 linestr
.insert (0, SGR_SEQ (COLOR_BG_RED
));
2885 else if (count
* 5 > maximum_count
) /* > 20%. */
2886 linestr
.insert (0, SGR_SEQ (COLOR_BG_YELLOW
));
2887 else if (count
* 10 > maximum_count
) /* > 10%. */
2888 linestr
.insert (0, SGR_SEQ (COLOR_BG_GREEN
));
2889 linestr
+= SGR_RESET
;
2892 fprintf (f
, "%s:%s", s
.c_str (), linestr
.c_str ());
2896 print_source_line (FILE *f
, const vector
<const char *> &source_lines
,
2899 gcc_assert (line
>= 1);
2900 gcc_assert (line
<= source_lines
.size ());
2902 fprintf (f
, ":%s\n", source_lines
[line
- 1]);
2905 /* Output line details for LINE and print it to F file. LINE lives on
2909 output_line_details (FILE *f
, const line_info
*line
, unsigned line_num
)
2911 if (flag_all_blocks
)
2917 for (vector
<block_info
*>::const_iterator it
= line
->blocks
.begin ();
2918 it
!= line
->blocks
.end (); it
++)
2920 if (!(*it
)->is_call_return
)
2922 output_line_beginning (f
, line
->exists
,
2923 (*it
)->exceptional
, false,
2924 (*it
)->count
, line_num
,
2925 "%%%%%", "$$$$$", 0);
2926 fprintf (f
, "-block %2d", ix
++);
2928 fprintf (f
, " (BB %u)", (*it
)->id
);
2932 for (arc
= (*it
)->succ
; arc
; arc
= arc
->succ_next
)
2933 jx
+= output_branch_count (f
, jx
, arc
);
2936 else if (flag_branches
)
2941 for (vector
<arc_info
*>::const_iterator it
= line
->branches
.begin ();
2942 it
!= line
->branches
.end (); it
++)
2943 ix
+= output_branch_count (f
, ix
, (*it
));
2947 /* Output detail statistics about function FN to file F. */
2950 output_function_details (FILE *f
, function_info
*fn
)
2955 arc_info
*arc
= fn
->blocks
[EXIT_BLOCK
].pred
;
2956 gcov_type return_count
= fn
->blocks
[EXIT_BLOCK
].count
;
2957 gcov_type called_count
= fn
->blocks
[ENTRY_BLOCK
].count
;
2959 for (; arc
; arc
= arc
->pred_next
)
2961 return_count
-= arc
->count
;
2963 fprintf (f
, "function %s", fn
->get_name ());
2964 fprintf (f
, " called %s",
2965 format_gcov (called_count
, 0, -1));
2966 fprintf (f
, " returned %s",
2967 format_gcov (return_count
, called_count
, 0));
2968 fprintf (f
, " blocks executed %s",
2969 format_gcov (fn
->blocks_executed
, fn
->get_block_count (), 0));
2973 /* Read in the source file one line at a time, and output that line to
2974 the gcov file preceded by its execution count and other
2978 output_lines (FILE *gcov_file
, const source_info
*src
)
2980 #define DEFAULT_LINE_START " -: 0:"
2981 #define FN_SEPARATOR "------------------\n"
2986 /* Print colorization legend. */
2987 if (flag_use_colors
)
2988 fprintf (gcov_file
, "%s",
2989 DEFAULT_LINE_START
"Colorization: profile count: " \
2990 SGR_SEQ (COLOR_BG_CYAN
) "zero coverage (exceptional)" SGR_RESET \
2992 SGR_SEQ (COLOR_BG_RED
) "zero coverage (unexceptional)" SGR_RESET \
2994 SGR_SEQ (COLOR_BG_MAGENTA
) "unexecuted block" SGR_RESET
"\n");
2996 if (flag_use_hotness_colors
)
2997 fprintf (gcov_file
, "%s",
2998 DEFAULT_LINE_START
"Colorization: line numbers: hotness: " \
2999 SGR_SEQ (COLOR_BG_RED
) "> 50%" SGR_RESET
" " \
3000 SGR_SEQ (COLOR_BG_YELLOW
) "> 20%" SGR_RESET
" " \
3001 SGR_SEQ (COLOR_BG_GREEN
) "> 10%" SGR_RESET
"\n");
3003 fprintf (gcov_file
, DEFAULT_LINE_START
"Source:%s\n", src
->coverage
.name
);
3004 if (!multiple_files
)
3006 fprintf (gcov_file
, DEFAULT_LINE_START
"Graph:%s\n", bbg_file_name
);
3007 fprintf (gcov_file
, DEFAULT_LINE_START
"Data:%s\n",
3008 no_data_file
? "-" : da_file_name
);
3009 fprintf (gcov_file
, DEFAULT_LINE_START
"Runs:%u\n", object_runs
);
3012 source_file
= fopen (src
->name
, "r");
3014 fnotice (stderr
, "Cannot open source file %s\n", src
->name
);
3015 else if (src
->file_time
== 0)
3016 fprintf (gcov_file
, DEFAULT_LINE_START
"Source is newer than graph\n");
3018 vector
<const char *> source_lines
;
3020 while ((retval
= read_line (source_file
)) != NULL
)
3021 source_lines
.push_back (xstrdup (retval
));
3023 unsigned line_start_group
= 0;
3024 vector
<function_info
*> fns
;
3026 for (unsigned line_num
= 1; line_num
<= source_lines
.size (); line_num
++)
3028 if (line_num
>= src
->lines
.size ())
3030 fprintf (gcov_file
, "%9s:%5u", "-", line_num
);
3031 print_source_line (gcov_file
, source_lines
, line_num
);
3035 const line_info
*line
= &src
->lines
[line_num
];
3037 if (line_start_group
== 0)
3039 fns
= src
->get_functions_at_location (line_num
);
3040 if (fns
.size () > 1)
3042 /* It's possible to have functions that partially overlap,
3043 thus take the maximum end_line of functions starting
3045 for (unsigned i
= 0; i
< fns
.size (); i
++)
3046 if (fns
[i
]->end_line
> line_start_group
)
3047 line_start_group
= fns
[i
]->end_line
;
3049 else if (fns
.size () == 1)
3051 function_info
*fn
= fns
[0];
3052 output_function_details (gcov_file
, fn
);
3056 /* For lines which don't exist in the .bb file, print '-' before
3057 the source line. For lines which exist but were never
3058 executed, print '#####' or '=====' before the source line.
3059 Otherwise, print the execution count before the source line.
3060 There are 16 spaces of indentation added before the source
3061 line so that tabs won't be messed up. */
3062 output_line_beginning (gcov_file
, line
->exists
, line
->unexceptional
,
3063 line
->has_unexecuted_block
, line
->count
,
3064 line_num
, "=====", "#####", src
->maximum_count
);
3066 print_source_line (gcov_file
, source_lines
, line_num
);
3067 output_line_details (gcov_file
, line
, line_num
);
3069 if (line_start_group
== line_num
)
3071 for (vector
<function_info
*>::iterator it
= fns
.begin ();
3072 it
!= fns
.end (); it
++)
3074 function_info
*fn
= *it
;
3075 vector
<line_info
> &lines
= fn
->lines
;
3077 fprintf (gcov_file
, FN_SEPARATOR
);
3079 string fn_name
= fn
->get_name ();
3080 if (flag_use_colors
)
3082 fn_name
.insert (0, SGR_SEQ (COLOR_FG_CYAN
));
3083 fn_name
+= SGR_RESET
;
3086 fprintf (gcov_file
, "%s:\n", fn_name
.c_str ());
3088 output_function_details (gcov_file
, fn
);
3090 /* Print all lines covered by the function. */
3091 for (unsigned i
= 0; i
< lines
.size (); i
++)
3093 line_info
*line
= &lines
[i
];
3094 unsigned l
= fn
->start_line
+ i
;
3096 /* For lines which don't exist in the .bb file, print '-'
3097 before the source line. For lines which exist but
3098 were never executed, print '#####' or '=====' before
3099 the source line. Otherwise, print the execution count
3100 before the source line.
3101 There are 16 spaces of indentation added before the source
3102 line so that tabs won't be messed up. */
3103 output_line_beginning (gcov_file
, line
->exists
,
3104 line
->unexceptional
,
3105 line
->has_unexecuted_block
,
3107 l
, "=====", "#####",
3108 src
->maximum_count
);
3110 print_source_line (gcov_file
, source_lines
, l
);
3111 output_line_details (gcov_file
, line
, l
);
3115 fprintf (gcov_file
, FN_SEPARATOR
);
3116 line_start_group
= 0;
3121 fclose (source_file
);