Files
skills/public/debugging-gdb-fundamentals.html
zeekayandHanzo Dev 9e10c1c10e Each llms index points at the other two
hanzoskills.com/llms.txt now opens with the install line, the API
reference index and the company index, so an agent that lands on any
one of the three can find the rest.

robots.txt claimed 537 documents while llms.txt counts 920. The number
is gone from robots.txt; llms.txt derives it.

public/ is regenerated from scripts/site.py, which it had fallen
behind: the copy-prompt menu and agent bar were in the generator and
not in the committed pages. tests/site.mjs passes against the result.

Co-authored-by: Hanzo Dev <[email protected]>
2026-09-11 00:27:59 -07:00

792 lines
28 KiB
HTML

<!doctype html>
<html lang="en"><head>
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
<title>debugging-gdb-fundamentals</title>
<meta name="color-scheme" content="dark">
<style>
/* Committed to one visual world: a dark instrument panel. No light variant —
the dot field and the hairline rules only read on black, and a naive
inversion would wash both out. Every colour is painted explicitly so the page
never borrows a host background. */
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
:root{
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
--font-zen-pixel-square:'Zen Pixel Square',monospace;
--mono:var(--font-zen-mono);
--sans:var(--font-zen-sans);
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
--r:999px; --r-soft:14px;
}
*{box-sizing:border-box}
html{-webkit-text-size-adjust:100%}
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
/* The dot field. A halftone made of one repeating radial-gradient, faded out
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
/* No overflow clip here: the dot field is inset to the box already, and a clip
would cut off the copy-prompt menu. */
.hero{position:relative;border-bottom:1px solid var(--line)}
.hero::before{content:"";position:absolute;inset:0;
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
background-size:7px 7px;
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
pointer-events:none}
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
nav{border-bottom:1px solid var(--line)}
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
justify-content:space-between;align-items:center;gap:1rem}
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--ink);text-decoration:none;
display:inline-flex;align-items:center;gap:.6rem}
.brand i{font-style:normal;color:var(--faint)}
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
text-transform:uppercase;color:var(--soft);text-decoration:none}
nav a.up:hover{color:var(--ink)}
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
h1 em{font-style:normal;color:var(--faint)}
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
line-height:1.2;font-weight:400}
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
.btn.solid:hover{background:#d8d8d4}
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
/* Copy-prompt selector. Each row copies the prompt for its own target. */
.copy{position:relative;display:inline-flex}
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
padding:.4rem;display:flex;flex-direction:column;
box-shadow:0 12px 32px rgba(0,0,0,.75)}
.menu[hidden]{display:none}
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
white-space:nowrap}
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
.mi:hover .mark{color:var(--ink)}
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
letter-spacing:.1em;text-transform:uppercase}
/* Works-with bar: one scrolling row, name and mark per agent. */
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
display:flex;align-items:center}
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
-webkit-overflow-scrolling:touch;
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
.bar::-webkit-scrollbar{display:none}
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
text-decoration:none;background:var(--ground)}
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
.agent .mark{width:.95rem;height:.95rem}
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
p{margin:0 0 1rem;max-width:70ch}
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
li{margin:.22rem 0}
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
text-decoration-color:var(--line-hi)}
a:hover{text-decoration-color:var(--ink)}
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
display:block;overflow-x:auto}
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
.curl{display:block;background:var(--panel);border:1px solid var(--line);
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
white-space:pre;line-height:1.9}
.curl b{color:var(--ink);font-weight:400}
.curl i{font-style:normal;color:var(--faint)}
/* index */
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
#q:focus{outline:none;border-color:var(--soft)}
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
text-transform:uppercase;margin:0 0 2rem}
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
padding-bottom:.45rem}
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
border-radius:var(--r-soft);text-decoration:none}
.row:hover{background:#0a0a0a}
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
color:var(--faint);font-size:.85rem}
footer a{color:var(--soft)}
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
margin:0 0 2rem;font-size:.85rem}
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
border-bottom:1px solid var(--line);padding-bottom:.4rem}
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
.fmap a:hover{text-decoration:underline}
.fmap div{color:var(--faint);line-height:1.5}
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
@media (max-width:640px){
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
.btns{gap:.5rem}
.btn{padding:.75rem 1.15rem;font-size:.68rem}
.copy,.copy .btn{width:100%;justify-content:center}
.menu{left:0;right:0;min-width:0}
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
.strip b{border-right:0;padding-right:0}
.bar{width:100%}
}
</style>
<link rel="alternate" type="text/markdown" href="/debugging-gdb-fundamentals.md">
<link rel="icon" href="/favicon.svg">
<link rel="canonical" href="https://hanzoskills.com/debugging-gdb-fundamentals">
</head>
<!-- Reading this with a machine? Every page here is also plain markdown.
This one: https://hanzoskills.com/debugging-gdb-fundamentals.md
Index: https://hanzoskills.com/llms.txt
Corpus: https://hanzoskills.com/all.md
Append .md to any path for the markdown twin. -->
<body>
<nav><div class="in">
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
<a class="up" href="/">All skills</a>
</div></nav>
<div class="wrap">
<h1>debugging-gdb-fundamentals</h1><p class="lede">Comprehensive guide to GNU Debugger (GDB) for debugging C/C++/Rust programs. Covers breakpoints, stack traces, variable inspection, TUI mode, .gdbinit customization, Python scripting, remote debugging, and core file analysis.</p><h1>GDB Fundamentals</h1>
<p><strong>Last Updated</strong>: 2025-10-26</p>
<h2>Overview</h2>
<p>GDB (GNU Debugger) is the standard debugger for C, C++, Rust, Go, and other compiled languages. This guide covers fundamental debugging workflows, advanced features, and best practices for effective debugging.</p>
<h2>Core Concepts</h2>
<h3>GDB Architecture</h3>
<pre><code>Program (debuggee)
↓
ptrace() system call → GDB (debugger)
↓
Debug symbols (DWARF) → Source mapping
↓
User commands → GDB commands → ptrace() actions</code></pre>
<h3>Debug Symbols</h3>
<p><strong>Compile with debug symbols</strong>:</p>
<pre><code class="lang-bash"># C/C++
gcc -g program.c -o program
g++ -g -O0 program.cpp -o program # -O0 disables optimization
# Rust
cargo build # Debug build includes symbols
cargo build --release # No debug symbols
# Zig
zig build-exe program.zig -O Debug # Debug symbols</code></pre>
<p><strong>Check if symbols present</strong>:</p>
<pre><code class="lang-bash">file program
# program: ELF 64-bit LSB executable, x86-64, with debug_info, not stripped
nm program | grep -i debug
objdump -h program | grep debug</code></pre>
<hr>
<h2>Starting GDB</h2>
<h3>Basic Launch</h3>
<pre><code class="lang-bash"># Start GDB with program
gdb ./program
# Start with arguments
gdb --args ./program arg1 arg2
# Attach to running process
gdb -p &lt;pid&gt;
gdb attach &lt;pid&gt;
# Load core dump
gdb ./program core.12345
# Quiet mode (no banner)
gdb -q ./program</code></pre>
<h3>Batch Mode</h3>
<pre><code class="lang-bash"># Run commands from file
gdb -batch -x commands.gdb ./program
# Example commands.gdb:
# break main
# run
# backtrace
# quit</code></pre>
<hr>
<h2>Breakpoints</h2>
<h3>Setting Breakpoints</h3>
<p><strong>Function breakpoints</strong>:</p>
<pre><code class="lang-gdb"># Break at function entry
(gdb) break main
(gdb) b calculate_sum
# Break at C++ method
(gdb) break MyClass::method
# Break at Rust function
(gdb) break my_crate::my_function
# Conditional breakpoint
(gdb) break main if argc &gt; 1
(gdb) b process_data if count &gt; 100
# Temporary breakpoint (auto-delete after hit)
(gdb) tbreak main</code></pre>
<p><strong>Line breakpoints</strong>:</p>
<pre><code class="lang-gdb"># Break at line number
(gdb) break file.c:42
(gdb) b 42 # Current file
# Break at all matching functions
(gdb) rbreak ^calculate.* # Regex: all functions starting with &quot;calculate&quot;</code></pre>
<p><strong>Address breakpoints</strong>:</p>
<pre><code class="lang-gdb"># Break at memory address
(gdb) break *0x400567</code></pre>
<h3>Managing Breakpoints</h3>
<pre><code class="lang-gdb"># List all breakpoints
(gdb) info breakpoints
(gdb) i b
# Disable/enable breakpoint
(gdb) disable 1
(gdb) enable 1
# Delete breakpoint
(gdb) delete 1
(gdb) d 1
# Delete all breakpoints
(gdb) delete
# Ignore breakpoint N times
(gdb) ignore 1 10 # Ignore breakpoint 1 for 10 hits</code></pre>
<h3>Watchpoints</h3>
<p><strong>Monitor variable changes</strong>:</p>
<pre><code class="lang-gdb"># Watch variable (break when value changes)
(gdb) watch my_variable
# Watch memory location
(gdb) watch *0x7fffffffe000
# Watch expression
(gdb) watch count &gt; 100
# Read watchpoint (break on read)
(gdb) rwatch my_variable
# Access watchpoint (break on read or write)
(gdb) awatch my_variable</code></pre>
<h3>Catchpoints</h3>
<p><strong>Break on events</strong>:</p>
<pre><code class="lang-gdb"># Catch C++ exceptions
(gdb) catch throw
(gdb) catch catch
# Catch system calls
(gdb) catch syscall open
(gdb) catch syscall write read
# Catch signals
(gdb) catch signal SIGSEGV
# Catch library loads
(gdb) catch load libcrypto.so</code></pre>
<hr>
<h2>Program Control</h2>
<h3>Running Programs</h3>
<pre><code class="lang-gdb"># Start program
(gdb) run
(gdb) r
# Run with arguments
(gdb) run arg1 arg2
(gdb) set args arg1 arg2
(gdb) run
# Run with input redirection
(gdb) run &lt; input.txt
# Run with environment variables
(gdb) set environment VAR=value
(gdb) run</code></pre>
<h3>Stepping Through Code</h3>
<pre><code class="lang-gdb"># Step into (enter functions)
(gdb) step
(gdb) s
# Step over (don&#x27;t enter functions)
(gdb) next
(gdb) n
# Step one instruction
(gdb) stepi
(gdb) si
# Continue until function returns
(gdb) finish
# Continue until line
(gdb) until 50
# Continue execution
(gdb) continue
(gdb) c</code></pre>
<h3>Advanced Control</h3>
<pre><code class="lang-gdb"># Skip function during stepping
(gdb) skip function std::string::operator=
# List skipped functions
(gdb) info skip
# Return from function early
(gdb) return
(gdb) return 42 # Return with value</code></pre>
<hr>
<h2>Stack Inspection</h2>
<h3>Backtraces</h3>
<pre><code class="lang-gdb"># Full backtrace
(gdb) backtrace
(gdb) bt
# Backtrace with local variables
(gdb) bt full
# Limited backtrace
(gdb) bt 10 # Show 10 frames
# Backtrace all threads
(gdb) thread apply all bt</code></pre>
<h3>Frame Navigation</h3>
<pre><code class="lang-gdb"># Show current frame
(gdb) frame
(gdb) f
# Select frame by number
(gdb) frame 2
(gdb) f 2
# Move up/down stack
(gdb) up
(gdb) down
(gdb) up 3
# Show frame info
(gdb) info frame
(gdb) info locals
(gdb) info args</code></pre>
<hr>
<h2>Variable Inspection</h2>
<h3>Print Variables</h3>
<pre><code class="lang-gdb"># Print variable
(gdb) print my_variable
(gdb) p my_variable
# Print with format
(gdb) p/x my_variable # Hexadecimal
(gdb) p/d my_variable # Decimal
(gdb) p/t my_variable # Binary
(gdb) p/c my_variable # Character
(gdb) p/f my_variable # Float
# Print pointer
(gdb) p *ptr
(gdb) p ptr[0]@10 # Print array of 10 elements
# Print structure
(gdb) p my_struct
(gdb) p my_struct.field</code></pre>
<h3>Display (Auto-print)</h3>
<pre><code class="lang-gdb"># Display variable every stop
(gdb) display count
(gdb) display expr
# List displays
(gdb) info display
# Delete display
(gdb) delete display 1</code></pre>
<h3>Memory Examination</h3>
<pre><code class="lang-gdb"># Examine memory
(gdb) x/10xw 0x7fffffffe000 # 10 words in hex
(gdb) x/10i $pc # 10 instructions at PC
(gdb) x/s 0x400678 # String at address
# Format: x/[count][format][size] address
# Formats: x(hex) d(decimal) u(unsigned) o(octal) t(binary) a(address) c(char) s(string) i(instruction)
# Sizes: b(byte) h(halfword) w(word) g(giant, 8 bytes)</code></pre>
<h3>Type Inspection</h3>
<pre><code class="lang-gdb"># Show type
(gdb) ptype my_variable
(gdb) whatis my_variable
# Show type with size
(gdb) p sizeof(my_struct)</code></pre>
<hr>
<h2>TUI Mode (Text User Interface)</h2>
<h3>Activation</h3>
<pre><code class="lang-bash"># Start GDB in TUI mode
gdb -tui ./program
# Or within GDB:
(gdb) tui enable
(gdb) Ctrl-x Ctrl-a # Toggle TUI mode</code></pre>
<h3>TUI Layouts</h3>
<pre><code class="lang-gdb"># Source + command
(gdb) layout src
# Assembly + command
(gdb) layout asm
# Source + assembly
(gdb) layout split
# Registers + source
(gdb) layout regs
# Cycle layouts
(gdb) Ctrl-x 2</code></pre>
<h3>TUI Navigation</h3>
<pre><code>Ctrl-x o # Switch active window
Ctrl-x 1 # Single window
Ctrl-x 2 # Split window
Ctrl-l # Refresh screen
Ctrl-p/n # Command history
PgUp/PgDn # Scroll source window</code></pre>
<hr>
<h2>Advanced Features</h2>
<h3>.gdbinit Customization</h3>
<p><strong>~/.gdbinit</strong> (global) or <strong>./.gdbinit</strong> (project):</p>
<pre><code class="lang-gdb"># Pretty printing
set print pretty on
set print array on
set print array-indexes on
# History
set history save on
set history size 10000
set history filename ~/.gdb_history
# Disable pagination
set pagination off
# Auto-load local .gdbinit
set auto-load safe-path /
# Custom commands
define hook-stop
info registers
x/24wx $sp
end
# Aliases
alias -a bp = break
alias -a c = continue
alias -a s = step
alias -a n = next</code></pre>
<h3>Python Scripting</h3>
<p><strong>Load Python scripts</strong>:</p>
<pre><code class="lang-gdb">(gdb) source script.py</code></pre>
<p><strong>script.py</strong>:</p>
<pre><code class="lang-python">import gdb
class HelloCommand(gdb.Command):
&quot;&quot;&quot;Print hello message.&quot;&quot;&quot;
def __init__(self):
super(HelloCommand, self).__init__(&quot;hello&quot;, gdb.COMMAND_USER)
def invoke(self, arg, from_tty):
print(f&quot;Hello, {arg}!&quot;)
HelloCommand()
# Custom breakpoint
class CountBreakpoint(gdb.Breakpoint):
def __init__(self, spec):
super(CountBreakpoint, self).__init__(spec)
self.count = 0
def stop(self):
self.count += 1
print(f&quot;Hit count: {self.count}&quot;)
return True # Stop execution
CountBreakpoint(&quot;main&quot;)</code></pre>
<p><strong>Pretty printers</strong>:</p>
<pre><code class="lang-python">import gdb
class MyStructPrinter:
def __init__(self, val):
self.val = val
def to_string(self):
return f&quot;MyStruct(x={self.val[&#x27;x&#x27;]}, y={self.val[&#x27;y&#x27;]})&quot;
def my_struct_printer(val):
if str(val.type) == &#x27;struct MyStruct&#x27;:
return MyStructPrinter(val)
return None
gdb.pretty_printers.append(my_struct_printer)</code></pre>
<h3>Remote Debugging</h3>
<p><strong>Start gdbserver on target</strong>:</p>
<pre><code class="lang-bash"># Remote machine
gdbserver :2345 ./program
gdbserver :2345 --attach &lt;pid&gt;</code></pre>
<p><strong>Connect from GDB</strong>:</p>
<pre><code class="lang-gdb"># Local machine
(gdb) target remote 192.168.1.100:2345
(gdb) continue</code></pre>
<p><strong>SSH tunnel</strong>:</p>
<pre><code class="lang-bash"># Local machine
ssh -L 2345:localhost:2345 user@remote
gdb ./program
(gdb) target remote localhost:2345</code></pre>
<h3>Core Dump Analysis</h3>
<p><strong>Enable core dumps</strong>:</p>
<pre><code class="lang-bash"># Check current limit
ulimit -c
# Enable unlimited core dumps
ulimit -c unlimited
# Set core pattern (Linux)
sudo sysctl -w kernel.core_pattern=/tmp/core.%e.%p</code></pre>
<p><strong>Load core dump</strong>:</p>
<pre><code class="lang-gdb">gdb ./program core.12345
# Or within GDB:
(gdb) core-file core.12345
# Analyze crash
(gdb) bt full
(gdb) info registers
(gdb) x/10i $pc</code></pre>
<hr>
<h2>Multi-threaded Debugging</h2>
<h3>Thread Commands</h3>
<pre><code class="lang-gdb"># List threads
(gdb) info threads
# Switch to thread
(gdb) thread 2
# Apply command to all threads
(gdb) thread apply all bt
# Thread-specific breakpoint
(gdb) break main thread 2
# Lock scheduler (single-step one thread)
(gdb) set scheduler-locking on
(gdb) set scheduler-locking off</code></pre>
<hr>
<h2>Debugging Optimized Code</h2>
<h3>Challenges</h3>
<p>Optimized code problems:</p>
<ul><li>Variables optimized out</li><li>Inlined functions</li><li>Reordered instructions</li><li>Registers used instead of stack</li></ul>
<h3>Strategies</h3>
<pre><code class="lang-gdb"># Compile with minimal optimization
gcc -g -O1 program.c -o program # -O1 safer than -O2/-O3
# Use -Og (optimize for debugging)
gcc -g -Og program.c -o program
# Disable specific optimizations
gcc -g -O2 -fno-inline program.c -o program</code></pre>
<p><strong>Handling optimized variables</strong>:</p>
<pre><code class="lang-gdb"># Variable optimized out
(gdb) p my_var
$1 = &lt;optimized out&gt;
# Try different frame
(gdb) up
(gdb) p my_var
# Use disassembly to find value in register
(gdb) disassemble
(gdb) info registers</code></pre>
<hr>
<h2>Common Workflows</h2>
<h3>Debugging Segfaults</h3>
<pre><code class="lang-gdb"># Run until crash
gdb ./program
(gdb) run
# Examine crash
(gdb) bt full
(gdb) info registers
(gdb) x/10i $pc
(gdb) frame 0
(gdb) list
(gdb) info locals</code></pre>
<h3>Debugging Memory Leaks</h3>
<p>Use Valgrind instead of GDB:</p>
<pre><code class="lang-bash">valgrind --leak-check=full --show-leak-kinds=all ./program</code></pre>
<h3>Debugging Race Conditions</h3>
<pre><code class="lang-gdb"># Break on thread creation
(gdb) catch syscall clone
# Enable scheduler debugging
(gdb) set scheduler-locking step
# Record execution for reverse debugging
(gdb) record
(gdb) reverse-continue
(gdb) reverse-step</code></pre>
<hr>
<h2>GDB with Rust</h2>
<h3>Rust-specific Commands</h3>
<pre><code class="lang-gdb"># Break at Rust function
(gdb) break my_crate::my_module::my_function
# Pretty-print Rust types
(gdb) set language rust
(gdb) p my_vec
# Load Rust pretty printers
(gdb) source /path/to/rust-gdb</code></pre>
<p><strong>Use rust-gdb wrapper</strong>:</p>
<pre><code class="lang-bash">rust-gdb ./target/debug/my_program</code></pre>
<hr>
<h2>GDB with C++</h2>
<h3>C++-specific Features</h3>
<pre><code class="lang-gdb"># Break at method
(gdb) break MyClass::myMethod
# Print STL containers
(gdb) p my_vector
(gdb) p my_map
# Catch exceptions
(gdb) catch throw
(gdb) catch catch
# Demangle symbols
(gdb) set print asm-demangle on</code></pre>
<hr>
<h2>Performance Tips</h2>
<h3>Faster Debugging</h3>
<pre><code class="lang-gdb"># Disable pagination for scripts
set pagination off
# Disable confirmation prompts
set confirm off
# Reduce output
set print elements 10 # Limit array elements
# Use hardware breakpoints (limited, but faster)
(gdb) hbreak main</code></pre>
<h3>Logging</h3>
<pre><code class="lang-gdb"># Enable logging
(gdb) set logging on
(gdb) set logging file gdb.log
# Log overwrite vs append
(gdb) set logging overwrite on</code></pre>
<hr>
<h2>Anti-Patterns</h2>
<h3>Common Mistakes</h3>
<pre><code>❌ NEVER: Debug optimized code without trying -Og first
→ Variables optimized out, inaccurate stepping
❌ NEVER: Forget to compile with -g
→ No source mapping, only assembly
❌ NEVER: Set too many breakpoints in hot loops
→ Massive slowdown, unusable debugging
❌ NEVER: Use GDB for memory leak detection
→ Use Valgrind, AddressSanitizer instead
❌ NEVER: Attach to production process without understanding impact
→ Process paused = downtime
❌ NEVER: Modify variables in production debugging
→ Undefined behavior, data corruption</code></pre>
<h3>Best Practices</h3>
<pre><code>✅ ALWAYS: Compile with -g -O0 for debug builds
✅ ALWAYS: Use conditional breakpoints in hot paths
✅ ALWAYS: Save .gdbinit for project-specific commands
✅ ALWAYS: Use TUI mode for visual debugging
✅ ALWAYS: Test core dump analysis before production issues
✅ ALWAYS: Use gdbserver for remote/embedded debugging</code></pre>
<hr>
<h2>Related Skills</h2>
<ul><li><strong>lldb-macos-debugging.md</strong>: LLDB debugger for macOS/iOS</li><li><strong>python-debugging.md</strong>: Python-specific debugging tools</li><li><strong>browser-devtools.md</strong>: Browser debugging for web applications</li><li><strong>remote-debugging.md</strong>: Remote debugging techniques</li><li><strong>test-debugging-strategies.md</strong>: Debugging test failures</li></ul>
<hr>
<h2>Summary</h2>
<p>GDB is the standard debugger for compiled languages. Key capabilities:</p>
<ol><li><strong>Breakpoints</strong>: Function, line, conditional, watchpoints, catchpoints</li><li><strong>Stack inspection</strong>: Backtraces, frame navigation, variable inspection</li><li><strong>TUI mode</strong>: Visual interface for source/assembly viewing</li><li><strong>Python scripting</strong>: Custom commands, pretty printers, automation</li><li><strong>Remote debugging</strong>: gdbserver for remote/embedded targets</li><li><strong>Core dumps</strong>: Post-mortem analysis of crashes</li><li><strong>Multi-threading</strong>: Thread-aware debugging, scheduler control</li></ol>
<p><strong>Quick start</strong>:</p>
<pre><code class="lang-bash">gcc -g -O0 program.c -o program
gdb -tui ./program
(gdb) break main
(gdb) run
(gdb) step
(gdb) print my_variable
(gdb) backtrace</code></pre>
<p>Master GDB for efficient low-level debugging across C, C++, Rust, and Go.</p>
<footer>
<div class="fmap">
<div><b>Build</b>
<a href="https://hanzo.app">hanzo.app</a> app builder
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
<div><b>Run</b>
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
<div><b>Account</b>
<a href="https://hanzo.id">hanzo.id</a> sign in
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
<div><b>Company</b>
<a href="https://hanzo.ai">hanzo.ai</a> canonical
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
</div>
<div class="fend"><a href="/debugging-gdb-fundamentals.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
</footer>
</div></body></html>