This is
/es/build/frv-050408/1/frv550-uclinux/X-tools-build/gcc/doc/gcc.info,
produced by makeinfo version 4.0 from
/es/build/frv-050408/1/frv550-uclinux/sources/tools-src/gcc/doc/gcc.texi.

START-INFO-DIR-ENTRY
* usegcc: (usegcc).			Using the GNU C compiler.
END-INFO-DIR-ENTRY

Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
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 section entitled "GNU Free Documentation License".

   (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.
INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gcc: (gcc).                  The GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the use of the GNU compilers.

   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA

File: gcc.info,  Node: What you can and what you cannot do in +load,  Prev: Executing code before main,  Up: Executing code before main

What you can and what you cannot do in `+load'
----------------------------------------------

   The `+load' implementation in the GNU runtime guarantees you the
following things:

   * you can write whatever C code you like;

   * you can send messages to Objective-C constant strings (`@"this is a
     constant string"');

   * you can allocate and send messages to objects whose class is
     implemented in the same file;

   * the `+load' implementation of all super classes of a class are
     executed before the `+load' of that class is executed;

   * the `+load' implementation of a class is executed before the
     `+load' implementation of any category.


   In particular, the following things, even if they can work in a
particular case, are not guaranteed:

   * allocation of or sending messages to arbitrary objects;

   * allocation of or sending messages to objects whose classes have a
     category implemented in the same file;


   You should make no assumptions about receiving `+load' in sibling
classes when you write `+load' of a class.  The order in which sibling
classes receive `+load' is not guaranteed.

   The order in which `+load' and `+initialize' are called could be
problematic if this matters.  If you don't allocate objects inside
`+load', it is guaranteed that `+load' is called before `+initialize'.
If you create an object inside `+load' the `+initialize' method of
object's class is invoked even if `+load' was not invoked.  Note if you
explicitly call `+load' on a class, `+initialize' will be called first.
To avoid possible problems try to implement only one of these methods.

   The `+load' method is also invoked when a bundle is dynamically
loaded into your running program.  This happens automatically without
any intervening operation from you.  When you write bundles and you
need to write `+load' you can safely create and send messages to
objects whose classes already exist in the running program.  The same
restrictions as above apply to classes defined in bundle.


File: gcc.info,  Node: Type encoding,  Next: Garbage Collection,  Prev: Executing code before main,  Up: Objective-C

Type encoding
=============

   The Objective-C compiler generates type encodings for all the types.
These type encodings are used at runtime to find out information about
selectors and methods and about objects and classes.

   The types are encoded in the following way:

`char'             `c'
`unsigned char'    `C'
`short'            `s'
`unsigned short'   `S'
`int'              `i'
`unsigned int'     `I'
`long'             `l'
`unsigned long'    `L'
`long long'        `q'
`unsigned long     `Q'
long'              
`float'            `f'
`double'           `d'
`void'             `v'
`id'               `@'
`Class'            `#'
`SEL'              `:'
`char*'            `*'
unknown type       `?'
bit-fields         `b' followed by the starting position of the
                   bit-field, the type of the bit-field and the size of
                   the bit-field (the bit-fields encoding was changed
                   from the NeXT's compiler encoding, see below)

   The encoding of bit-fields has changed to allow bit-fields to be
properly handled by the runtime functions that compute sizes and
alignments of types that contain bit-fields.  The previous encoding
contained only the size of the bit-field.  Using only this information
it is not possible to reliably compute the size occupied by the
bit-field.  This is very important in the presence of the Boehm's
garbage collector because the objects are allocated using the typed
memory facility available in this collector.  The typed memory
allocation requires information about where the pointers are located
inside the object.

   The position in the bit-field is the position, counting in bits, of
the bit closest to the beginning of the structure.

   The non-atomic types are encoded as follows:

pointers       `^' followed by the pointed type.
arrays         `[' followed by the number of elements in the array
               followed by the type of the elements followed by `]'
structures     `{' followed by the name of the structure (or `?' if the
               structure is unnamed), the `=' sign, the type of the
               members and by `}'
unions         `(' followed by the name of the structure (or `?' if the
               union is unnamed), the `=' sign, the type of the members
               followed by `)'

   Here are some types and their encodings, as they are generated by the
compiler on an i386 machine:


Objective-C type   Compiler encoding
     int a[10];    `[10i]'
     struct {      `{?=i[3f]b128i3b131i2c}'
       int i;      
       float f[3]; 
       int a:3;    
       int b:2;    
       char c;     
     }             


   In addition to the types the compiler also encodes the type
specifiers.  The table below describes the encoding of the current
Objective-C type specifiers:


Specifier          Encoding
`const'            `r'
`in'               `n'
`inout'            `N'
`out'              `o'
`bycopy'           `O'
`oneway'           `V'


   The type specifiers are encoded just before the type.  Unlike types
however, the type specifiers are only encoded when they appear in method
argument types.


File: gcc.info,  Node: Garbage Collection,  Next: Constant string objects,  Prev: Type encoding,  Up: Objective-C

Garbage Collection
==================

   Support for a new memory management policy has been added by using a
powerful conservative garbage collector, known as the
Boehm-Demers-Weiser conservative garbage collector.  It is available
from `http://www.hpl.hp.com/personal/Hans_Boehm/gc/'.

   To enable the support for it you have to configure the compiler
using an additional argument, `--enable-objc-gc'.  You need to have
garbage collector installed before building the compiler.  This will
build an additional runtime library which has several enhancements to
support the garbage collector.  The new library has a new name,
`libobjc_gc.a' to not conflict with the non-garbage-collected library.

   When the garbage collector is used, the objects are allocated using
the so-called typed memory allocation mechanism available in the
Boehm-Demers-Weiser collector.  This mode requires precise information
on where pointers are located inside objects.  This information is
computed once per class, immediately after the class has been
initialized.

   There is a new runtime function `class_ivar_set_gcinvisible()' which
can be used to declare a so-called "weak pointer" reference.  Such a
pointer is basically hidden for the garbage collector; this can be
useful in certain situations, especially when you want to keep track of
the allocated objects, yet allow them to be collected.  This kind of
pointers can only be members of objects, you cannot declare a global
pointer as a weak reference.  Every type which is a pointer type can be
declared a weak pointer, including `id', `Class' and `SEL'.

   Here is an example of how to use this feature.  Suppose you want to
implement a class whose instances hold a weak pointer reference; the
following class does this:


     @interface WeakPointer : Object
     {
         const void* weakPointer;
     }
     
     - initWithPointer:(const void*)p;
     - (const void*)weakPointer;
     @end
     
     
     @implementation WeakPointer
     
     + (void)initialize
     {
       class_ivar_set_gcinvisible (self, "weakPointer", YES);
     }
     
     - initWithPointer:(const void*)p
     {
       weakPointer = p;
       return self;
     }
     
     - (const void*)weakPointer
     {
       return weakPointer;
     }
     
     @end

   Weak pointers are supported through a new type character specifier
represented by the `!' character.  The `class_ivar_set_gcinvisible()'
function adds or removes this specifier to the string type description
of the instance variable named as argument.


File: gcc.info,  Node: Constant string objects,  Next: compatibility_alias,  Prev: Garbage Collection,  Up: Objective-C

Constant string objects
=======================

   GNU Objective-C provides constant string objects that are generated
directly by the compiler.  You declare a constant string object by
prefixing a C constant string with the character `@':

       id myString = @"this is a constant string object";

   The constant string objects are by default instances of the
`NXConstantString' class which is provided by the GNU Objective-C
runtime.  To get the definition of this class you must include the
`objc/NXConstStr.h' header file.

   User defined libraries may want to implement their own constant
string class.  To be able to support them, the GNU Objective-C compiler
provides a new command line options
`-fconstant-string-class=CLASS-NAME'.  The provided class should adhere
to a strict structure, the same as `NXConstantString''s structure:


     @interface MyConstantStringClass
     {
       Class isa;
       char *c_string;
       unsigned int len;
     }
     @end

   `NXConstantString' inherits from `Object'; user class libraries may
choose to inherit the customized constant string class from a different
class than `Object'.  There is no requirement in the methods the
constant string class has to implement, but the final ivar layout of
the class must be the compatible with the given structure.

   When the compiler creates the statically allocated constant string
object, the `c_string' field will be filled by the compiler with the
string; the `length' field will be filled by the compiler with the
string length; the `isa' pointer will be filled with `NULL' by the
compiler, and it will later be fixed up automatically at runtime by the
GNU Objective-C runtime library to point to the class which was set by
the `-fconstant-string-class' option when the object file is loaded (if
you wonder how it works behind the scenes, the name of the class to
use, and the list of static objects to fixup, are stored by the
compiler in the object file in a place where the GNU runtime library
will find them at runtime).

   As a result, when a file is compiled with the
`-fconstant-string-class' option, all the constant string objects will
be instances of the class specified as argument to this option.  It is
possible to have multiple compilation units referring to different
constant string classes, neither the compiler nor the linker impose any
restrictions in doing this.


File: gcc.info,  Node: compatibility_alias,  Prev: Constant string objects,  Up: Objective-C

compatibility_alias
===================

   This is a feature of the Objective-C compiler rather than of the
runtime, anyway since it is documented nowhere and its existence was
forgotten, we are documenting it here.

   The keyword `@compatibility_alias' allows you to define a class name
as equivalent to another class name.  For example:

     @compatibility_alias WOApplication GSWApplication;

   tells the compiler that each time it encounters `WOApplication' as a
class name, it should replace it with `GSWApplication' (that is,
`WOApplication' is just an alias for `GSWApplication').

   There are some constraints on how this can be used--

   * `WOApplication' (the alias) must not be an existing class;

   * `GSWApplication' (the real class) must be an existing class.



File: gcc.info,  Node: Compatibility,  Next: Gcov,  Prev: Objective-C,  Up: Top

Binary Compatibility
********************

   Binary compatibility encompasses several related concepts:

"application binary interface (ABI)"
     The set of runtime conventions followed by all of the tools that
     deal with binary representations of a program, including
     compilers, assemblers, linkers, and language runtime support.
     Some ABIs are formal with a written specification, possibly
     designed by multiple interested parties.  Others are simply the
     way things are actually done by a particular set of tools.

"ABI conformance"
     A compiler conforms to an ABI if it generates code that follows
     all of the specifications enumerated by that ABI.  A library
     conforms to an ABI if it is implemented according to that ABI.  An
     application conforms to an ABI if it is built using tools that
     conform to that ABI and does not contain source code that
     specifically changes behavior specified by the ABI.

"calling conventions"
     Calling conventions are a subset of an ABI that specify of how
     arguments are passed and function results are returned.

"interoperability"
     Different sets of tools are interoperable if they generate files
     that can be used in the same program.  The set of tools includes
     compilers, assemblers, linkers, libraries, header files, startup
     files, and debuggers.  Binaries produced by different sets of
     tools are not interoperable unless they implement the same ABI.
     This applies to different versions of the same tools as well as
     tools from different vendors.

"intercallability"
     Whether a function in a binary built by one set of tools can call a
     function in a binary built by a different set of tools is a subset
     of interoperability.

"implementation-defined features"
     Language standards include lists of implementation-defined
     features whose behavior can vary from one implementation to
     another.  Some of these features are normally covered by a
     platform's ABI and others are not.  The features that are not
     covered by an ABI generally affect how a program behaves, but not
     intercallability.

"compatibility"
     Conformance to the same ABI and the same behavior of
     implementation-defined features are both relevant for
     compatibility.

   The application binary interface implemented by a C or C++ compiler
affects code generation and runtime support for:

   * size and alignment of data types

   * layout of structured types

   * calling conventions

   * register usage conventions

   * interfaces for runtime arithmetic support

   * object file formats

   In addition, the application binary interface implemented by a C++
compiler affects code generation and runtime support for:
   * name mangling

   * exception handling

   * invoking constructors and destructors

   * layout, alignment, and padding of classes

   * layout and alignment of virtual tables

   Some GCC compilation options cause the compiler to generate code that
does not conform to the platform's default ABI.  Other options cause
different program behavior for implementation-defined features that are
not covered by an ABI.  These options are provided for consistency with
other compilers that do not follow the platform's default ABI or the
usual behavior of implementation-defined features for the platform.  Be
very careful about using such options.

   Most platforms have a well-defined ABI that covers C code, but ABIs
that cover C++ functionality are not yet common.

   Starting with GCC 3.2, GCC binary conventions for C++ are based on a
written, vendor-neutral C++ ABI that was designed to be specific to
64-bit Itanium but also includes generic specifications that apply to
any platform.  This C++ ABI is also implemented by other compiler
vendors on some platforms, notably GNU/Linux and BSD systems.  We have
tried hard to provide a stable ABI that will be compatible with future
GCC releases, but it is possible that we will encounter problems that
make this difficult.  Such problems could include different
interpretations of the C++ ABI by different vendors, bugs in the ABI, or
bugs in the implementation of the ABI in different compilers.  GCC's
`-Wabi' switch warns when G++ generates code that is probably not
compatible with the C++ ABI.

   The C++ library used with a C++ compiler includes the Standard C++
Library, with functionality defined in the C++ Standard, plus language
runtime support.  The runtime support is included in a C++ ABI, but
there is no formal ABI for the Standard C++ Library.  Two
implementations of that library are interoperable if one follows the
de-facto ABI of the other and if they are both built with the same
compiler, or with compilers that conform to the same ABI for C++
compiler and runtime support.

   When G++ and another C++ compiler conform to the same C++ ABI, but
the implementations of the Standard C++ Library that they normally use
do not follow the same ABI for the Standard C++ Library, object files
built with those compilers can be used in the same program only if they
use the same C++ library.  This requires specifying the location of the
C++ library header files when invoking the compiler whose usual library
is not being used.  The location of GCC's C++ header files depends on
how the GCC build was configured, but can be seen by using the G++ `-v'
option.  With default configuration options for G++ 3.3 the compile
line for a different C++ compiler needs to include

         -IGCC_INSTALL_DIRECTORY/include/c++/3.3

   Similarly, compiling code with G++ that must use a C++ library other
than the GNU C++ library requires specifying the location of the header
files for that other library.

   The most straightforward way to link a program to use a particular
C++ library is to use a C++ driver that specifies that C++ library by
default.  The `g++' driver, for example, tells the linker where to find
GCC's C++ library (`libstdc++') plus the other libraries and startup
files it needs, in the proper order.

   If a program must use a different C++ library and it's not possible
to do the final link using a C++ driver that uses that library by
default, it is necessary to tell `g++' the location and name of that
library.  It might also be necessary to specify different startup files
and other runtime support libraries, and to suppress the use of GCC's
support libraries with one or more of the options `-nostdlib',
`-nostartfiles', and `-nodefaultlibs'.


File: gcc.info,  Node: Gcov,  Next: Trouble,  Prev: Compatibility,  Up: Top

`gcov'--a Test Coverage Program
*******************************

   `gcov' is a tool you can use in conjunction with GCC to test code
coverage in your programs.

* Menu:

* Gcov Intro::         	        Introduction to gcov.
* Invoking Gcov::       	How to use gcov.
* Gcov and Optimization::       Using gcov with GCC optimization.
* Gcov Data Files::             The files used by gcov.


File: gcc.info,  Node: Gcov Intro,  Next: Invoking Gcov,  Up: Gcov

Introduction to `gcov'
======================

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

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


File: gcc.info,  Node: Invoking Gcov,  Next: Gcov and Optimization,  Prev: Gcov Intro,  Up: Gcov

Invoking gcov
=============

     gcov [OPTIONS] SOURCEFILE

   `gcov' accepts the following 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.

`-a'
`--all-blocks'
     Write individual execution counts for every basic block. Normally
     gcov outputs execution counts only for the main blocks of a line.
     With this option you can determine if blocks within a single line
     are not being executed.

`-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. Unconditional
     branches will not be shown, unless the `-u' option is given.

`-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 if `x.h' is included in multiple source files. If
     you uses the `-p' option, both the including and included file
     names will be complete path names.

`-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 `.gcno', and `.gcda' 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.

`-u'
`--unconditional-branches'
     When branch counts are given, include those of unconditional
     branches.  Unconditional branches are normally not interesting.

   `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 MANGLEDNAME part of the output file name is usually simply
the source file name, but can be something more complicated if the `-l'
or `-p' options are given. Refer to those options for details.

   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.

   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:Graph:tmp.gcno
             -:    0:Data:tmp.gcda
             -:    0:Runs:1
             -:    0:Programs:1
             -:    1:#include <stdio.h>
             -:    2:
             -:    3:int main (void)
     function main called 1 returned 1 blocks executed 75%
             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;
             -:   17:}

   When you use the `-a' option, you will get individual block counts,
and the output looks like this:

             -:    0:Source:tmp.c
             -:    0:Graph:tmp.gcno
             -:    0:Data:tmp.gcda
             -:    0:Runs:1
             -:    0:Programs:1
             -:    1:#include <stdio.h>
             -:    2:
             -:    3:int main (void)
     function main called 1 returned 1 blocks executed 75%
             1:    4:{
             1:    4-block  0
             1:    5:  int i, total;
             -:    6:
             1:    7:  total = 0;
             -:    8:
            11:    9:  for (i = 0; i < 10; i++)
            11:    9-block  0
            10:   10:    total += i;
            10:   10-block  0
             -:   11:
             1:   12:  if (total != 45)
             1:   12-block  0
         #####:   13:    printf ("Failure\n");
         $$$$$:   13-block  0
             -:   14:  else
             1:   15:    printf ("Success\n");
             1:   15-block  0
             1:   16:  return 0;
             1:   16-block  0
             -:   17:}

   In this mode, each basic block is only shown on one line - the last
line of the block. A multi-line block will only contribute to the
execution count of that last line, and other lines will not be shown to
contain code, unless previous blocks end on those lines.  The total
execution count of a line is shown and subsequent lines show the
execution counts for individual blocks that end on that line. After each
block, the branch and call counts of the block will be shown, if the
`-b' option is given.

   Because of the way gcc instruments calls, a call count can be shown
after a line with no individual blocks.  As you can see, line 13
contains a basic block that was not executed.

   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:Graph:tmp.gcno
             -:    0:Data:tmp.gcda
             -:    0:Runs:1
             -:    0:Programs:1
             -:    1:#include <stdio.h>
             -:    2:
             -:    3:int main (void)
     function main called 1 returned 1 blocks executed 75%
             1:    4:{
             1:    5:  int i, total;
             -:    6:
             1:    7:  total = 0;
             -:    8:
            11:    9:  for (i = 0; i < 10; i++)
     branch  0 taken 91% (fallthrough)
     branch  1 taken 9%
            10:   10:    total += i;
             -:   11:
             1:   12:  if (total != 45)
     branch  0 taken 0% (fallthrough)
     branch  1 taken 100%
         #####:   13:    printf ("Failure\n");
     call    0 never executed
             -:   14:  else
             1:   15:    printf ("Success\n");
     call    0 called 1 returned 100%
             1:   16:  return 0;
             -:   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 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.


File: gcc.info,  Node: Gcov and Optimization,  Next: Gcov Data Files,  Prev: Invoking Gcov,  Up: Gcov

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


File: gcc.info,  Node: Gcov Data Files,  Prev: Gcov and Optimization,  Up: Gcov

Brief description of `gcov' data files
======================================

   `gcov' uses two files for profiling.  The names of these files are
derived from the original _object_ file by substituting the file suffix
with either `.gcno', or `.gcda'.  All of these files are placed in the
same directory as the object file, and contain data stored in a
platform-independent format.

   The `.gcno' file is generated when the source file is compiled with
the GCC `-ftest-coverage' option.  It contains information to
reconstruct the basic block graphs and assign source line numbers to
blocks.

   The `.gcda' file is generated when a program containing object files
built with the GCC `-fprofile-arcs' option is executed.  A separate
`.gcda' file is created for each object file compiled with this option.
It contains arc transition counts, and some summary information.

   The full details of the file format is specified in `gcov-io.h', and
functions provided in that header file should be used to access the
coverage files.


File: gcc.info,  Node: Trouble,  Next: Bugs,  Prev: Gcov,  Up: Top

Known Causes of Trouble with GCC
********************************

   This section describes known problems that affect users of GCC.  Most
of these are not GCC bugs per se--if they were, we would fix them.  But
the result for a user may be like the result of a bug.

   Some of these problems are due to bugs in other software, some are
missing features that are too much work to add, and some are places
where people's opinions differ as to what is best.

* Menu:

* Actual Bugs::		      Bugs we will fix later.
* Cross-Compiler Problems::   Common problems of cross compiling with GCC.
* Interoperation::      Problems using GCC with other compilers,
			   and with certain linkers, assemblers and debuggers.
* External Bugs::	Problems compiling certain programs.
* Incompatibilities::   GCC is incompatible with traditional C.
* Fixed Headers::       GCC uses corrected versions of system header files.
                           This is necessary, but doesn't always work smoothly.
* Standard Libraries::  GCC uses the system C library, which might not be
                           compliant with the ISO C standard.
* Disappointments::     Regrettable things we can't change, but not quite bugs.
* C++ Misunderstandings::     Common misunderstandings with GNU C++.
* Protoize Caveats::    Things to watch out for when using `protoize'.
* Non-bugs::		Things we think are right, but some others disagree.
* Warnings and Errors:: Which problems in your code get warnings,
                         and which get errors.


File: gcc.info,  Node: Actual Bugs,  Next: Cross-Compiler Problems,  Up: Trouble

Actual Bugs We Haven't Fixed Yet
================================

   * The `fixincludes' script interacts badly with automounters; if the
     directory of system header files is automounted, it tends to be
     unmounted while `fixincludes' is running.  This would seem to be a
     bug in the automounter.  We don't know any good way to work around
     it.

   * The `fixproto' script will sometimes add prototypes for the
     `sigsetjmp' and `siglongjmp' functions that reference the
     `jmp_buf' type before that type is defined.  To work around this,
     edit the offending file and place the typedef in front of the
     prototypes.

   * When `-pedantic-errors' is specified, GCC will incorrectly give an
     error message when a function name is specified in an expression
     involving the comma operator.


File: gcc.info,  Node: Cross-Compiler Problems,  Next: Interoperation,  Prev: Actual Bugs,  Up: Trouble

Cross-Compiler Problems
=======================

   You may run into problems with cross compilation on certain machines,
for several reasons.

   * Cross compilation can run into trouble for certain machines because
     some target machines' assemblers require floating point numbers to
     be written as _integer_ constants in certain contexts.

     The compiler writes these integer constants by examining the
     floating point value as an integer and printing that integer,
     because this is simple to write and independent of the details of
     the floating point representation.  But this does not work if the
     compiler is running on a different machine with an incompatible
     floating point format, or even a different byte-ordering.

     In addition, correct constant folding of floating point values
     requires representing them in the target machine's format.  (The C
     standard does not quite require this, but in practice it is the
     only way to win.)

     It is now possible to overcome these problems by defining macros
     such as `REAL_VALUE_TYPE'.  But doing so is a substantial amount of
     work for each target machine.  *Note Cross Compilation and
     Floating Point: (gccint)Cross-compilation.

   * At present, the program `mips-tfile' which adds debug support to
     object files on MIPS systems does not work in a cross compile
     environment.


File: gcc.info,  Node: Interoperation,  Next: External Bugs,  Prev: Cross-Compiler Problems,  Up: Trouble

Interoperation
==============

   This section lists various difficulties encountered in using GCC
together with other compilers or with the assemblers, linkers,
libraries and debuggers on certain systems.

   * On many platforms, GCC supports a different ABI for C++ than do
     other compilers, so the object files compiled by GCC cannot be
     used with object files generated by another C++ compiler.

     An area where the difference is most apparent is name mangling.
     The use of different name mangling is intentional, to protect you
     from more subtle problems.  Compilers differ as to many internal
     details of C++ implementation, including: how class instances are
     laid out, how multiple inheritance is implemented, and how virtual
     function calls are handled.  If the name encoding were made the
     same, your programs would link against libraries provided from
     other compilers--but the programs would then crash when run.
     Incompatible libraries are then detected at link time, rather than
     at run time.

   * Older GDB versions sometimes fail to read the output of GCC version
     2.  If you have trouble, get GDB version 4.4 or later.

   * DBX rejects some files produced by GCC, though it accepts similar
     constructs in output from PCC.  Until someone can supply a coherent
     description of what is valid DBX input and what is not, there is
     nothing I can do about these problems.  You are on your own.

   * The GNU assembler (GAS) does not support PIC.  To generate PIC
     code, you must use some other assembler, such as `/bin/as'.

   * On some BSD systems, including some versions of Ultrix, use of
     profiling causes static variable destructors (currently used only
     in C++) not to be run.

   * On some SGI systems, when you use `-lgl_s' as an option, it gets
     translated magically to `-lgl_s -lX11_s -lc_s'.  Naturally, this
     does not happen when you use GCC.  You must specify all three
     options explicitly.

   * On a SPARC, GCC aligns all values of type `double' on an 8-byte
     boundary, and it expects every `double' to be so aligned.  The Sun
     compiler usually gives `double' values 8-byte alignment, with one
     exception: function arguments of type `double' may not be aligned.

     As a result, if a function compiled with Sun CC takes the address
     of an argument of type `double' and passes this pointer of type
     `double *' to a function compiled with GCC, dereferencing the
     pointer may cause a fatal signal.

     One way to solve this problem is to compile your entire program
     with GCC.  Another solution is to modify the function that is
     compiled with Sun CC to copy the argument into a local variable;
     local variables are always properly aligned.  A third solution is
     to modify the function that uses the pointer to dereference it via
     the following function `access_double' instead of directly with
     `*':

          inline double
          access_double (double *unaligned_ptr)
          {
            union d2i { double d; int i[2]; };
          
            union d2i *p = (union d2i *) unaligned_ptr;
            union d2i u;
          
            u.i[0] = p->i[0];
            u.i[1] = p->i[1];
          
            return u.d;
          }

     Storing into the pointer can be done likewise with the same union.

   * On Solaris, the `malloc' function in the `libmalloc.a' library may
     allocate memory that is only 4 byte aligned.  Since GCC on the
     SPARC assumes that doubles are 8 byte aligned, this may result in a
     fatal signal if doubles are stored in memory allocated by the
     `libmalloc.a' library.

     The solution is to not use the `libmalloc.a' library.  Use instead
     `malloc' and related functions from `libc.a'; they do not have
     this problem.

   * Sun forgot to include a static version of `libdl.a' with some
     versions of SunOS (mainly 4.1).  This results in undefined symbols
     when linking static binaries (that is, if you use `-static').  If
     you see undefined symbols `_dlclose', `_dlsym' or `_dlopen' when
     linking, compile and link against the file `mit/util/misc/dlsym.c'
     from the MIT version of X windows.

   * The 128-bit long double format that the SPARC port supports
     currently works by using the architecturally defined quad-word
     floating point instructions.  Since there is no hardware that
     supports these instructions they must be emulated by the operating
     system.  Long doubles do not work in Sun OS versions 4.0.3 and
     earlier, because the kernel emulator uses an obsolete and
     incompatible format.  Long doubles do not work in Sun OS version
     4.1.1 due to a problem in a Sun library.  Long doubles do work on
     Sun OS versions 4.1.2 and higher, but GCC does not enable them by
     default.  Long doubles appear to work in Sun OS 5.x (Solaris 2.x).

   * On HP-UX version 9.01 on the HP PA, the HP compiler `cc' does not
     compile GCC correctly.  We do not yet know why.  However, GCC
     compiled on earlier HP-UX versions works properly on HP-UX 9.01
     and can compile itself properly on 9.01.

   * On the HP PA machine, ADB sometimes fails to work on functions
     compiled with GCC.  Specifically, it fails to work on functions
     that use `alloca' or variable-size arrays.  This is because GCC
     doesn't generate HP-UX unwind descriptors for such functions.  It
     may even be impossible to generate them.

   * Debugging (`-g') is not supported on the HP PA machine, unless you
     use the preliminary GNU tools.

   * Taking the address of a label may generate errors from the HP-UX
     PA assembler.  GAS for the PA does not have this problem.

   * Using floating point parameters for indirect calls to static
     functions will not work when using the HP assembler.  There simply
     is no way for GCC to specify what registers hold arguments for
     static functions when using the HP assembler.  GAS for the PA does
     not have this problem.

   * In extremely rare cases involving some very large functions you may
     receive errors from the HP linker complaining about an out of
     bounds unconditional branch offset.  This used to occur more often
     in previous versions of GCC, but is now exceptionally rare.  If
     you should run into it, you can work around by making your
     function smaller.

   * GCC compiled code sometimes emits warnings from the HP-UX
     assembler of the form:

          (warning) Use of GR3 when
            frame >= 8192 may cause conflict.

     These warnings are harmless and can be safely ignored.

   * On the IBM RS/6000, compiling code of the form

          extern int foo;
          
          ... foo ...
          
          static int foo;

     will cause the linker to report an undefined symbol `foo'.
     Although this behavior differs from most other systems, it is not a
     bug because redefining an `extern' variable as `static' is
     undefined in ISO C.

   * In extremely rare cases involving some very large functions you may
     receive errors from the AIX Assembler complaining about a
     displacement that is too large.  If you should run into it, you
     can work around by making your function smaller.

   * The `libstdc++.a' library in GCC relies on the SVR4 dynamic linker
     semantics which merges global symbols between libraries and
     applications, especially necessary for C++ streams functionality.
     This is not the default behavior of AIX shared libraries and
     dynamic linking.  `libstdc++.a' is built on AIX with
     "runtime-linking" enabled so that symbol merging can occur.  To
     utilize this feature, the application linked with `libstdc++.a'
     must include the `-Wl,-brtl' flag on the link line.  G++ cannot
     impose this because this option may interfere with the semantics
     of the user program and users may not always use `g++' to link his
     or her application. Applications are not required to use the
     `-Wl,-brtl' flag on the link line--the rest of the `libstdc++.a'
     library which is not dependent on the symbol merging semantics
     will continue to function correctly.

   * An application can interpose its own definition of functions for
     functions invoked by `libstdc++.a' with "runtime-linking" enabled
     on AIX.  To accomplish this the application must be linked with
     "runtime-linking" option and the functions explicitly must be
     exported by the application (`-Wl,-brtl,-bE:exportfile').

   * AIX on the RS/6000 provides support (NLS) for environments outside
     of the United States.  Compilers and assemblers use NLS to support
     locale-specific representations of various objects including
     floating-point numbers (`.' vs `,' for separating decimal
     fractions). There have been problems reported where the library
     linked with GCC does not produce the same floating-point formats
     that the assembler accepts. If you have this problem, set the
     `LANG' environment variable to `C' or `En_US'.

   * Even if you specify `-fdollars-in-identifiers', you cannot
     successfully use `$' in identifiers on the RS/6000 due to a
     restriction in the IBM assembler.  GAS supports these identifiers.

   * On Ultrix, the Fortran compiler expects registers 2 through 5 to
     be saved by function calls.  However, the C compiler uses
     conventions compatible with BSD Unix: registers 2 through 5 may be
     clobbered by function calls.

     GCC uses the same convention as the Ultrix C compiler.  You can use
     these options to produce code compatible with the Fortran compiler:

          -fcall-saved-r2 -fcall-saved-r3 -fcall-saved-r4 -fcall-saved-r5

   * On the Alpha, you may get assembler errors about invalid syntax as
     a result of floating point constants.  This is due to a bug in the
     C library functions `ecvt', `fcvt' and `gcvt'.  Given valid
     floating point numbers, they sometimes print `NaN'.

