Master GDB: Essential Debugging Techniques for C/C++ Developers

In software development, bugs can cause catastrophic failures, as illustrated by the Ariane 5 rocket disaster caused by a 64‑bit floating‑point to 16‑bit integer overflow. To combat such hidden "monsters", the GNU Debugger (GDB) provides a powerful command‑line interface for inspecting and controlling program execution.

What Is GDB?

GDB (GNU Debugger) is an open‑source debugging tool released by the GNU project in 1986. It supports many languages (C, C++, Fortran, Ada, Objective‑C, Go, D, etc.) and integrates with compilers like GCC and Clang. GDB works on Linux, Windows (via MinGW or Cygwin), macOS, and embedded platforms, making it a versatile choice for desktop, server, and embedded development.

Key Advantages

Rich functionality: breakpoints (including conditional), step execution, variable inspection, memory examination, and backtrace.

Cross‑platform support: runs on Linux, Windows, macOS, ARM, RISC‑V, and more.

Extensibility: plugins and Python scripting allow custom analysis, memory checks, and performance profiling.

Open‑source and free: a large community provides documentation, tutorials, and support.

Basic Operations

Installation and Startup

Check installation with gdb -v. If missing, install via the system package manager (ensure a compiler like gcc is present). Launch GDB with the executable name, e.g., gdb my_program, or start GDB first and then load a file with file test_file.exe. Command‑line arguments can be passed using gdb --args prog arg1 arg2 or after startup with set args ….

Compiling with Debug Information

gcc -g -o my_program my_program.c

The -g flag embeds symbol information, enabling GDB to map machine code back to source lines, variables, and types.

Running Programs

Use run (or r) to start execution. You can attach to a running process with attach <PID> or debug a core dump with gdb program core.

Common Commands

break

( b) – set a breakpoint at a line, function, or with a condition. continue ( c) – resume execution until the next breakpoint. next ( n) – step over a line (does not enter functions). step ( s) – step into a function. finish – run until the current function returns. print ( p) – display variable values or evaluate expressions. info break ( i b) – list all breakpoints. backtrace ( bt) – show the call stack.

Advanced Features

Backtrace (Stack Tracing)

When a program crashes or stops at a breakpoint, bt prints each stack frame with function name, source file, line number, and arguments, helping locate the origin of errors.

Dynamic Memory Inspection

Load a heap‑analysis plugin (e.g., gdbheap.py) with source /path/to/gdbheap.py. After attaching to a process, the plugin can report allocated blocks, sizes, and potential leaks.

Conditional Breakpoints and Watchpoints

Set a breakpoint that triggers only when a condition is true, e.g., break func if i >= array_size. Use watch variable to pause execution whenever the variable’s value changes; rwatch and awatch monitor reads or reads/writes.

Remote Debugging

Run gdbserver :<port> /path/to/program on the target machine. On the host, start GDB with the same binary and connect using target remote <host>:<port>. This enables full debugging of programs on embedded devices or remote servers.

TUI (Text User Interface) Mode

Start GDB with gdb -tui program or toggle with Ctrl‑X A. TUI splits the terminal into a source view and a command console, highlighting the current line and showing breakpoints.

Custom Commands and Scripts

Define reusable command sequences:

define my_debug
    b main
    b func_a
    r
end

Or write a .gdb script and load it with source script.gdb. Scripts can contain control structures ( if…else…end, while…end) for complex automation.

IDE Integration

GDB can be used behind graphical IDEs such as Eclipse CDT. Build the project with debug symbols, set breakpoints in the IDE, and launch debugging; the IDE forwards commands to GDB while presenting a visual interface.

Practical Tips

Use ulimit -c unlimited to enable core‑dump generation for post‑mortem analysis.

Leverage monitor heap after loading a heap plugin to spot memory leaks.

Combine TUI with custom scripts for rapid, repeatable debugging workflows.

By mastering these GDB capabilities, developers can efficiently locate, diagnose, and fix bugs across a wide range of C/C++ projects.