Building a Debugger (Sy Brand)（Z-Library）

【One-Line Pitch】 A hands-on guide to demystifying debuggers by building one from scratch for x64 Linux in C++, taking you from an empty folder to a tool that sets breakpoints, steps through code, and inspects variables. Best for C++ programmers curious about operating systems, compilers, and low-level tooling. 【Book Arc】 - **Opening (~0%–8%)**: Sets up the project skeleton (CMake, vcpkg, directory layout) and lays the theoretical groundwork on compilation, computer architecture, user/kernel space, and how Linux loads programs. - **Early (~8%–27%)**: Implements the debugger's core mechanics—attaching to processes, inter-process communication via pipes and procfs, automated testing, register access, and both software and hardware breakpoints/watchpoints. - **Middle (~27%–57%)**: Dives into binary and debug-info formats: parsing ELF object files, DWARF debug information, line tables, and call frame information to enable source-level breakpoints, stepping, and stack unwinding. - **Late (~57%–76%)**: Extends the debugger to real-world complexity—shared libraries, multithreading, DWARF expressions, variable/type visualization, and expression evaluation with inferior function calls. - **Ending (~76%–100%)**: Surveys advanced topics (remote debugging, GDB/MI, DAP, time-travel debugging, non-stop mode) and closes with knowledge-check answers and a glossary. 【Key Takeaways】 - **Debuggers are built on OS primitives, not magic** (Early): attaching to processes, reading registers, and setting breakpoints all rely on Linux facilities like ptrace, procfs, and pipes—understanding these is the real payoff. - **Breakpoints come in two flavors with distinct trade-offs** (Early): software breakpoints patch instructions while hardware breakpoints use debug registers; the book implements both plus watchpoints. - **Binary formats are the bridge to source-level debugging** (Middle): parsing ELF and DWARF is what lets a debugger map machine addresses back to source lines, variables, and types. - **Stack unwinding depends on call frame information** (Middle): DWARF CFI lets you generate backtraces and restore registers to pre-call state, a prerequisite for meaningful stepping. - **Real programs are messy** (Late): shared libraries, multithreading, and inlined functions each require dedicated support beyond a single-threaded, statically-linked toy. - **Expression evaluation is the hardest feature** (Late): calling functions inside the inferior process requires ABI knowledge, argument classification, calling conventions, and memory allocation in the target. - **Testing is woven throughout** (Early–Late): each feature is paired with automated tests, reinforcing that debugger development demands rigorous verification. - **The book is deliberately scoped** (Middle): the debugger is not thread-safe by design, trading robustness for focus on core concepts. 【Reading Tips】 - Deep-read Chapters 1–4 even if you know C++; the build setup and testing harness pay off across the whole book. - Skim the DWARF/ELF parsing chapters (11–15) on first pass if binary formats are new—return to them when implementing source-level features. - Treat the "Check Your Knowledge" questions as genuine checkpoints; the appendix answers are useful for self-assessment. - Keep the companion GitHub repository (chapter-by-chapter branches) open alongside the text to compare your implementation. - Don't skip Chapter 2's architecture background—it's the conceptual foundation for everything that follows. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering the table of contents, introduction, and early chapters; specific code details, later-chapter depth, and the advanced topics chapter are only partially represented.