GCC Middle and Back End API Reference
gcov.cc File Reference
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "intl.h"
#include "diagnostic.h"
#include "version.h"
#include "demangle.h"
#include "color-macros.h"
#include "pretty-print.h"
#include "json.h"
#include "hwint.h"
#include "xregex.h"
#include <zlib.h>
#include <getopt.h>
#include "md5.h"
#include "gcov-io.h"
#include "gcov-io.cc"
Include dependency graph for gcov.cc:

Data Structures

struct  arc_info
 
class  block_location_info
 
struct  condition_info
 
class  block_info
 
class  line_info
 
class  function_info
 
struct  function_line_start_cmp
 
struct  coverage_info
 
class  source_info
 
class  name_map
 
struct  fnfilter
 
struct  function_start
 
struct  function_start_pair_hash
 

Macros

#define INCLUDE_ALGORITHM
 
#define INCLUDE_VECTOR
 
#define INCLUDE_STRING
 
#define INCLUDE_MAP
 
#define INCLUDE_SET
 
#define IN_GCOV   1
 
#define GCOV_JSON_FORMAT_VERSION   "2"
 
#define ENTRY_BLOCK   (0)
 
#define EXIT_BLOCK   (1)
 
#define DEFAULT_LINE_START   " -: 0:"
 
#define FN_SEPARATOR   "------------------\n"
 

Typedefs

typedef vector< arc_info * > arc_vector_t
 
typedef vector< const block_info * > block_vector_t
 

Functions

static int process_args (int, char **)
 
static void print_usage (int) ATTRIBUTE_NORETURN
 
static void print_version (void) ATTRIBUTE_NORETURN
 
static void process_file (const char *)
 
static void process_all_functions (void)
 
static void generate_results (const char *)
 
static void create_file_names (const char *)
 
static char * canonicalize_name (const char *)
 
static unsigned find_source (const char *)
 
static void read_graph_file (void)
 
static int read_count_file (void)
 
static void solve_flow_graph (function_info *)
 
static void find_exception_blocks (function_info *)
 
static void add_branch_counts (coverage_info *, const arc_info *)
 
static void add_condition_counts (coverage_info *, const block_info *)
 
static void add_line_counts (coverage_info *, function_info *)
 
static void executed_summary (unsigned, unsigned)
 
static void function_summary (const coverage_info *)
 
static void file_summary (const coverage_info *)
 
static const char * format_gcov (gcov_type, gcov_type, int)
 
static void accumulate_line_counts (source_info *)
 
static void output_gcov_file (const char *, source_info *)
 
static int output_branch_count (FILE *, int, const arc_info *)
 
static void output_conditions (FILE *, const block_info *)
 
static void output_lines (FILE *, const source_info *)
 
static string make_gcov_file_name (const char *, const char *)
 
static char * mangle_name (const char *)
 
static void release_structures (void)
 
int main (int, char **)
 
static const vector< const char * > & slurp (const source_info &src, FILE *gcov_file, const char *line_start)
 
static void handle_cycle (const arc_vector_t &edges, int64_t &count)
 
static void unblock (const block_info *u, block_vector_t &blocked, vector< block_vector_t > &block_lists)
 
static bool path_contains_zero_or_negative_cycle_arc (arc_vector_t &path)
 
static bool circuit (block_info *v, arc_vector_t &path, block_info *start, block_vector_t &blocked, vector< block_vector_t > &block_lists, line_info &linfo, int64_t &count)
 
static gcov_type get_cycles_count (line_info &linfo)
 
static void output_intermediate_json_line (json::array *object, line_info *line, unsigned line_num, const char *function_name)
 
static string strip_extention (string str)
 
static string get_md5sum (const char *input)
 
static string get_gcov_intermediate_filename (const char *input_file_name)
 
static void output_json_intermediate_file (json::array *json_files, source_info *src)
 
static char const * format_count (gcov_type count)
 
static void accumulate_line_info (line_info *line, source_info *src, bool add_coverage)
 
static const char * read_line (FILE *file)
 
static void pad_count_string (string &s)
 
static void output_line_beginning (FILE *f, bool exists, bool unexceptional, bool has_unexecuted_block, gcov_type count, unsigned line_num, const char *exceptional_string, const char *unexceptional_string, unsigned int maximum_count)
 
static void print_source_line (FILE *f, const vector< const char * > &source_lines, unsigned line)
 
static void output_line_details (FILE *f, const line_info *line, unsigned line_num)
 
static void output_function_details (FILE *f, function_info *fn)
 

Variables

static int flag_demangled_names = 0
 
static vector< function_info * > functions
 
static map< unsigned, function_info * > ident_to_fn
 
static vector< source_infosources
 
static vector< name_mapnames
 
static vector< char * > processed_files
 
static vector< vector< const char * > * > source_lines
 
static unsigned object_runs
 
static unsigned total_lines
 
static unsigned total_executed
 
static time_t bbg_file_time
 
static char * bbg_file_name
 
static unsigned bbg_stamp
 
static unsigned bbg_supports_has_unexecuted_blocks
 
static const char * bbg_cwd
 
static char * da_file_name
 
static int no_data_file
 
static int multiple_files = 0
 
static int flag_branches = 0
 
static bool flag_conditions = 0
 
static int flag_unconditional = 0
 
static int flag_gcov_file = 1
 
static int flag_use_stdout = 0
 
static int flag_display_progress = 0
 
static int flag_json_format = 0
 
static int flag_long_names = 0
 
static int flag_hash_filenames = 0
 
static int flag_verbose = 0
 
static int flag_use_colors = 0
 
static int flag_use_hotness_colors = 0
 
static int flag_all_blocks = 0
 
static int flag_human_readable_numbers = 0
 
static int flag_function_summary = 0
 
static int flag_debug = 0
 
static char * object_directory = 0
 
static char * source_prefix = 0
 
static size_t source_length = 0
 
static int flag_relative_only = 0
 
static int flag_preserve_paths = 0
 
static int flag_counts = 0
 
static int return_code = 0
 
static bool default_keep = true
 
static bool flag_filter_on_demangled = false
 
static vector< fnfilterfilters
 
static const struct option options []
 

Macro Definition Documentation

◆ DEFAULT_LINE_START

#define DEFAULT_LINE_START   " -: 0:"

Referenced by output_lines().

◆ ENTRY_BLOCK

#define ENTRY_BLOCK   (0)

◆ EXIT_BLOCK

#define EXIT_BLOCK   (1)

◆ FN_SEPARATOR

#define FN_SEPARATOR   "------------------\n"

Referenced by output_lines().

◆ GCOV_JSON_FORMAT_VERSION

#define GCOV_JSON_FORMAT_VERSION   "2"

Referenced by generate_results(), and print_version().

◆ IN_GCOV

#define IN_GCOV   1

◆ INCLUDE_ALGORITHM

#define INCLUDE_ALGORITHM
Gcov.c: prepend line execution counts and branch probabilities to a
   source file.
   Copyright (C) 1990-2024 Free Software Foundation, Inc.
   Contributed by James E. Wilson of Cygnus Support.
   Mangled by Bob Manson of Cygnus Support.
   Mangled further by Nathan Sidwell <nathan@codesourcery.com>

Gcov is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.

Gcov is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with Gcov; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.   
??? Print a list of the ten blocks with the highest execution counts,
and list the line numbers corresponding to those blocks.  Also, perhaps
list the line numbers with the highest execution counts, only printing
the first if there are several which are all listed in the same block.   
??? Should have an option to print the number of basic blocks, and the
percent of them that are covered.   
Need an option to show individual block counts, and show
probabilities of fall through arcs.   

◆ INCLUDE_MAP

#define INCLUDE_MAP

◆ INCLUDE_SET

#define INCLUDE_SET

◆ INCLUDE_STRING

#define INCLUDE_STRING

◆ INCLUDE_VECTOR

#define INCLUDE_VECTOR

Typedef Documentation

◆ arc_vector_t

typedef vector<arc_info *> arc_vector_t
Cycle detection!
There are a bajillion algorithms that do this.  Boost's function is named
hawick_cycles, so I used the algorithm by K. A. Hawick and H. A. James in
"Enumerating Circuits and Loops in Graphs with Self-Arcs and Multiple-Arcs"
(url at <http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf>).

The basic algorithm is simple: effectively, we're finding all simple paths
in a subgraph (that shrinks every iteration).  Duplicates are filtered by
"blocking" a path when a node is added to the path (this also prevents non-
simple paths)--the node is unblocked only when it participates in a cycle.

◆ block_vector_t

typedef vector<const block_info *> block_vector_t

Function Documentation

◆ accumulate_line_counts()

◆ accumulate_line_info()

static void accumulate_line_info ( line_info * line,
source_info * src,
bool add_coverage )
static

◆ add_branch_counts()

static void add_branch_counts ( coverage_info * coverage,
const arc_info * arc )
static

◆ add_condition_counts()

static void add_condition_counts ( coverage_info * coverage,
const block_info * block )
static

◆ add_line_counts()

◆ canonicalize_name()

static char * canonicalize_name ( const char * name)
static
Canonicalize the filename NAME by canonicalizing directory
separators, eliding . components and resolving .. components
appropriately.  Always returns a unique string.   

Referenced by find_source(), and generate_results().

◆ circuit()

static bool circuit ( block_info * v,
arc_vector_t & path,
block_info * start,
block_vector_t & blocked,
vector< block_vector_t > & block_lists,
line_info & linfo,
int64_t & count )
static
Find circuit going to block V, PATH is provisional seen cycle.
BLOCKED is vector of blocked vertices, BLOCK_LISTS contains vertices
blocked by a block.  COUNT is accumulated count of the current LINE.
Returns what type of loop it contains.   

References circuit(), count, find(), gcc_assert, handle_cycle(), line_info::has_block(), path_contains_zero_or_negative_cycle_arc(), block_info::succ, and unblock().

Referenced by circuit(), and get_cycles_count().

◆ create_file_names()

static void create_file_names ( const char * file_name)
static
Generate the names of the graph and data files.  If OBJECT_DIRECTORY
is not specified, these are named from FILE_NAME sans extension.  If
OBJECT_DIRECTORY is specified and is a directory, the files are in that
directory, but named from the basename of the FILE_NAME, sans extension.
Otherwise OBJECT_DIRECTORY is taken to be the name of the object *file*
and the data files are named from that.   

References bbg_file_name, bbg_file_time, bbg_stamp, CONST_CAST, da_file_name, free(), GCOV_DATA_SUFFIX, GCOV_NOTE_SUFFIX, NULL, object_directory, and S_ISDIR.

Referenced by process_file().

◆ executed_summary()

static void executed_summary ( unsigned lines,
unsigned executed )
static
Summary of execution  

References fnotice(), and format_gcov().

Referenced by file_summary(), function_summary(), and main().

◆ file_summary()

◆ find_exception_blocks()

static void find_exception_blocks ( function_info * fn)
static
Mark all the blocks only reachable via an incoming catch.   

References function_info::blocks, queue, and block_info::succ.

Referenced by process_all_functions().

◆ find_source()

static unsigned find_source ( const char * file_name)
static

◆ format_count()

static char const * format_count ( gcov_type count)
static
Format COUNT, if flag_human_readable_numbers is set, return it human
readable format.   

References count, flag_human_readable_numbers, i, PRId64, and r.

Referenced by format_gcov().

◆ format_gcov()

static char const * format_gcov ( gcov_type top,
gcov_type bottom,
int decimal_places )
static
Format a GCOV_TYPE integer as either a percent ratio, or absolute
count.  If DECIMAL_PLACES >= 0, format TOP/BOTTOM * 100 to DECIMAL_PLACES.
If DECIMAL_PLACES is zero, no decimal point is printed. Only print 100% when
TOP==BOTTOM and only print 0% when TOP=0.  If DECIMAL_PLACES < 0, then simply
format TOP.  Return pointer to a static string.   

References format_count().

Referenced by executed_summary(), file_summary(), output_branch_count(), output_function_details(), and output_line_beginning().

◆ function_summary()

static void function_summary ( const coverage_info * coverage)
static

◆ generate_results()

◆ get_cycles_count()

static gcov_type get_cycles_count ( line_info & linfo)
static
Find cycles for a LINFO.   

References line_info::blocks, circuit(), count, and path.

Referenced by accumulate_line_info().

◆ get_gcov_intermediate_filename()

static string get_gcov_intermediate_filename ( const char * input_file_name)
static
Get the name of the gcov file.  The return value must be free'd.

It appends the '.gcov' extension to the *basename* of the file.
The resulting file name will be in PWD.

e.g.,
input: foo.da,       output: foo.da.gcov
input: a/b/foo.cc,   output: foo.cc.gcov   

References flag_hash_filenames, flag_preserve_paths, get_md5sum(), mangle_path(), and strip_extention().

Referenced by generate_results().

◆ get_md5sum()

static string get_md5sum ( const char * input)
static
Calcualte md5sum for INPUT string and return it in hex string format.   

References b, and i.

Referenced by get_gcov_intermediate_filename(), and make_gcov_file_name().

◆ handle_cycle()

static void handle_cycle ( const arc_vector_t & edges,
int64_t & count )
static
Handle cycle identified by EDGES, where the function finds minimum cs_count
and subtract the value from all counts.  The subtracted value is added
to COUNT.  Returns type of loop.   

References count, gcc_assert, i, and INTTYPE_MAXIMUM.

Referenced by circuit().

◆ main()

◆ make_gcov_file_name()

static string make_gcov_file_name ( const char * input_name,
const char * src_name )
static
Generate an output file name. INPUT_NAME is the canonicalized main
input file and SRC_NAME is the canonicalized file name.
LONG_OUTPUT_NAMES and PRESERVE_PATHS affect name generation.  With
long_output_names we prepend the processed name of the input file
to each output name (except when the current source file is the
input file, so you don't get a double concatenation). The two
components are separated by '##'.  With preserve_paths we create a
filename from all path components of the source file, replacing '/'
with '#', and .. with '^', without it we simply take the basename
component.  (Remember, the canonicalized name will already have
elided '.' components and converted \\ separators.)   

References flag_hash_filenames, flag_long_names, get_md5sum(), and mangle_name().

Referenced by output_gcov_file().

◆ mangle_name()

static char * mangle_name ( char const * base)
static
Mangle BASE name, copy it at the beginning of PTR buffer and
return address of the \0 character of the buffer.   

References flag_preserve_paths, and mangle_path().

Referenced by make_gcov_file_name().

◆ output_branch_count()

static int output_branch_count ( FILE * gcov_file,
int ix,
const arc_info * arc )
static
Output information about ARC number IX.  Returns nonzero if
anything is output.   

References flag_counts, flag_unconditional, flag_verbose, fnotice(), and format_gcov().

Referenced by output_line_details().

◆ output_conditions()

static void output_conditions ( FILE * gcov_file,
const block_info * binfo )
static
Output information about the conditions in block BINFO.  The output includes
* a summary (n/m outcomes covered) and a list of the missing (uncovered)
* outcomes.   

References block_info::conditions, condition_info::falsev, fnotice(), i, condition_info::n_terms, condition_info::popcount(), and condition_info::truev.

Referenced by output_line_details().

◆ output_function_details()

static void output_function_details ( FILE * f,
function_info * fn )
static

◆ output_gcov_file()

static void output_gcov_file ( const char * file_name,
source_info * src )
static

◆ output_intermediate_json_line()

static void output_intermediate_json_line ( json::array * object,
line_info * line,
unsigned line_num,
const char * function_name )
static

◆ output_json_intermediate_file()

static void output_json_intermediate_file ( json::array * json_files,
source_info * src )
static

◆ output_line_beginning()

static void output_line_beginning ( FILE * f,
bool exists,
bool unexceptional,
bool has_unexecuted_block,
gcov_type count,
unsigned line_num,
const char * exceptional_string,
const char * unexceptional_string,
unsigned int maximum_count )
static
Print GCOV line beginning to F stream.  If EXISTS is set to true, the
line exists in source file.  UNEXCEPTIONAL indicated that it's not in
an exceptional statement.  The output is printed for LINE_NUM of given
COUNT of executions.  EXCEPTIONAL_STRING and UNEXCEPTIONAL_STRING are
used to indicate non-executed blocks.   

References bbg_supports_has_unexecuted_blocks, COLOR_BG_CYAN, COLOR_BG_GREEN, COLOR_BG_MAGENTA, COLOR_BG_RED, COLOR_BG_YELLOW, COLOR_FG_WHITE, COLOR_SEPARATOR, count, flag_use_colors, flag_use_hotness_colors, format_gcov(), pad_count_string(), SGR_RESET, and SGR_SEQ.

Referenced by output_line_details(), and output_lines().

◆ output_line_details()

static void output_line_details ( FILE * f,
const line_info * line,
unsigned line_num )
static
Output line details for LINE and print it to F file.  LINE lives on
LINE_NUM.   

References line_info::blocks, line_info::branches, line_info::exists, flag_all_blocks, flag_branches, flag_conditions, flag_verbose, output_branch_count(), output_conditions(), and output_line_beginning().

Referenced by output_lines().

◆ output_lines()

◆ pad_count_string()

static void pad_count_string ( string & s)
static
Pad string S with spaces from left to have total width equal to 9.   

Referenced by output_line_beginning().

◆ path_contains_zero_or_negative_cycle_arc()

static bool path_contains_zero_or_negative_cycle_arc ( arc_vector_t & path)
static
Return true when PATH contains a zero cycle arc count.   

References i.

Referenced by circuit().

◆ print_source_line()

static void print_source_line ( FILE * f,
const vector< const char * > & source_lines,
unsigned line )
static

References gcc_assert, and source_lines.

Referenced by output_lines().

◆ print_usage()

static void print_usage ( int error_p)
static
Print a usage message and exit.  If ERROR_P is nonzero, this is an error,
otherwise the output of --help.   

References FATAL_EXIT_CODE, fnotice(), and SUCCESS_EXIT_CODE.

◆ print_version()

static void print_version ( void )
static
Print version information and exit.   

References _, fnotice(), GCOV_JSON_FORMAT_VERSION, and SUCCESS_EXIT_CODE.

Referenced by process_args().

◆ process_all_functions()

◆ process_args()

◆ process_file()

static void process_file ( const char * file_name)
static
Process a single input file.   

References create_file_names(), da_file_name, fnotice(), i, processed_files, read_count_file(), and read_graph_file().

Referenced by main().

◆ read_count_file()

◆ read_graph_file()

◆ read_line()

static const char * read_line ( FILE * file)
static

References NULL.

Referenced by slurp().

◆ release_structures()

static void release_structures ( void )
static
Release all memory used.   

References filters, free(), functions, ident_to_fn, names, source_lines, and sources.

Referenced by main().

◆ slurp()

static const vector< const char * > & slurp ( const source_info & src,
FILE * gcov_file,
const char * line_start )
static
Get the vector with the contents SRC, possibly from a cache.  If
the reading fails, a message prefixed with LINE_START is written to
GCOV_FILE.   

References source_info::file_time, fnotice(), fopen, source_info::index, line_start(), source_info::name, read_line(), and source_lines.

Referenced by output_lines().

◆ solve_flow_graph()

◆ strip_extention()

static string strip_extention ( string str)
static
Strip filename extension in STR.   

Referenced by get_gcov_intermediate_filename().

◆ unblock()

static void unblock ( const block_info * u,
block_vector_t & blocked,
vector< block_vector_t > & block_lists )
static
Unblock a block U from BLOCKED.  Apart from that, iterate all blocks
blocked by U in BLOCK_LISTS.   

References find(), and unblock().

Referenced by circuit(), and unblock().

Variable Documentation

◆ bbg_cwd

const char* bbg_cwd
static
Working directory in which a TU was compiled.   

Referenced by generate_results(), and read_graph_file().

◆ bbg_file_name

char* bbg_file_name
static
Name of the notes (gcno) output file.  The "bbg" prefix is for
historical reasons, when the notes file contained only the
basic block graph notes.   

Referenced by add_line_counts(), create_file_names(), find_source(), output_lines(), read_graph_file(), and solve_flow_graph().

◆ bbg_file_time

time_t bbg_file_time
static
Modification time of graph file.   

Referenced by create_file_names(), find_source(), and read_graph_file().

◆ bbg_stamp

unsigned bbg_stamp
static
Stamp of the bbg file  

Referenced by create_file_names(), read_count_file(), and read_graph_file().

◆ bbg_supports_has_unexecuted_blocks

unsigned bbg_supports_has_unexecuted_blocks
static
Supports has_unexecuted_blocks functionality.   

Referenced by output_line_beginning(), and read_graph_file().

◆ da_file_name

char* da_file_name
static
Name and file pointer of the input file for the count data (gcda).   

Referenced by create_file_names(), output_lines(), process_file(), and read_count_file().

◆ default_keep

bool default_keep = true
static
"Keep policy" when adding functions to the global function table.  This will
be set to false when --include is used, otherwise every function should be
added to the table.  Used for --include/exclude.   

Referenced by process_args(), and read_graph_file().

◆ filters

vector<fnfilter> filters
static
A collection of filter functions for including/exclude functions in the
output.  This is empty unless --include/--exclude is used.   

Referenced by output_lines(), process_args(), process_register_constraint_filters(), read_graph_file(), and release_structures().

◆ flag_all_blocks

int flag_all_blocks = 0
static
Output count information for every basic block, not merely those
that contain line number information.   

Referenced by output_line_details(), and process_args().

◆ flag_branches

int flag_branches = 0
static

◆ flag_conditions

bool flag_conditions = 0
static
Output conditions (modified condition/decision coverage).   

Referenced by file_summary(), output_intermediate_json_line(), output_line_details(), and process_args().

◆ flag_counts

int flag_counts = 0
static
Output the number of times a branch was taken as opposed to the percentage
of times it was taken.   

Referenced by output_branch_count(), and process_args().

◆ flag_debug

int flag_debug = 0
static
Print debugging dumps.   

Referenced by generate_results(), and process_args().

◆ flag_demangled_names

int flag_demangled_names = 0
static
Output demangled function names.   

Referenced by function_info::get_name(), and process_args().

◆ flag_display_progress

int flag_display_progress = 0
static
Output progress indication if this is true.  This is off by default
and can be turned on by the -d option.   

Referenced by main(), and process_args().

◆ flag_filter_on_demangled

bool flag_filter_on_demangled = false
static
Include/exclude filters function based on matching the (de)mangled name.
The default is to match the mangled name.  Note that flag_demangled_names
does not affect this.   

Referenced by process_args(), and read_graph_file().

◆ flag_function_summary

int flag_function_summary = 0
static
Output summary info for each function.   

Referenced by generate_results(), and process_args().

◆ flag_gcov_file

int flag_gcov_file = 1
static
Output a gcov file if this is true.  This is on by default, and can
be turned off by the -n option.   

Referenced by generate_results(), and process_args().

◆ flag_hash_filenames

int flag_hash_filenames = 0
static
For situations when a long name can potentially hit filesystem path limit,
let's calculate md5sum of the path and append it to a file name.   

Referenced by get_gcov_intermediate_filename(), make_gcov_file_name(), and process_args().

◆ flag_human_readable_numbers

int flag_human_readable_numbers = 0
static
Output human readable numbers.   

Referenced by format_count(), and process_args().

◆ flag_json_format

int flag_json_format = 0
static
Output *.gcov file in JSON intermediate format used by consumers.   

Referenced by accumulate_line_counts(), generate_results(), main(), and process_args().

◆ flag_long_names

int flag_long_names = 0
static
For included files, make the gcov output file name include the name
of the input source file.  For example, if x.h is included in a.c,
then the output file name is a.c##x.h.gcov instead of x.h.gcov.   

Referenced by make_gcov_file_name(), and process_args().

◆ flag_preserve_paths

int flag_preserve_paths = 0
static
Preserve all pathname components. Needed when object files and
source files are in subdirectories. '/' is mangled as '#', '.' is
elided and '..' mangled to '^'.   

Referenced by get_gcov_intermediate_filename(), mangle_name(), and process_args().

◆ flag_relative_only

int flag_relative_only = 0
static
Only show data for sources with relative pathnames.  Absolute ones
usually indicate a system header file, which although it may
contain inline functions, is usually uninteresting.   

Referenced by generate_results(), and process_args().

◆ flag_unconditional

int flag_unconditional = 0
static
Show unconditional branches too.   

Referenced by output_branch_count(), and process_args().

◆ flag_use_colors

int flag_use_colors = 0
static
Print colored output.   

Referenced by output_line_beginning(), output_lines(), and process_args().

◆ flag_use_hotness_colors

int flag_use_hotness_colors = 0
static
Use perf-like colors to indicate hot lines.   

Referenced by output_line_beginning(), output_lines(), and process_args().

◆ flag_use_stdout

int flag_use_stdout = 0
static
Output to stdout instead to a gcov file.   

Referenced by generate_results(), main(), and process_args().

◆ flag_verbose

int flag_verbose = 0
static
Print verbose informations.   

Referenced by output_branch_count(), output_line_details(), and process_args().

◆ functions

vector<function_info *> functions
static

◆ ident_to_fn

map<unsigned, function_info *> ident_to_fn
static
Function ident to function_info * map.   

Referenced by read_count_file(), read_graph_file(), and release_structures().

◆ multiple_files

int multiple_files = 0
static
If there is several input files, compute and display results after
reading all data files.  This way if two or more gcda file refer to
the same source file (eg inline subprograms in a .h file), the
counts are added.   

Referenced by main(), and output_lines().

◆ names

◆ no_data_file

int no_data_file
static
Data file is missing.   

Referenced by output_lines(), process_all_functions(), and read_count_file().

◆ object_directory

char* object_directory = 0
static
Object directory file prefix.  This is the directory/file where the
graph and data files are looked for, if nonzero.   

Referenced by create_file_names(), and process_args().

◆ object_runs

unsigned object_runs
static
This holds data summary information.   

Referenced by output_lines(), and read_count_file().

◆ options

const struct option options[]
static

◆ processed_files

vector<char *> processed_files
static
Record all processed files in order to warn about
a file being read multiple times.   

Referenced by process_file().

◆ return_code

int return_code = 0
static
Return code of the tool invocation.   

Referenced by generate_results(), main(), output_gcov_file(), read_count_file(), and read_graph_file().

◆ source_length

size_t source_length = 0
static

Referenced by find_source(), and process_args().

◆ source_lines

vector<vector<const char *>*> source_lines
static
The contents of a source file.  The nth SOURCE_LINES entry is the
contents of the nth SOURCES, or empty if it has not or could not be
read.   

Referenced by output_lines(), print_source_line(), release_structures(), and slurp().

◆ source_prefix

char* source_prefix = 0
static
Source directory prefix.  This is removed from source pathnames
that match, when generating the output file name.   

Referenced by find_source(), and process_args().

◆ sources

◆ total_executed

unsigned total_executed
static

Referenced by generate_results(), and main().

◆ total_lines

unsigned total_lines
static

Referenced by generate_results(), and main().