Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
Copyright Info
Terms of Use
Privacy Info
Masthead / Impressum
Your Account

Private Messages

News Archive
Submit News
User Articles
Web Links


The Web

Who's Online
There are currently, 71 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here




       gcov [-v|--version] [-h|--help]
            [-o|--object-directory directory|file] sourcefile


       gcov is a test coverage program.  Use it in concert with
       GCC to analyze your programs to help create more effi­
       cient, 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:

       ·   how often each line of code executes

       ·   what lines of code are actually executed

       ·   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 pro­
       gram 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.  Like­
       wise, because gcov accumulates statistics by line (at the
       lowest resolution), it works best with a programming style
       that places only one statement on each line.  If you use
       patible with any other profiling or test coverage mecha­


           Display help about using gcov (on the standard out­
           put), and exit without doing any further processing.

           Display the gcov version number (on the standard out­
           put), and exit without doing any further processing.

           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.

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

           Do not create the gcov output file.

           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
           if x.h is included in multiple source files.

           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.

           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

       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 gen­
       erating 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 gener­
       ated.  For each source file compiled with -fprofile-arcs,
       an accompanying .da file will be placed in the object file

       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.

                       -:    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:

               $ 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
       executed'' is printed.

       For a call, if it was executed at least once, then a per­
       centage 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 pro­
       gram 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 -fpro­
       file-arcs, the profiling code first attempts to read in an
       existing .da file; if the file doesn't match the exe­
       cutable (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 exam­
       ple, code like this:

               if (a != b)
                 c = 1;
                 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 sepa­
       rate 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;


       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 Documenta­
       tion License, Version 1.2 or any later version published
       by the Free Software Foundation; with the Invariant Sec­
       tions 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.

gcc-3.3.1                   2003-08-04                    GCOV(1)
Show your Support for the Linux Tutorial

Purchase one of the products from our new online shop. For each product you purchase, the Linux Tutorial gets a portion of the proceeds to help keep us going.



Security Code
Security Code
Type Security Code

Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!

Amazon Wish List

Did You Know?
The Linux Tutorial welcomes your suggestions and ideas.


Tell a Friend About Us

Bookmark and Share

Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.10 Seconds