Debugging with GDB (February 2008)
Table Of Contents
- Summary of GDB
- A Sample GDB Session
- Getting In and Out of GDB
- GDB Commands
- Running Programs Under GDB
- Stopping and Continuing
- Examining the Stack
- Examining Source Files
- Examining Data
- Using GDB with Different Languages
- Examining the Symbol Table
- Altering Execution
- GDB Files
- Specifying a Debugging Target
- HP-UX Configuration-Specific Information
- Summary of HP Enhancements to GDB
- HP-UX dependencies
- Supported Platforms and Modes
- HP-UX targets
- Support for Alternate root
- Specifying object file directories
- Fix and continue debugging
- Inline Support
- Debugging Macros
- Debugging Memory Problems
- When to suspect a memory leak
- Memory debugging restrictions
- Memory Debugging Methodologies
- Debugging Memory in Interactive Mode
- Debugging Memory in Batch Mode
- Debugging Memory Interactively After Attaching to a Running Process
- Configuring memory debugging settings
- Scenarios in memory debugging
- Stop when freeing unallocated or deallocated blocks
- Stop when freeing a block if bad writes occurred outside block boundary
- Stop when a specified block address is allocated or deallocated
- Scramble previous memory contents at malloc/free calls
- Detect dangling pointers and dangling blocks
- Detect in-block corruption of freed blocks
- Specify the amount of guard bytes for every block of allocated memory
- Comparison of Memory Debugging Commands in Interactive Mode and Batch Mode
- Heap Profiling
- Memory Checking Analysis for User Defined Memory Management Routines
- Commands to track the change in data segment value
- Thread Debugging Support
- Debugging MPI Programs
- Debugging multiple processes ( programs with fork and vfork calls)
- Debugging Core Files
- Printing the Execution Path Entries for the Current Frame or Thread
- Invoking GDB Before a Program Aborts
- Aborting a Command Line Call
- Instruction Level Stepping
- Enhanced support for watchpoints and breakpoints
- Debugging support for shared libraries
- Language support
- Enhanced Java Debugging Support
- Commands for Examining Java Virtual Machine(JVM) internals
- Support for stack traces in Java, C, and C++ programs
- Support for 64-bit Java, C, aC++ stack unwinding
- Enhanced support for C++ templates
- Support for __fpreg data type on IPF
- Support for _Complex variables in HP C
- Support for debugging namespaces
- Command for evaluating the address of an expression
- Viewing Wide Character Strings
- Support for output logging
- Getting information from a non-debug executable
- Debugging optimized code
- Visual Interface for WDB
- Starting and stopping Visual Interface for WDB
- Navigating the Visual Interface for WDB display
- Specifying foreground and background colors
- Using the X-window graphical interface
- Using the TUI mode
- Changing the size of the source or debugger pane
- Using commands to browse through source files
- Loading source files
- Editing source files
- Editing the command line and command-line history
- Saving the contents of a debugging session to a file
- Support for ddd
- Support for XDB commands
- GNU GDB Logging Commands
- Support for command line calls in a stripped executable
- Displaying the current block scope information
- Linux support
- The HP-UX Terminal User Interface
- XDB to WDB Transition Guide
- By-function lists of XDB commands and HP WDB equivalents
- Overall breakpoint commands
- XDB data formats and HP WDB equivalents
- XDB location syntax and HP WDB equivalents
- XDB special language operators and HP WDB equivalents
- XDB special variables and HP WDB equivalents
- XDB variable identifiers and HP WDB equivalents
- Alphabetical lists of XDB commands and HP WDB equivalents
- Controlling GDB
- Canned Sequences of Commands
- Using GDB under gnu Emacs
- GDB Annotations
- The gdb/mi Interface
- Function and purpose
- Notation and terminology
- gdb/mi Command Syntax
- gdb/mi compatibility with CLI
- gdb/mi output records
- gdb/mi command description format
- gdb/mi breakpoint table commands
- gdb/mi Data manipulation
- gdb/mi program control
- Miscellaneous GDB commands in gdb/mi
- gdb/mi Stack Manipulation Commands
- gdb/mi Symbol query commands
- gdb/mi Target Manipulation Commands
- gdb/mi thread commands
- gdb/mi tracepoint commands
- gdb/mi variable objects
- Reporting Bugs in GDB
- Installing GDB
- Index
Chapter 5: Stopping and Continuing 33
5 Stopping and Continuing
The principal purpose of a debugger is to let you stop your program before it terminates
abnormaly or runs into trouble, so that you can investigate and determine the reason.
Inside GDB, your program can stop for several reasons, such as a signal, a breakpoint, or
reaching a new line after a GDB command such as step. You can then examine and change
variables, set new breakpoints or remove old ones, and then continue execution. Usually,
the messages shown by GDB provide information on 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
A breakpoint makes your program stop whenever a certain point in the program is
reached. For each breakpoint, you can add conditions to control in finer detail whether
your program stops. You can set breakpoints with the break command and its variants.
(see Section 5.1.1 [Setting breakpoints], page 33) You can stop your program by line number,
function name or an address in the program.
You can arrange to have values from your program displayed automatically whenever
GDB stops at a breakpoint. See Section 8.6 [Automatic display], page 68.
In HP-UX, SunOS 4.x, SVR4, and Alpha OSF/1 configurations, you can set breakpoints
in shared libraries before the executable is run. See Section 14.20 [Stopping and starting in
shared libraries], page 174.
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 5.1.2 [Setting
catchpoints], page 37), 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
Section 5.3 [Signals], page 46.)
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
Breakpoints are set with the break command (abbreviated b). The debugger conve-
nience variable ‘$bpnum’ records the number of the breakpoint you’ve set most recently;