This file documents the GNU debugger {No value for `GDBN'}. This is the Ninth Edition, December 2001, of `Debugging with {No value for `GDBN'}: the GNU Source-Level Debugger' for {No value for `GDBN'} Version {No value for `GDBVN'}. Copyright (C) 1988,1989,1990,1991,1992,1993,1994,1995,1996,1998,1999,2000,2001 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.1 or any later version published by the Free Software Foundation; with the Invariant Sections being "Free Software" and "Free Software Needs Free Documentation", with the Front-Cover Texts being "A GNU Manual," and with the Back-Cover Texts as in (a) below. (a) 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." Debugging with {No value for `GDBN'} ************************************ This file describes {No value for `GDBN'}, the GNU symbolic debugger. This is the Ninth Edition, December 2001, for {No value for `GDBN'} Version {No value for `GDBVN'}. Copyright (C) 1988-2001 Free Software Foundation, Inc. Summary of {No value for `GDBN'} ******************************** The purpose of a debugger such as {No value for `GDBN'} 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. {No value for `GDBN'} 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 {No value for `GDBN'} to debug programs written in C and C++. For more information, see *Note Supported languages: Support. For more information, see *Note C and C++: C. Support for Modula-2 and Chill is partial. For information on Modula-2, see *Note Modula-2: Modula-2. For information on Chill, see *Note Chill::. Debugging Pascal programs which use sets, subranges, file variables, or nested functions does not currently work. {No value for `GDBN'} does not support entering expressions, printing values, or similar features using Pascal syntax. {No value for `GDBN'} can be used to debug programs written in Fortran, although it may be necessary to refer to some variables with a trailing underscore. Free software ============= {No value for `GDBN'} 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. Free Software Needs Free Documentation ====================================== The biggest deficiency in the free software community today is not in the software--it is the lack of good free documentation that we can include with the free software. Many of our most important programs do not come with free reference manuals and free introductory texts. Documentation is an essential part of any software package; when an important free software package does not come with a free manual and a free tutorial, that is a major gap. We have many such gaps today. Consider Perl, for instance. The tutorial manuals that people normally use are non-free. How did this come about? Because the authors of those manuals published them with restrictive terms--no copying, no modification, source files not available--which exclude them from the free software world. That wasn't the first time this sort of thing happened, and it was far from the last. Many times we have heard a GNU user eagerly describe a manual that he is writing, his intended contribution to the community, only to learn that he had ruined everything by signing a publication contract to make it non-free. Free documentation, like free software, is a matter of freedom, not price. The problem with the non-free manual is not that publishers charge a price for printed copies--that in itself is fine. (The Free Software Foundation sells printed copies of manuals, too.) The problem is the restrictions on the use of the manual. Free manuals are available in source code form, and give you permission to copy and modify. Non-free manuals do not allow this. The criteria of freedom for a free manual are roughly the same as for free software. Redistribution (including the normal kinds of commercial redistribution) must be permitted, so that the manual can accompany every copy of the program, both on-line and on paper. Permission for modification of the technical content is crucial too. When people modify the software, adding or changing features, if they are conscientious they will change the manual too--so they can provide accurate and clear documentation for the modified program. A manual that leaves you no choice but to write a new manual to document a changed version of the program is not really available to our community. Some kinds of limits on the way modification is handled are acceptable. For example, requirements to preserve the original author's copyright notice, the distribution terms, or the list of authors, are ok. It is also no problem to require modified versions to include notice that they were modified. Even entire sections that may not be deleted or changed are acceptable, as long as they deal with nontechnical topics (like this one). These kinds of restrictions are acceptable because they don't obstruct the community's normal use of the manual. However, it must be possible to modify all the _technical_ content of the manual, and then distribute the result in all the usual media, through all the usual channels. Otherwise, the restrictions obstruct the use of the manual, it is not free, and we need another manual to replace it. Please spread the word about this issue. Our community continues to lose manuals to proprietary publishing. If we spread the word that free software needs free reference manuals and free tutorials, perhaps the next person who wants to contribute by writing documentation will realize, before it is too late, that only free manuals contribute to the free software community. If you are writing documentation, please insist on publishing it under the GNU Free Documentation License or another free documentation license. Remember that this decision requires your approval--you don't have to let the publisher decide. Some commercial publishers will use a free license if you insist, but they will not propose the option; it is up to you to raise the issue and say firmly that this is what you want. If the publisher you are dealing with refuses, please try other publishers. If you're not sure whether a proposed license is free, write to . You can encourage commercial publishers to sell more free, copylefted manuals and tutorials by buying them, and particularly by buying copies from the publishers that paid for their writing or for major improvements. Meanwhile, try to avoid buying non-free documentation at all. Check the distribution terms of a manual before you buy it, and insist that whoever seeks your business must respect your freedom. Check the history of the book, and try to reward the publishers that have paid or pay the authors to work on it. The Free Software Foundation maintains a list of free documentation published by other publishers, at . Contributors to {No value for `GDBN'} ===================================== Richard Stallman was the original author of {No value for `GDBN'}, 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 {No value for `GDBN'} 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 many labors as thankless, we particularly thank those who shepherded {No value for `GDBN'} through major releases: Andrew Cagney (releases 5.0 and 5.1); Jim Blandy (release 4.18); Jason Molenda (release 4.17); Stan Shebs (release 4.14); Fred Fish (releases 4.16, 4.15, 4.13, 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). 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 {No value for `GDBN'}, with significant additional contributions from Per Bothner and Daniel Berlin. 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). {No value for `GDBN'} 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. Brent Benson of Harris Computer Systems contributed DWARF2 support. 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. Andreas Schwab contributed M68K Linux support. Rich Schaefer and Peter Schauer helped with support of SunOS shared libraries. Jay Fenlason and Roland McGrath ensured that {No value for `GDBN'} and GAS agree about several machine instruction sets. Patrick Duval, Ted Goldstein, Vikram Koka and Glenn Engel helped develop remote debugging. Intel Corporation, Wind River Systems, AMD, and ARM contributed remote debugging modules for the i960, VxWorks, A29K UDI, and RDI targets, respectively. 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, the Modula-2 support, 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 H8/300, H8/500, and Super-H processors. NEC sponsored the support for the v850, Vr4xxx, and Vr5xxx processors. Mitsubishi sponsored the support for D10V, D30V, and M32R/D processors. Toshiba sponsored the support for the TX39 Mips processor. Matsushita sponsored the support for the MN10200 and MN10300 processors. Fujitsu sponsored the support for SPARClite and FR30 processors. Kung Hsu, Jeff Law, and Rick Sladkey added support for hardware watchpoints. Michael Snyder added support for tracepoints. Stu Grossman wrote gdbserver. Jim Kingdon, Peter Schauer, Ian Taylor, and Stu Grossman made nearly innumerable bug fixes and cleanups throughout {No value for `GDBN'}. The following people at the Hewlett-Packard Company contributed support for the PA-RISC 2.0 architecture, HP-UX 10.20, 10.30, and 11.0 (narrow mode), HP's implementation of kernel threads, HP's aC++ compiler, and the terminal user interface: Ben Krepp, Richard Title, John Bishop, Susan Macchia, Kathy Mann, Satish Pai, India Paul, Steve Rehrauer, and Elena Zannoni. Kim Haase provided HP-specific information in this manual. DJ Delorie ported {No value for `GDBN'} to MS-DOS, for the DJGPP project. Robert Hoehne made significant contributions to the DJGPP port. Cygnus Solutions has sponsored {No value for `GDBN'} maintenance and much of its development since 1991. Cygnus engineers who have worked on {No value for `GDBN'} fulltime include Mark Alexander, Jim Blandy, Per Bothner, Kevin Buettner, Edith Epstein, Chris Faylor, Fred Fish, Martin Hunt, Jim Ingham, John Gilmore, Stu Grossman, Kung Hsu, Jim Kingdon, John Metzler, Fernando Nasser, Geoffrey Noer, Dawn Perchik, Rich Pixley, Zdenek Radouch, Keith Seitz, Stan Shebs, David Taylor, and Elena Zannoni. In addition, Dave Brolley, Ian Carmichael, Steve Chamberlain, Nick Clifton, JT Conklin, Stan Cox, DJ Delorie, Ulrich Drepper, Frank Eigler, Doug Evans, Sean Fagan, David Henkel-Wallace, Richard Henderson, Jeff Holcomb, Jeff Law, Jim Lemke, Tom Lord, Bob Manson, Michael Meissner, Jason Merrill, Catherine Moore, Drew Moseley, Ken Raeburn, Gavin Romig-Koch, Rob Savoye, Jamie Smith, Mike Stump, Ian Taylor, Angela Thomas, Michael Tiemann, Tom Tromey, Ron Unrau, Jim Wilson, and David Zuhn have made contributions both large and small. A Sample {No value for `GDBN'} Session ************************************** You can use this manual at your leisure to read all about {No value for `GDBN'}. However, a handful of commands are enough to get started using the debugger. This chapter illustrates those commands. 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 `' and the close quote string to `', 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(,) define(baz,defn(foo)) baz C-d m4: End of input: 0: fatal error: EOF in string Let us use {No value for `GDBN'} to try to see what is going on. $ {No value for `GDBP'} m4 {No value for `GDBN'} 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 {No value for `GDBN'}; type "show warranty" for details. {No value for `GDBN'} {No value for `GDBVN'}, Copyright 1999 Free Software Foundation, Inc... ({No value for `GDBP'}) {No value for `GDBN'} 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 {No value for `GDBN'} to use a narrower display width than usual, so that examples fit in this manual. ({No value for `GDBP'}) 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 {No value for `GDBN'} `break' command. ({No value for `GDBP'}) break m4_changequote Breakpoint 1 at 0x62f4: file builtin.c, line 879. Using the `run' command, we start `m4' running under {No value for `GDBN'} control; as long as control does not reach the `m4_changequote' subroutine, the program runs as usual: ({No value for `GDBP'}) run Starting program: /work/Editorial/gdb/gnu/m4/m4 define(foo,0000) foo 0000 To trigger the breakpoint, we call `changequote'. {No value for `GDBN'} suspends execution of `m4', displaying information about the context where it stops. changequote(,) 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. ({No value for `GDBP'}) 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'. ({No value for `GDBP'}) s set_quotes (lq=0x34c78 "", rq=0x34c88 "") 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. ({No value for `GDBP'}) bt #0 set_quotes (lq=0x34c78 "", rq=0x34c88 "") 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. ({No value for `GDBP'}) s 0x3b5c 532 if (rquote != def_rquote) ({No value for `GDBP'}) s 0x3b80 535 lquote = (lq == nil || *lq == '\0') ? \ def_lquote : xstrdup(lq); ({No value for `GDBP'}) n 536 rquote = (rq == nil || *rq == '\0') ? def_rquote\ : xstrdup(rq); ({No value for `GDBP'}) 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. ({No value for `GDBP'}) p lquote $1 = 0x35d40 "" ({No value for `GDBP'}) p rquote $2 = 0x35d50 "" `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. ({No value for `GDBP'}) 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. ({No value for `GDBP'}) n 539 len_rquote = strlen(lquote); ({No value for `GDBP'}) n 540 } ({No value for `GDBP'}) p len_lquote $3 = 9 ({No value for `GDBP'}) 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. ({No value for `GDBP'}) p len_lquote=strlen(lquote) $5 = 7 ({No value for `GDBP'}) 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: ({No value for `GDBP'}) c Continuing. define(baz,defn(foo)) 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 {No value for `GDBN'}; it indicates `m4' has finished executing. We can end our {No value for `GDBN'} session with the {No value for `GDBN'} `quit' command. ({No value for `GDBP'}) quit Getting In and Out of {No value for `GDBN'} ******************************************* This chapter discusses how to start {No value for `GDBN'}, and how to get out of it. The essentials are: * type `{No value for `GDBP'}' to start {No value for `GDBN'}. * type `quit' or `C-d' to exit. Invoking {No value for `GDBN'} ============================== Invoke {No value for `GDBN'} by running the program `{No value for `GDBP'}'. Once started, {No value for `GDBN'} reads commands from the terminal until you tell it to exit. You can also run `{No value for `GDBP'}' with a variety of arguments and options, to specify more of your debugging environment at the outset. The command-line options described here are designed to cover a variety of situations; in some environments, some of these options may effectively be unavailable. The most usual way to start {No value for `GDBN'} is with one argument, specifying an executable program: {No value for `GDBP'} PROGRAM You can also start with both an executable program and a core file specified: {No value for `GDBP'} PROGRAM CORE You can, instead, specify a process ID as a second argument, if you want to debug a running process: {No value for `GDBP'} PROGRAM 1234 would attach {No value for `GDBN'} to process `1234' (unless you also have a file named `1234'; {No value for `GDBN'} does check for a core file first). Taking advantage of the second command-line argument requires a fairly complete operating system; when you use {No value for `GDBN'} 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. {No value for `GDBN'} will warn you if it is unable to attach or to read core dumps. You can run `{No value for `GDBP'}' without printing the front material, which describes {No value for `GDBN'}'s non-warranty, by specifying `-silent': {No value for `GDBP'} -silent You can further control how {No value for `GDBN'} starts up by using command-line options. {No value for `GDBN'} itself can remind you of the options available. Type {No value for `GDBP'} -help to display all available options and briefly describe their use (`{No value for `GDBP'} -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. Choosing files -------------- When {No value for `GDBN'} 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. ({No value for `GDBN'} 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.) If {No value for `GDBN'} has not been configured to included core file support, such as for most embedded targets, then it will complain about a second argument and ignore it. Many options have both long and short forms; both are shown in the following list. {No value for `GDBN'} 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 {No value for `GDBN'} commands from file FILE. *Note Command files: 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._ If memory-mapped files are available on your system through the `mmap' system call, you can use this option to have {No value for `GDBN'} write the symbols from your program into a reusable file in the current directory. If the program you are debugging is called `/tmp/fred', the mapped symbol file is `/tmp/fred.syms'. Future {No value for `GDBN'} debugging sessions notice the presence of this file, and can quickly map in symbol information from it, rather than reading the symbol table from the executable program. The `.syms' file is specific to the host machine where {No value for `GDBN'} is run. It holds an exact image of the internal {No value for `GDBN'} symbol table. It cannot be shared across multiple host platforms. `-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. You typically combine the `-mapped' and `-readnow' options in order to build a `.syms' file that contains complete symbol information. (*Note Commands to specify files: Files, for information on `.syms' files.) A simple {No value for `GDBN'} invocation to do nothing but build a `.syms' file for future use is: gdb -batch -nx -mapped -readnow programname Choosing modes -------------- You can run {No value for `GDBN'} in various alternative modes--for example, in batch mode or quiet mode. `-nx' `-n' Do not execute commands found in any initialization files (normally called `.gdbinit', or `gdb.ini' on PCs). Normally, {No value for `GDBN'} executes the commands in these files after all the command options and arguments have been processed. *Note Command files: Command Files. `-quiet' `-silent' `-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 {No value for `GDBN'} commands in the command files. Batch mode may be useful for running {No value for `GDBN'} as a filter, for example to download and run a program on another computer; in order to make this more useful, the message Program exited normally. (which is ordinarily issued whenever a program running under {No value for `GDBN'} control terminates) is not issued when running in batch mode. `-nowindows' `-nw' "No windows". If {No value for `GDBN'} comes with a graphical user interface (GUI) built in, then this option tells {No value for `GDBN'} to only use the command-line interface. If no GUI is available, this option has no effect. `-windows' `-w' If {No value for `GDBN'} includes a GUI, then this option requires it to be used if possible. `-cd DIRECTORY' Run {No value for `GDBN'} using DIRECTORY as its working directory, instead of the current directory. `-fullname' `-f' GNU Emacs sets this option when it runs {No value for `GDBN'} as a subprocess. It tells {No value for `GDBN'} 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-{No value for `GDBN'} interface program uses the two `\032' characters as a signal to display the source code for the frame. `-epoch' The Epoch Emacs-{No value for `GDBN'} interface sets this option when it runs {No value for `GDBN'} as a subprocess. It tells {No value for `GDBN'} to modify its print routines so as to allow Epoch to display values of expressions in a separate window. `-annotate LEVEL' This option sets the "annotation level" inside {No value for `GDBN'}. Its effect is identical to using `set annotate LEVEL' (*note Annotations::). Annotation level controls how much information does {No value for `GDBN'} print together with its prompt, values of expressions, source lines, and other types of output. Level 0 is the normal, level 1 is for use when {No value for `GDBN'} is run as a subprocess of GNU Emacs, level 2 is the maximum annotation suitable for programs that control {No value for `GDBN'}. `-async' Use the asynchronous event loop for the command-line interface. {No value for `GDBN'} processes all events, such as user keyboard input, via a special event loop. This allows {No value for `GDBN'} to accept and process user commands in parallel with the debugged process being run(1), so you don't need to wait for control to return to {No value for `GDBN'} before you type the next command. (_Note:_ as of version 5.1, the target side of the asynchronous operation is not yet in place, so `-async' does not work fully yet.) When the standard input is connected to a terminal device, {No value for `GDBN'} uses the asynchronous event loop by default, unless disabled by the `-noasync' option. `-noasync' Disable the asynchronous event loop for the command-line interface. `-baud BPS' `-b BPS' Set the line speed (baud rate or bits per second) of any serial interface used by {No value for `GDBN'} for remote debugging. `-tty DEVICE' `-t DEVICE' Run using DEVICE for your program's standard input and output. `-tui' Activate the Terminal User Interface when starting. The Terminal User Interface manages several text windows on the terminal, showing source, assembly, registers and {No value for `GDBN'} command outputs (*note {No value for `GDBN'} Text User Interface: TUI.). Do not use this option if you run {No value for `GDBN'} from Emacs (*note Using {No value for `GDBN'} under GNU Emacs: Emacs.). `-interpreter INTERP' Use the interpreter INTERP for interface with the controlling program or device. This option is meant to be set by programs which communicate with {No value for `GDBN'} using it as a back end. `--interpreter=mi' (or `--interpreter=mi1') causes {No value for `GDBN'} to use the "gdb/mi interface" (*note The GDB/MI Interface: GDB/MI.). The older GDB/MI interface, included in {No value for `GDBN'} version 5.0 can be selected with `--interpreter=mi0'. `-write' Open the executable and core files for both reading and writing. This is equivalent to the `set write on' command inside {No value for `GDBN'} (*note Patching::). `-statistics' This option causes {No value for `GDBN'} to print statistics about time and memory usage after it completes each command and returns to the prompt. `-version' This option causes {No value for `GDBN'} to print its version number and no-warranty blurb, and exit. ---------- Footnotes ---------- (1) {No value for `GDBN'} built with DJGPP tools for MS-DOS/MS-Windows supports this mode of operation, but the event loop is suspended when the debuggee runs. Quitting {No value for `GDBN'} ============================== `quit [EXPRESSION]' `q' To exit {No value for `GDBN'}, use the `quit' command (abbreviated `q'), or type an end-of-file character (usually `C-d'). If you do not supply EXPRESSION, {No value for `GDBN'} will terminate normally; otherwise it will terminate using the result of EXPRESSION as the error code. An interrupt (often `C-c') does not exit from {No value for `GDBN'}, but rather terminates the action of any {No value for `GDBN'} command that is in progress and returns to {No value for `GDBN'} command level. It is safe to type the interrupt character at any time because {No value for `GDBN'} does not allow it to take effect until a time when it is safe. If you have been using {No value for `GDBN'} to control an attached process or device, you can release it with the `detach' command (*note Debugging an already-running process: Attach.). Shell commands ============== If you need to execute occasional shell commands during your debugging session, there is no need to leave or suspend {No value for `GDBN'}; you can just use the `shell' command. `shell COMMAND STRING' Invoke a standard shell to execute COMMAND STRING. If it exists, the environment variable `SHELL' determines which shell to run. Otherwise {No value for `GDBN'} uses the default shell (`/bin/sh' on Unix systems, `COMMAND.COM' on MS-DOS, etc.). The utility `make' is often needed in development environments. You do not have to use the `shell' command for this purpose in {No value for `GDBN'}: `make MAKE-ARGS' Execute the `make' program with the specified arguments. This is equivalent to `shell make MAKE-ARGS'. {No value for `GDBN'} Commands ****************************** You can abbreviate a {No value for `GDBN'} command to the first few letters of the command name, if that abbreviation is unambiguous; and you can repeat certain {No value for `GDBN'} commands by typing just . You can also use the key to get {No value for `GDBN'} 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 ============== A {No value for `GDBN'} 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 commands do not allow any arguments. {No value for `GDBN'} 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 {No value for `GDBN'} (typing just ) 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 , construct new arguments rather than repeating exactly as typed. This permits easy scanning of source or memory. {No value for `GDBN'} can also use in another way: to partition lengthy output, in a way similar to the common utility `more' (*note Screen size: Screen Size.). Since it is easy to press one too many in this situation, {No value for `GDBN'} 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 (*note Command files: Command Files.). Command completion ================== {No value for `GDBN'} 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 {No value for `GDBN'} commands, {No value for `GDBN'} subcommands, and the names of symbols in your program. Press the key whenever you want {No value for `GDBN'} to fill out the rest of a word. If there is only one possibility, {No value for `GDBN'} fills in the word, and waits for you to finish the command (or press to enter it). For example, if you type ({No value for `GDBP'}) info bre {No value for `GDBN'} fills in the rest of the word `breakpoints', since that is the only `info' subcommand beginning with `bre': ({No value for `GDBP'}) info breakpoints You can either press 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 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 , {No value for `GDBN'} sounds a bell. You can either supply more characters and try again, or just press a second time; {No value for `GDBN'} 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_' {No value for `GDBN'} just sounds the bell. Typing again displays all the function names in your program that begin with those characters, for example: ({No value for `GDBP'}) b make_ {No value for `GDBN'} sounds bell; press 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 ({No value for `GDBP'}) b make_ After displaying the available possibilities, {No value for `GDBN'} 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 twice. `M-?' means ` ?'. You can type this either by holding down a key designated as the shift on your keyboard (if there is one) while typing `?', or as followed by `?'. Sometimes the string you need, while logically a "word", may contain parentheses or other characters that {No value for `GDBN'} 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 {No value for `GDBN'} 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 {No value for `GDBN'} that it may need to consider more information than usual when you press or `M-?' to request word completion: ({No value for `GDBP'}) b 'bubble( M-? bubble(double,double) bubble(int,int) ({No value for `GDBP'}) b 'bubble( In some cases, {No value for `GDBN'} can tell that completing a name requires using quotes. When this happens, {No value for `GDBN'} inserts the quote for you (while completing as much as it can) if you do not type the quote in the first place: ({No value for `GDBP'}) b bub {No value for `GDBN'} alters your input line to the following, and rings a bell: ({No value for `GDBP'}) b 'bubble( In general, {No value for `GDBN'} 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. For more information about overloaded functions, see *Note C++ expressions: C plus plus expressions. You can use the command `set overload-resolution off' to disable overload resolution; see *Note {No value for `GDBN'} features for C++: Debugging C plus plus. Getting help ============ You can always ask {No value for `GDBN'} 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: ({No value for `GDBP'}) help List of classes of commands: aliases -- Aliases of other commands breakpoints -- Making program stop at certain points data -- Examining data files -- Specifying and examining files internals -- Maintenance commands obscure -- Obscure features running -- Running the program stack -- Examining the stack status -- Status inquiries support -- Support facilities tracepoints -- Tracing of program execution without stopping the program user-defined -- User-defined commands Type "help" followed by a class name for a list of commands in that class. Type "help" followed by command name for full documentation. Command name abbreviations are allowed if unambiguous. ({No value for `GDBP'}) `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': ({No value for `GDBP'}) help status Status inquiries. List of commands: info -- Generic command for showing things about the program being debugged show -- Generic command for showing things about the debugger Type "help" followed by command name for full documentation. Command name abbreviations are allowed if unambiguous. ({No value for `GDBP'}) `help COMMAND' With a command name as `help' argument, {No value for `GDBN'} displays a short paragraph on how to use that command. `apropos ARGS' The `apropos ARGS' command searches through all of the {No value for `GDBN'} commands, and their documentation, for the regular expression specified in ARGS. It prints out all matches found. For example: apropos reload results in: set symbol-reloading -- Set dynamic symbol table reloading multiple times in one run show symbol-reloading -- Show dynamic symbol table reloading multiple times in one run `complete ARGS' The `complete ARGS' command lists all the possible completions for the beginning of a command. Use ARGS to specify the beginning of the command you want completed. For example: complete i results in: if ignore info inspect This is intended for use by GNU Emacs. In addition to `help', you can use the {No value for `GDBN'} commands `info' and `show' to inquire about the state of your program, or the state of {No value for `GDBN'} 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. *Note 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'. `set' You can assign the result of an expression to an environment variable with `set'. For example, you can set the {No value for `GDBN'} prompt to a $-sign with `set prompt $'. `show' In contrast to `info', `show' is for describing the state of {No value for `GDBN'} 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 {No value for `GDBN'} is running. You should include this information in {No value for `GDBN'} bug-reports. If multiple versions of {No value for `GDBN'} are in use at your site, you may need to determine which version of {No value for `GDBN'} you are running; as {No value for `GDBN'} evolves, new commands are introduced, and old ones may wither away. Also, many system vendors ship variant versions of {No value for `GDBN'}, and there are variant versions of {No value for `GDBN'} in GNU/Linux distributions as well. The version number is the same as the one announced when you start {No value for `GDBN'}. `show copying' Display information about permission for copying {No value for `GDBN'}. `show warranty' Display the GNU "NO WARRANTY" statement, or a warranty, if your version of {No value for `GDBN'} comes with one. Running Programs Under {No value for `GDBN'} ******************************************** When you run a program under {No value for `GDBN'}, you must first generate debugging information when you compile it. You may start {No value for `GDBN'} with its arguments, if any, in an environment of your choice. If you are doing native debugging, you may redirect your program's input and output, debug an already running process, or kill a child process. 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. {No value for `NGCC'}, 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, {No value for `GDBN'} 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 to us as a bug (including a test case!). Older versions of the GNU C compiler permitted a variant option `-gg' for debugging information. {No value for `GDBN'} no longer supports this format; if your GNU C compiler has this option, do not use it. Starting your program ===================== `run' `r' Use the `run' command to start your program under {No value for `GDBN'}. You must first specify the program name (except on VxWorks) with an argument to {No value for `GDBN'} (*note Getting In and Out of {No value for `GDBN'}: Invocation.), or by using the `file' or `exec-file' command (*note Commands to specify files: 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. {No value for `GDBN'} 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. *Note Your program's arguments: Arguments. The _environment._ Your program normally inherits its environment from {No value for `GDBN'}, but you can use the {No value for `GDBN'} commands `set environment' and `unset environment' to change parts of the environment that affect your program. *Note Your program's environment: Environment. The _working directory._ Your program inherits its working directory from {No value for `GDBN'}. You can set the {No value for `GDBN'} working directory with the `cd' command in {No value for `GDBN'}. *Note Your program's working directory: Working Directory. The _standard input and output._ Your program normally uses the same device for standard input and standard output as {No value for `GDBN'} 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. *Note Your program's input and output: Input/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, {No value for `GDBN'} is likely to wind up debugging the wrong program. When you issue the `run' command, your program begins to execute immediately. *Note Stopping and continuing: Stopping, 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. *Note Examining Data: Data. If the modification time of your symbol file has changed since the last time {No value for `GDBN'} read its symbols, {No value for `GDBN'} discards its symbol table, and reads it again. When it does this, {No value for `GDBN'} tries to retain your current breakpoints. 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 {No value for `GDBN'} uses. If you do not define `SHELL', {No value for `GDBN'} uses the default shell (`/bin/sh' on Unix). On non-Unix systems, the program is usually invoked directly by {No value for `GDBN'}, which emulates I/O redirection via the appropriate system calls, and the wildcard characters are expanded by the startup code of the program, not by the shell. `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. 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 {No value for `GDBN'} over again. `path DIRECTORY' Add DIRECTORY to the front of the `PATH' environment variable (the search path for executables) that will be passed to your program. The value of `PATH' used by {No value for `GDBN'} does not change. You may specify several directory names, separated by whitespace or by a system-dependent separator character (`:' on Unix, `;' on MS-DOS and MS-Windows). 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 {No value for `GDBN'} searches the path. If you use `.' instead, it refers to the directory where you executed the `path' command. {No value for `GDBN'} 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 {No value for `GDBN'} 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: set env USER = foo tells the debugged program, when subsequently run, that its user is named `foo'. (The spaces around `=' are used for clarity here; they are not actually required.) `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:_ On Unix systems, {No value for `GDBN'} 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'. Your program's working directory ================================ Each time you start your program with `run', it inherits its working directory from the current working directory of {No value for `GDBN'}. The {No value for `GDBN'} working directory is initially whatever it inherited from its parent process (typically the shell), but you can specify a new working directory in {No value for `GDBN'} with the `cd' command. The {No value for `GDBN'} working directory also serves as a default for the commands that specify files for {No value for `GDBN'} to operate on. *Note Commands to specify files: Files. `cd DIRECTORY' Set the {No value for `GDBN'} working directory to DIRECTORY. `pwd' Print the {No value for `GDBN'} working directory. Your program's input and output =============================== By default, the program you run under {No value for `GDBN'} does input and output to the same terminal that {No value for `GDBN'} uses. {No value for `GDBN'} 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 {No value for `GDBN'} 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 {No value for `GDBN'} still comes from your terminal. Debugging an already-running process ==================================== `attach PROCESS-ID' This command attaches to a running process--one that was started outside {No value for `GDBN'}. (`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 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 you use `attach', the debugger finds the program running in the process first by looking in the current working directory, then (if the program is not found) by using the source file search path (*note Specifying source directories: Source Path.). You can also use the `file' command to load the program. *Note Commands to Specify Files: Files. The first thing {No value for `GDBN'} does after arranging to debug the specified process is to stop it. You can examine and modify an attached process with all the {No value for `GDBN'} 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 {No value for `GDBN'} to the process. `detach' When you have finished debugging the attached process, you can use the `detach' command to release it from {No value for `GDBN'} control. Detaching the process continues its execution. After the `detach' command, that process and {No value for `GDBN'} 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 again after executing the command. If you exit {No value for `GDBN'} or use the `run' command while you have an attached process, you kill that process. By default, {No value for `GDBN'} 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 (*note Optional warnings and messages: Messages/Warnings.). Killing the child process ========================= `kill' Kill the child process in which your program is running under {No value for `GDBN'}. This command is useful if you wish to debug a core dump instead of a running process. {No value for `GDBN'} ignores any core dump file while your program is running. On some operating systems, a program cannot be executed outside {No value for `GDBN'} while you have breakpoints set on it inside {No value for `GDBN'}. 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', {No value for `GDBN'} notices that the file has changed, and reads the symbol table again (while trying to preserve your current breakpoint settings). Debugging programs with multiple threads ======================================== In some operating systems, such as HP-UX and Solaris, 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. {No value for `GDBN'} 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 apply [THREADNO] [ALL] ARGS', a command to apply a command to a list of threads * thread-specific breakpoints _Warning:_ These facilities are not yet available on every {No value for `GDBN'} configuration where the operating system supports threads. If your {No value for `GDBN'} 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: ({No value for `GDBP'}) info threads ({No value for `GDBP'}) thread 1 Thread ID 1 not known. Use the "info threads" command to see the IDs of currently known threads. The {No value for `GDBN'} thread debugging facility allows you to observe all threads while your program runs--but whenever {No value for `GDBN'} 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 {No value for `GDBN'} 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 {No value for `GDBN'} 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, {No value for `GDBN'} 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. {No value for `GDBN'} displays for each thread (in this order): 1. the thread number assigned by {No value for `GDBN'} 2. the target system's thread identifier (SYSTAG) 3. the current stack frame summary for that thread An asterisk `*' to the left of the {No value for `GDBN'} thread number indicates the current thread. For example, ({No value for `GDBP'}) 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 On HP-UX systems: For debugging purposes, {No value for `GDBN'} associates its own thread number--a small integer assigned in thread-creation order--with each thread in your program. Whenever {No value for `GDBN'} detects a new thread in your program, it displays both {No value for `GDBN'}'s thread number and 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 HP-UX, you see [New thread 2 (system thread 26594)] when {No value for `GDBN'} notices a new thread. `info threads' Display a summary of all threads currently in your program. {No value for `GDBN'} displays for each thread (in this order): 1. the thread number assigned by {No value for `GDBN'} 2. the target system's thread identifier (SYSTAG) 3. the current stack frame summary for that thread An asterisk `*' to the left of the {No value for `GDBN'} thread number indicates the current thread. For example, ({No value for `GDBP'}) info threads * 3 system thread 26607 worker (wptr=0x7b09c318 "@") \ at quicksort.c:137 2 system thread 26606 0x7b0030d8 in __ksleep () \ from /usr/lib/libc.2 1 system thread 27905 0x7b003498 in _brk () \ from /usr/lib/libc.2 `thread THREADNO' Make thread number THREADNO the current thread. The command argument THREADNO is the internal {No value for `GDBN'} thread number, as shown in the first field of the `info threads' display. {No value for `GDBN'} responds by displaying the system identifier of the thread you selected, and its current stack frame summary: ({No value for `GDBP'}) thread 2 [Switching to process 35 thread 23] 0x34e5 in sigpause () As with the `[New ...]' message, the form of the text after `Switching to' depends on your system's conventions for identifying threads. `thread apply [THREADNO] [ALL] ARGS' The `thread apply' command allows you to apply a command to one or more threads. Specify the numbers of the threads that you want affected with the command argument THREADNO. THREADNO is the internal {No value for `GDBN'} thread number, as shown in the first field of the `info threads' display. To apply a command to all threads, use `thread apply all' ARGS. Whenever {No value for `GDBN'} stops your program, due to a breakpoint or a signal, it automatically selects the thread where that breakpoint or signal happened. {No value for `GDBN'} alerts you to the context switch with a message of the form `[Switching to SYSTAG]' to identify the thread. *Note Stopping and starting multi-thread programs: Thread Stops, for more information about how {No value for `GDBN'} behaves when you stop and start programs with multiple threads. *Note Setting watchpoints: Set Watchpoints, for information about watchpoints in programs with multiple threads. Debugging programs with multiple processes ========================================== On most systems, {No value for `GDBN'} has no special support for debugging programs which create additional processes using the `fork' function. When a program forks, {No value for `GDBN'} will continue to debug the parent process and the child process will run unimpeded. If you have set a breakpoint in any code which the child then executes, the child will get a `SIGTRAP' signal which (unless it catches the signal) will cause it to terminate. However, if you want to debug the child process there is a workaround which isn't too painful. Put a call to `sleep' in the code which the child process executes after the fork. It may be useful to sleep only if a certain environment variable is set, or a certain file exists, so that the delay need not occur when you don't want to run {No value for `GDBN'} on the child. While the child is sleeping, use the `ps' program to get its process ID. Then tell {No value for `GDBN'} (a new invocation of {No value for `GDBN'} if you are also debugging the parent process) to attach to the child process (*note Attach::). From that point on you can debug the child process just like any other process which you attached to. On HP-UX (11.x and later only?), {No value for `GDBN'} provides support for debugging programs that create additional processes using the `fork' or `vfork' function. By default, when a program forks, {No value for `GDBN'} will continue to debug the parent process and the child process will run unimpeded. If you want to follow the child process instead of the parent process, use the command `set follow-fork-mode'. `set follow-fork-mode MODE' Set the debugger response to a program call of `fork' or `vfork'. A call to `fork' or `vfork' creates a new process. The MODE can be: `parent' The original process is debugged after a fork. The child process runs unimpeded. This is the default. `child' The new process is debugged after a fork. The parent process runs unimpeded. `ask' The debugger will ask for one of the above choices. `show follow-fork-mode' Display the current debugger response to a `fork' or `vfork' call. If you ask to debug a child process and a `vfork' is followed by an `exec', {No value for `GDBN'} executes the new target up to the first breakpoint in the new target. If you have a breakpoint set on `main' in your original program, the breakpoint will also be set on the child process's `main'. When a child process is spawned by `vfork', you cannot debug the child or parent until an `exec' call completes. If you issue a `run' command to {No value for `GDBN'} after an `exec' call executes, the new target restarts. To restart the parent process, use the `file' command with the parent executable name as its argument. You can use the `catch' command to make {No value for `GDBN'} stop whenever a `fork', `vfork', or `exec' call is made. *Note Setting catchpoints: Set Catchpoints. 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 {No value for `GDBN'}, your program may stop for any of several reasons, such as a signal, a breakpoint, or reaching a new line after a {No value for `GDBN'} 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 {No value for `GDBN'} 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, watchpoints, and catchpoints ========================================= 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 (*note Setting breakpoints: Set Breaks.), to specify the place where your program should stop by line number, function name or exact address in the program. In HP-UX, SunOS 4.x, SVR4, and Alpha OSF/1 configurations, you can set breakpoints in shared libraries before the executable is run. There is a minor limitation on HP-UX systems: you must wait until the executable is run in order to set breakpoints in shared library routines that are not called directly by the program (for example, routines that are arguments in a `pthread_create' call). 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 (*note Setting watchpoints: Set 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 {No value for `GDBN'} stops at a breakpoint. *Note Automatic display: Auto Display. A "catchpoint" is another special breakpoint that stops your program when a certain kind of event occurs, such as the throwing of a C++ exception or the loading of a library. As with watchpoints, you use a different command to set a catchpoint (*note Setting catchpoints: Set Catchpoints.), but aside from that, you can manage a catchpoint like any other breakpoint. (To stop when your program receives a signal, use the `handle' command; see *Note Signals: Signals.) {No value for `GDBN'} assigns a number to each breakpoint, watchpoint, or catchpoint 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. Some {No value for `GDBN'} commands accept a range of breakpoints on which to operate. A breakpoint range is either a single breakpoint number, like `5', or two such numbers, in increasing order, separated by a hyphen, like `5-7'. When a breakpoint range is given to a command, all breakpoint in that range are operated on. Setting breakpoints ------------------- Breakpoints are set with the `break' command (abbreviated `b'). The debugger convenience variable `$bpnum' records the number of the breakpoint you've set most recently; see *Note Convenience variables: Convenience Vars, 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. *Note Breakpoint menus: 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 "stack frame". (*Note Frames: Frames, for a description of stack frames.) `break LINENUM' Set a breakpoint at line LINENUM in the current source file. The current source file is the last file whose source text was printed. The breakpoint will stop 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 (*note Examining the Stack: 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, {No value for `GDBN'} stops the next time it reaches the current location; this may be useful inside loops. {No value for `GDBN'} 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. *Note Break conditions: 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. *Note Disabling breakpoints: Disabling. `hbreak ARGS' Set a hardware-assisted breakpoint. ARGS are the same as for the `break' command and the breakpoint is set in the same way, but the breakpoint requires hardware support and some target hardware may not have this support. The main purpose of this is EPROM/ROM code debugging, so you can set a breakpoint at an instruction without changing the instruction. This can be used with the new trap-generation provided by SPARClite DSU and some x86-based targets. These targets will generate traps when a program accesses some data or instruction address that is assigned to the debug registers. However the hardware breakpoint registers can take a limited number of breakpoints. For example, on the DSU, only two data breakpoints can be set at a time, and {No value for `GDBN'} will reject this command if more than two are used. Delete or disable unused hardware breakpoints before setting new ones (*note Disabling: Disabling.). *Note Break conditions: Conditions. `thbreak ARGS' Set a hardware-assisted breakpoint enabled only for one stop. ARGS are the same as for the `hbreak' command and the breakpoint is set in the same way. However, like the `tbreak' command, the breakpoint is automatically deleted after the first time your program stops there. Also, like the `hbreak' command, the breakpoint requires hardware support and some target hardware may not have this support. *Note Disabling breakpoints: Disabling. See also *Note Break conditions: Conditions. `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. The syntax of the regular expression is the standard one used with tools like `grep'. Note that this is different from the syntax used by shells, so for instance `foo*' matches all functions that include an `fo' followed by zero or more `o's. There is an implicit `.*' leading and trailing the regular expression you supply, so to match only functions that begin with `foo', use `^foo'. 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, watchpoints, and catchpoints set and not deleted, with the following columns for each breakpoint: _Breakpoint Numbers_ _Type_ Breakpoint, watchpoint, or catchpoint. _Disposition_ Whether the breakpoint is marked to be disabled or deleted when hit. _Enabled or Disabled_ Enabled breakpoints are marked with `y'. `n' marks breakpoints that are not enabled. _Address_ Where the breakpoint is in your program, as a memory address. _What_ Where the breakpoint is in the source for your program, as a file and line number. If a breakpoint is conditional, `info break' shows the condition on the line following the affected breakpoint; breakpoint commands, if any, are listed after that. `info break' with a breakpoint number N as argument lists only that breakpoint. The convenience variable `$_' and the default examining-address for the `x' command are set to the address of the last breakpoint listed (*note Examining memory: Memory.). `info break' displays a count of the number of times the breakpoint has been hit. This is especially useful in conjunction with the `ignore' command. You can ignore a large number of breakpoint hits, look at the breakpoint info to see how many times the breakpoint was hit, and then run again, ignoring one less than that number. This will get you quickly to the last hit of that breakpoint. {No value for `GDBN'} 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 (*note Break conditions: Conditions.). {No value for `GDBN'} 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 {No value for `GDBN'} 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 {No value for `GDBN'} is using for internal purposes. Internal breakpoints are shown with negative breakpoint numbers. The type column identifies what kind of breakpoint is shown: `breakpoint' Normal, explicitly set breakpoint. `watchpoint' Normal, explicitly set watchpoint. `longjmp' Internal breakpoint, used to handle correctly stepping through `longjmp' calls. `longjmp resume' Internal breakpoint at the target of a `longjmp'. `until' Temporary internal breakpoint used by the {No value for `GDBN'} `until' command. `finish' Temporary internal breakpoint used by the {No value for `GDBN'} `finish' command. `shlib events' Shared library events. 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. Depending on your system, watchpoints may be implemented in software or hardware. {No value for `GDBN'} does software watchpointing by single-stepping your program and testing the variable's value each time, which is hundreds of times slower than normal execution. (But this may still be worth it, to catch errors where you have no clue what part of your program is the culprit.) On some systems, such as HP-UX, Linux and some other x86-based targets, {No value for `GDBN'} includes support for hardware watchpoints, which do not slow down the running of your program. `watch EXPR' Set a watchpoint for an expression. {No value for `GDBN'} will break when EXPR is written into by the program and its value changes. `rwatch EXPR' Set a watchpoint that will break when watch EXPR is read by the program. `awatch EXPR' Set a watchpoint that will break when EXPR is either read or written into by the program. `info watchpoints' This command prints a list of watchpoints, breakpoints, and catchpoints; it is the same as `info break'. {No value for `GDBN'} sets a "hardware watchpoint" if possible. Hardware watchpoints execute very quickly, and the debugger reports a change in value at the exact instruction where the change occurs. If {No value for `GDBN'} cannot set a hardware watchpoint, it sets a software watchpoint, which executes more slowly and reports the change in value at the next statement, not the instruction, after the change occurs. When you issue the `watch' command, {No value for `GDBN'} reports Hardware watchpoint NUM: EXPR if it was able to set a hardware watchpoint. Currently, the `awatch' and `rwatch' commands can only set hardware watchpoints, because accesses to data that don't change the value of the watched expression cannot be detected without examining every instruction as it is being executed, and {No value for `GDBN'} does not do that currently. If {No value for `GDBN'} finds that it is unable to set a hardware breakpoint with the `awatch' or `rwatch' command, it will print a message like this: Expression cannot be implemented with read/access watchpoint. Sometimes, {No value for `GDBN'} cannot set a hardware watchpoint because the data type of the watched expression is wider than what a hardware watchpoint on the target machine can handle. For example, some systems can only watch regions that are up to 4 bytes wide; on such systems you cannot set hardware watchpoints for an expression that yields a double-precision floating-point number (which is typically 8 bytes wide). As a work-around, it might be possible to break the large region into a series of smaller ones and watch them with separate watchpoints. If you set too many hardware watchpoints, {No value for `GDBN'} might be unable to insert all of them when you resume the execution of your program. Since the precise number of active watchpoints is unknown until such time as the program is about to be resumed, {No value for `GDBN'} might not be able to warn you about this when you set the watchpoints, and the warning will be printed only when the program is resumed: Hardware watchpoint NUM: Could not insert watchpoint If this happens, delete or disable some of the watchpoints. The SPARClite DSU will generate traps when a program accesses some data or instruction address that is assigned to the debug registers. For the data addresses, DSU facilitates the `watch' command. However the hardware breakpoint registers can only take two data watchpoints, and both watchpoints must be the same kind. For example, you can set two watchpoints with `watch' commands, two with `rwatch' commands, *or* two with `awatch' commands, but you cannot set one watchpoint with one command and the other with a different command. {No value for `GDBN'} will reject the command if you try to mix watchpoints. Delete or disable unused watchpoint commands before setting new ones. If you call a function interactively using `print' or `call', any watchpoints you have set will be inactive until {No value for `GDBN'} reaches another kind of breakpoint or the call completes. {No value for `GDBN'} automatically deletes watchpoints that watch local (automatic) variables, or expressions that involve such variables, when they go out of scope, that is, when the execution leaves the block in which these variables were defined. In particular, when the program being debugged terminates, _all_ local variables go out of scope, and so only watchpoints that watch global variables remain set. If you rerun the program, you will need to set all such watchpoints again. One way of doing that would be to set a code breakpoint at the entry to the `main' function and when it breaks, set all the watchpoints. _Warning:_ In multi-thread programs, watchpoints have only limited usefulness. With the current watchpoint implementation, {No value for `GDBN'} 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, {No value for `GDBN'} may not notice when a non-current thread's activity changes the expression. _HP-UX Warning:_ In multi-thread programs, software watchpoints have only limited usefulness. If {No value for `GDBN'} creates a software watchpoint, it 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 software watchpoints as usual. However, {No value for `GDBN'} may not notice when a non-current thread's activity changes the expression. (Hardware watchpoints, in contrast, watch an expression in all threads.) Setting catchpoints ------------------- You can use "catchpoints" to cause the debugger to stop for certain kinds of program events, such as C++ exceptions or the loading of a shared library. Use the `catch' command to set a catchpoint. `catch EVENT' Stop when EVENT occurs. EVENT can be any of the following: `throw' The throwing of a C++ exception. `catch' The catching of a C++ exception. `exec' A call to `exec'. This is currently only available for HP-UX. `fork' A call to `fork'. This is currently only available for HP-UX. `vfork' A call to `vfork'. This is currently only available for HP-UX. `load' `load LIBNAME' The dynamic loading of any shared library, or the loading of the library LIBNAME. This is currently only available for HP-UX. `unload' `unload LIBNAME' The unloading of any dynamically loaded shared library, or the unloading of the library LIBNAME. This is currently only available for HP-UX. `tcatch EVENT' Set a catchpoint that is enabled only for one stop. The catchpoint is automatically deleted after the first time the event is caught. Use the `info break' command to list the current catchpoints. There are currently some limitations to C++ exception handling (`catch throw' and `catch catch') in {No value for `GDBN'}: * If you call a function interactively, {No value for `GDBN'} 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 either to abort or to simply continue running until it hits a breakpoint, catches a signal that {No value for `GDBN'} is listening for, or exits. This is the case even if you set a catchpoint for the exception; catchpoints on exceptions are disabled within interactive calls. * 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' (*note Breakpoints; watchpoints; and exceptions: Breakpoints.). With a conditional breakpoint (*note Break conditions: 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. Deleting breakpoints -------------------- It is often necessary to eliminate a breakpoint, watchpoint, or catchpoint 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, watchpoints, or catchpoints by specifying their breakpoint numbers. It is not necessary to delete a breakpoint to proceed past it. {No value for `GDBN'} 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 (*note Selecting a frame: Selection.). 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] [RANGE...]' Delete the breakpoints, watchpoints, or catchpoints of the breakpoint ranges specified as arguments. If no argument is specified, delete all breakpoints ({No value for `GDBN'} asks confirmation, unless you have `set confirm off'). You can abbreviate this command as `d'. Disabling breakpoints --------------------- Rather than deleting a breakpoint, watchpoint, or catchpoint, 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, watchpoints, and catchpoints 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, watchpoints, and catchpoints if you do not know which numbers to use. A breakpoint, watchpoint, or catchpoint 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. * Enabled for deletion. The breakpoint stops your program, but immediately after it does so it is deleted permanently. A breakpoint set with the `tbreak' command starts out in this state. You can use the following commands to enable or disable breakpoints, watchpoints, and catchpoints: `disable [breakpoints] [RANGE...]' 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] [RANGE...]' Enable the specified breakpoints (or all defined breakpoints). They become effective once again in stopping your program. `enable [breakpoints] once RANGE...' Enable the specified breakpoints temporarily. {No value for `GDBN'} disables any of these breakpoints immediately after stopping your program. `enable [breakpoints] delete RANGE...' Enable the specified breakpoints to work once, then die. {No value for `GDBN'} deletes any of these breakpoints as soon as your program stops there. Except for a breakpoint set with `tbreak' (*note Setting breakpoints: Set Breaks.), 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 *Note Continuing and stepping: Continuing and Stepping.) 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 (*note Expressions: 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, {No value for `GDBN'} 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 than break conditions for the purpose of performing side effects when a breakpoint is reached (*note Breakpoint command lists: Break Commands.). Break conditions can be specified when a breakpoint is set, by using `if' in the arguments to the `break' command. *Note Setting breakpoints: Set Breaks. They can also be changed at any time with the `condition' command. You can also use the `if' keyword with the `watch' command. The `catch' command does not recognize the `if' keyword; `condition' is the only way to impose a further condition on a catchpoint. `condition BNUM EXPRESSION' Specify EXPRESSION as the break condition for breakpoint, watchpoint, or catchpoint 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', {No value for `GDBN'} checks EXPRESSION immediately for syntactic correctness, and to determine whether symbols in it have referents in the context of your breakpoint. If EXPRESSION uses symbols not referenced in the context of the breakpoint, {No value for `GDBN'} prints an error message: No symbol "foo" in current context. {No value for `GDBN'} does not actually evaluate EXPRESSION at the time the `condition' command (or a command that sets a breakpoint with a condition, like `break if ...') is given, however. *Note Expressions: 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, {No value for `GDBN'} 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'. *Note Continuing and stepping: 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, {No value for `GDBN'} 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. *Note Convenience variables: Convenience Vars. Ignore counts apply to breakpoints, watchpoints, and catchpoints. Breakpoint command lists ------------------------ You can give any breakpoint (or watchpoint or catchpoint) 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, watchpoint, or catchpoint set (not to the breakpoint most recently encountered). Pressing as a means of repeating the last {No value for `GDBN'} 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. *Note Commands for controlled output: 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 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 {No value for `GDBN'} 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, {No value for `GDBN'} 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: ({No value for `GDBP'}) 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. ({No value for `GDBP'}) "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 {No value for `GDBN'} to print an error message: Cannot insert breakpoints. The same program may be running in another process. When this happens, you have three ways to proceed: 1. Remove or disable the breakpoints, then continue. 2. Suspend {No value for `GDBN'}, and copy the file containing your program to a new name. Resume {No value for `GDBN'} and use the `exec-file' command to specify that {No value for `GDBN'} should run your program under that name. Then start your program again. 3. 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. A similar message can be printed if you request too many active hardware-assisted breakpoints and watchpoints: Stopped; cannot insert breakpoints. You may have requested too many hardware breakpoints and watchpoints. This message is printed when you attempt to resume the program, since only then {No value for `GDBN'} knows exactly how many hardware breakpoints and watchpoints it needs to insert. When this message is printed, you need to disable or remove some of the hardware-assisted breakpoints and watchpoints, and then continue. 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 it stops due to a signal, you may want to use `handle', or use `signal 0' to resume execution. *Note 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' (*note Break conditions: 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' (for "foreground", as the debugged program is deemed to be the foreground program) are provided purely for convenience, and have exactly the same behavior as `continue'. To resume execution at a different place, you can use `return' (*note Returning from a function: Returning.) to go back to the calling function; or `jump' (*note Continuing at a different address: Jumping.) to go to an arbitrary location in your program. A typical technique for using stepping is to set a breakpoint (*note Breakpoints; watchpoints; and catchpoints: Breakpoints.) 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 {No value for `GDBN'}. This command is abbreviated `s'. _Warning:_ If you use the `step' command while control is within a function that was compiled without debugging information, execution proceeds until control reaches a function that does have debugging information. Likewise, it will not step into a function which is compiled without debugging information. To step through functions without debugging information, use the `stepi' command, described below. The `step' command only stops at the first instruction of a source line. This prevents the multiple stops that could otherwise occur in `switch' statements, `for' loops, etc. `step' continues to stop if a function that has debugging information is called within the line. In other words, `step' _steps inside_ any functions called within the line. Also, the `step' command only enters a function if there is line number information for the function. Otherwise it acts like the `next' command. This avoids problems when using `cc -gl' on MIPS machines. Previously, `step' entered subroutines if there was any debugging information about the routine. `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. This is similar to `step', but function calls that appear within the line of code are executed without stopping. Execution stops when control reaches a different line of code at the original stack level that was executing when you gave the `next' command. This command is abbreviated `n'. An argument COUNT is a repeat count, as for `step'. The `next' command only stops at the first instruction of a source line. This prevents multiple stops that could otherwise occur in `switch' statements, `for' loops, etc. `set step-mode' `set step-mode on' The `set step-mode on' command causes the `step' command to stop at the first instruction of a function which contains no debug line information rather than stepping over it. This is useful in cases where you may be interested in inspecting the machine instructions of a function which has no symbolic info and do not want {No value for `GDBN'} to automatically skip over this function. `set step-mode off' Causes the `step' command to step over any functions which contains no debug information. This is the default. `finish' Continue running until just after function in the selected stack frame returns. Print the returned value (if any). Contrast this with the `return' command (*note Returning from a function: Returning.). `until' `u' Continue running until a source line past the current line, in the current stack frame, is reached. This command is used to avoid single stepping through a loop more than once. It is like the `next' command, except that when `until' encounters a jump, it automatically continues execution until the program counter is greater than the address of the jump. This means that when you reach the end of a loop after single stepping though it, `until' makes your program continue execution until it exits the loop. In contrast, a `next' command at the end of a loop simply steps back to the beginning of the loop, which forces you to step through the next iteration. `until' always stops your program if it attempts to exit the current stack frame. `until' may produce somewhat counterintuitive results if the order of machine code does not match the order of the source lines. For example, in the following excerpt from a debugging session, the `f' (`frame') command shows that execution is stopped at line `206'; yet when we use `until', we get to line `195': ({No value for `GDBP'}) f #0 main (argc=4, argv=0xf7fffae8) at m4.c:206 206 expand_input(); ({No value for `GDBP'}) until 195 for ( ; argc > 0; NEXTARG) { This happened because, for execution efficiency, the compiler had generated code for the loop closure test at the end, rather than the start, of the loop--even though the test in a C `for'-loop is written before the body of the loop. The `until' command appeared to step back to the beginning of the loop when it advanced to this expression; however, it has not really gone to an earlier statement--not in terms of the actual machine code. `until' with no argument works by means of single instruction stepping, and hence is slower than `until' with an argument. `until LOCATION' `u LOCATION' Continue running your program until either the specified location is reached, or the current stack frame returns. LOCATION is any of the forms of argument acceptable to `break' (*note Setting breakpoints: Set Breaks.). This form of the command uses breakpoints, and hence is quicker than `until' without an argument. `stepi' `stepi ARG' `si' Execute one machine instruction, then stop and return to the debugger. It is often useful to do `display/i $pc' when stepping by machine instructions. This makes {No value for `GDBN'} automatically display the next instruction to be executed, each time your program stops. *Note Automatic display: Auto Display. An argument is a repeat count, as in `step'. `nexti' `nexti ARG' `ni' Execute one machine instruction, but if it is a function call, proceed until the function returns. An argument is a repeat count, as in `next'. Signals ======= A signal is an asynchronous event that can happen in a program. The operating system defines the possible kinds of signals, and gives each kind a name and a number. For example, in Unix `SIGINT' is the signal a program gets when you type an interrupt character (often `C-c'); `SIGSEGV' is the signal a program gets from referencing a place in memory far away from all the areas in use; `SIGALRM' occurs when the alarm clock timer goes off (which happens only if your program has requested an alarm). Some signals, including `SIGALRM', are a normal part of the functioning of your program. Others, such as `SIGSEGV', indicate errors; these signals are "fatal" (they kill your program immediately) if the program has not specified in advance some other way to handle the signal. `SIGINT' does not indicate an error in your program, but it is normally fatal so it can carry out the purpose of the interrupt: to kill the program. {No value for `GDBN'} has the ability to detect any occurrence of a signal in your program. You can tell {No value for `GDBN'} in advance what to do for each kind of signal. Normally, {No value for `GDBN'} is set up to let the non-erroneous signals like `SIGALRM' be silently passed to your program (so as not to interfere with their role in the program's functioning) but to stop your program immediately whenever an error signal happens. You can change these settings with the `handle' command. `info signals' `info handle' Print a table of all the kinds of signals and how {No value for `GDBN'} has been told to handle each one. You can use this to see the signal numbers of all the defined types of signals. `info handle' is an alias for `info signals'. `handle SIGNAL KEYWORDS...' Change the way {No value for `GDBN'} handles signal SIGNAL. SIGNAL can be the number of a signal or its name (with or without the `SIG' at the beginning); a list of signal numbers of the form `LOW-HIGH'; or the word `all', meaning all the known signals. The KEYWORDS say what change to make. The keywords allowed by the `handle' command can be abbreviated. Their full names are: `nostop' {No value for `GDBN'} should not stop your program when this signal happens. It may still print a message telling you that the signal has come in. `stop' {No value for `GDBN'} should stop your program when this signal happens. This implies the `print' keyword as well. `print' {No value for `GDBN'} should print a message when this signal happens. `noprint' {No value for `GDBN'} should not mention the occurrence of the signal at all. This implies the `nostop' keyword as well. `pass' `noignore' {No value for `GDBN'} should allow your program to see this signal; your program can handle the signal, or else it may terminate if the signal is fatal and not handled. `pass' and `noignore' are synonyms. `nopass' `ignore' {No value for `GDBN'} should not allow your program to see this signal. `nopass' and `ignore' are synonyms. When a signal stops your program, the signal is not visible to the program until you continue. Your program sees the signal then, if `pass' is in effect for the signal in question _at that time_. In other words, after {No value for `GDBN'} reports a signal, you can use the `handle' command with `pass' or `nopass' to control whether your program sees that signal when you continue. The default is set to `nostop', `noprint', `pass' for non-erroneous signals such as `SIGALRM', `SIGWINCH' and `SIGCHLD', and to `stop', `print', `pass' for the erroneous signals. You can also use the `signal' command to prevent your program from seeing a signal, or cause it to see a signal it normally would not see, or to give it any signal at any time. For example, if your program stopped due to some sort of memory reference error, you might store correct values into the erroneous variables and continue, hoping to see more execution; but your program would probably terminate immediately as a result of the fatal signal once it saw the signal. To prevent this, you can continue with `signal 0'. *Note Giving your program a signal: Signaling. Stopping and starting multi-thread programs =========================================== When your program has multiple threads (*note Debugging programs with multiple threads: Threads.), you can choose whether to set breakpoints on all threads, or on a particular thread. `break LINESPEC thread THREADNO' `break LINESPEC thread THREADNO if ...' LINESPEC specifies source lines; there are several ways of writing them, but the effect is always to specify some source line. Use the qualifier `thread THREADNO' with a breakpoint command to specify that you only want {No value for `GDBN'} to stop the program when a particular thread reaches this breakpoint. THREADNO is one of the numeric thread identifiers assigned by {No value for `GDBN'}, shown in the first column of the `info threads' display. If you do not specify `thread THREADNO' when you set a breakpoint, the breakpoint applies to _all_ threads of your program. You can use the `thread' qualifier on conditional breakpoints as well; in this case, place `thread THREADNO' before the breakpoint condition, like this: ({No value for `GDBP'}) break frik.c:13 thread 28 if bartab > lim Whenever your program stops under {No value for `GDBN'} for any reason, _all_ threads of execution stop, not just the current thread. This allows you to examine the overall state of the program, including switching between threads, without worrying that things may change underfoot. Conversely, whenever you restart the program, _all_ threads start executing. _This is true even when single-stepping_ with commands like `step' or `next'. In particular, {No value for `GDBN'} cannot single-step all threads in lockstep. Since thread scheduling is up to your debugging target's operating system (not controlled by {No value for `GDBN'}), other threads may execute more than one statement while the current thread completes a single step. Moreover, in general other threads stop in the middle of a statement, rather than at a clean statement boundary, when the program stops. You might even find your program stopped in another thread after continuing or even single-stepping. This happens whenever some other thread runs into a breakpoint, a signal, or an exception before the first thread completes whatever you requested. On some OSes, you can lock the OS scheduler and thus allow only a single thread to run. `set scheduler-locking MODE' Set the scheduler locking mode. If it is `off', then there is no locking and any thread may run at any time. If `on', then only the current thread may run when the inferior is resumed. The `step' mode optimizes for single-stepping. It stops other threads from "seizing the prompt" by preempting the current thread while you are stepping. Other threads will only rarely (or never) get a chance to run when you step. They are more likely to run when you `next' over a function call, and they are completely free to run when you use commands like `continue', `until', or `finish'. However, unless another thread hits a breakpoint during its timeslice, they will never steal the {No value for `GDBN'} prompt away from the thread that you are debugging. `show scheduler-locking' Display the current scheduler locking mode. Examining the Stack ******************* When your program has stopped, the first thing you need to know is where it stopped and how it got there. Each time your program performs a function call, information about the call is generated. That information includes the location of the call in your program, the arguments of the call, and the local variables of the function being called. The information is saved in a block of data called a "stack frame". The stack frames are allocated in a region of memory called the "call stack". When your program stops, the {No value for `GDBN'} commands for examining the stack allow you to see all of this information. One of the stack frames is "selected" by {No value for `GDBN'} and many {No value for `GDBN'} commands refer implicitly to the selected frame. In particular, whenever you ask {No value for `GDBN'} for the value of a variable in your program, the value is found in the selected frame. There are special {No value for `GDBN'} commands to select whichever frame you are interested in. *Note Selecting a frame: Selection. When your program stops, {No value for `GDBN'} automatically selects the currently executing frame and describes it briefly, similar to the `frame' command (*note Information about a frame: Frame Info.). Stack frames ============ The call stack is divided up into contiguous pieces called "stack frames", or "frames" for short; each frame is the data associated with one call to one function. The frame contains the arguments given to the function, the function's local variables, and the address at which the function is executing. When your program is started, the stack has only one frame, that of the function `main'. This is called the "initial" frame or the "outermost" frame. Each time a function is called, a new frame is made. Each time a function returns, the frame for that function invocation is eliminated. If a function is recursive, there can be many frames for the same function. The frame for the function in which execution is actually occurring is called the "innermost" frame. This is the most recently created of all the stack frames that still exist. Inside your program, stack frames are identified by their addresses. A stack frame consists of many bytes, each of which has its own address; each kind of computer has a convention for choosing one byte whose address serves as the address of the frame. Usually this address is kept in a register called the "frame pointer register" while execution is going on in that frame. {No value for `GDBN'} assigns numbers to all existing stack frames, starting with zero for the innermost frame, one for the frame that called it, and so on upward. These numbers do not really exist in your program; they are assigned by {No value for `GDBN'} to give you a way of designating stack frames in {No value for `GDBN'} commands. Some compilers provide a way to compile functions so that they operate without stack frames. (For example, the {No value for `GCC'} option `-fomit-frame-pointer' generates functions without a frame.) This is occasionally done with heavily used library functions to save the frame setup time. {No value for `GDBN'} has limited facilities for dealing with these function invocations. If the innermost function invocation has no stack frame, {No value for `GDBN'} nevertheless regards it as though it had a separate frame, which is numbered zero as usual,