gdb使用手册
来源：互联网 发布：ubuntu查看存储空间 编辑：程序博客网 时间：2024/05/16 06:33
1. A Sample GDB Session
You can use this manual at your leisure to read all about GDB. 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 <QUOTE> and the close quote string to <UNQUOTE>, the same procedure fails to define a new synonym baz:
$ cd gnu/m4
$ ./m4
define(foo,0000)
foo
0000
define(bar,defn(`foo'))
bar
0000
changequote(<QUOTE>,<UNQUOTE>)
define(baz,defn(<QUOTE>foo<UNQUOTE>))
baz
C-d
m4: End of input: 0: fatal error: EOF in string
Let us use GDB to try to see what is going on.
$ gdb m4
GDB is free software and you are welcome to distribute copies
of it under certain conditions; type "show copying" to see
the conditions.
There is absolutely no warranty for GDB; type "show warranty"
for details.
GDB
(gdb)
GDB 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 GDB to use a narrower display width than usual, so that examples fit in this manual.
(gdb) 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 GDB break command.
(gdb) break m4_changequote
Breakpoint 1 at 0x
Using the run command, we start m4 running under GDB control; as long as control does not reach the m4_changequote subroutine, the program runs as usual:
(gdb) run
Starting program: /work/Editorial/gdb/gnu/m4/m4
define(foo,0000)
foo
0000
To trigger the breakpoint, we call changequote. GDB suspends execution of m4, displaying information about the context where it stops.
changequote(<QUOTE>,<UNQUOTE>)
Breakpoint 1, m4_changequote (argc=3, argv=0x
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.
(gdb) 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.
(gdb) s
set_quotes (lq=0x
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.
(gdb) bt
#0 set_quotes (lq=0x
at input.c:530
#1 0x
at builtin.c:882
#2 0x
#3 0x
at macro.c:71
#4 0x79dc in expand_input () at macro.c:40
#5 0x
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.
(gdb) s
0x3b
(gdb) s
0x3b80 535 lquote = (lq == nil || *lq == '/0') ? /
def_lquote : xstrdup(lq);
(gdb) n
536 rquote = (rq == nil || *rq == '/0') ? def_rquote/
: xstrdup(rq);
(gdb) 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.
(gdb) p lquote
$1 = 0x35d40 "<QUOTE>"
(gdb) p rquote
$2 = 0x35d50 "<UNQUOTE>"
lquote and rquote are indeed the new left and right quotes. To look at some context, we can display ten lines of source surrounding the current line with the l (list) command.
(gdb) 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.
(gdb) n
539 len_rquote = strlen(lquote);
(gdb) n
540 }
(gdb) p len_lquote
$3 = 9
(gdb) 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.
(gdb) p len_lquote=strlen(lquote)
$5 = 7
(gdb) 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:
(gdb) c
Continuing.
define(baz,defn(<QUOTE>foo<UNQUOTE>))
baz
0000
Success! The new quotes now work just as well as the default ones. The problem seems to have been just the two typos defining the wrong lengths. We allow m4 exit by giving it an EOF as input:
C-d
Program exited normally.
The message `Program exited normally.' is from GDB; it indicates m4 has finished executing. We can end our GDB session with the GDB quit command.
(gdb) quit
2. Getting In and Out of GDB
This chapter discusses how to start GDB, and how to get out of it. The essentials are:
- type `gdb' to start GDB.
- type quit or Ctrl-d to exit.
2.1 Invoking GDB
How to start GDB
2.2 Quitting GDB
How to quit GDB
2.3 Shell commands
How to use shell commands inside GDB
2.4 Logging output
How to log GDB's output to a file
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.1 Invoking GDB
Invoke GDB by running the program gdb. Once started, GDB reads commands from the terminal until you tell it to exit.
You can also run gdb 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 GDB is with one argument, specifying an executable program:
gdb program You can also start with both an executable program and a core file specified:
gdb program core You can, instead, specify a process ID as a second argument, if you want to debug a running process:
gdb program 1234 would attach GDB to process 1234 (unless you also have a file named `1234'; GDB does check for a core file first).
Taking advantage of the second command-line argument requires a fairly complete operating system; when you use GDB 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. GDB will warn you if it is unable to attach or to read core dumps.
You can optionally have gdb pass any arguments after the executable file to the inferior using --args. This option stops option processing.
gdb --args gcc -O2 -c foo.c This will cause gdb to debug gcc, and to set gcc's command-line arguments (see section 4.3 Your program's arguments) to `-O2 -c foo.c'.
You can run gdb without printing the front material, which describes GDB's non-warranty, by specifying -silent:
gdb -silent You can further control how GDB starts up by using command-line options. GDB itself can remind you of the options available.
Type
gdb -help to display all available options and briefly describe their use (`gdb -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.
2.1.1 Choosing files
2.1.2 Choosing modes
2.1.3 What GDB does during startup
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.1.1 Choosing files
When GDB 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' (or `-p' options respectively. (GDB 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'/`-p' option followed by that argument.) If the second argument begins with a decimal digit, GDB will first attempt to attach to it as a process, and if that fails, attempt to open it as a corefile. If you have a corefile whose name begins with a digit, you can prevent GDB from treating it as a pid by prefixing it with `./', e.g. `./12345'.
If GDB 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. GDB 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
-pid number
-p number
Connect to process ID number, as with the attach command. If there is no such process, GDB will attempt to open a core file named number.
-command file
-x file
Execute GDB commands from file file. See section Command files.
-eval-command command
-ex command
Execute a single GDB command.
This option may be used multiple times to call multiple commands. It may also be interleaved with `-command' as required.
gdb -ex 'target sim' -ex 'load' / -x setbreakpoints -ex 'run' a.out -directory directory
-d directory
Add directory to the path to search for source and script files.
-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.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.1.2 Choosing modes
You can run GDB in various alternative modes--for example, in batch mode or quiet mode.
-nx
-n
Do not execute commands found in any initialization files. Normally, GDB executes the commands in these files after all the command options and arguments have been processed. See section 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 GDB commands in the command files.
Batch mode may be useful for running GDB 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 GDB control terminates) is not issued when running in batch mode.
-batch-silent
Run in batch mode exactly like `-batch', but totally silently. All GDB output to stdout is prevented (stderr is unaffected). This is much quieter than `-silent' and would be useless for an interactive session.
This is particularly useful when using targets that give `Loading section' messages, for example.
Note that targets that give their output via GDB, as opposed to writing directly to stdout, will also be made silent.
-return-child-result
The return code from GDB will be the return code from the child process (the process being debugged), with the following exceptions:
· GDB exits abnormally. E.g., due to an incorrect argument or an internal error. In this case the exit code is the same as it would have been without `-return-child-result'.
· The user quits with an explicit value. E.g., `quit 1'.
· The child process never runs, or is not allowed to terminate, in which case the exit code will be -1.
This option is useful in conjunction with `-batch' or `-batch-silent', when GDB is being used as a remote program loader or simulator interface.
-nowindows
-nw
"No windows". If GDB comes with a graphical user interface (GUI) built in, then this option tells GDB to only use the command-line interface. If no GUI is available, this option has no effect.
-windows
-w
If GDB includes a GUI, then this option requires it to be used if possible.
-cd directory
Run GDB using directory as its working directory, instead of the current directory.
-fullname
-f
GNU Emacs sets this option when it runs GDB as a subprocess. It tells GDB 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-GDB interface program uses the two `/032' characters as a signal to display the source code for the frame.
-epoch
The Epoch Emacs-GDB interface sets this option when it runs GDB as a subprocess. It tells GDB 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 GDB. Its effect is identical to using `set annotate level' (see section 25. GDB Annotations). The annotation level controls how much information GDB prints 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 GDB is run as a subprocess of GNU Emacs, level 3 is the maximum annotation suitable for programs that control GDB, and level 2 has been deprecated.
The annotation mechanism has largely been superseded by GDB/MI (see section 24. The GDB/MI Interface).
--args
Change interpretation of command line so that arguments following the executable file are passed as command line arguments to the inferior. This option stops option processing.
-baud bps
-b bps
Set the line speed (baud rate or bits per second) of any serial interface used by GDB for remote debugging.
-l timeout
Set the timeout (in seconds) of any communication used by GDB for remote debugging.
-tty device
-t device
Run using device for your program's standard input and output.
-tui
Activate the Text User Interface when starting. The Text User Interface manages several text windows on the terminal, showing source, assembly, registers and GDB command outputs (see section GDB Text User Interface). Alternatively, the Text User Interface can be enabled by invoking the program `gdbtui'. Do not use this option if you run GDB from Emacs (see section Using GDB under GNU 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 GDB using it as a back end. See section Command Interpreters.
`--interpreter=mi' (or `--interpreter=mi2') causes GDB to use the GDB/MI interface (see section The GDB/MI Interface) included since GDB version 6.0. The previous GDB/MI interface, included in GDB version 5.3 and selected with `--interpreter=mi1', is deprecated. Earlier GDB/MI interfaces are no longer supported.
-write
Open the executable and core files for both reading and writing. This is equivalent to the `set write on' command inside GDB (see section 14.6 Patching programs).
-statistics
This option causes GDB to print statistics about time and memory usage after it completes each command and returns to the prompt.
-version
This option causes GDB to print its version number and no-warranty blurb, and exit.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.1.3 What GDB does during startup
Here's the description of what GDB does during session startup:
- Sets up the command interpreter as specified by the command line (see section interpreter).
- Reads the init file (if any) in your home directory(1) and executes all the commands in that file.
- Processes command line options and operands.
- Reads and executes the commands from init file (if any) in the current working directory. This is only done if the current directory is different from your home directory. Thus, you can have more than one init file, one generic in your home directory, and another, specific to the program you are debugging, in the directory where you invoke GDB.
- Reads command files specified by the `-x' option. See section 20.3 Command files, for more details about GDB command files.
- Reads the command history recorded in the history file. See section 19.3 Command history, for more details about the command history and the files where GDB records it.
Init files use the same syntax as command files (see section 20.3 Command files) and are processed by GDB in the same way. The init file in your home directory can set options (such as `set complaints') that affect subsequent processing of command line options and operands. Init files are not executed if you use the `-nx' option (see section Choosing modes).
The GDB init files are normally called `.gdbinit'. On some configurations of GDB, the init file is known by a different name (these are typically environments where a specialized form of GDB may need to coexist with other forms, hence a different name for the specialized version's init file). These are the environments with special init file names:
- The DJGPP
- VxWorks (Wind River Systems real-time OS): `.vxgdbinit'
- OS68K (Enea Data Systems real-time OS): `.os68gdbinit'
- ES-1800 (Ericsson Telecom AB M68000 emulator): `.esgdbinit'
- CISCO 68k: `.cisco-gdbinit'
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.2 Quitting GDB
quit [expression]
q
To exit GDB, use the quit command (abbreviated q), or type an end-of-file character (usually Ctrl-d). If you do not supply expression, GDB will terminate normally; otherwise it will terminate using the result of expression as the error code.
An interrupt (often Ctrl-c) does not exit from GDB, but rather terminates the action of any GDB command that is in progress and returns to GDB command level. It is safe to type the interrupt character at any time because GDB does not allow it to take effect until a time when it is safe.
If you have been using GDB to control an attached process or device, you can release it with the detach command (see section Debugging an already-running process).
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.3 Shell commands
If you need to execute occasional shell commands during your debugging session, there is no need to leave or suspend GDB; 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 GDB 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 GDB:
make make-args
Execute the make program with the specified arguments. This is equivalent to `shell make make-args'.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
2.4 Logging output
You may want to save the output of GDB commands to a file. There are several commands to control GDB's logging.
set logging on
Enable logging.
set logging off
Disable logging.
set logging file file
Change the name of the current logfile. The default logfile is `gdb.txt'.
set logging overwrite [on|off]
By default, GDB will append to the logfile. Set overwrite if you want set logging on to overwrite the logfile instead.
set logging redirect [on|off]
By default, GDB output will go to both the terminal and the logfile. Set redirect if you want output to go only to the log file.
show logging
Show the current values of the logging settings.
3. GDB Commands
You can abbreviate a GDB command to the first few letters of the command name, if that abbreviation is unambiguous; and you can repeat certain GDB commands by typing just RET. You can also use the TAB key to get GDB 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).
3.1 Command syntax
How to give commands to GDB
3.2 Command completion
3.3 Getting help
How to ask GDB for help
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
3.1 Command syntax
A GDB 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.
GDB 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 GDB (typing just RET) means to repeat the previous command. Certain commands (for example, run) will not repeat this way; these are commands whose unintentional repetition might cause trouble and which you are unlikely to want to repeat. User-defined commands can disable this feature; see dont-repeat.
The list and x commands, when you repeat them with RET, construct new arguments rather than repeating exactly as typed. This permits easy scanning of source or memory.
GDB can also use RET in another way: to partition lengthy output, in a way similar to the common utility more (see section Screen size). Since it is easy to press one RET too many in this situation, GDB disables command repetition after any command that generates this sort of display.
Any text from a # to the end of the line is a comment; it does nothing. This is useful mainly in command files (see section Command files).
The Ctrl-o binding is useful for repeating a complex sequence of commands. This command accepts the current line, like RET, and then fetches the next line relative to the current line from the history for editing.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
3.2 Command completion
GDB 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 GDB commands, GDB subcommands, and the names of symbols in your program.
Press the TAB key whenever you want GDB to fill out the rest of a word. If there is only one possibility, GDB fills in the word, and waits for you to finish the command (or press RET to enter it). For example, if you type
(gdb) info bre TAB
GDB fills in the rest of the word `breakpoints', since that is the only info subcommand beginning with `bre':
(gdb) info breakpoints You can either press RET at this point, to run the info breakpoints command, or backspace and enter something else, if `breakpoints' does not look like the command you expected. (If you were sure you wanted info breakpoints in the first place, you might as well just type RET immediately after `info bre', to exploit command abbreviations rather than command completion).
If there is more than one possibility for the next word when you press TAB, GDB sounds a bell. You can either supply more characters and try again, or just press TAB a second time; GDB displays all the possible completions for that word. For example, you might want to set a breakpoint on a subroutine whose name begins with `make_', but when you type b make_TAB GDB just sounds the bell. Typing TAB again displays all the function names in your program that begin with those characters, for example:
(gdb) b make_ TAB
GDB sounds bell; press TAB again, to see:
make_a_section_from_file make_environ make_abs_section make_function_type make_blockvector make_pointer_type make_cleanup make_reference_type make_command make_symbol_completion_list (gdb) b make_ After displaying the available possibilities, GDB copies your partial input (`b make_' in the example) so you can finish the command.
If you just want to see the list of alternatives in the first place, you can press M-? rather than pressing TAB twice. M-? means
Sometimes the string you need, while logically a "word", may contain parentheses or other characters that GDB 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 GDB 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 GDB that it may need to consider more information than usual when you press TAB or M-? to request word completion:
(gdb) b 'bubble( M-?
bubble(double,double) bubble(int,int) (gdb) b 'bubble( In some cases, GDB can tell that completing a name requires using quotes. When this happens, GDB inserts the quote for you (while completing as much as it can) if you do not type the quote in the first place:
(gdb) b bub TAB
GDB alters your input line to the following, and rings a bell: (gdb) b 'bubble( In general, GDB 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 C++ expressions. You can use the command set overload-resolution off to disable overload resolution; see GDB features for C++.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
3.3 Getting help
You can always ask GDB 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:
(gdb) 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. (gdb) 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:
(gdb) 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. (gdb) help command
With a command name as help argument, GDB displays a short paragraph on how to use that command.
apropos args
The apropos command searches through all of the GDB 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 GDB commands info and show to inquire about the state of your program, or the state of GDB itself. Each command supports many topics of inquiry; this manual introduces each of them in the appropriate context. The listings under info and under show in the Index point to all the sub-commands. See section Index.
info
This command (abbreviated i) is for describing the state of your program. For example, you can list the arguments given to your program with info args, list the registers currently in use with info registers, or list the breakpoints you have set with info breakpoints. You can get a complete list of the info sub-commands with help info.
set
You can assign the result of an expression to an environment variable with set. For example, you can set the GDB prompt to a $-sign with set prompt $.
show
In contrast to info, show is for describing the state of GDB 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 GDB is running. You should include this information in GDB bug-reports. If multiple versions of GDB are in use at your site, you may need to determine which version of GDB you are running; as GDB evolves, new commands are introduced, and old ones may wither away. Also, many system vendors ship variant versions of GDB, and there are variant versions of GDB in GNU/Linux distributions as well. The version number is the same as the one announced when you start GDB.
show copying
info copying
Display information about permission for copying GDB.
show warranty
info warranty
Display the GNU "NO WARRANTY" statement, or a warranty, if your version of GDB comes with one.
4. Running Programs Under GDB
When you run a program under GDB, you must first generate debugging information when you compile it.
You may start GDB 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.
4.1 Compiling for debugging
4.2 Starting your program
4.3 Your program's arguments
4.4 Your program's environment
4.5 Your program's working directory
4.6 Your program's input and output
4.7 Debugging an already-running process
4.8 Killing the child process
4.9 Debugging programs with multiple threads
4.10 Debugging programs with multiple processes
4.11 Setting a bookmark to return to later
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.1 Compiling for debugging
In order to debug a program effectively, you need to generate debugging information when you compile it. This debugging information is stored in the object file; it describes the data type of each variable or function and the correspondence between source line numbers and addresses in the executable code.
To request debugging information, specify the `-g' option when you run the compiler.
Programs that are to be shipped to your customers are compiled with optimizations, using the `-O' compiler option. However, many compilers are unable to handle the `-g' and `-O' options together. Using those compilers, you cannot generate optimized executables containing debugging information.
GCC, the GNU C/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, GDB 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!). See section 8.2 Program variables, for more information about debugging optimized code.
Older versions of the GNU C compiler permitted a variant option `-gg' for debugging information. GDB no longer supports this format; if your GNU C compiler has this option, do not use it.
GDB knows about preprocessor macros and can show you their expansion (see section 9. C Preprocessor Macros). Most compilers do not include information about preprocessor macros in the debugging information if you specify the `-g' flag alone, because this information is rather large. Version 3.1 and later of GCC, the GNU C compiler, provides macro information if you specify the options `-gdwarf-2' and `-g3'; the former option requests debugging information in the Dwarf 2 format, and the latter requests "extra information". In the future, we hope to find more compact ways to represent macro information, so that it can be included with `-g' alone.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.2 Starting your program
run
r
Use the run command to start your program under GDB. You must first specify the program name (except on VxWorks) with an argument to GDB (see section Getting In and Out of GDB), or by using the file or exec-file command (see section Commands to specify files).
If you are running your program in an execution environment that supports processes, run creates an inferior process and makes that process run your program. (In environments without processes, run jumps to the start of your program.)
The execution of a program is affected by certain information it receives from its superior. GDB provides ways to specify this information, which you must do before starting your program. (You can change it after starting your program, but such changes only affect your program the next time you start it.) This information may be divided into four categories:
The arguments.
Specify the arguments to give your program as the arguments of the run command. If a shell is available on your target, the shell is used to pass the arguments, so that you may use normal conventions (such as wildcard expansion or variable substitution) in describing the arguments. In Unix systems, you can control which shell is used with the SHELL environment variable. See section Your program's arguments.
The environment.
Your program normally inherits its environment from GDB, but you can use the GDB commands set environment and unset environment to change parts of the environment that affect your program. See section Your program's environment.
The working directory.
Your program inherits its working directory from GDB. You can set the GDB working directory with the cd command in GDB. See section Your program's working directory.
The standard input and output.
Your program normally uses the same device for standard input and standard output as GDB is using. You can redirect input and output in the run command line, or you can use the tty command to set a different device for your program. See section Your program's input and output.
Warning: While input and output redirection work, you cannot use pipes to pass the output of the program you are debugging to another program; if you attempt this, GDB is likely to wind up debugging the wrong program.
When you issue the run command, your program begins to execute immediately. See section Stopping and continuing, for discussion of how to arrange for your program to stop. Once your program has stopped, you may call functions in your program, using the print or call commands. See section Examining Data.
If the modification time of your symbol file has changed since the last time GDB read its symbols, GDB discards its symbol table, and reads it again. When it does this, GDB tries to retain your current breakpoints.
start
The name of the main procedure can vary from language to language. With C or C++, the main procedure name is always main, but other languages such as
The `start' command does the equivalent of setting a temporary breakpoint at the beginning of the main procedure and then invoking the `run' command.
Some programs contain an elaboration phase where some startup code is executed before the main procedure is called. This depends on the languages used to write your program. In C++, for instance, constructors for static and global objects are executed before main is called. It is therefore possible that the debugger stops before reaching the main procedure. However, the temporary breakpoint will remain to halt execution.
Specify the arguments to give to your program as arguments to the `start' command. These arguments will be given verbatim to the underlying `run' command. Note that the same arguments will be reused if no argument is provided during subsequent calls to `start' or `run'.
It is sometimes necessary to debug the program during elaboration. In these cases, using the start command would stop the execution of your program too late, as the program would have already completed the elaboration phase. Under these circumstances, insert breakpoints in your elaboration code before running your program.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.3 Your program's arguments
The arguments to your program can be specified by the arguments of the run command. They are passed to a shell, which expands wildcard characters and performs redirection of I/O, and thence to your program. Your SHELL environment variable (if it exists) specifies what shell GDB uses. If you do not define SHELL, GDB uses the default shell (`/bin/sh' on Unix).
On non-Unix systems, the program is usually invoked directly by GDB, 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.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.4 Your program's environment
The environment consists of a set of environment variables and their values. Environment variables conventionally record such things as your user name, your home directory, your terminal type, and your search path for programs to run. Usually you set up environment variables with the shell and they are inherited by all the other programs you run. When debugging, it can be useful to try running your program with a modified environment without having to start GDB 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 GDB 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 GDB searches the path. If you use `.' instead, it refers to the directory where you executed the path command. GDB 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 GDB 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, GDB 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'.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.5 Your program's working directory
Each time you start your program with run, it inherits its working directory from the current working directory of GDB. The GDB working directory is initially whatever it inherited from its parent process (typically the shell), but you can specify a new working directory in GDB with the cd command.
The GDB working directory also serves as a default for the commands that specify files for GDB to operate on. See section Commands to specify files.
cd directory
Set the GDB working directory to directory.
pwd
Print the GDB working directory.
It is generally impossible to find the current working directory of the process being debugged (since a program can change its directory during its run). If you work on a system where GDB is configured with the `/proc' support, you can use the info proc command (see section 18.1.3 SVR4 process information) to find out the current working directory of the debuggee.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.6 Your program's input and output
By default, the program you run under GDB does input and output to the same terminal that GDB uses. GDB 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 GDB 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 GDB still comes from your terminal. tty is an alias for set inferior-tty.
You can use the show inferior-tty command to tell GDB to display the name of the terminal that will be used for future runs of your program.
set inferior-tty /dev/ttyb
Set the tty for the program being debugged to /dev/ttyb.
show inferior-tty
Show the current tty for the program being debugged.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.7 Debugging an already-running process
attach process-id
This command attaches to a running process--one that was started outside GDB. (info files shows your active targets.) The command takes as argument a process ID. The usual way to find out the process-id of a Unix process is with the ps utility, or with the `jobs -l' shell command.
attach does not repeat if you press RET a second time after executing the command.
To use attach, your program must be running in an environment which supports processes; for example, attach does not work for programs on bare-board targets that lack an operating system. You must also have permission to send the process a signal.
When 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 (see section Specifying source directories). You can also use the file command to load the program. See section Commands to Specify Files.
The first thing GDB does after arranging to debug the specified process is to stop it. You can examine and modify an attached process with all the GDB 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 GDB to the process.
detach
When you have finished debugging the attached process, you can use the detach command to release it from GDB control. Detaching the process continues its execution. After the detach command, that process and GDB become completely independent once more, and you are ready to attach another process or start one with run. detach does not repeat if you press RET again after executing the command.
If you exit GDB or use the run command while you have an attached process, you kill that process. By default, GDB asks for confirmation if you try to do either of these things; you can control whether or not you need to confirm by using the set confirm command (see section Optional warnings and messages).
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.8 Killing the child process
kill
Kill the child process in which your program is running under GDB.
This command is useful if you wish to debug a core dump instead of a running process. GDB ignores any core dump file while your program is running.
On some operating systems, a program cannot be executed outside GDB while you have breakpoints set on it inside GDB. 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, GDB notices that the file has changed, and reads the symbol table again (while trying to preserve your current breakpoint settings).
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.9 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.
GDB 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 GDB configuration where the operating system supports threads. If your GDB 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:
(gdb) info threads (gdb) thread 1 Thread ID 1 not known. Use the "info threads" command to see the IDs of currently known threads. The GDB thread debugging facility allows you to observe all threads while your program runs--but whenever GDB 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 GDB 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 GDB 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, GDB 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. GDB displays for each thread (in this order):
1. the thread number assigned by GDB
2. the target system's thread identifier (systag)
3. the current stack frame summary for that thread
An asterisk `*' to the left of the GDB thread number indicates the current thread.
For example,
(gdb) 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, GDB associates its own thread number--a small integer assigned in thread-creation order--with each thread in your program.
Whenever GDB detects a new thread in your program, it displays both GDB'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 GDB notices a new thread.
info threads
Display a summary of all threads currently in your program. GDB displays for each thread (in this order):
1. the thread number assigned by GDB
2. the target system's thread identifier (systag)
3. the current stack frame summary for that thread
An asterisk `*' to the left of the GDB thread number indicates the current thread.
For example,
(gdb) info threads * 3 system thread 26607 worker (wptr=0x7b09c 318 "@") /
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 On Solaris, you can display more information about user threads with a Solaris-specific command:
maint info sol-threads
Display info on Solaris user threads.
thread threadno
Make thread number threadno the current thread. The command argument threadno is the internal GDB thread number, as shown in the first field of the `info threads' display. GDB responds by displaying the system identifier of the thread you selected, and its current stack frame summary:
(gdb) 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] command
The thread apply command allows you to apply the named command to one or more threads. Specify the numbers of the threads that you want affected with the command argument threadno. It can be a single thread number, one of the numbers shown in the first field of the `info threads' display; or it could be a range of thread numbers, as in 2-4. To apply a command to all threads, type thread apply all command.
Whenever GDB stops your program, due to a breakpoint or a signal, it automatically selects the thread where that breakpoint or signal happened. GDB alerts you to the context switch with a message of the form `[Switching to systag]' to identify the thread.
See section Stopping and starting multi-thread programs, for more information about how GDB behaves when you stop and start programs with multiple threads.
See section Setting watchpoints, for information about watchpoints in programs with multiple threads.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.10 Debugging programs with multiple processes
On most systems, GDB has no special support for debugging programs which create additional processes using the fork function. When a program forks, GDB 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 GDB on the child. While the child is sleeping, use the ps program to get its process ID. Then tell GDB (a new invocation of GDB if you are also debugging the parent process) to attach to the child process (see section 4.7 Debugging an already-running process). From that point on you can debug the child process just like any other process which you attached to.
On some systems, GDB provides support for debugging programs that create additional processes using the fork or vfork functions. Currently, the only platforms with this feature are HP-UX (11.x and later only?) and GNU/Linux (kernel version 2.5.60 and later).
By default, when a program forks, GDB 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 argument 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.
show follow-fork-mode
Display the current debugger response to a fork or vfork call.
On Linux, if you want to debug both the parent and child processes, use the command set detach-on-fork.
set detach-on-fork mode
Tells gdb whether to detach one of the processes after a fork, or retain debugger control over them both.
on
The child process (or parent process, depending on the value of follow-fork-mode) will be detached and allowed to run independently. This is the default.
off
Both processes will be held under the control of GDB. One process (child or parent, depending on the value of follow-fork-mode) is debugged as usual, while the other is held suspended.
show detach-on-follow
Show whether detach-on-follow mode is on/off.
If you choose to set detach-on-follow mode off, then GDB will retain control of all forked processes (including nested forks). You can list the forked processes under the control of GDB by using the info forks command, and switch from one fork to another by using the fork command.
info forks
Print a list of all forked processes under the control of GDB. The listing will include a fork id, a process id, and the current position (program counter) of the process.
fork fork-id
Make fork number fork-id the current process. The argument fork-id is the internal fork number assigned by GDB, as shown in the first field of the `info forks' display.
To quit debugging one of the forked processes, you can either detach from it by using the detach-fork command (allowing it to run independently), or delete (and kill) it using the delete fork command.
detach-fork fork-id
Detach from the process identified by GDB fork number fork-id, and remove it from the fork list. The process will be allowed to run independently.
delete fork fork-id
Kill the process identified by GDB fork number fork-id, and remove it from the fork list.
If you ask to debug a child process and a vfork is followed by an exec, GDB 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 GDB 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 GDB stop whenever a fork, vfork, or exec call is made. See section Setting catchpoints.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.11 Setting a bookmark to return to later
On certain operating systems(2), GDB is able to save a snapshot of a program's state, called a checkpoint, and come back to it later.
Returning to a checkpoint effectively undoes everything that has happened in the program since the checkpoint was saved. This includes changes in memory, registers, and even (within some limits) system state. Effectively, it is like going back in time to the moment when the checkpoint was saved.
Thus, if you're stepping thru a program and you think you're getting close to the point where things go wrong, you can save a checkpoint. Then, if you accidentally go too far and miss the critical statement, instead of having to restart your program from the beginning, you can just go back to the checkpoint and start again from there.
This can be especially useful if it takes a lot of time or steps to reach the point where you think the bug occurs.
To use the checkpoint/restart method of debugging:
checkpoint
Save a snapshot of the debugged program's current execution state. The checkpoint command takes no arguments, but each checkpoint is assigned a small integer id, similar to a breakpoint id.
info checkpoints
List the checkpoints that have been saved in the current debugging session. For each checkpoint, the following information will be listed:
Checkpoint ID
Process ID
Code Address
Source line, or label
restart checkpoint-id
Restore the program state that was saved as checkpoint number checkpoint-id. All program variables, registers, stack frames etc. will be returned to the values that they had when the checkpoint was saved. In essence, gdb will "wind back the clock" to the point in time when the checkpoint was saved.
Note that breakpoints, GDB variables, command history etc. are not affected by restoring a checkpoint. In general, a checkpoint only restores things that reside in the program being debugged, not in the debugger.
delete checkpoint checkpoint-id
Delete the previously-saved checkpoint identified by checkpoint-id.
Returning to a previously saved checkpoint will restore the user state of the program being debugged, plus a significant subset of the system (OS) state, including file pointers. It won't "un-write" data from a file, but it will rewind the file pointer to the previous location, so that the previously written data can be overwritten. For files opened in read mode, the pointer will also be restored so that the previously read data can be read again.
Of course, characters that have been sent to a printer (or other external device) cannot be "snatched back", and characters received from eg. a serial device can be removed from internal program buffers, but they cannot be "pushed back" into the serial pipeline, ready to be received again. Similarly, the actual contents of files that have been changed cannot be restored (at this time).
However, within those constraints, you actually can "rewind" your program to a previously saved point in time, and begin debugging it again -- and you can change the course of events so as to debug a different execution path this time.
Finally, there is one bit of internal program state that will be different when you return to a checkpoint -- the program's process id. Each checkpoint will have a unique process id (or pid), and each will be different from the program's original pid. If your program has saved a local copy of its process id, this could potentially pose a problem.
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
4.11.1 A non-obvious benefit of using checkpoints
On some systems such as GNU/Linux, address space randomization is performed on new processes for security reasons. This makes it difficult or impossible to set a breakpoint, or watchpoint, on an absolute address if you have to restart the program, since the absolute location of a symbol will change from one execution to the next.
A checkpoint, however, is an identical copy of a process. Therefore if you create a checkpoint at (eg.) the start of main, and simply return to that checkpoint instead of restarting the process, you can avoid the effects of address randomization and your symbols will all stay in the same place.
5. Stopping and Continuing
The principal purposes of using a debugger are so that you can stop your program before it terminates; or so that, if your program runs into trouble, you can investigate and find out why.
Inside GDB, your program may stop for any of several reasons, such as a signal, a breakpoint, or reaching a new line after a GDB 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 GDB 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.
5.1 Breakpoints, watchpoints, and catchpoints
5.2 Continuing and stepping
Resuming execution
5.3 Signals
5.4 Stopping and starting multi-thread programs
[ < ]
[ > ]
[ << ]
[ Up ]
[ >> ]
[Top]
[Contents]
[Index]
[ ? ]
5.1 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 (see section Setting breakpoints), to specify the place where your program should stop by line number, function name or exact address in the program.
On some systems, 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. The expression may be a value of a variable, or it could involve values of one or more variables combined by operators, such as `a + b'. This is sometimes called data breakpoints. You must use a different command to set watchpoints (see section Setting watchpoints), but aside from that, you can manage a watchpoint like any other breakpoint: you enable, disable, and delete both breakpoints and watchpoints using the same commands.
You can arrange to have values from your program displayed automatically whenever GDB stops at a breakpoint. See section Automatic 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 (see section Setting 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 Signals.)
GDB 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 GDB 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.
5.1.1 Setting breakpoints
5.1.2 Setting watchpoints
5.1.3 Setting catchpoints
5.1.4 Deleting breakpoints
5.1.5 Disabling breakpoints
5.1.6 Break conditions
5.1.7 Breakpoint command lists
5.1.8 Breakpoint menus
- GDB使用手册
- gdb使用手册
- gdb使用手册
- gdb使用手册
- GDB使用手册
- GDB使用手册
- GDB使用手册
- GDB使用手册
- GDB使用手册
- GDB使用手册
- gdb使用手册
- GDB使用手册
- GDB使用手册
- GDB使用手册
- gdb使用手册
- gdb 使用手册
- GDB使用手册
- gdb 使用手册
- 在.NET开发环境中新建页面时，弹出“Automation 服务器不能创建对象”
- 呵呵
- 文件恢复
- 细说用电脑的正确坐姿
- UI设计注意点
- gdb使用手册
- Java 存储过程
- 电子公务eGBCP初探
- 新的开始
- 让SVN能正确显示中文信息
- WebService 学习笔记
- ASP.NET:访问Excel 电子表格
- 用WM_COPYDATA传递struct
- 1 / 0 = ?
