Compiling a Program for Profiling
*********************************
The first step in generating profile information for your program is
to compile and link it with profiling enabled.
To compile a source file for profiling, specify the `-pg' option when
you run the compiler. (This is in addition to the options you normally
use.)
To link the program for profiling, if you use a compiler such as `cc'
to do the linking, simply specify `-pg' in addition to your usual
options. The same option, `-pg', alters either compilation or linking
to do what is necessary for profiling. Here are examples:
If you use gcc 2.95.x or 3.0.x, you may need to add the
`-fprofile-arcs' option to the compile line along with `-pg' in order
to allow the call-graphs to be properly included in the gmon.out file.
cc -g -c myprog.c utils.c -pg
cc -o myprog myprog.o utils.o -pg
The `-pg' option also works with a command that both compiles and
links:
cc -o myprog myprog.c utils.c -g -pg
If you run the linker `ld' directly instead of through a compiler
such as `cc', you may have to specify a profiling startup file
`gcrt0.o' as the first input file instead of the usual startup file
`crt0.o'. In addition, you would probably want to specify the
profiling C library, `libc_p.a', by writing `-lc_p' instead of the
usual `-lc'. This is not absolutely necessary, but doing this gives
you number-of-calls information for standard library functions such as
`read' and `open'. For example:
ld -o myprog /lib/gcrt0.o myprog.o utils.o -lc_p
If you compile only some of the modules of the program with `-pg',
you can still profile the program, but you won't get complete
information about the modules that were compiled without `-pg'. The
only information you get for the functions in those modules is the
total time spent in them; there is no record of how many times they
were called, or from where. This will not affect the flat profile
(except that the `calls' field for the functions will be blank), but
will greatly reduce the usefulness of the call graph.
If you wish to perform line-by-line profiling, you will also need to
specify the `-g' option, instructing the compiler to insert debugging
symbols into the program that match program addresses to source code
lines. Note:Line-by-line.
In addition to the `-pg' and `-g' options, you may also wish to
specify the `-a' option when compiling. This will instrument the
program to perform basic-block counting. As the program runs, it will
count how many times it executed each branch of each `if' statement,
each iteration of each `do' loop, etc. This will enable `gprof' to
construct an annotated source code listing showing how many times each
line of code was executed.