Info Node: (ddd.info)Top

CFHT HOME ddd.info: Top

up: (dir) next: Summary Back to Software Index 

Debugging with DDD
******************

DDD is a graphical front-end for GDB and other command-line debuggers.

   This is the First Edition of `Debugging with DDD', 8 Feb, 2009, for
DDD Version 3.3.12.

   The first part of this master menu lists the major nodes in this Info
document, including the label and command indices.  The rest of the menu
lists all the lower level nodes in the document.
* Summary
Summary of DDD.
* Sample Session
A sample DDD session.
* Invocation
Getting in and out of DDD.
* Windows
The DDD windows, menus, and buttons.
* Navigating
Moving through the source code.
* Stopping
Making your program stop at specific locations.
* Running
Running programs under DDD.
* Examining Data
Examining variable values and data structures.
* Machine-Level Debugging
Examining machine code and registers.
* Changing the Program
Changing source and object code.
* Commands
Entering and editing DDD commands.
* Application Defaults
Resources used in DDD.
* Bugs
How, when, and why to report DDD bugs.
* Configuration Notes
Configuration-specific notes.
* Dirty Tricks
Room for your contributions.
* Extending
Extending DDD.
* FAQ
Frequently Answered Questions.
* License
The DDD license.
* Help and Assistance
Mailing Lists and other resources.
* Documentation License
The license of this document.
* Label Index
All labels shown on the DDD GUI.
* Key Index
Keys used to control DDD.
* Command Index
Commands that can be typed within DDD.
* Resource Index
All resources and environment variables.
* File Index
All programs and files referenced by DDD.
* Concept Index
All concepts as mentioned in this manual. 
 --- The Detailed Node Listing ---

Summary of DDD
* About this Manual
Getting copies in various formats.
* Free Software
How to copy and redistribute DDD.
* Getting DDD
How to obtain copies of DDD.
* Contributors
Who has done all this?
* History
Old DDD versions. 
A Sample DDD Session
* Sample Program
Source `sample.c' 
Getting In and Out of DDD
* Invoking
How to invoke DDD.
* Quitting
How to quit DDD.
* Sessions
Saving work across invocations.
* Remote Debugging
Running DDD on a different host.
* Customizing Debugger Interaction
How DDD and GDB communicate. 
Invoking DDD
* Choosing an Inferior Debugger
Which debugger to use?
* Options
How to invoke DDD
* X Options
Setting X properties
* Inferior Debugger Options
Customizing GDB, DBX, and so on
* Multiple Instances
Running multiple DDD instances
* X Warnings
Turning off obnoxious warnings 
Inferior Debugger Options
* GDB Options
* DBX and Ladebug Options
* XDB Options
* JDB Options
* PYDB Options
* Perl Options
* Bash Options
* GNU Make Options
Persistent Sessions
* Saving Sessions
* Resuming Sessions
* Deleting Sessions
* Customizing Sessions
Remote Debugging
* Remote Host
Running DDD on a Remote Host
* Remote Debugger
Using a Remote Inferior Debugger
* Remote Program
Debugging a Remote Program 
Using DDD with a Remote Inferior Debugger
* Customizing Remote Debugging
Customizing Interaction with the Inferior Debugger
* Debugger Invocation
* Debugger Initialization
* Debugger Communication
Initializing the Inferior Debugger
* GDB Initialization
* DBX Initialization
* XDB Initialization
* JDB Initialization
* PYDB Initialization
* Perl Initialization
* Bash Initialization
* Finding a Place to Start
* Opening the Selection
The DDD Windows
* Menu Bar
All DDD pull-down menus.
* Tool Bar
The DDD icon buttons.
* Command Tool
The floating command tool.
* Getting Help
What does this thing mean?
* Undo and Redo
Oops!
* Customizing
You can customize DDD 
The Menu Bar
* File Menu
Selecting programs and processes.
* Edit Menu
Cut, copy, paste, and preferences.
* View Menu
All DDD windows.
* Program Menu
Starting and stopping.
* Commands Menu
All DDD commands.
* Status Menu
Examining the program status.
* Source Menu
Navigating around.
* Data Menu
Examining data.
* Maintenance Menu
Maintaining DDD.
* Help Menu
Getting help.
* Customizing the Menu Bar
Alternate key bindings, etc. 
Customizing the Menu Bar
* Auto-Raise Menus
* Customizing the Edit Menu
The Tool Bar
* Customizing the Tool Bar
The Command Tool
* Customizing the Command Tool
* Customizing Tool Position
Customizing the Command Tool
* Disabling the Command Tool
Command Tool Position
* Customizing Tool Decoration
Customizing DDD
* How Customizing Works
* Customizing Help
* Customizing Undo
* Customizing Windows
* Debugger Settings
How Customizing DDD Works
* Resources
* Changing Resources
* Saving Options
Customizing DDD Help
* Button tips
Turning off tips.
* Tip of the day
Turning off the tip of the day.
* Help Helpers
Helper programs invoked by Help. 
Customizing the DDD Windows
* Splash Screen
Turning off the splash screen.
* Window Layout
Re-arranging windows.
* Customizing Fonts
Using alternate fonts.
* Toggling Windows
Turning off windows.
* Text Fields
Popdown histories.
* Icons
Iconifying DDD windows.
* Adding Buttons
Create your own button set.
* More Customizations
Navigating through the Code
* Compiling for Debugging
Always use `-g' to compile.
* Opening Files
How to open a program for debugging.
* Looking up Items
Searching files and functions.
* Customizing Source
Arranging the source window. 
Opening Files
* Opening Programs
How to open a program for debugging.
* Opening Core Dumps
Analyze a previous crash.
* Opening Source Files
Open a source file of the program.
* Filtering Files
DDD only lists matching files. 
Looking up Items
* Looking up Definitions
Jump towards a specific item.
* Textual Search
Search within the current source.
* Looking up Previous Locations
Navigate back and forth.
* Source Path
Make DDD know where to search. 
Customizing the Source Window
* Customizing Glyphs
* Customizing Searching
* Customizing Source Appearance
* Customizing Source Scrolling
* Customizing Source Lookup
* Customizing File Filtering
Stopping the Program
* Breakpoints
Stop at a certain point.
* Watchpoints
Stop at a certain condition.
* Interrupting
Stop manually.
* Stopping X Programs
Take care of grabbed pointers! 
Breakpoints
* Setting Breakpoints
* Deleting Breakpoints
* Disabling Breakpoints
* Temporary Breakpoints
* Editing Breakpoint Properties
* Breakpoint Conditions
* Breakpoint Ignore Counts
* Breakpoint Commands
* Moving and Copying Breakpoints
* Looking up Breakpoints
* Editing all Breakpoints
* Hardware-Assisted Breakpoints
Watchpoints
* Setting Watchpoints
* Editing Watchpoint Properties
* Editing all Watchpoints
* Deleting Watchpoints
Stopping X Programs
* Customizing Grab Checking
Running the Program
* Starting Program Execution
* Using the Execution Window
* Attaching to a Process
* Program Stop
* Resuming Execution
* Continuing Somewhere Else
* Stack
* Undoing Program Execution
* Threads
* Signals
* Killing the Program
Starting Program Execution
* Arguments
Your program's arguments.
* Environment
Your program's environment.
* Working Directory
Your program's directory.
* Input/Output
Your program's I/O. 
Using the Execution Window
* Customizing the Execution Window
Attaching to a Running Process
* Customizing Attaching to Processes
Examining the Stack
* Frames
Callers and callees.
* Backtraces
And you may ask yourself, `how did I get here?'
* Selecting a frame
Moving up and down. 
Examining Data
* Value Tips
Just move the pointer on a variable.
* Printing Values
Printing a value in the debugger console.
* Displaying Values
Displaying structures as graphs.
* Plotting Values
Displaying values as plots.
* Examining Memory
Low-level memory examination. 
Displaying Complex Values in the Data Window
* Display Basics
How to create, manipulate, and delete displays.
* Arrays
Special functions for arrays.
* Assignment
Setting variable values.
* Examining Structures
Dereferencing pointers and other references.
* Customizing Displays
Data Themes.
* Layouting the Graph
Automatic layout.
* Printing the Graph
Printing on paper. 
Display Basics
* Creating Single Displays
* Selecting Displays
* Showing and Hiding Details
* Rotating Displays
* Displaying Local Variables
* Displaying Program Status
* Refreshing the Data Window
* Placement
* Clustering
* Creating Multiple Displays
* Editing all Displays
* Deleting Displays
Arrays
* Array Slices
Displaying FROM..TO parts of an array
* Repeated Values
How repeated values are handled.
* Arrays as Tables
Displaying two-dimensional arrays. 
Examining Structures
* Dependent Values
Edges from values to values.
* Dereferencing Pointers
Examining pointer-based data structures.
* Shared Structures
Multiple pointers to one display.
* Display Shortcuts
Customize your own menus. 
Customizing Displays
* Using Data Themes
* Applying Data Themes to Several Values
* Editing Themes
* Writing Data Themes
* Display Resources
* VSL Resources
Layouting the Graph
* Moving Displays
* Scrolling Data
* Aligning Displays
* Automatic Layout
* Rotating the Graph
Plotting Values
* Plotting Arrays
Plotting 1-D and 2-D arrays.
* Plot Appearance
Controlling the appearance.
* Scalars and Composites
Plotting simple values.
* Plotting Histories
Plotting the history of a variable.
* Printing Plots
Printing on paper.
* Entering Plotting Commands
Raw Gnuplot commands.
* Exporting Plot Data
Processing data outside of DDD
* Animating Plots
Visualizing dynamic behaviour.
* Customizing Plots
All at your leisure. 
Customizing Plots
* Gnuplot Invocation
* Gnuplot Settings
Machine-Level Debugging
* Machine Code
Examining machine code.
* Machine Code Execution
Stepping across instructions.
* Registers
Examining registers.
* Customizing Machine Code
Settings. 
Changing the Program
* Editing Source Code
You can invoke a source editor from DDD.
* Recompiling
Invoking `make' from within DDD.
* Patching
Changing source and object code. 
Editing Source Code
* Customizing Editing
* In-Place Editing
The Command-Line Interface
* Entering Commands
Direct interaction with the inferior debugger.
* TTY mode
Controlling DDD from a terminal.
* Integrating DDD
DDD and your programming environment.
* Defining Buttons
Add your own DDD buttons.
* Defining Commands
Add your own DDD commands. 
Entering Commands
* Command Completion
Using the <TAB> key.
* Command History
Repeating previous commands.
* Typing in the Source Window
Defining Buttons
* Customizing Buttons
Adding your own command buttons. 
Defining Commands
* GDB Simple Commands
* GDB Argument Commands
* Commands with Other Debuggers
Application Defaults
* Actions
All actions used in translation tables.
* Images
All images used in resources, 
Actions
* General Actions
* Data Display Actions
* Debugger Console Actions
* Source Window Actions
Bugs and How To Report Them
* Where to Send Bug Reports
Our e-mail address.
* Is it a DDD Bug?
DDD may not be at fault.
* How to Report Bugs
Report all the facts.
* Bug Reports
Include all configuration information.
* Diagnostics
Maintaining DDD 
Getting Diagnostics
* Logging
DDD logs all interactions.
* Debugging DDD
Facilities to debug DDD.
* Customizing Diagnostics
All diagnostics resources. 
Logging
* Disabling Logging
Configuration Notes
* GDB
Using DDD with GDB
* DBX
Using DDD with DBX
* Ladebug
Using DDD with Ladebug
* XDB
Using DDD with XDB
* JDB
Using DDD with JDB
* Perl
Using DDD with Perl
* Bash
Using DDD with Bash
* Make
Using DDD with GNU Make
* LessTif
Using DDD with LessTif 
Using DDD with GDB
* WDB
Using DDD with WDB
* WindRiver GDB
Using DDD with WindRiver GDB (Tornado)
automatically generated by info2www version 1.2