Debug Optimized Builds

mohitmishra786/low-level-dev-skills/skills/debuggers/debug-optimized-builds

by mohitmishra786bdc58472fa9fNo license253 starsListed Oct 9, 2026Updated Oct 9, 2026Repository updated 3 months ago

Debugging optimized builds skill for diagnosing issues in release code. Use when debugging RelWithDebInfo builds, using -Og for debuggable optimization, working with split-DWARF, applying GDB scheduler-locking, reading inlined frames, or understanding "value optimized out" messages. Activates on queries about debugging optimized code, RelWithDebInfo, -Og, inlined functions in GDB, value optimized out, GDB with -O2, or debugging release builds.

Instructions onlySoftware Development

AI-generated overview

Guides debugging of optimized C/C++ builds: choosing debug-friendly optimization levels, reading inlined frames, and using GDB.

What it does: This skill provides instructions for diagnosing problems in optimized (release) builds, covering build configuration choices such as -O0, -Og, RelWithDebInfo and split-DWARF. It explains causes and workarounds for "value optimized out" messages, how to read inlined frames and line-number discrepancies in GDB, and GDB techniques like scheduler-locking and disassembly views. It produces guidance and command examples rather than files or code.
When to use it: Use it when debugging code compiled with optimization, such as RelWithDebInfo or -O2 builds, or when GDB reports "value optimized out" or breakpoints land on unexpected lines. It also fits questions about -Og versus -O0, inlined function frames, split-DWARF, or scheduler-locking in multithreaded debugging.
Requirements: No scripts are shipped; it is instructions only. Following it assumes a C/C++ toolchain (GCC or Clang), CMake optionally, and GDB, plus the dwp tool for packaging split-DWARF files.

Debugging Optimized Builds

Purpose

Guide agents through debugging code compiled with optimization: choosing the right debug-friendly optimization level, reading inlined frames, diagnosing "value optimized out", using split-DWARF for faster debug builds, and applying GDB techniques specific to optimized code.

Triggers

"GDB says 'value optimized out' — what does that mean?"
"How do I debug a release build?"
"How do I see inlined function frames in GDB?"
"What's the difference between -O0 and -Og for debugging?"
"How do I use RelWithDebInfo with CMake?"
"Breakpoints in optimized code land on wrong lines"

Workflow

1. Choose the right build configuration

Goal?├── Full debuggability, no optimization│   → -O0 -g                        (slowest, all vars visible)├── Debuggable, some optimization (recommended for most dev work)│   → -Og -g                        (-Og keeps debug experience good)├── Release build with debug info (shipped, debuggable crashes)│   → -O2 -g -gsplit-dwarf          (or -O2 -g1 for lighter info)└── Full release (no debug symbols)    → -O2 -DNDEBUG

Goal?├── Full debuggability, no optimization│   → -O0 -g                        (slowest, all vars visible)├── Debuggable, some optimization (recommended for most dev work)│   → -Og -g                        (-Og keeps debug experience good)├── Release build with debug info (shipped, debuggable crashes)│   → -O2 -g -gsplit-dwarf          (or -O2 -g1 for lighter info)└── Full release (no debug symbols)    → -O2 -DNDEBUG

-Og: GCC's "debug-friendly optimization" — enables optimizations that don't interfere with debugging. Variables stay in registers where GDB can see them. Line numbers stay accurate. Best balance for development.

bash

# GCC / Clanggcc -Og -g -Wall main.c -o prog
# CMake build typescmake -S . -B build -DCMAKE_BUILD_TYPE=Debug          # -O0 -gcmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo # -O2 -g -DNDEBUGcmake -S . -B build -DCMAKE_BUILD_TYPE=Release        # -O2 -DNDEBUG

# GCC / Clanggcc -Og -g -Wall main.c -o prog
# CMake build typescmake -S . -B build -DCMAKE_BUILD_TYPE=Debug          # -O0 -gcmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo # -O2 -g -DNDEBUGcmake -S . -B build -DCMAKE_BUILD_TYPE=Release        # -O2 -DNDEBUG

2. "Value optimized out" — causes and workarounds

This means the compiler decided the variable's value doesn't need to be stored at this point — it might be:

Kept only in a register (not the one GDB is looking at)
Folded into a constant by constant propagation
Eliminated because it's not used after this point
Replaced by a later optimized value

Workarounds:

// 1. Mark variable volatile (prevents optimization away)volatile int counter = 0;// Use sparingly — changes semantics
// 2. Use GCC attributeint counter __attribute__((used)) = 0;
// 3. Compile problematic TU at lower optimization// In CMake:set_source_files_properties(tricky.c PROPERTIES COMPILE_FLAGS "-O0")
// 4. Use -Og instead of -O2 for the whole build
// 5. Look at register values directly// (gdb) info registers// (gdb) p/x $rax       # value may be in a register

// 1. Mark variable volatile (prevents optimization away)volatile int counter = 0;// Use sparingly — changes semantics
// 2. Use GCC attributeint counter __attribute__((used)) = 0;
// 3. Compile problematic TU at lower optimization// In CMake:set_source_files_properties(tricky.c PROPERTIES COMPILE_FLAGS "-O0")
// 4. Use -Og instead of -O2 for the whole build
// 5. Look at register values directly// (gdb) info registers// (gdb) p/x $rax       # value may be in a register

3. Reading inlined frames in GDB

With optimization, frequently-called small functions get inlined. GDB shows these as extra frames:

text

(gdb) bt#0  process_packet (data=0x7ff..., len=<optimized out>)    at network.c:45#1  0x0000... in dispatch_handler (pkt=0x7ff...)    at handler.c:102#2  (inlined by) event_loop () at main.c:78#3  0x0000... in main () at main.c:200
# (inlined by) frames are virtual — they show the call chain# that was inlined into the actual frame above

(gdb) bt#0  process_packet (data=0x7ff..., len=<optimized out>)    at network.c:45#1  0x0000... in dispatch_handler (pkt=0x7ff...)    at handler.c:102#2  (inlined by) event_loop () at main.c:78#3  0x0000... in main () at main.c:200
# (inlined by) frames are virtual — they show the call chain# that was inlined into the actual frame above

bash

# Navigate inlined frames(gdb) frame 2          # jump to the inlined frame(gdb) up               # move up through frames (including inlined)(gdb) down             # move down
# Show all frames including inlined(gdb) backtrace full
# Set breakpoint inside inlined function(gdb) break network.c:45      # may hit multiple inlined call sites(gdb) break process_packet    # hits all inline expansions

# Navigate inlined frames(gdb) frame 2          # jump to the inlined frame(gdb) up               # move up through frames (including inlined)(gdb) down             # move down
# Show all frames including inlined(gdb) backtrace full
# Set breakpoint inside inlined function(gdb) break network.c:45      # may hit multiple inlined call sites(gdb) break process_packet    # hits all inline expansions

4. Line number discrepancies

Optimizers reorder instructions, so the "current line" in GDB may jump around:

bash

# See which instructions map to which source lines(gdb) disassemble /s function_name    # interleaved source and asm
# Step by machine instruction (more accurate in optimized code)(gdb) si        # stepi — one machine instruction(gdb) ni        # nexti — one machine instruction (no step into)
# Show mixed source/asm at current point(gdb) layout split   # TUI mode: source + asm side by side(gdb) set disassemble-next-line on
# Jump to specific address (when line stepping is unreliable)(gdb) jump *0x400a2c

# See which instructions map to which source lines(gdb) disassemble /s function_name    # interleaved source and asm
# Step by machine instruction (more accurate in optimized code)(gdb) si        # stepi — one machine instruction(gdb) ni        # nexti — one machine instruction (no step into)
# Show mixed source/asm at current point(gdb) layout split   # TUI mode: source + asm side by side(gdb) set disassemble-next-line on
# Jump to specific address (when line stepping is unreliable)(gdb) jump *0x400a2c

5. GDB scheduler-locking for optimized multithreaded code

With optimization, threads may race in unexpected ways when stepping:

bash

# Lock the scheduler — only the current thread runs while stepping(gdb) set scheduler-locking on
# Modes:# off      — all threads run freely (default)# on       — only current thread runs while stepping# step     — only current thread runs while single-stepping#            (all run on continue)# replay   — for reverse debugging
# Common debugging session(gdb) set scheduler-locking step    # prevent other threads interfering with step(gdb) break my_function(gdb) continue(gdb) set scheduler-locking on     # lock while examining(gdb) next(gdb) set scheduler-locking off    # unlock to continue normally

# Lock the scheduler — only the current thread runs while stepping(gdb) set scheduler-locking on
# Modes:# off      — all threads run freely (default)# on       — only current thread runs while stepping# step     — only current thread runs while single-stepping#            (all run on continue)# replay   — for reverse debugging
# Common debugging session(gdb) set scheduler-locking step    # prevent other threads interfering with step(gdb) break my_function(gdb) continue(gdb) set scheduler-locking on     # lock while examining(gdb) next(gdb) set scheduler-locking off    # unlock to continue normally

6. split-DWARF — faster debug builds

Split DWARF offloads debug info to .dwo files, reducing linker input:

bash

# Compile with split DWARFgcc -g -gsplit-dwarf -O2 -c file.c -o file.o# Creates: file.o (object) + file.dwo (DWARF sidecar)
# Link — no debug info in final binary, just referencesgcc -g -gsplit-dwarf file.o -o prog
# GDB finds .dwo files via the path embedded in the binarygdb prog    # works automatically if .dwo files are next to the binary
# Package all .dwo into a single .dwp for distributiondwp -o prog.dwp prog    # GNU dwp toolgdb prog    # with .dwp in same directory
# CMakeadd_compile_options(-gsplit-dwarf)

# Compile with split DWARFgcc -g -gsplit-dwarf -O2 -c file.c -o file.o# Creates: file.o (object) + file.dwo (DWARF sidecar)
# Link — no debug info in final binary, just referencesgcc -g -gsplit-dwarf file.o -o prog
# GDB finds .dwo files via the path embedded in the binarygdb prog    # works automatically if .dwo files are next to the binary
# Package all .dwo into a single .dwp for distributiondwp -o prog.dwp prog    # GNU dwp toolgdb prog    # with .dwp in same directory
# CMakeadd_compile_options(-gsplit-dwarf)

7. Useful GDB commands for optimized builds

bash

# Show where variables actually live (register vs stack)(gdb) info locals           # all locals (may show <optimized out>)(gdb) info args             # function arguments
# Force evaluation of an expression(gdb) call (int)my_func(42)  # call actual function to get value
# Watch a memory address directly (not a variable name)(gdb) watch *0x7fffffffe430
# Print memory contents(gdb) x/10xw $rsp           # 10 words at stack pointer (hex)(gdb) x/s 0x4008a0          # string at address
# Catch crashes without debug symbols(gdb) bt             # backtrace — shows addresses even without symbols(gdb) info sharedlibrary    # shows loaded libs for symbol resolution
# .gdbinit helpers for optimized debugging# set print pretty on# set print array on# set disassembly-flavor intel

# Show where variables actually live (register vs stack)(gdb) info locals           # all locals (may show <optimized out>)(gdb) info args             # function arguments
# Force evaluation of an expression(gdb) call (int)my_func(42)  # call actual function to get value
# Watch a memory address directly (not a variable name)(gdb) watch *0x7fffffffe430
# Print memory contents(gdb) x/10xw $rsp           # 10 words at stack pointer (hex)(gdb) x/s 0x4008a0          # string at address
# Catch crashes without debug symbols(gdb) bt             # backtrace — shows addresses even without symbols(gdb) info sharedlibrary    # shows loaded libs for symbol resolution
# .gdbinit helpers for optimized debugging# set print pretty on# set print array on# set disassembly-flavor intel

Related skills

Use skills/debuggers/gdb for full GDB session management
Use skills/debuggers/dwarf-debug-format for DWARF debug info details
Use skills/debuggers/core-dumps for post-mortem debugging of optimized crashes
Use skills/compilers/gcc for -Og, -g, and debug flag selection

Source and attribution

Source:mohitmishra786/low-level-dev-skillsinskills/debuggers/debug-optimized-buildsat commitbdc5847

License: No license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Debug Optimized Builds

Debugging Optimized Builds

Purpose

Triggers

Workflow

1. Choose the right build configuration

2. "Value optimized out" — causes and workarounds

3. Reading inlined frames in GDB

4. Line number discrepancies

5. GDB scheduler-locking for optimized multithreaded code

6. split-DWARF — faster debug builds

7. Useful GDB commands for optimized builds

Related skills

Source and attribution

More from mohitmishra786/low-level-dev-skills

Zig Debugging

Simd Intrinsics

Zig Cross

Rustc Basics

Zig Cinterop

Zig Build System

More in Software Development

Playground

M5 Onboard

Cardputer Buddy

Web Design Guidelines

Vercel React Native Skills

Vercel React Best Practices