


GCOV(1)                        GNU                        GCOV(1)


NAME
       gcov - coverage testing tool

SYNOPSIS
       gcov [-v|--version] [-h|--help]
            [-b|--branch-probabilities]
            [-c|--branch-counts]
            [-n|--no-output]
            [-l|--long-file-names]
            [-p|--preserve-paths]
            [-f|--function-summaries]
            [-o|--object-directory directory|file] sourcefile

DESCRIPTION
       gcov is a test coverage program.  Use it in concert with
       GCC to analyze your programs to help create more
       efficient, faster running code and to discover untested
       parts of your program.  You can use gcov as a profiling
       tool to help discover where your optimization efforts will
       best affect your code.  You can also use gcov along with
       the other profiling tool, gprof, to assess which parts of
       your code use the greatest amount of computing time.

       Profiling tools help you analyze your code's performance.
       Using a profiler such as gcov or gprof, you can find out
       some basic performance statistics, such as:

       o   how often each line of code executes

       o   what lines of code are actually executed

       o   how much computing time each section of code uses

       Once you know these things about how your code works when
       compiled, you can look at each module to see which modules
       should be optimized.  gcov helps you determine where to
       work on optimization.

       Software developers also use coverage testing in concert
       with testsuites, to make sure software is actually good
       enough for a release.  Testsuites can verify that a
       program works as expected; a coverage program tests to see
       how much of the program is exercised by the testsuite.
       Developers can then determine what kinds of test cases
       need to be added to the testsuites to create both better
       testing and a better final product.

       You should compile your code without optimization if you
       plan to use gcov because the optimization, by combining
       some lines of code into one function, may not give you as
       much information as you need to look for `hot spots' where
       the code is using a great deal of computer time.
       Likewise, because gcov accumulates statistics by line (at
       the lowest resolution), it works best with a programming



2004-05-31                  gcc-3.3.4                           1





GCOV(1)                        GNU                        GCOV(1)


       style that places only one statement on each line.  If you
       use complicated macros that expand to loops or to other
       control structures, the statistics are less helpful---they
       only report on the line where the macro call appears.  If
       your complex macros behave like functions, you can replace
       them with inline functions to solve this problem.

       gcov creates a logfile called sourcefile.gcov which
       indicates how many times each line of a source file
       sourcefile.c has executed.  You can use these logfiles
       along with gprof to aid in fine-tuning the performance of
       your programs.  gprof gives timing information you can use
       along with the information you get from gcov.

       gcov works only on code compiled with GCC.  It is not
       compatible with any other profiling or test coverage
       mechanism.

OPTIONS
       -h
       --help
           Display help about using gcov (on the standard
           output), and exit without doing any further
           processing.

       -v
       --version
           Display the gcov version number (on the standard
           output), and exit without doing any further
           processing.

       -b
       --branch-probabilities
           Write branch frequencies to the output file, and write
           branch summary info to the standard output.  This
           option allows you to see how often each branch in your
           program was taken.

       -c
       --branch-counts
           Write branch frequencies as the number of branches
           taken, rather than the percentage of branches taken.

       -n
       --no-output
           Do not create the gcov output file.

       -l
       --long-file-names
           Create long file names for included source files.  For
           example, if the header file x.h contains code, and was
           included in the file a.c, then running gcov on the
           file a.c will produce an output file called
           a.c##x.h.gcov instead of x.h.gcov.  This can be useful



2004-05-31                  gcc-3.3.4                           2





GCOV(1)                        GNU                        GCOV(1)


           if x.h is included in multiple source files.

       -p
       --preserve-paths
           Preserve complete path information in the names of
           generated .gcov files. Without this option, just the
           filename component is used. With this option, all
           directories are used, with '/' characters translated
           to '#' characters, '.' directory components removed
           and '..'  components renamed to '^'. This is useful if
           sourcefiles are in several different directories. It
           also affects the -l option.

       -f
       --function-summaries
           Output summaries for each function in addition to the
           file level summary.

       -o directory|file
       --object-directory directory
       --object-file file
           Specify either the directory containing the gcov data
           files, or the object path name. The .bb, .bbg, and .da
           data files are searched for using this option. If a
           directory is specified, the data files are in that
           directory and named after the source file name,
           without its extension. If a file is specified here,
           the data files are named after that file, without its
           extension. If this option is not supplied, it defaults
           to the current directory.

       gcov should be run with the current directory the same as
       that when you invoked the compiler. Otherwise it will not
       be able to locate the source files. gcov produces files
       called mangledname.gcov in the current directory. These
       contain the coverage information of the source file they
       correspond to.  One .gcov file is produced for each source
       file containing code, which was compiled to produce the
       data files. The .gcov files contain the ':' separated
       fields along with program source code. The format is

               <execution_count>:<line_number>:<source line text>

       Additional block information may succeed each line, when
       requested by command line option. The execution_count is -
       for lines containing no code and ##### for lines which
       were never executed. Some lines of information at the
       start have line_number of zero.

       When printing percentages, 0% and 100% are only printed
       when the values are exactly 0% and 100% respectively.
       Other values which would conventionally be rounded to 0%
       or 100% are instead printed as the nearest non-boundary
       value.



2004-05-31                  gcc-3.3.4                           3





GCOV(1)                        GNU                        GCOV(1)


       When using gcov, you must first compile your program with
       two special GCC options: -fprofile-arcs -ftest-coverage.
       This tells the compiler to generate additional information
       needed by gcov (basically a flow graph of the program) and
       also includes additional code in the object files for
       generating the extra profiling information needed by gcov.
       These additional files are placed in the directory where
       the object file is located.

       Running the program will cause profile output to be
       generated.  For each source file compiled with -fprofile-
       arcs, an accompanying .da file will be placed in the
       object file directory.

       Running gcov with your program's source file names as
       arguments will now produce a listing of the code along
       with frequency of execution for each line.  For example,
       if your program is called tmp.c, this is what you see when
       you use the basic gcov facility:

               $ gcc -fprofile-arcs -ftest-coverage tmp.c
               $ a.out
               $ gcov tmp.c
               90.00% of 10 source lines executed in file tmp.c
               Creating tmp.c.gcov.

       The file tmp.c.gcov contains output from gcov.  Here is a
       sample:

                       -:    0:Source:tmp.c
                       -:    0:Object:tmp.bb
                       -:    1:#include <stdio.h>
                       -:    2:
                       -:    3:int main (void)
                       1:    4:{
                       1:    5:  int i, total;
                       -:    6:
                       1:    7:  total = 0;
                       -:    8:
                      11:    9:  for (i = 0; i < 10; i++)
                      10:   10:    total += i;
                       -:   11:
                       1:   12:  if (total != 45)
                   #####:   13:    printf ("Failure\n");
                       -:   14:  else
                       1:   15:    printf ("Success\n");
                       1:   16:  return 0;
                       1:   17:}

       When you use the -b option, your output looks like this:







2004-05-31                  gcc-3.3.4                           4





GCOV(1)                        GNU                        GCOV(1)


               $ gcov -b tmp.c
               90.00% of 10 source lines executed in file tmp.c
               80.00% of 5 branches executed in file tmp.c
               80.00% of 5 branches taken at least once in file tmp.c
               50.00% of 2 calls executed in file tmp.c
               Creating tmp.c.gcov.

       Here is a sample of a resulting tmp.c.gcov file:

                       -:    0:Source:tmp.c
                       -:    0:Object:tmp.bb
                       -:    1:#include <stdio.h>
                       -:    2:
                       -:    3:int main (void)
                       1:    4:{
                       1:    5:  int i, total;
                       -:    6:
                       1:    7:  total = 0;
                       -:    8:
                      11:    9:  for (i = 0; i < 10; i++)
               branch  0: taken 90%
               branch  1: taken 100%
               branch  2: taken 100%
                      10:   10:    total += i;
                       -:   11:
                       1:   12:  if (total != 45)
               branch  0: taken 100%
                   #####:   13:    printf ("Failure\n");
               call    0: never executed
               branch  1: never executed
                       -:   14:  else
                       1:   15:    printf ("Success\n");
               call    0: returns 100%
                       1:   16:  return 0;
                       1:   17:}

       For each basic block, a line is printed after the last
       line of the basic block describing the branch or call that
       ends the basic block.  There can be multiple branches and
       calls listed for a single source line if there are
       multiple basic blocks that end on that line.  In this
       case, the branches and calls are each given a number.
       There is no simple way to map these branches and calls
       back to source constructs.  In general, though, the lowest
       numbered branch or call will correspond to the leftmost
       construct on the source line.

       For a branch, if it was executed at least once, then a
       percentage indicating the number of times the branch was
       taken divided by the number of times the branch was
       executed will be printed.  Otherwise, the message ``never
       executed'' is printed.

       For a call, if it was executed at least once, then a



2004-05-31                  gcc-3.3.4                           5





GCOV(1)                        GNU                        GCOV(1)


       percentage indicating the number of times the call
       returned divided by the number of times the call was
       executed will be printed.  This will usually be 100%, but
       may be less for functions call "exit" or "longjmp", and
       thus may not return every time they are called.

       The execution counts are cumulative.  If the example
       program were executed again without removing the .da file,
       the count for the number of times each line in the source
       was executed would be added to the results of the previous
       run(s).  This is potentially useful in several ways.  For
       example, it could be used to accumulate data over a number
       of program runs as part of a test verification suite, or
       to provide more accurate long-term information over a
       large number of program runs.

       The data in the .da files is saved immediately before the
       program exits.  For each source file compiled with
       -fprofile-arcs, the profiling code first attempts to read
       in an existing .da file; if the file doesn't match the
       executable (differing number of basic block counts) it
       will ignore the contents of the file.  It then adds in the
       new execution counts and finally writes the data to the
       file.

       Using gcov with GCC Optimization

       If you plan to use gcov to help optimize your code, you
       must first compile your program with two special GCC
       options: -fprofile-arcs -ftest-coverage.  Aside from that,
       you can use any other GCC options; but if you want to
       prove that every single line in your program was executed,
       you should not compile with optimization at the same time.
       On some machines the optimizer can eliminate some simple
       code lines by combining them with other lines.  For
       example, code like this:

               if (a != b)
                 c = 1;
               else
                 c = 0;

       can be compiled into one instruction on some machines.  In
       this case, there is no way for gcov to calculate separate
       execution counts for each line because there isn't
       separate code for each line.  Hence the gcov output looks
       like this if you compiled the program with optimization:

                     100:   12:if (a != b)
                     100:   13:  c = 1;
                     100:   14:else
                     100:   15:  c = 0;

       The output shows that this block of code, combined by



2004-05-31                  gcc-3.3.4                           6





GCOV(1)                        GNU                        GCOV(1)


       optimization, executed 100 times.  In one sense this
       result is correct, because there was only one instruction
       representing all four of these lines.  However, the output
       does not indicate how many times the result was 0 and how
       many times the result was 1.

SEE ALSO
       gpl(7), gfdl(7), fsf-funding(7), gcc(1) and the Info entry
       for gcc.

COPYRIGHT
       Copyright (c) 1996, 1997, 1999, 2000, 2001, 2002, 2003
       Free Software Foundation, Inc.

       Permission is granted to copy, distribute and/or modify
       this document under the terms of the GNU Free
       Documentation License, Version 1.2 or any later version
       published by the Free Software Foundation; with the
       Invariant Sections being ``GNU General Public License''
       and ``Funding Free Software'', the Front-Cover texts being
       (a) (see below), and with the Back-Cover Texts being (b)
       (see below).  A copy of the license is included in the
       gfdl(7) man page.

       (a) The FSF's Front-Cover Text is:

            A GNU Manual

       (b) The FSF's Back-Cover Text is:

            You have freedom to copy and modify this GNU Manual, like GNU
            software.  Copies published by the Free Software Foundation raise
            funds for GNU development.
























2004-05-31                  gcc-3.3.4                           7


