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 14: HP-UX Configuration-Specific Information 187
local variables may be examined, except for unused variables (which may be elimi-
nated). New values may be assigned to a global and a local variable (set <var> =
<expression>) when stepping by line (step/next/break <line>). However, while
stepping by instruction (stepi/nexti) at optimization level +O1, assign a value to a
variable only if stopped at the very first instruction. This is a must as local optimiza-
tions are performed within a statement.
Backtrace commands (backtrace) may be used to display the current nest of function
calls, including for calls that are inlined. Note that even at +O1, C++ methods that
are defined within a class and Fortran arithmetic statement functions are implicitly
inlinable and are inlined. Other functions are not inlined, regardless of the inline
pragmas or keywords.
14.25.1.2 +O2/+O3/+O4/-ipo
Stepping by line number (step/next) and running to a breakpoint(break) moves the
state of a program forward. However, the program execution does not necessarily stop
at the given line.
You can set breakpoints (break) at the entry to a routine that is not inlined and
examine the values of parameters when the program execution stops at the entry of a
routine. The local variables can be examined within a function. However, the values of
the local variables may not be available at all code locations in the function. Assignment
of new values to formal parameters or local variables is NOT supported in code compiled
with optimization above +O1.
Optimization of code results in the reordering of the instructions and the source line-
numbers. Hence, the value of the variable, which is printed by the debugger may not
correspond to the reported source code location. The debugger may print the value of
the variable at a source code location either before or after the reported source code
location.(If the printed value is not current with respect to the current source line,
the printed value will be the immediately previous or immediately later value for the
variable.)
Backtrace commands (backtrace) can be used to display the current nest of function
calls, including calls that are inlined. When stopped within the code for an inlined
call, the parameters and the local variables of the inlined routine are not reported
or available. The disassem command does not work for functions that have no code
(because all calls to these functions are inlined or these functions are not called at all).
HP WDB 5.7 and later versions provide support to prevent the debugged program
from stopping at instructions that are predicated false. The program execution can be
stopped by a software breakpoint, a hardware breakpoint, or an asynchronous signal. In
the case of optimizations such as if-conversion, the predicated false instructions indicate
that an alternate source path is executed. Hence, stopping the program at a predicated
false instruction results in the misleading conclusion that the path corresponding to
the predicated false instruction is executed. To prevent this ambiguity, HP WDB does
not stop at predicated false instructions.
The predicated false instructions are equated to NOPs (No OPeration), because these
instructions do not modify the processor state. The exception to this rule is the use