The Art of Debugging with GDB, DDD and Eclipse

1. Debugging is an Art Guided by Principles

Fixing a buggy program is a process of confirming, one by one, that the many things you believe to be true about the code actually are true.

Confirmation is Key. Debugging isn't just about finding errors; it's about systematically validating your assumptions about how the code works. The core principle is to confirm each belief about the code's behavior, and when an assumption proves false, it becomes a clue to the bug's location. This approach transforms debugging from a frustrating guessing game into a structured process of discovery.

Embrace Surprises. Unexpected behavior is a gift in debugging. When the program deviates from your expectations, it highlights a discrepancy between your mental model and the actual code execution. These surprises are valuable because they pinpoint the area where your understanding is flawed, leading you closer to the root cause of the bug.

Start Small and Top-Down. Begin with simple test cases to expose obvious errors early. Then, debug from the top down, verifying the behavior of high-level functions before diving into their implementation details. This modular approach helps isolate problems and avoids wasting time on code that is already working correctly.

2. Leverage Debugging Tools: GDB, DDD, and Eclipse

In many situations, a debugger can tell you the approximate location of a bug.

GDB: The Text-Based Powerhouse. GDB, the GNU Debugger, is a command-line tool that provides precise control over program execution. Its text-based interface is lightweight and efficient, making it ideal for remote debugging or situations where a GUI is impractical. GDB's power lies in its ability to inspect variables, set breakpoints, and step through code with fine-grained control.

DDD: Visualizing Debugging. DDD, the Data Display Debugger, offers a graphical front-end to GDB, enhancing the debugging experience with visual aids. DDD displays source code, variable values, and data structures in an intuitive manner, making it easier to understand program state and identify anomalies. DDD also allows direct execution of GDB commands.

Eclipse: The Integrated Environment. Eclipse is a full-fledged Integrated Development Environment (IDE) that combines an editor, compiler, and debugger into a single package. Eclipse provides a rich set of features for debugging, including visual breakpoints, variable inspection, and call stack navigation. While Eclipse has a larger footprint than GDB or DDD, its integration and ease of use make it a popular choice for many developers.

3. Master Breakpoints, Watchpoints, and Catchpoints

A breakpoint is like a tripwire within a program: You set a breakpoint at a particular “place” within your program, and when execution reaches that point, the debugger will pause the program’s execution.

Breakpoints: Strategic Pauses. Breakpoints are essential for pausing program execution at specific locations, such as a line of code or the entry point of a function. They allow you to examine the program's state at critical points and verify that variables have the expected values. Conditional breakpoints pause execution only when a specified condition is met, enabling you to focus on specific scenarios.

Watchpoints: Variable Change Alerts. Watchpoints monitor the value of a variable or expression and pause execution whenever it changes. This is particularly useful for tracking down unexpected modifications to variables, especially in complex code where the source of the change may not be immediately obvious. Watchpoints are invaluable for identifying the exact moment when a variable takes on an incorrect value.

Catchpoints: Event-Driven Debugging. Catchpoints pause execution when specific events occur, such as the throwing of an exception or the loading of a shared library. This allows you to investigate the program's behavior in response to these events and identify potential issues related to error handling or dynamic linking.

4. Inspect and Modify Variables to Validate Assumptions

In many situations, a debugger can tell you the approximate location of a bug.

Printing and Displaying Variables. The most basic way to inspect variables is to print their values using the print command in GDB or by hovering the mouse over them in DDD and Eclipse. However, debuggers offer more advanced features for displaying complex data structures, such as arrays, linked lists, and trees. These features allow you to visualize the contents of memory and identify inconsistencies or errors.

Advanced Inspection Techniques. GDB's display command automatically prints the value of a variable each time execution pauses, saving you the effort of repeatedly typing the print command. DDD provides a graphical interface for navigating linked data structures, allowing you to follow pointers and explore the relationships between objects. Eclipse offers a Variables view that displays the values of local and global variables, as well as the ability to add watch expressions to monitor specific variables or expressions.

Modifying Variables on the Fly. Debuggers also allow you to modify the values of variables during execution. This can be useful for testing different scenarios or correcting errors temporarily to see if they resolve the problem. However, use this feature with caution, as it can mask underlying bugs or introduce new ones.

5. Understand Memory Management to Conquer Crashes

Why didn’t a segmentation fault occur when your erroneous code exceeded the bounds of an array?

Segmentation Faults Explained. A segmentation fault (seg fault) occurs when a program attempts to access memory that it does not have permission to access. This is often caused by out-of-bounds array accesses, dereferencing null pointers, or writing to read-only memory. Understanding how memory is organized and managed is crucial for diagnosing and preventing seg faults.

Virtual Memory and the Page Table. Modern operating systems use virtual memory to provide each process with its own isolated address space. The OS maintains a page table that maps virtual addresses to physical addresses. When a program attempts to access a virtual address, the hardware checks the page table to ensure that the access is valid. If the access violates the permissions for the page, a seg fault occurs.

Core Files for Post-Mortem Analysis. When a program crashes with a seg fault, the OS can create a core file, which is a snapshot of the program's memory at the time of the crash. You can use a debugger to examine the core file and determine the cause of the seg fault. Core files are particularly useful for debugging crashes that are difficult to reproduce.

6. Navigate Debugging in Concurrent Environments

Client/server network programming does count as parallel processing, with even our tools being used in parallel—for example, two windows in which we use GDB, one for the client, one for the server.

Debugging Client/Server Applications. Debugging client/server applications requires coordinating debugging efforts across multiple processes. You can use multiple instances of GDB, one for each process, to step through the code and inspect variables. Network traffic analyzers like Wireshark can help you monitor the communication between the client and server.

Debugging Threaded Code. Threaded programming introduces new challenges, such as race conditions and deadlocks. GDB provides commands for inspecting threads, switching between threads, and setting thread-specific breakpoints. Understanding thread synchronization mechanisms, such as mutexes and semaphores, is crucial for debugging threaded code.

Debugging Parallel Applications. Parallel programming, whether using shared memory or message passing, involves coordinating the execution of multiple processes or threads. Debugging parallel applications requires specialized tools and techniques for monitoring communication, detecting deadlocks, and ensuring data consistency.

7. Employ Supplementary Tools for Comprehensive Debugging

The debugging process can be greatly enhanced through the use of supplementary tools.

Text Editors: Syntax Highlighting and Bracket Matching. A good text editor can help you catch syntax errors and other common mistakes before you even compile your code. Syntax highlighting makes it easier to identify keywords, variables, and other code elements, while bracket matching helps you ensure that parentheses, braces, and brackets are properly balanced.

Compilers: Warning Flags. Compilers can detect a wide range of potential problems in your code, such as unused variables, implicit type conversions, and potential buffer overflows. Enabling compiler warning flags, such as -Wall in GCC, can help you identify these issues early in the development process.

Static Code Checkers: Lint and Friends. Static code checkers, such as Splint, analyze your code without executing it and identify potential errors, style violations, and security vulnerabilities. These tools can help you enforce coding standards and improve the overall quality of your code.

8. Debugging Other Languages with GDB/DDD/Eclipse

“Hey, this thing really works!” So said one of our students, Andrew, after he made serious use of a debugging tool for the first time.

Java Debugging. While GDB can be used to debug Java code, it's often more convenient to use a Java-specific debugger, such as JDB or the Eclipse Java debugger. These tools provide features tailored to Java development, such as support for inspecting objects, stepping through bytecode, and debugging multithreaded applications.

Python Debugging. Python offers its own built-in debugger, pdb, which can be used from the command line. However, DDD and Eclipse also provide Python debugging support, allowing you to use a graphical interface to step through code, inspect variables, and set breakpoints.

Perl Debugging. Perl has a built-in debugger that can be invoked with the -d flag. DDD and Eclipse also offer Perl debugging support, providing a more visual and interactive debugging experience.

Last updated: April 10, 2025