Hardware Podcasts

209: Debuggerception

Embedded.fm · 3 Aug 2017 · 53m · Episode 209

What this episode covers

Pierre-Marie de Rodat, a software engineer at AdaCore, explains the inner workings of debuggers, focusing on how GDB uses DWARF debug information to interpret program state. He details how compilers generate this metadata to allow debuggers to handle optimizations and complex types, and discusses the use of Python scripting in GDB for custom pretty printers. The conversation also covers code coverage tools like GNATcoverage and the AdaCore-sponsored Make with Ada competition.

Most relevant to

early-stage companies

Topics

Mentioned

Companies
AdaCore
Chips
STM32
Tools
GDB, GNATcoverage
Also
DWARF

Related episodes from other shows

Other shows on the same ground, closest first.

  • Oxide and Friends · 1h 34m

    Debugger-Driven Development

    Bryan Cantrill and Adam Leventhal host Oxide colleagues Dave Pacheco, John Gallagher, Alan Hanson, and Eliza Weisman to discuss debugger-driven development at Oxide Computer Company. They detail the creation of omdb, a domain-specific debugging tool that allows developers to inspect and modify internal state across components like Nexus, CockroachDB, and Crucible. The team explains how omdb accelerated the development of complex systems like Reconfigurator and Fault Management by providing immediate, visual feedback and enabling incremental deployment of incomplete features. The episode highlights how this approach reduced risk, improved demo quality, and allowed the team to ship robust, rack-scale hardware and software faster.

    Embedded firmwareDebugging & failure analysis
    8 chapters

  • Oxide and Friends · 1h 06m

    What's a bug? What's a debugger?

    Bryan Cantrill and Adam Leventhal of Oxide Computer Company discuss the philosophy and mechanics of debugging, arguing that the term 'debugger' is regrettable and that tools should focus on observability and understanding system behavior rather than just fixing reproducible errors. They critique traditional in-situ breakpoint debugging for its fragility ('killing the patient') and advocate for post-mortem analysis, memory forensics, and tools like DTrace and Hubris. The conversation highlights how modern practices like CI/CD and languages like Rust have shifted the debugging landscape, making traditional debuggers less relevant for simple errors but more critical for complex, distributed system pathologies.

    Debugging & failure analysisEmbedded firmware
    10 chapters

  • Oxide and Friends · 1h 30m

    Debugging Methodologies

    Jordan Hendricks and Luqman Aden of Oxide Computer Company detail their methodologies for debugging complex hardware and compiler issues. Hendricks explains how he used the KMDB in-situ debugger to diagnose an NVMe reset hang, discovering that switching from abrupt to normal shutdown notifications resolved the issue. Aden describes his process for debugging a rustc segfault involving inline assembly in async blocks, using LLVM IR analysis and Rust Analyzer to isolate a bug in the compiler's code generation. The episode also covers a third case involving a triple fault caused by undefined behavior in a bare-metal bootloader, highlighting the importance of tooling and collaborative debugging culture at Oxide.

    Debugging & failure analysisEmbedded firmware
    5 chapters

  • The Amp Hour · 1h 45m

    An Interview with Scott Shawcroft

    Chris Gammell, a software engineer at Adafruit, explains the architecture and philosophy behind CircuitPython, the fork of MicroPython designed for beginners. He details the technical differences between interpreted and compiled languages, the use of a virtual machine to execute byte code, and the uniform API that allows drivers to work across different microcontroller families like the SAMD21 and SAMD51. Gammell also walks through the low-level debugging process using J-Link and GDB, explaining how hardware breakpoints and the Micro Trace Buffer help troubleshoot firmware issues.

    Embedded firmwareMicrocontrollers & dev platforms
    5 chapters

  • Oxide and Friends · 1h 35m

    A Debugging Odyssey

    Dave Pacheco of Oxide Computer Company details his months-long debugging odyssey to resolve a critical memory corruption bug in the Go runtime on Illumos. He explains how he used DTrace, MDB, and binary patching to identify that the OS failed to preserve YMM registers during signal handling, a flaw that could have caused catastrophic data corruption in their CockroachDB control plane. The episode highlights the importance of rigorous documentation, deep tooling mastery, and the cultural value of tackling seemingly unreproducible low-level failures.

    Debugging & failure analysisEmbedded firmware
    9 chapters

The summary, chapters and topics are generated from the episode’s audio by this directory, not written by Embedded.fm. The episode itself belongs to its publisher.