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 <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  function_start
struct  function_start_pair_hash


#define IN_GCOV   1
#define ENTRY_BLOCK   (0)
#define EXIT_BLOCK   (1)
#define DEFAULT_LINE_START   " -: 0:"
#define FN_SEPARATOR   "------------------\n"


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


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 charcanonicalize_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 charformat_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 charmangle_name (const char *)
static void release_structures (void)
int main (int, char **)
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 constformat_count (gcov_type count)
static void accumulate_line_info (line_info *line, source_info *src, bool add_coverage)
static const charread_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)


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 unsigned object_runs
static unsigned total_lines
static unsigned total_executed
static time_t bbg_file_time
static charbbg_file_name
static unsigned bbg_stamp
static unsigned bbg_supports_has_unexecuted_blocks
static const charbbg_cwd
static charda_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 charobject_directory = 0
static charsource_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 const struct option options []

Macro Definition Documentation


#define DEFAULT_LINE_START   " -: 0:"


#define ENTRY_BLOCK   (0)


#define EXIT_BLOCK   (1)


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



Referenced by generate_results(), and print_version().


#define IN_GCOV   1


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
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
??? 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.   









Typedef Documentation

◆ 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

Function Documentation

◆ accumulate_line_counts()

◆ accumulate_line_info()

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

◆ add_branch_counts()

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

◆ add_condition_counts()

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

◆ add_line_counts()

◆ canonicalize_name()

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

References ggc_alloc().

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 )
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, ggc_alloc(), handle_cycle(), 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)
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, ggc_alloc(), NULL, object_directory, and S_ISDIR.

Referenced by process_file().

◆ executed_summary()

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

References fnotice(), format_gcov(), and ggc_alloc().

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

◆ file_summary()

◆ find_exception_blocks()

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

References function_info::blocks, ggc_alloc(), queue, and block_info::succ.

Referenced by process_all_functions().

◆ find_source()

static unsigned find_source ( const char * file_name)

◆ format_count()

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

References count, flag_human_readable_numbers, ggc_alloc(), i, PRId64, and r.

Referenced by format_gcov().

◆ format_gcov()

static char const * format_gcov ( gcov_type top,
gcov_type bottom,
int decimal_places )
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(), and ggc_alloc().

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)

◆ generate_results()

◆ get_cycles_count()

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

References circuit(), count, ggc_alloc(), and path.

Referenced by accumulate_line_info().

◆ get_gcov_intermediate_filename()

static string get_gcov_intermediate_filename ( const char * input_file_name)
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.

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(), ggc_alloc(), mangle_path(), and strip_extention().

Referenced by generate_results().

◆ get_md5sum()

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

References b, ggc_alloc(), 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 )
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, ggc_alloc(), 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 )
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(), ggc_alloc(), and mangle_name().

Referenced by output_gcov_file().

◆ mangle_name()

static char * mangle_name ( char const * base)
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, ggc_alloc(), 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 )
Output information about ARC number IX.  Returns nonzero if
anything is output.   

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

Referenced by output_line_details().

◆ output_conditions()

static void output_conditions ( FILE * gcov_file,
const block_info * binfo )
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 condition_info::falsev, fnotice(), ggc_alloc(), 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 )

◆ output_gcov_file()

◆ output_intermediate_json_line()

◆ output_json_intermediate_file()

static void output_json_intermediate_file ( json::array * json_files,
source_info * src )
Output the result in JSON intermediate format.
Source info SRC is dumped into JSON_FILES which is JSON array.   

References source_info::functions, functions, source_info::get_functions_at_location(), ggc_alloc(), i, source_info::lines, source_info::name, NULL, output_intermediate_json_line(), json::object::set(), and json::object::set_string().

Referenced by generate_results().

◆ 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 )
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
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(), ggc_alloc(), 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 )
Output line details for LINE and print it to F file.  LINE lives on

References line_info::blocks, line_info::branches, line_info::exists, flag_all_blocks, flag_branches, flag_conditions, flag_verbose, ggc_alloc(), 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)
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)
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 )

References gcc_assert, and ggc_alloc().

Referenced by output_lines().

◆ print_usage()

static void print_usage ( int error_p)
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(), ggc_alloc(), and SUCCESS_EXIT_CODE.

◆ print_version()

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

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

Referenced by process_args().

◆ process_all_functions()

◆ process_args()

◆ process_file()

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

References create_file_names(), da_file_name, fnotice(), ggc_alloc(), 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)

References ggc_alloc(), and NULL.

Referenced by output_lines().

◆ release_structures()

static void release_structures ( void )
Release all memory used.   

References functions, ggc_alloc(), ident_to_fn, names, and sources.

Referenced by main().

◆ solve_flow_graph()

static void solve_flow_graph ( function_info * fn)

◆ strip_extention()

static string strip_extention ( string str)
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 )
Unblock a block U from BLOCKED.  Apart from that, iterate all blocks
blocked by U in BLOCK_LISTS.   

References find(), ggc_alloc(), and unblock().

Referenced by circuit(), and unblock().

Variable Documentation

◆ bbg_cwd

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

Referenced by generate_results(), and read_graph_file().

◆ bbg_file_name

char* bbg_file_name
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
Modification time of graph file.   

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

◆ bbg_stamp

unsigned bbg_stamp
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
Supports has_unexecuted_blocks functionality.   

Referenced by output_line_beginning(), and read_graph_file().

◆ da_file_name

char* da_file_name
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().

◆ flag_all_blocks

int flag_all_blocks = 0
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

◆ flag_conditions

bool flag_conditions = 0
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
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
Print debugging dumps.   

Referenced by generate_results(), and process_args().

◆ flag_demangled_names

int flag_demangled_names = 0
Output demangled function names.   

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

◆ flag_display_progress

int flag_display_progress = 0
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_function_summary

int flag_function_summary = 0
Output summary info for each function.   

Referenced by generate_results(), and process_args().

◆ flag_gcov_file

int flag_gcov_file = 1
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
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
Output human readable numbers.   

Referenced by format_count(), and process_args().

◆ flag_json_format

int flag_json_format = 0
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
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
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
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
Show unconditional branches too.   

Referenced by output_branch_count(), and process_args().

◆ flag_use_colors

int flag_use_colors = 0
Print colored output.   

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

◆ flag_use_hotness_colors

int flag_use_hotness_colors = 0
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
Output to stdout instead to a gcov file.   

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

◆ flag_verbose

int flag_verbose = 0
Print verbose informations.   

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

◆ functions

◆ ident_to_fn

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

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

◆ multiple_files

int multiple_files = 0
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
Data file is missing.   

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

◆ object_directory

char* object_directory = 0
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
This holds data summary information.   

Referenced by output_lines(), and read_count_file().

◆ options

const struct option options[]
Initial value:
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "verbose", no_argument, NULL, 'w' },
{ "all-blocks", no_argument, NULL, 'a' },
{ "branch-probabilities", no_argument, NULL, 'b' },
{ "branch-counts", no_argument, NULL, 'c' },
{ "conditions", no_argument, NULL, 'g' },
{ "json-format", no_argument, NULL, 'j' },
{ "human-readable", no_argument, NULL, 'H' },
{ "no-output", no_argument, NULL, 'n' },
{ "long-file-names", no_argument, NULL, 'l' },
{ "function-summaries", no_argument, NULL, 'f' },
{ "demangled-names", no_argument, NULL, 'm' },
{ "preserve-paths", no_argument, NULL, 'p' },
{ "relative-only", no_argument, NULL, 'r' },
{ "object-directory", required_argument, NULL, 'o' },
{ "object-file", required_argument, NULL, 'o' },
{ "source-prefix", required_argument, NULL, 's' },
{ "stdout", no_argument, NULL, 't' },
{ "unconditional-branches", no_argument, NULL, 'u' },
{ "display-progress", no_argument, NULL, 'd' },
{ "hash-filenames", no_argument, NULL, 'x' },
{ "use-colors", no_argument, NULL, 'k' },
{ "use-hotness-colors", no_argument, NULL, 'q' },
{ "debug", no_argument, NULL, 'D' },
{ 0, 0, 0, 0 }
Definition ggc.h:184
#define NULL
Definition system.h:50

◆ processed_files

vector<char *> processed_files
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
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

Referenced by find_source(), and process_args().

◆ source_prefix

char* source_prefix = 0
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

Referenced by generate_results(), and main().

◆ total_lines

unsigned total_lines

Referenced by generate_results(), and main().