Debugging with

Published by the Free Software Foundation
675 Massachusetts Avenue,
Cambridge, MA 02139 USA
Printed copies are available for $20 each.
ISBN 1-882114-11-6

Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are preserved on all copies.

Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also that the entire resulting derived work is distributed under the terms of a permission notice identical to this one.

Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified versions.

Summary of

The purpose of a debugger such as is to allow you to see what is going on "inside" another program while it executes--or what another program was doing at the moment it crashed.

can do four main kinds of things (plus other things in support of these) to help you catch bugs in the act:

Start your program, specifying anything that might affect its behavior.
Make your program stop on specified conditions.
Examine what has happened, when your program has stopped.
Change things in your program, so you can experiment with correcting the effects of one bug and go on to learn about another.

You can use to debug programs written in C or C++. For more information, see section 9.3 Supported languages.

Free Software: Freely redistributable software
Contributors: Contributors to GDB

Free software

is free software, protected by the GNU General Public License (GPL). The GPL gives you the freedom to copy or adapt a licensed program--but every person getting a copy also gets with it the freedom to modify that copy (which means that they must get access to the source code), and the freedom to distribute further copies. Typical software companies use copyrights to limit your freedoms; the Free Software Foundation uses the GPL to preserve these freedoms.

Fundamentally, the General Public License is a license which says that you have these freedoms and that you cannot take these freedoms away from anyone else.

Contributors to GDB

Richard Stallman was the original author of GDB, and of many other GNU programs. Many others have contributed to its development. This section attempts to credit major contributors. One of the virtues of free software is that everyone is free to contribute to it; with regret, we cannot actually acknowledge everyone here. The file `ChangeLog' in the GDB distribution approximates a blow-by-blow account.

Changes much prior to version 2.0 are lost in the mists of time.

Plea: Additions to this section are particularly welcome. If you or your friends (or enemies, to be evenhanded) have been unfairly omitted from this list, we would like to add your names!

So that they may not regard their long labor as thankless, we particularly thank those who shepherded GDB through major releases: Fred Fish (releases 4.12, 4.11, 4.10, and 4.9), Stu Grossman and John Gilmore (releases 4.8, 4.7, 4.6, 4.5, and 4.4), John Gilmore (releases 4.3, 4.2, 4.1, 4.0, and 3.9); Jim Kingdon (releases 3.5, 3.4, and 3.3); and Randy Smith (releases 3.2, 3.1, and 3.0). As major maintainer of GDB for some period, each contributed significantly to the structure, stability, and capabilities of the entire debugger.

Richard Stallman, assisted at various times by Peter TerMaat, Chris Hanson, and Richard Mlynarik, handled releases through 2.8.

Michael Tiemann is the author of most of the GNU C++ support in GDB, with significant additional contributions from Per Bothner. James Clark wrote the GNU C++ demangler. Early work on C++ was by Peter TerMaat (who also did much general update work leading to release 3.0).

GDB 4 uses the BFD subroutine library to examine multiple object-file formats; BFD was a joint project of David V. Henkel-Wallace, Rich Pixley, Steve Chamberlain, and John Gilmore.

David Johnson wrote the original COFF support; Pace Willison did the original support for encapsulated COFF.

Adam de Boor and Bradley Davis contributed the ISI Optimum V support. Per Bothner, Noboyuki Hikichi, and Alessandro Forin contributed MIPS support. Jean-Daniel Fekete contributed Sun 386i support. Chris Hanson improved the HP9000 support. Noboyuki Hikichi and Tomoyuki Hasei contributed Sony/News OS 3 support. David Johnson contributed Encore Umax support. Jyrki Kuoppala contributed Altos 3068 support. Jeff Law contributed HP PA and SOM support. Keith Packard contributed NS32K support. Doug Rabson contributed Acorn Risc Machine support. Bob Rusk contributed Harris Nighthawk CX-UX support. Chris Smith contributed Convex support (and Fortran debugging). Jonathan Stone contributed Pyramid support. Michael Tiemann contributed SPARC support. Tim Tucker contributed support for the Gould NP1 and Gould Powernode. Pace Willison contributed Intel 386 support. Jay Vosburgh contributed Symmetry support.

Rich Schaefer and Peter Schauer helped with support of SunOS shared libraries.

Jay Fenlason and Roland McGrath ensured that GDB and GAS agree about several machine instruction sets.

Patrick Duval, Ted Goldstein, Vikram Koka and Glenn Engel helped develop remote debugging. Intel Corporation and Wind River Systems contributed remote debugging modules for their products.

Brian Fox is the author of the readline libraries providing command-line editing and command history.

Andrew Beers of SUNY Buffalo wrote the language-switching code, and contributed the Languages chapter of this manual.

Fred Fish wrote most of the support for Unix System Vr4. He also enhanced the command-completion support to cover C++ overloaded symbols.

Hitachi America, Ltd. sponsored the support for Hitachi microprocessors.

Kung Hsu, Jeff Law, and Rick Sladkey added support for hardware watchpoints.

Stu Grossman wrote gdbserver.

Jim Kingdon, Peter Schauer, Ian Taylor, and Stu Grossman made nearly innumerable bug fixes and cleanups throughout GDB.

Command Rationalization Many GDB commands have been renamed to make them easier to remember and use. In particular, the subcommands of info and show/set are grouped to make the former refer to the state of your program, and the latter refer to the state of GDB itself. @xref{Renamed Commands}, for details on what commands were renamed.

Shared Libraries GDB 4 can debug programs and core files that use SunOS, SVR4, or IBM RS/6000 shared libraries.

Threads On some systems, GDB 4 has facilities to debug multi-thread programs.

Reference Card GDB 4 has a reference card. See section A Formatting Documentation, for instructions about how to print it.

1 A Sample Session

You can use this manual at your leisure to read all about . However, a handful of commands are enough to get started using the debugger. This chapter illustrates those commands.

In this sample session, we emphasize user input like this: input, to make it easier to pick out from the surrounding output.

One of the preliminary versions of GNU m4 (a generic macro processor) exhibits the following bug: sometimes, when we change its quote strings from the default, the commands used to capture one macro definition within another stop working. In the following short m4 session, we define a macro foo which expands to 0000; we then use the m4 built-in defn to define bar as the same thing. However, when we change the open quote string to <QUOTE> and the close quote string to <UNQUOTE>, the same procedure fails to define a new synonym baz:

$ cd gnu/m4
$ ./m4
define(foo,0000)

foo
0000
define(bar,defn(`foo'))

bar
0000
changequote(<QUOTE>,<UNQUOTE>)

define(baz,defn(<QUOTE>foo<UNQUOTE>))
baz
C-d
m4: End of input: 0: fatal error: EOF in string

Let us use to try to see what is going on.

$  m4
GDB is free software and you are welcome to distribute copies
 of it under certain conditions; type "show copying" to see 
 the conditions.
There is absolutely no warranty for GDB; type "show warranty" 
 for details.
GDB , Copyright 1993 Free Software Foundation, Inc...
()

reads only enough symbol data to know where to find the rest when needed; as a result, the first prompt comes up very quickly. We now tell to use a narrower display width than usual, so that examples fit in this manual.

() set width 70

We need to see how the m4 built-in changequote works. Having looked at the source, we know the relevant subroutine is m4_changequote, so we set a breakpoint there with the break command.

() break m4_changequote
Breakpoint 1 at 0x62f4: file builtin.c, line 879.

Using the run command, we start m4 running under control; as long as control does not reach the m4_changequote subroutine, the program runs as usual:

() run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)

foo
0000

To trigger the breakpoint, we call changequote. suspends execution of m4, displaying information about the context where it stops.

changequote(<QUOTE>,<UNQUOTE>)

Breakpoint 1, m4_changequote (argc=3, argv=0x33c70) 
    at builtin.c:879
879         if (bad_argc(TOKEN_DATA_TEXT(argv[0]),argc,1,3))

Now we use the command n (next) to advance execution to the next line of the current function.

() n
882         set_quotes((argc >= 2) ? TOKEN_DATA_TEXT(argv[1])\
 : nil,

set_quotes looks like a promising subroutine. We can go into it by using the command s (step) instead of next. step goes to the next line to be executed in any subroutine, so it steps into set_quotes.

() s
set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
    at input.c:530
530         if (lquote != def_lquote)

The display that shows the subroutine where m4 is now suspended (and its arguments) is called a stack frame display. It shows a summary of the stack. We can use the backtrace command (which can also be spelled bt), to see where we are in the stack as a whole: the backtrace command displays a stack frame for each active subroutine.

() bt
#0  set_quotes (lq=0x34c78 "<QUOTE>", rq=0x34c88 "<UNQUOTE>")
    at input.c:530
#1  0x6344 in m4_changequote (argc=3, argv=0x33c70) 
    at builtin.c:882
#2  0x8174 in expand_macro (sym=0x33320) at macro.c:242
#3  0x7a88 in expand_token (obs=0x0, t=209696, td=0xf7fffa30)
    at macro.c:71
#4  0x79dc in expand_input () at macro.c:40
#5  0x2930 in main (argc=0, argv=0xf7fffb20) at m4.c:195

We step through a few more lines to see what happens. The first two times, we can use `s'; the next two times we use n to avoid falling into the xstrdup subroutine.

() s
0x3b5c  532         if (rquote != def_rquote)
() s
0x3b80  535         lquote = (lq == nil || *lq == '\0') ?  \
def_lquote : xstrdup(lq);
() n
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
 : xstrdup(rq);
() n
538         len_lquote = strlen(rquote);

The last line displayed looks a little odd; we can examine the variables lquote and rquote to see if they are in fact the new left and right quotes we specified. We use the command p (print) to see their values.

() p lquote
$1 = 0x35d40 "<QUOTE>"
() p rquote
$2 = 0x35d50 "<UNQUOTE>"

lquote and rquote are indeed the new left and right quotes. To look at some context, we can display ten lines of source surrounding the current line with the l (list) command.

() l
533             xfree(rquote);
534
535         lquote = (lq == nil || *lq == '\0') ? def_lquote\
 : xstrdup (lq);
536         rquote = (rq == nil || *rq == '\0') ? def_rquote\
 : xstrdup (rq);
537
538         len_lquote = strlen(rquote);
539         len_rquote = strlen(lquote);
540     }
541
542     void

Let us step past the two lines that set len_lquote and len_rquote, and then examine the values of those variables.

() n
539         len_rquote = strlen(lquote);
() n
540     }
() p len_lquote
$3 = 9
() p len_rquote
$4 = 7

That certainly looks wrong, assuming len_lquote and len_rquote are meant to be the lengths of lquote and rquote respectively. We can set them to better values using the p command, since it can print the value of any expression--and that expression can include subroutine calls and assignments.

() p len_lquote=strlen(lquote)
$5 = 7
() p len_rquote=strlen(rquote)
$6 = 9

Is that enough to fix the problem of using the new quotes with the m4 built-in defn? We can allow m4 to continue executing with the c (continue) command, and then try the example that caused trouble initially:

() c
Continuing.

define(baz,defn(<QUOTE>foo<UNQUOTE>))

baz
0000

Success! The new quotes now work just as well as the default ones. The problem seems to have been just the two typos defining the wrong lengths. We allow m4 exit by giving it an EOF as input:

C-d
Program exited normally.

The message `Program exited normally.' is from ; it indicates m4 has finished executing. We can end our session with the quit command.

() quit

2 Getting In and Out of

This chapter discusses how to start , and how to get out of it. (The essentials: type `' to start GDB, and type quit or C-d to exit.)

Invoking GDB: How to start
Quitting GDB: How to quit
Shell Commands: How to use shell commands inside

2.1 Invoking

Invoke by running the program . Once started, reads commands from the terminal until you tell it to exit.

You can also run with a variety of arguments and options, to specify more of your debugging environment at the outset.

The most usual way to start is with one argument, specifying an executable program:

 program

You can also start with both an executable program and a core file specified:

 program core

You can, instead, specify a process ID as a second argument, if you want to debug a running process:

 program 1234

would attach to process 1234 (unless you also have a file named `1234'; does check for a core file first).

Taking advantage of the second command-line argument requires a fairly complete operating system; when you use as a remote debugger attached to a bare board, there may not be any notion of "process", and there is often no way to get a core dump.

You can further control how starts up by using command-line options. itself can remind you of the options available.

Type

 -help

to display all available options and briefly describe their use (` -h' is a shorter equivalent).

All options and command line arguments you give are processed in sequential order. The order makes a difference when the `-x' option is used.

File Options: Choosing files
Mode Options: Choosing modes

The debugging stub is specific to the architecture of the remote machine; for example, use `sparc-stub.c' to debug programs on SPARC boards. These working remote stubs are distributed with :

sparc-stub.c: For SPARC architectures.
m68k-stub.c: For Motorola 680x0 architectures.
i386-stub.c: For Intel 386 and compatible architectures.

The `README' file in the distribution may list other recently added stubs.

Stub Contents: What the stub can do for you
Bootstrapping: What you must do for the stub
Debug Session: Putting it all together
Protocol: Outline of the communication protocol

2.1.0.1 What the stub can do for you

The debugging stub for your architecture supplies these three subroutines:

set_debug_traps: This routine arranges for handle_exception to run when your program stops. You must call this subroutine explicitly near the beginning of your program.
handle_exception: This is the central workhorse, but your program never calls it explicitly--the setup code arranges for handle_exception to run when a trap is triggered. handle_exception takes control when your program stops during execution (for example, on a breakpoint), and mediates communications with on the host machine. This is where the communications protocol is implemented; handle_exception acts as the representative on the target machine; it begins by sending summary information on the state of your program, then continues to execute, retrieving and transmitting any information needs, until you execute a command that makes your program resume; at that point, handle_exception returns control to your own code on the target machine.
breakpoint: Use this auxiliary subroutine to make your program contain a breakpoint. Depending on the particular situation, this may be the only way for to get control. For instance, if your target machine has some sort of interrupt button, you won't need to call this; pressing the interrupt button transfers control to handle_exception---in effect, to . On some machines, simply receiving characters on the serial port may also trigger a trap; again, in that situation, you don't need to call breakpoint from your own program--simply running `target remote' from the host session gets control. Call breakpoint if none of these is true, or if you simply want to make certain your program stops at a predetermined point for the start of your debugging session.

2.1.0.2 What you must do for the stub

The debugging stubs that come with are set up for a particular chip architecture, but they have no information about the rest of your debugging target machine.

First of all you need to tell the stub how to communicate with the serial port.

int getDebugChar(): Write this subroutine to read a single character from the serial port. It may be identical to getchar for your target system; a different name is used to allow you to distinguish the two if you wish.
void putDebugChar(int): Write this subroutine to write a single character to the serial port. It may be identical to putchar for your target system; a different name is used to allow you to distinguish the two if you wish.

If you want to be able to stop your program while it is running, you need to use an interrupt-driven serial driver, and arrange for it to stop when it receives a ^C (`\003', the control-C character). That is the character which uses to tell the remote system to stop.

Getting the debugging target to return the proper status to probably requires changes to the standard stub; one quick and dirty way is to just execute a breakpoint instruction (the "dirty" part is that reports a SIGTRAP instead of a SIGINT).

Other routines you need to supply are:

void exceptionHandler (int exception_number, void *exception_address): Write this function to install exception_address in the exception handling tables. You need to do this because the stub does not have any way of knowing what the exception handling tables on your target system are like (for example, the processor's table might be in ROM, containing entries which point to a table in RAM). exception_number is the exception number which should be changed; its meaning is architecture-dependent (for example, different numbers might represent divide by zero, misaligned access, etc). When this exception occurs, control should be transferred directly to exception_address, and the processor state (stack, registers, and so on) should be just as it is when a processor exception occurs. So if you want to use a jump instruction to reach exception_address, it should be a simple jump, not a jump to subroutine. For the 386, exception_address should be installed as an interrupt gate so that interrupts are masked while the handler runs. The gate should be at privilege level 0 (the most privileged level). The SPARC and 68k stubs are able to mask interrupts themself without help from exceptionHandler.
void flush_i_cache(): Write this subroutine to flush the instruction cache, if any, on your target machine. If there is no instruction cache, this subroutine may be a no-op. On target machines that have instruction caches, requires this function to make certain that the state of your program is stable.

You must also make sure this library routine is available:

void *memset(void *, int, int): This is the standard library function memset that sets an area of memory to a known value. If you have one of the free versions of libc.a, memset can be found there; otherwise, you must either obtain it from your hardware manufacturer, or write your own.

If you do not use the GNU C compiler, you may need other standard library subroutines as well; this varies from one stub to another, but in general the stubs are likely to use any of the common library subroutines which gcc generates as inline code.

2.1.0.3 Putting it all together

In summary, when your program is ready to debug, you must follow these steps.

Make sure you have the supporting low-level routines (see section 2.1.0.2 What you must do for the stub):

getDebugChar, putDebugChar,
flush_i_cache, memset, exceptionHandler.

Insert these lines near the top of your program:

set_debug_traps();
breakpoint();

For the 680x0 stub only, you need to provide a variable called exceptionHook. Normally you just use

void (*exceptionHook)() = 0;

set_debug_traps

exceptionHook

int

Compile and link together: your program, the debugging stub for your target architecture, and the supporting subroutines.
Make sure you have a serial connection between your target machine and the host, and identify the serial port used for this on the host.
Download your program to your target machine (or get it there by whatever means the manufacturer provides), and start it.
To start remote debugging, run on the host machine, and specify as an executable file the program that is running in the remote machine. This tells how to find your program's symbols and the contents of its pure text. Then establish communication using the target remote command. Its argument specifies how to communicate with the target machine--either via a devicename attached to a direct serial line, or a TCP port (usually to a terminal server which in turn has a serial line to the target). For example, to use a serial line connected to the device named `/dev/ttyb':

target remote /dev/ttyb

host:port

manyfarms

target remote manyfarms:2828

Now you can use all the usual commands to examine and change data and to step and continue the remote program.

To resume the remote program and stop debugging it, use the detach command.

Whenever is waiting for the remote program, if you type the interrupt character (often C-C), attempts to stop the program. This may or may not succeed, depending in part on the hardware and the serial drivers the remote system uses. If you type the interrupt character once again, displays this prompt:

Interrupted while waiting for the program.
Give up (and stop debugging it)?  (y or n)

If you type y, abandons the remote debugging session. (If you decide you want to try again later, you can use `target remote' again to connect once more.) If you type n, goes back to waiting.

2.1.0.4 Communication protocol

The stub files provided with implement the target side of the communication protocol, and the side is implemented in the source file `remote.c'. Normally, you can simply allow these subroutines to communicate, and ignore the details. (If you're implementing your own stub file, you can still ignore the details: start with one of the existing stub files. `sparc-stub.c' is the best organized, and therefore the easiest to read.)

However, there may be occasions when you need to know something about the protocol--for example, if there is only one serial port to your target machine, you might want your program to do something special if it recognizes a packet meant for .

All commands and responses (other than acknowledgements, which are single characters) are sent as a packet which includes a checksum. A packet is introduced with the character `$', and ends with the character `#' followed by a two-digit checksum:

$packet info#checksum

checksum is computed as the modulo 256 sum of the packet info characters.

When either the host or the target machine receives a packet, the first response expected is an acknowledgement: a single character, either `+' (to indicate the package was received correctly) or `-' (to request retransmission).

The host () sends commands, and the target (the debugging stub incorporated in your program) sends data in response. The target also sends data when your program stops.

Command packets are distinguished by their first character, which identifies the kind of command.

These are the commands currently supported:

g: Requests the values of CPU registers.
G: Sets the values of CPU registers.
maddr,count: Read count bytes at location addr.
Maddr,count:...: Write count bytes at location addr.
c
caddr: Resume execution at the current address (or at addr if supplied).
s
saddr: Step the target program for one instruction, from either the current program counter or from addr if supplied.
k: Kill the target program.
?: Report the most recent signal. To allow you to take advantage of the signal handling commands, one of the functions of the debugging stub is to report CPU traps as the corresponding POSIX signal values.

If you have trouble with the serial connection, you can use the command set remotedebug. This makes report on all packets sent back and forth across the serial line to the remote machine. The packet-debugging information is printed on the standard output stream. set remotedebug off turns it off, and show remotedebug shows you its current state.

2.1.0.5 Using the E7000 in-circuit emulator

You can use the E7000 in-circuit emulator to develop code for either the Hitachi SH or the H8/300H. Use one of these forms of the `target e7000' command to connect to your E7000:

target e7000 port speed: Use this form if your E7000 is connected to a serial port. The port argument identifies what serial port to use (for example, `com2'). The third argument is the line speed in bits per second (for example, `9600').
target e7000 hostname: If your E7000 is installed as a host on a TCP/IP network, you can just specify its hostname; uses telnet to connect.

2.1.0.6 Special commands for Hitachi micros

Some commands are available only on the H8/300 or the H8/500 configurations:

set machine h8300
set machine h8300h: Condition for one of the two variants of the H8/300 architecture with `set machine'. You can use `show machine' to check which variant is currently in effect.
set memory mod
show memory: Specify which H8/500 memory model (mod) you are using with `set memory'; check which memory model is in effect with `show memory'. The accepted values for mod are small, big, medium, and compact.

target sim: Debug programs on a simulated CPU

After specifying this target, you can debug programs for the simulated CPU in the same style as programs for your host computer; use the file command to load a new program image, the run command to run your program, and so on.

As well as making available all the usual machine registers (see info reg), this debugging target provides three additional items of information as specially named registers:

cycles: Counts clock-ticks in the simulator.
insts: Counts instructions run in the simulator.
time: Execution time in 60ths of a second.

You can refer to these values in expressions with the usual conventions; for example, `b fputc if $cycles>5000' sets a conditional breakpoint that suspends only after at least 5000 simulated clock ticks.

2.1.1 Choosing files

When starts, it reads any arguments other than options as specifying an executable file and core file (or process ID). This is the same as if the arguments were specified by the `-se' and `-c' options respectively. ( reads the first argument that does not have an associated option flag as equivalent to the `-se' option followed by that argument; and the second argument that does not have an associated option flag, if any, as equivalent to the `-c' option followed by that argument.)

Many options have both long and short forms; both are shown in the following list. also recognizes the long forms if you truncate them, so long as enough of the option is present to be unambiguous. (If you prefer, you can flag option arguments with `--' rather than `-', though we illustrate the more usual convention.)

-symbols file
-s file: Read symbol table from file file.
-exec file
-e file: Use file file as the executable file to execute when appropriate, and for examining pure data in conjunction with a core dump.
-se file: Read symbol table from file file and use it as the executable file.
-core file
-c file: Use file file as a core dump to examine.
-c number: Connect to process ID number, as with the attach command (unless there is a file in core-dump format named number, in which case `-c' specifies that file as a core dump to read).
-command file
-x file: Execute commands from file file. See section 15.3 Command files.
-directory directory
-d directory: Add directory to the path to search for source files.
-m
-mapped: Warning: this option depends on operating system facilities that are not supported on all systems.
-r
-readnow: Read each symbol file's entire symbol table immediately, rather than the default, which is to read it incrementally as it is needed. This makes startup slower, but makes future operations faster.

The -mapped and -readnow options are typically combined in order to build a `.syms' file that contains complete symbol information. (See section 12.1 Commands to specify files, for information on `.syms' files.) A simple GDB invocation to do nothing but build a `.syms' file for future use is:

        gdb -batch -nx -mapped -readnow programname

2.1.2 Choosing modes

You can run in various alternative modes--for example, in batch mode or quiet mode.

-nx
-n: Do not execute commands from any initialization files (normally called `'). Normally, the commands in these files are executed after all the command options and arguments have been processed. See section 15.3 Command files.
-quiet
-q: "Quiet". Do not print the introductory and copyright messages. These messages are also suppressed in batch mode.
-batch: Run in batch mode. Exit with status 0 after processing all the command files specified with `-x' (and all commands from initialization files, if not inhibited with `-n'). Exit with nonzero status if an error occurs in executing the commands in the command files. Batch mode may be useful for running as a filter, for example to download and run a program on another computer; in order to make this more useful, the message
-cd directory: Run using directory as its working directory, instead of the current directory.
-fullname
-f: Emacs sets this option when it runs as a subprocess. It tells to output the full file name and line number in a standard, recognizable fashion each time a stack frame is displayed (which includes each time your program stops). This recognizable format looks like two `\032' characters, followed by the file name, line number and character position separated by colons, and a newline. The Emacs-to- interface program uses the two `\032' characters as a signal to display the source code for the frame.

2.2 Quitting

quit: To exit , use the quit command (abbreviated q), or type an end-of-file character (usually C-d).

An interrupt (often C-c) does not exit from , but rather terminates the action of any command that is in progress and returns to command level. It is safe to type the interrupt character at any time because does not allow it to take effect until a time when it is safe.

If you have been using to control an attached process or device, you can release it with the detach command (see section 4.7 Debugging an already-running process).

2.3 Shell commands

If you need to execute occasional shell commands during your debugging session, there is no need to leave or suspend ; you can just use the shell command.

shell command string: Invoke a the standard shell to execute command string. If it exists, the environment variable SHELL determines which shell to run. Otherwise uses /bin/sh.

The utility make is often needed in development environments. You do not have to use the shell command for this purpose in :

make make-args: Execute the make program with the specified arguments. This is equivalent to `shell make make-args'.

3 Commands

You can abbreviate a command to the first few letters of the command name, if that abbreviation is unambiguous; and you can repeat certain commands by typing just RET. You can also use the TAB key to get to fill out the rest of a word in a command (or to show you the alternatives available, if there is more than one possibility).

Command Syntax: How to give commands to
Completion: Command completion
Help: How to ask for help

3.1 Command syntax

A command is a single line of input. There is no limit on how long it can be. It starts with a command name, which is followed by arguments whose meaning depends on the command name. For example, the command step accepts an argument which is the number of times to step, as in `step 5'. You can also use the step command with no arguments. Some command names do not allow any arguments.

command names may always be truncated if that abbreviation is unambiguous. Other possible command abbreviations are listed in the documentation for individual commands. In some cases, even ambiguous abbreviations are allowed; for example, s is specially defined as equivalent to step even though there are other commands whose names start with s. You can test abbreviations by using them as arguments to the help command.

A blank line as input to (typing just RET) means to repeat the previous command. Certain commands (for example, run) will not repeat this way; these are commands whose unintentional repetition might cause trouble and which you are unlikely to want to repeat.

The list and x commands, when you repeat them with RET, construct new arguments rather than repeating exactly as typed. This permits easy scanning of source or memory.

can also use RET in another way: to partition lengthy output, in a way similar to the common utility more (see section 14.4 Screen size). Since it is easy to press one RET too many in this situation, disables command repetition after any command that generates this sort of display.

Any text from a # to the end of the line is a comment; it does nothing. This is useful mainly in command files (see section 15.3 Command files).

3.2 Command completion

can fill in the rest of a word in a command for you, if there is only one possibility; it can also show you what the valid possibilities are for the next word in a command, at any time. This works for commands, subcommands, and the names of symbols in your program.

Press the TAB key whenever you want to fill out the rest of a word. If there is only one possibility, fills in the word, and waits for you to finish the command (or press RET to enter it). For example, if you type

() info bre TAB

fills in the rest of the word `breakpoints', since that is the only info subcommand beginning with `bre':

() info breakpoints

You can either press RET at this point, to run the info breakpoints command, or backspace and enter something else, if `breakpoints' does not look like the command you expected. (If you were sure you wanted info breakpoints in the first place, you might as well just type RET immediately after `info bre', to exploit command abbreviations rather than command completion).

If there is more than one possibility for the next word when you press TAB, sounds a bell. You can either supply more characters and try again, or just press TAB a second time; displays all the possible completions for that word. For example, you might want to set a breakpoint on a subroutine whose name begins with `make_', but when you type b make_TAB just sounds the bell. Typing TAB again displays all the function names in your program that begin with those characters, for example:

() b make_ TAB
 sounds bell; press TAB again, to see:
make_a_section_from_file     make_environ               
make_abs_section             make_function_type         
make_blockvector             make_pointer_type          
make_cleanup                 make_reference_type        
make_command                 make_symbol_completion_list
() b make_

After displaying the available possibilities, copies your partial input (`b make_' in the example) so you can finish the command.

If you just want to see the list of alternatives in the first place, you can press M-? rather than pressing TAB twice. M-? means META ?. You can type this either by holding down a key designated as the META shift on your keyboard (if there is one) while typing ?, or as ESC followed by ?.

Sometimes the string you need, while logically a "word", may contain parentheses or other characters that normally excludes from its notion of a word. To permit word completion to work in this situation, you may enclose words in ' (single quote marks) in commands.

The most likely situation where you might need this is in typing the name of a C++ function. This is because C++ allows function overloading (multiple definitions of the same function, distinguished by argument type). For example, when you want to set a breakpoint you may need to distinguish whether you mean the version of name that takes an int parameter, name(int), or the version that takes a float parameter, name(float). To use the word-completion facilities in this situation, type a single quote ' at the beginning of the function name. This alerts that it may need to consider more information than usual when you press TAB or M-? to request word completion:

() b 'bubble( M-?
bubble(double,double)    bubble(int,int)
() b 'bubble(

In some cases, can tell that completing a name requires using quotes. When this happens, inserts the quote for you (while completing as much as it can) if you do not type the quote in the first place:

() b bub TAB
 alters your input line to the following, and rings a bell:
() b 'bubble(

In general, can tell that a quote is needed (and inserts it) if you have not yet started typing the argument list when you ask for completion on an overloaded symbol.

3.3 Getting help

You can always ask itself for information on its commands, using the command help.

help
h: You can use help (abbreviated h) with no arguments to display a short list of named classes of commands:
help class: Using one of the general help classes as an argument, you can get a list of the individual commands in that class. For example, here is the help display for the class status:
help command: With a command name as help argument, displays a short paragraph on how to use that command.

In addition to help, you can use the commands info and show to inquire about the state of your program, or the state of itself. Each command supports many topics of inquiry; this manual introduces each of them in the appropriate context. The listings under info and under show in the Index point to all the sub-commands. See section Index.

info: This command (abbreviated i) is for describing the state of your program. For example, you can list the arguments given to your program with info args, list the registers currently in use with info registers, or list the breakpoints you have set with info breakpoints. You can get a complete list of the info sub-commands with help info.
show: In contrast, show is for describing the state of itself. You can change most of the things you can show, by using the related command set; for example, you can control what number system is used for displays with set radix, or simply inquire which is currently in use with show radix. To display all the settable parameters and their current values, you can use show with no arguments; you may also use info set. Both commands produce the same display.

Here are three miscellaneous show subcommands, all of which are exceptional in lacking corresponding set commands:

show version: Show what version of is running. You should include this information in bug-reports. If multiple versions of are in use at your site, you may occasionally want to determine which version of you are running; as evolves, new commands are introduced, and old ones may wither away. The version number is also announced when you start .
show copying: Display information about permission for copying .
show warranty: Display the GNU "NO WARRANTY" statement.

4 Running Programs Under

When you run a program under , you must first generate debugging information when you compile it. You may start it with its arguments, if any, in an environment of your choice. You may redirect your program's input and output, debug an already running process, or kill a child process.

Compilation: Compiling for debugging
Starting: Starting your program
Arguments: Your program's arguments
Environment: Your program's environment
Working Directory: Your program's working directory
Input/Output: Your program's input and output
Attach: Debugging an already-running process
Kill Process: Killing the child process
Process Information: Additional process information
Threads: Debugging programs with multiple threads

4.1 Compiling for debugging

In order to debug a program effectively, you need to generate debugging information when you compile it. This debugging information is stored in the object file; it describes the data type of each variable or function and the correspondence between source line numbers and addresses in the executable code.

To request debugging information, specify the `-g' option when you run the compiler.

Many C compilers are unable to handle the `-g' and `-O' options together. Using those compilers, you cannot generate optimized executables containing debugging information.

, the GNU C compiler, supports `-g' with or without `-O', making it possible to debug optimized code. We recommend that you always use `-g' whenever you compile a program. You may think your program is correct, but there is no sense in pushing your luck.

When you debug a program compiled with `-g -O', remember that the optimizer is rearranging your code; the debugger shows you what is really there. Do not be too surprised when the execution path does not exactly match your source file! An extreme example: if you define a variable, but never use it, never sees that variable--because the compiler optimizes it out of existence.

Some things do not work as well with `-g -O' as with just `-g', particularly on machines with instruction scheduling. If in doubt, recompile with `-g' alone, and if this fixes the problem, please report it as a bug (including a test case!).

Older versions of the GNU C compiler permitted a variant option `-gg' for debugging information. no longer supports this format; if your GNU C compiler has this option, do not use it.

4.2 Starting your program

run
r: Use the run command to start your program under . You must first specify the program name with an argument to (see section 2 Getting In and Out of), or by using the file or exec-file command (see section 12.1 Commands to specify files).

If you are running your program in an execution environment that supports processes, run creates an inferior process and makes that process run your program. (In environments without processes, run jumps to the start of your program.)

The execution of a program is affected by certain information it receives from its superior. provides ways to specify this information, which you must do before starting your program. (You can change it after starting your program, but such changes only affect your program the next time you start it.) This information may be divided into four categories:

The arguments.: Specify the arguments to give your program as the arguments of the run command. If a shell is available on your target, the shell is used to pass the arguments, so that you may use normal conventions (such as wildcard expansion or variable substitution) in describing the arguments. In Unix systems, you can control which shell is used with the SHELL environment variable. See section 4.3 Your program's arguments.
The environment.: Your program normally inherits its environment from , but you can use the commands set environment and unset environment to change parts of the environment that affect your program. See section 4.4 Your program's environment.
The working directory.: Your program inherits its working directory from . You can set the working directory with the cd command in . See section 4.5 Your program's working directory.
The standard input and output.: Your program normally uses the same device for standard input and standard output as is using. You can redirect input and output in the run command line, or you can use the tty command to set a different device for your program. See section 4.6 Your program's input and output. Warning: While input and output redirection work, you cannot use pipes to pass the output of the program you are debugging to another program; if you attempt this, is likely to wind up debugging the wrong program.

When you issue the run command, your program begins to execute immediately. See section 5 Stopping and Continuing, for discussion of how to arrange for your program to stop. Once your program has stopped, you may call functions in your program, using the print or call commands. See section 8 Examining Data.

If the modification time of your symbol file has changed since the last time read its symbols, discards its symbol table, and reads it again. When it does this, tries to retain your current breakpoints.

4.3 Your program's arguments

The arguments to your program can be specified by the arguments of the run command. They are passed to a shell, which expands wildcard characters and performs redirection of I/O, and thence to your program. Your SHELL environment variable (if it exists) specifies what shell uses. If you do not define SHELL, uses /bin/sh.

run with no arguments uses the same arguments used by the previous run, or those set by the set args command.

set args: Specify the arguments to be used the next time your program is run. If set args has no arguments, run executes your program with no arguments. Once you have run your program with arguments, using set args before the next run is the only way to run it again without arguments.
show args: Show the arguments to give your program when it is started.

4.4 Your program's environment

The environment consists of a set of environment variables and their values. Environment variables conventionally record such things as your user name, your home directory, your terminal type, and your search path for programs to run. Usually you set up environment variables with the shell and they are inherited by all the other programs you run. When debugging, it can be useful to try running your program with a modified environment without having to start over again.

path directory: Add directory to the front of the PATH environment variable (the search path for executables), for both and your program. You may specify several directory names, separated by `:' or whitespace. If directory is already in the path, it is moved to the front, so it is searched sooner. You can use the string `$cwd' to refer to whatever is the current working directory at the time searches the path. If you use `.' instead, it refers to the directory where you executed the path command. replaces `.' in the directory argument (with the current path) before adding directory to the search path.
show paths: Display the list of search paths for executables (the PATH environment variable).
show environment [varname]: Print the value of environment variable varname to be given to your program when it starts. If you do not supply varname, print the names and values of all environment variables to be given to your program. You can abbreviate environment as env.
set environment varname [=] value: Set environment variable varname to value. The value changes for your program only, not for itself. value may be any string; the values of environment variables are just strings, and any interpretation is supplied by your program itself. The value parameter is optional; if it is eliminated, the variable is set to a null value. For example, this command:
unset environment varname: Remove variable varname from the environment to be passed to your program. This is different from `set env varname ='; unset environment removes the variable from the environment, rather than assigning it an empty value.

Warning: runs your program using the shell indicated by your SHELL environment variable if it exists (or /bin/sh if not). If your SHELL variable names a shell that runs an initialization file--such as `.cshrc' for C-shell, or `.bashrc' for BASH--any variables you set in that file affect your program. You may wish to move setting of environment variables to files that are only run when you sign on, such as `.login' or `.profile'.

4.5 Your program's working directory

Each time you start your program with run, it inherits its working directory from the current working directory of . The working directory is initially whatever it inherited from its parent process (typically the shell), but you can specify a new working directory in with the cd command.

The working directory also serves as a default for the commands that specify files for to operate on. See section 12.1 Commands to specify files.

cd directory: Set the working directory to directory.
pwd: Print the working directory.

4.6 Your program's input and output

By default, the program you run under does input and output to the same terminal that uses. switches the terminal to its own terminal modes to interact with you, but it records the terminal modes your program was using and switches back to them when you continue running your program.

info terminal: Displays information recorded by about the terminal modes your program is using.

You can redirect your program's input and/or output using shell redirection with the run command. For example,

run > outfile

starts your program, diverting its output to the file `outfile'.

Another way to specify where your program should do input and output is with the tty command. This command accepts a file name as argument, and causes this file to be the default for future run commands. It also resets the controlling terminal for the child process, for future run commands. For example,

tty /dev/ttyb

directs that processes started with subsequent run commands default to do input and output on the terminal `/dev/ttyb' and have that as their controlling terminal.

An explicit redirection in run overrides the tty command's effect on the input/output device, but not its effect on the controlling terminal.

When you use the tty command or redirect input in the run command, only the input for your program is affected. The input for still comes from your terminal.

4.7 Debugging an already-running process

attach process-id: This command attaches to a running process--one that was started outside . (info files shows your active targets.) The command takes as argument a process ID. The usual way to find out the process-id of a Unix process is with the ps utility, or with the `jobs -l' shell command. attach does not repeat if you press RET a second time after executing the command.

To use attach, your program must be running in an environment which supports processes; for example, attach does not work for programs on bare-board targets that lack an operating system. You must also have permission to send the process a signal.

When using attach, you should first use the file command to specify the program running in the process and load its symbol table. See section 12.1 Commands to specify files.

The first thing does after arranging to debug the specified process is to stop it. You can examine and modify an attached process with all the commands that are ordinarily available when you start processes with run. You can insert breakpoints; you can step and continue; you can modify storage. If you would rather the process continue running, you may use the continue command after attaching to the process.

detach: When you have finished debugging the attached process, you can use the detach command to release it from control. Detaching the process continues its execution. After the detach command, that process and become completely independent once more, and you are ready to attach another process or start one with run. detach does not repeat if you press RET again after executing the command.

If you exit or use the run command while you have an attached process, you kill that process. By default, asks for confirmation if you try to do either of these things; you can control whether or not you need to confirm by using the set confirm command (see section 14.6 Optional warnings and messages).

4.8 Killing the child process

kill: Kill the child process in which your program is running under .

This command is useful if you wish to debug a core dump instead of a running process. ignores any core dump file while your program is running.

On some operating systems, a program cannot be executed outside while you have breakpoints set on it inside . You can use the kill command in this situation to permit running your program outside the debugger.

The kill command is also useful if you wish to recompile and relink your program, since on many systems it is impossible to modify an executable file while it is running in a process. In this case, when you next type run, notices that the file has changed, and reads the symbol table again (while trying to preserve your current breakpoint settings).

4.9 Additional process information

Some operating systems provide a facility called `/proc' that can be used to examine the image of a running process using file-system subroutines. If is configured for an operating system with this facility, the command info proc is available to report on several kinds of information about the process running your program.

info proc: Summarize available information about the process.
info proc mappings: Report on the address ranges accessible in the program, with information on whether your program may read, write, or execute each range.
info proc times: Starting time, user CPU time, and system CPU time for your program and its children.
info proc id: Report on the process IDs related to your program: its own process ID, the ID of its parent, the process group ID, and the session ID.
info proc status: General information on the state of the process. If the process is stopped, this report includes the reason for stopping, and any signal received.
info proc all: Show all the above information about the process.

4.10 Debugging programs with multiple threads

In some operating systems, a single program may have more than one thread of execution. The precise semantics of threads differ from one operating system to another, but in general the threads of a single program are akin to multiple processes--except that they share one address space (that is, they can all examine and modify the same variables). On the other hand, each thread has its own registers and execution stack, and perhaps private memory.

provides these facilities for debugging multi-thread programs:

automatic notification of new threads
`thread threadno', a command to switch among threads
`info threads', a command to inquire about existing threads
thread-specific breakpoints

Warning: These facilities are not yet available on every configuration where the operating system supports threads. If your does not support threads, these commands have no effect. For example, a system without thread support shows no output from `info threads', and always rejects the thread command, like this:
() info threads
() thread 1
Thread ID 1 not known.  Use the "info threads" command to
see the IDs of currently known threads.

The thread debugging facility allows you to observe all threads while your program runs--but whenever takes control, one thread in particular is always the focus of debugging. This thread is called the current thread. Debugging commands show program information from the perspective of the current thread.

Whenever detects a new thread in your program, it displays the target system's identification for the thread with a message in the form `[New systag]'. systag is a thread identifier whose form varies depending on the particular system. For example, on LynxOS, you might see

[New process 35 thread 27]

when notices a new thread. In contrast, on an SGI system, the systag is simply something like `process 368', with no further qualifier.

For debugging purposes, associates its own thread number--always a single integer--with each thread in your program.

info threads: Display a summary of all threads currently in your program. displays for each thread (in this order):

() info threads
  3 process 35 thread 27  0x34e5 in sigpause ()
  2 process 35 thread 23  0x34e5 in sigpause ()
* 1 process 35 thread 13  main (argc=1, argv=0x7ffffff8)
    at threadtest.c:68

thread threadno: Make thread number threadno the current thread. The command argument threadno is the internal thread number, as shown in the first field of the `info threads' display. responds by displaying the system identifier of the thread you selected, and its current stack frame summary:

Whenever stops your program, due to a breakpoint or a signal, it automatically selects the thread where that breakpoint or signal happened. alerts you to the context switch with a message of the form `[Switching to systag]' to identify the thread.

See section 5.3 Stopping and starting multi-thread programs, for more information about how behaves when you stop and start programs with multiple threads.

See section 5.1.2 Setting watchpoints, for information about watchpoints in programs with multiple threads.

5 Stopping and Continuing

The principal purposes of using a debugger are so that you can stop your program before it terminates; or so that, if your program runs into trouble, you can investigate and find out why.

Inside , your program may stop for any of several reasons, such as a signal, a breakpoint, or reaching a new line after a command such as step. You may then examine and change variables, set new breakpoints or remove old ones, and then continue execution. Usually, the messages shown by provide ample explanation of the status of your program--but you can also explicitly request this information at any time.

info program: Display information about the status of your program: whether it is running or not, what process it is, and why it stopped.

Breakpoints: Breakpoints, watchpoints, and exceptions
Continuing and Stepping: Resuming execution
Thread Stops: Stopping and starting multi-thread programs

5.1 Breakpoints, watchpoints, and exceptions

A breakpoint makes your program stop whenever a certain point in the program is reached. For each breakpoint, you can add conditions to control in finer detail whether your program stops. You can set breakpoints with the break command and its variants (see section 5.1.1 Setting breakpoints), to specify the place where your program should stop by line number, function name or exact address in the program. In languages with exception handling (such as GNU C++), you can also set breakpoints where an exception is raised (see section 5.1.3 Breakpoints and exceptions).

A watchpoint is a special breakpoint that stops your program when the value of an expression changes. You must use a different command to set watchpoints (see section 5.1.2 Setting watchpoints), but aside from that, you can manage a watchpoint like any other breakpoint: you enable, disable, and delete both breakpoints and watchpoints using the same commands.

You can arrange to have values from your program displayed automatically whenever stops at a breakpoint. See section 8.6 Automatic display.

assigns a number to each breakpoint or watchpoint when you create it; these numbers are successive integers starting with one. In many of the commands for controlling various features of breakpoints you use the breakpoint number to say which breakpoint you want to change. Each breakpoint may be enabled or disabled; if disabled, it has no effect on your program until you enable it again.

Set Breaks: Setting breakpoints
Set Watchpoints: Setting watchpoints
Exception Handling: Breakpoints and exceptions
Delete Breaks: Deleting breakpoints
Disabling: Disabling breakpoints
Conditions: Break conditions
Break Commands: Breakpoint command lists
Breakpoint Menus: Breakpoint menus
Error in Breakpoints: "Cannot insert breakpoints"

5.1.1 Setting breakpoints

Breakpoints are set with the break command (abbreviated b). The debugger convenience variable `$bpnum' records the number of the beakpoint you've set most recently; see section 8.9 Convenience variables, for a discussion of what you can do with convenience variables.

You have several ways to say where the breakpoint should go.

break function: Set a breakpoint at entry to function function. When using source languages that permit overloading of symbols, such as C++, function may refer to more than one possible place to break. See section 5.1.8 Breakpoint menus, for a discussion of that situation.
break +offset
break -offset: Set a breakpoint some number of lines forward or back from the position at which execution stopped in the currently selected frame.
break linenum: Set a breakpoint at line linenum in the current source file. That file is the last file whose source text was printed. This breakpoint stops your program just before it executes any of the code on that line.
break filename:linenum: Set a breakpoint at line linenum in source file filename.
break filename:function: Set a breakpoint at entry to function function found in file filename. Specifying a file name as well as a function name is superfluous except when multiple files contain similarly named functions.
break *address: Set a breakpoint at address address. You can use this to set breakpoints in parts of your program which do not have debugging information or source files.
break: When called without any arguments, break sets a breakpoint at the next instruction to be executed in the selected stack frame (see section 6 Examining the Stack). In any selected frame but the innermost, this makes your program stop as soon as control returns to that frame. This is similar to the effect of a finish command in the frame inside the selected frame--except that finish does not leave an active breakpoint. If you use break without an argument in the innermost frame, stops the next time it reaches the current location; this may be useful inside loops. normally ignores breakpoints when it resumes execution, until at least one instruction has been executed. If it did not do this, you would be unable to proceed past a breakpoint without first disabling the breakpoint. This rule applies whether or not the breakpoint already existed when your program stopped.
break ... if cond: Set a breakpoint with condition cond; evaluate the expression cond each time the breakpoint is reached, and stop only if the value is nonzero--that is, if cond evaluates as true. `...' stands for one of the possible arguments described above (or no argument) specifying where to break. See section 5.1.6 Break conditions, for more information on breakpoint conditions.
tbreak args: Set a breakpoint enabled only for one stop. args are the same as for the break command, and the breakpoint is set in the same way, but the breakpoint is automatically deleted after the first time your program stops there. See section 5.1.5 Disabling breakpoints.
rbreak regex: Set breakpoints on all functions matching the regular expression regex. This command sets an unconditional breakpoint on all matches, printing a list of all breakpoints it set. Once these breakpoints are set, they are treated just like the breakpoints set with the break command. You can delete them, disable them, or make them conditional the same way as any other breakpoint. When debugging C++ programs, rbreak is useful for setting breakpoints on overloaded functions that are not members of any special classes.
info breakpoints [n]
info break [n]
info watchpoints [n]: Print a table of all breakpoints and watchpoints set and not deleted, with the following columns for each breakpoint:

allows you to set any number of breakpoints at the same place in your program. There is nothing silly or meaningless about this. When the breakpoints are conditional, this is even useful (see section 5.1.6 Break conditions).

itself sometimes sets breakpoints in your program for special purposes, such as proper handling of longjmp (in C programs). These internal breakpoints are assigned negative numbers, starting with -1; `info breakpoints' does not display them.

You can see these breakpoints with the maintenance command `maint info breakpoints'.

maint info breakpoints: Using the same format as `info breakpoints', display both the breakpoints you've set explicitly, and those is using for internal purposes. Internal breakpoints are shown with negative breakpoint numbers. The type column identifies what kind of breakpoint is shown:

5.1.2 Setting watchpoints

You can use a watchpoint to stop execution whenever the value of an expression changes, without having to predict a particular place where this may happen.

Watchpoints currently execute two orders of magnitude more slowly than other breakpoints, but this can be well worth it to catch errors where you have no clue what part of your program is the culprit.

watch expr: Set a watchpoint for an expression.
info watchpoints: This command prints a list of watchpoints and breakpoints; it is the same as info break.

Warning: in multi-thread programs, watchpoints have only limited usefulness. With the current watchpoint implementation, can only watch the value of an expression in a single thread. If you are confident that the expression can only change due to the current thread's activity (and if you are also confident that no other thread can become current), then you can use watchpoints as usual. However, may not notice when a non-current thread's activity changes the expression.

5.1.3 Breakpoints and exceptions

Some languages, such as GNU C++, implement exception handling. You can use to examine what caused your program to raise an exception, and to list the exceptions your program is prepared to handle at a given point in time.

catch exceptions: You can set breakpoints at active exception handlers by using the catch command. exceptions is a list of names of exceptions to catch.

You can use info catch to list active exception handlers. See section 6.4 Information about a frame.

There are currently some limitations to exception handling in :

If you call a function interactively, normally returns control to you when the function has finished executing. If the call raises an exception, however, the call may bypass the mechanism that returns control to you and cause your program to simply continue running until it hits a breakpoint, catches a signal that is listening for, or exits.
You cannot raise an exception interactively.
You cannot install an exception handler interactively.

Sometimes catch is not the best way to debug exception handling: if you need to know exactly where an exception is raised, it is better to stop before the exception handler is called, since that way you can see the stack before any unwinding takes place. If you set a breakpoint in an exception handler instead, it may not be easy to find out where the exception was raised.

To stop just before an exception handler is called, you need some knowledge of the implementation. In the case of GNU C++, exceptions are raised by calling a library function named __raise_exception which has the following ANSI C interface:

    /* addr is where the exception identifier is stored.
       ID is the exception identifier.  */
    void __raise_exception (void **addr, void *id);

To make the debugger catch all exceptions before any stack unwinding takes place, set a breakpoint on __raise_exception (see section 5.1 Breakpoints, watchpoints, and exceptions).

With a conditional breakpoint (see section 5.1.6 Break conditions) that depends on the value of id, you can stop your program when a specific exception is raised. You can use multiple conditional breakpoints to stop your program when any of a number of exceptions are raised.

5.1.4 Deleting breakpoints

It is often necessary to eliminate a breakpoint or watchpoint once it has done its job and you no longer want your program to stop there. This is called deleting the breakpoint. A breakpoint that has been deleted no longer exists; it is forgotten.

With the clear command you can delete breakpoints according to where they are in your program. With the delete command you can delete individual breakpoints or watchpoints by specifying their breakpoint numbers.

It is not necessary to delete a breakpoint to proceed past it. automatically ignores breakpoints on the first instruction to be executed when you continue execution without changing the execution address.

clear: Delete any breakpoints at the next instruction to be executed in the selected stack frame (see section 6.3 Selecting a frame). When the innermost frame is selected, this is a good way to delete a breakpoint where your program just stopped.
clear function
clear filename:function: Delete any breakpoints set at entry to the function function.
clear linenum
clear filename:linenum: Delete any breakpoints set at or within the code of the specified line.
delete [breakpoints] [bnums...]: Delete the breakpoints or watchpoints of the numbers specified as arguments. If no argument is specified, delete all breakpoints ( asks confirmation, unless you have set confirm off). You can abbreviate this command as d.

5.1.5 Disabling breakpoints

Rather than deleting a breakpoint or watchpoint, you might prefer to disable it. This makes the breakpoint inoperative as if it had been deleted, but remembers the information on the breakpoint so that you can enable it again later.

You disable and enable breakpoints and watchpoints with the enable and disable commands, optionally specifying one or more breakpoint numbers as arguments. Use info break or info watch to print a list of breakpoints or watchpoints if you do not know which numbers to use.

A breakpoint or watchpoint can have any of four different states of enablement:

Enabled. The breakpoint stops your program. A breakpoint set with the break command starts out in this state.
Disabled. The breakpoint has no effect on your program.
Enabled once. The breakpoint stops your program, but then becomes disabled. A breakpoint set with the tbreak command starts out in this state.
Enabled for deletion. The breakpoint stops your program, but immediately after it does so it is deleted permanently.

You can use the following commands to enable or disable breakpoints and watchpoints:

disable [breakpoints] [bnums...]: Disable the specified breakpoints--or all breakpoints, if none are listed. A disabled breakpoint has no effect but is not forgotten. All options such as ignore-counts, conditions and commands are remembered in case the breakpoint is enabled again later. You may abbreviate disable as dis.
enable [breakpoints] [bnums...]: Enable the specified breakpoints (or all defined breakpoints). They become effective once again in stopping your program.
enable [breakpoints] once bnums...: Enable the specified breakpoints temporarily. disables any of these breakpoints immediately after stopping your program.
enable [breakpoints] delete bnums...: Enable the specified breakpoints to work once, then die. deletes any of these breakpoints as soon as your program stops there.

Save for a breakpoint set with tbreak (see section 5.1.1 Setting breakpoints), breakpoints that you set are initially enabled; subsequently, they become disabled or enabled only when you use one of the commands above. (The command until can set and delete a breakpoint of its own, but it does not change the state of your other breakpoints; see section 5.2 Continuing and stepping.)

5.1.6 Break conditions

The simplest sort of breakpoint breaks every time your program reaches a specified place. You can also specify a condition for a breakpoint. A condition is just a Boolean expression in your programming language (see section 8.1 Expressions). A breakpoint with a condition evaluates the expression each time your program reaches it, and your program stops only if the condition is true.

This is the converse of using assertions for program validation; in that situation, you want to stop when the assertion is violated--that is, when the condition is false. In C, if you want to test an assertion expressed by the condition assert, you should set the condition `! assert' on the appropriate breakpoint.

Conditions are also accepted for watchpoints; you may not need them, since a watchpoint is inspecting the value of an expression anyhow--but it might be simpler, say, to just set a watchpoint on a variable name, and specify a condition that tests whether the new value is an interesting one.

Break conditions can have side effects, and may even call functions in your program. This can be useful, for example, to activate functions that log program progress, or to use your own print functions to format special data structures. The effects are completely predictable unless there is another enabled breakpoint at the same address. (In that case, might see the other breakpoint first and stop your program without checking the condition of this one.) Note that breakpoint commands are usually more convenient and flexible for the purpose of performing side effects when a breakpoint is reached (see section 5.1.7 Breakpoint command lists).

Break conditions can be specified when a breakpoint is set, by using `if' in the arguments to the break command. See section 5.1.1 Setting breakpoints. They can also be changed at any time with the condition command. The watch command does not recognize the if keyword; condition is the only way to impose a further condition on a watchpoint.

condition bnum expression: Specify expression as the break condition for breakpoint or watchpoint number bnum. After you set a condition, breakpoint bnum stops your program only if the value of expression is true (nonzero, in C). When you use condition, checks expression immediately for syntactic correctness, and to determine whether symbols in it have referents in the context of your breakpoint. does not actually evaluate expression at the time the condition command is given, however. See section 8.1 Expressions.
condition bnum: Remove the condition from breakpoint number bnum. It becomes an ordinary unconditional breakpoint.

A special case of a breakpoint condition is to stop only when the breakpoint has been reached a certain number of times. This is so useful that there is a special way to do it, using the ignore count of the breakpoint. Every breakpoint has an ignore count, which is an integer. Most of the time, the ignore count is zero, and therefore has no effect. But if your program reaches a breakpoint whose ignore count is positive, then instead of stopping, it just decrements the ignore count by one and continues. As a result, if the ignore count value is n, the breakpoint does not stop the next n times your program reaches it.

ignore bnum count: Set the ignore count of breakpoint number bnum to count. The next count times the breakpoint is reached, your program's execution does not stop; other than to decrement the ignore count, takes no action. To make the breakpoint stop the next time it is reached, specify a count of zero. When you use continue to resume execution of your program from a breakpoint, you can specify an ignore count directly as an argument to continue, rather than using ignore. See section 5.2 Continuing and stepping. If a breakpoint has a positive ignore count and a condition, the condition is not checked. Once the ignore count reaches zero, resumes checking the condition. You could achieve the effect of the ignore count with a condition such as `$foo-- <= 0' using a debugger convenience variable that is decremented each time. See section 8.9 Convenience variables.

5.1.7 Breakpoint command lists

You can give any breakpoint (or watchpoint) a series of commands to execute when your program stops due to that breakpoint. For example, you might want to print the values of certain expressions, or enable other breakpoints.

commands [bnum]
... command-list ...
end: Specify a list of commands for breakpoint number bnum. The commands themselves appear on the following lines. Type a line containing just end to terminate the commands. To remove all commands from a breakpoint, type commands and follow it immediately with end; that is, give no commands. With no bnum argument, commands refers to the last breakpoint or watchpoint set (not to the breakpoint most recently encountered).

Pressing RET as a means of repeating the last command is disabled within a command-list.

You can use breakpoint commands to start your program up again. Simply use the continue command, or step, or any other command that resumes execution.

Any other commands in the command list, after a command that resumes execution, are ignored. This is because any time you resume execution (even with a simple next or step), you may encounter another breakpoint--which could have its own command list, leading to ambiguities about which list to execute.

If the first command you specify in a command list is silent, the usual message about stopping at a breakpoint is not printed. This may be desirable for breakpoints that are to print a specific message and then continue. If none of the remaining commands print anything, you see no sign that the breakpoint was reached. silent is meaningful only at the beginning of a breakpoint command list.

The commands echo, output, and printf allow you to print precisely controlled output, and are often useful in silent breakpoints. See section 15.4 Commands for controlled output.

For example, here is how you could use breakpoint commands to print the value of x at entry to foo whenever x is positive.

break foo if x>0
commands
silent
printf "x is %d\n",x
cont
end

One application for breakpoint commands is to compensate for one bug so you can test for another. Put a breakpoint just after the erroneous line of code, give it a condition to detect the case in which something erroneous has been done, and give it commands to assign correct values to any variables that need them. End with the continue command so that your program does not stop, and start with the silent command so that no output is produced. Here is an example:

break 403
commands
silent
set x = y + 4
cont
end

5.1.8 Breakpoint menus

Some programming languages (notably C++) permit a single function name to be defined several times, for application in different contexts. This is called overloading. When a function name is overloaded, `break function' is not enough to tell where you want a breakpoint. If you realize this is a problem, you can use something like `break function(types)' to specify which particular version of the function you want. Otherwise, offers you a menu of numbered choices for different possible breakpoints, and waits for your selection with the prompt `>'. The first two options are always `[0] cancel' and `[1] all'. Typing 1 sets a breakpoint at each definition of function, and typing 0 aborts the break command without setting any new breakpoints.

For example, the following session excerpt shows an attempt to set a breakpoint at the overloaded symbol String::after. We choose three particular definitions of that function name:

() b String::after
[0] cancel
[1] all
[2] file:String.cc; line number:867
[3] file:String.cc; line number:860
[4] file:String.cc; line number:875
[5] file:String.cc; line number:853
[6] file:String.cc; line number:846
[7] file:String.cc; line number:735
> 2 4 6
Breakpoint 1 at 0xb26c: file String.cc, line 867.
Breakpoint 2 at 0xb344: file String.cc, line 875.
Breakpoint 3 at 0xafcc: file String.cc, line 846.
Multiple breakpoints were set.
Use the "delete" command to delete unwanted
 breakpoints.
()

5.1.9 "Cannot insert breakpoints"

Under some operating systems, breakpoints cannot be used in a program if any other process is running that program. In this situation, attempting to run or continue a program with a breakpoint causes to stop the other process.

When this happens, you have three ways to proceed:

Remove or disable the breakpoints, then continue.
Suspend , and copy the file containing your program to a new name. Resume and use the exec-file command to specify that should run your program under that name. Then start your program again.
Relink your program so that the text segment is nonsharable, using the linker option `-N'. The operating system limitation may not apply to nonsharable executables.

5.2 Continuing and stepping

Continuing means resuming program execution until your program completes normally. In contrast, stepping means executing just one more "step" of your program, where "step" may mean either one line of source code, or one machine instruction (depending on what particular command you use). Either when continuing or when stepping, your program may stop even sooner, due to a breakpoint or a signal. (If due to a signal, you may want to use handle, or use `signal 0' to resume execution. @xref{Signals, ,Signals}.)

continue [ignore-count]
c [ignore-count]
fg [ignore-count]: Resume program execution, at the address where your program last stopped; any breakpoints set at that address are bypassed. The optional argument ignore-count allows you to specify a further number of times to ignore a breakpoint at this location; its effect is like that of ignore (see section 5.1.6 Break conditions). The argument ignore-count is meaningful only when your program stopped due to a breakpoint. At other times, the argument to continue is ignored. The synonyms c and fg are provided purely for convenience, and have exactly the same behavior as continue.

To resume execution at a different place, you can use return (see section 11.4 Returning from a function) to go back to the calling function; or jump (see section 11.2 Continuing at a different address) to go to an arbitrary location in your program.

A typical technique for using stepping is to set a breakpoint (see section 5.1 Breakpoints, watchpoints, and exceptions) at the beginning of the function or the section of your program where a problem is believed to lie, run your program until it stops at that breakpoint, and then step through the suspect area, examining the variables that are interesting, until you see the problem happen.

step: Continue running your program until control reaches a different source line, then stop it and return control to . This command is abbreviated s.
step count: Continue running as in step, but do so count times. If a breakpoint is reached, or a signal not related to stepping occurs before count steps, stepping stops right away.
next [count]: Continue to the next source line in the current (innermost) stack frame. Similar to step, but any function calls appearing within the line of code are executed without stopping. Execution stops when control reaches a different line of code at the stack level which was executing when the next command was given. This command is abbreviated

Debugging with

The GNU Source-Level Debugger

Edition 4.12, for version

January 1994

Table of Contents