go-delve/delve

This system is a low-level debugger for the Go programming language, providing capabilities to inspect, control, and analyze running processes and crash dumps. It supports a wide range of architectures and operating systems, offering features such as breakpoint management, variable inspection, and eBPF-based tracing. The system exposes its functionality through a terminal interface, a JSON-RPC API, and the Debug Adapter Protocol for integration with IDEs.

37 changes.

This period focused on restructuring the debugger into a modular service with a new RPC2 API and client/server separation, enabling remote debugging and protocol unification. Significant architectural improvements included refactoring the DWARF parsing logic to support DWARFv5, introducing a unified process backend, and adding core file and GDB serial protocol support.

23 changes.

This period focused on integrating the Debug Adapter Protocol (DAP) to enable native support for IDE frontends like VS Code, while significantly expanding platform coverage through new Linux, FreeBSD, and Windows minidump capabilities. The work also introduced Starlark scripting for the terminal, modernized the logging subsystem, and enhanced low-level debugging features such as DWARF v5 support and hardware register management.

26 changes.

The project significantly expanded its platform support by adding native debugging capabilities for ARM64 on Windows, LoongArch64, and RISC-V, alongside standardized DWARF register mappings. Concurrently, it introduced advanced tracing features via an eBPF backend for parameter capture and implemented a new stack-machine expression evaluation engine to improve debugger performance and accuracy.

6 changes.

This period focused on enhancing runtime debugger detection capabilities through the new debugdetect package and expanding test coverage with various fixtures for process spawning, dynamic loading, and ARM64 trampolines. Additionally, the project migrated its vendored YAML library to the official go.yaml.in repository to ensure long-term maintenance and compatibility.

The Windows process debugger now supports ARM64 architectures in addition to the existing AMD64 support. This change introduces new register handling implementations for ARM64 (regs\_arm64\_arch.go) alongside the existing AMD64 implementation (regs\_amd64\_arch.go), enabling users to debug Go applications running on Windows ARM64 hardware.

pkg/proc/winutil · high confidence

A new \pkg/astutil\ package has been introduced to provide helper functions for constructing Go AST expressions. This includes utilities for creating equality checks (\Eql\), selector expressions (\Sel\, \PkgVar\), integer literals (\Int\), and logical operators (\And\, \Or\), as well as a function to convert AST expressions back to strings (\ExprToString\). These tools are intended to simplify the generation of \ast.Expr\ nodes within the \pkg/proc\ package.

pkg/astutil · high confidence

The pkg/elfwriter package now provides functionality to write ELF files, specifically targeting core dumps. This includes a new Writer struct that handles ELF headers, program headers, and section headers, along with support for writing notes (including Delve-specific notes) and section headers with string tables. This enables the creation of core files without loading the entire file into memory at once.

pkg/elfwriter · high confidence

The \_scripts directory now includes automation for running Google's capslock static analysis tool across all supported platforms (darwin, linux, windows on amd64, arm64, 386, ppc64le, riscv64) and generating the corresponding output files. Additionally, new Go scripts are introduced to generate CLI documentation, FAQ table of contents, opcode definitions, and backend test health reports, replacing manual or external generation processes.

_\scripts · high confidence

The debugger can now analyze crash dumps. This change introduces a new \pkg/proc/core\ backend that reads Linux ELF core files (supporting amd64, arm64, riscv64, and loong64 architectures) and Windows minidumps, allowing users to inspect the state of a process at the moment of a crash.

pkg/proc/core · high confidence

The vendor directory now includes the errgroup package, which provides synchronization, error propagation, and context cancellation for groups of goroutines. This addition introduces the Group type, allowing users to manage concurrent subtasks where the first error cancels the associated context and is returned by Wait. It also supports limiting the number of active goroutines via SetLimit and offers a TryGo method for non-blocking submission.

vendor/golang.org/x/sync · high confidence

The debugger can now load and analyze Windows minidump files, which serve as the Windows equivalent of Unix core dumps. This new capability allows users to debug crashed Windows applications by parsing minidump structures such as thread lists, module information, and memory ranges directly from the dump file.

pkg/proc/core/minidump · high confidence

The vendor directory now includes the golang.org/x/telemetry package, enabling opt-in telemetry collection and crash reporting for Go toolchain programs. This adds a counter system for recording public metrics (such as flag usage and completion errors) and a crash monitor that captures runtime crashes and reports them as telemetry data. The implementation includes configuration management for uploading data, platform-specific memory mapping for counter files, and Windows-specific process handling to ensure reliable crash reporting.

vendor/golang.org/x/telemetry · high confidence

The vendor directory now includes the \golang.org/x/arch/loong64\ package, providing the ability to decode, encode, and disassemble LoongArch64 (loong64) instructions. This adds support for the LoongArch architecture to the native backend, enabling assembly analysis for this new platform.

vendor/golang.org/x/arch/loong64 · high confidence

The \pkg/proc/amd64util\ package now includes \debugregs.go\ and \xsave.go\, providing utilities to manage x86 debug registers (enabling, clearing, and retrieving hardware breakpoints) and to decode AMD64 XSAVE areas (parsing legacy, AVX, and AVX-512 register states). This adds low-level support for inspecting and manipulating CPU debug and extended state registers, which is essential for accurate watchpoint handling and register state recovery during debugging.

pkg/proc/amd64util · high confidence

The vendor directory now includes the \golang.org/x/arch/ppc64/ppc64asm\ package, providing the ability to decode and disassemble 64-bit PowerPC (ppc64le) machine code. This addition introduces core decoding logic, instruction tables, and syntax formatters for both GNU and Plan 9 assemblers, enabling tools that rely on this location to analyze or display ppc64le binaries.

vendor/golang.org/x/arch/ppc64 · high confidence

The application now includes the vendored github.com/mattn/go-colorable library, enabling ANSI color escape sequences to be rendered correctly in Windows console applications. This change allows colored output (e.g., from loggers) to function on Windows without requiring external tools like ansicon, by providing platform-specific writers that handle terminal capabilities.

vendor/github.com/mattn/go-colorable · high confidence

The debuginfod client now supports downloading debug information with real-time progress notifications via a verbose mode that parses stderr output, and adds the capability to retrieve source code listings directly using the debuginfod-find tool.

pkg/proc/debuginfod · high confidence

The interactive debugger interface has been consolidated into the \pkg/terminal\ package, introducing a comprehensive command system with categorized groups (running, breakpoints, data, goroutines, stack) and a new \config\ command for managing aliases, substitute paths, and debug info directories. The terminal now features syntax highlighting for source listings, automatic paging for large outputs, and a transcript writer for session logging. Additionally, an embedded Starlark scripting environment is available for custom automation, and the \exit\ command now supports a \-d\ flag to detach from the target process without killing it.

pkg/terminal · high confidence

The terminal now provides syntax-highlighted output when printing Go source code listings. This new \pkg/terminal/colorize\ module parses Go files using the standard library AST and applies distinct color styles to keywords, strings, numbers, and comments, improving readability in the debugger interface.

pkg/terminal/colorize · high confidence

The \pkg/proc/gdbserial\ package is introduced to provide a debugger backend using the Gdb Remote Serial Protocol. This enables Delve to connect to and debug targets via \gdbserver\, \lldb-server\, macOS \debugserver\, and Mozilla \rr\. The implementation includes platform-specific handling for Unix and Windows, support for recording and replaying execution with \rr\, and a check to detect and prevent execution under Apple Rosetta translation on macOS.

pkg/proc/gdbserial · high confidence

The project now defines its continuous integration pipeline using a new \.teamcity/settings.kts\ script. This configuration establishes a structured hierarchy of projects and build types for testing across multiple operating systems (Linux, Windows, macOS) and architectures (amd64, 386, arm64, ppc64le, riscv64). It explicitly includes a test matrix for Go versions 1.25, 1.26, 1.27, and tip, while excluding Windows ARM64 and Loong64 from the current scope. The setup integrates with GitHub for pull request handling and commit status publishing, sets the TeamCity UI to read-only, and configures specific triggers, such as daily scheduled runs for tip builds.

.teamcity · high confidence

Added two new Go source files, plugin1.go and plugin2.go, to the \_fixtures directory. These files define simple exported functions and types (such as Fn1, HelloFn, Fn2, and the asomethingelse struct with its Callback2 method) intended to serve as test fixtures for the newly introduced plugin support feature in the debugger.

_\_fixtures/plugin1, \fixtures/plugin2 · high confidence

The service/debugger package is introduced as a new component, providing a higher-level abstraction over the internal process backend. It handles the conversion of internal types to client-facing types and manages core debugging functionalities such as launching new processes, attaching to existing ones, and managing breakpoints. The package includes platform-specific implementations for error reporting (e.g., detailed Yama ptrace scope checks on Linux) and comprehensive test coverage for launch scenarios, executable validation, and TTY support.

service/debugger · high confidence

The service layer now exposes a remote debugger API via a new client/server architecture, allowing external tools to connect to a headless debugging instance. This change introduces a \Client\ interface for synchronous debugger operations (such as continuing, stepping, setting breakpoints, and inspecting variables) and a \Server\ interface for managing the remote connection lifecycle. It also adds configuration options for listener setup, multi-client support, and API versioning, along with an in-memory listener pipe for local non-headless connections.

service · high confidence

Users can now write and execute scripts in the Delve terminal using the Starlark language. This change adds a new \pkg/terminal/starbind\ package that provides a REPL, converts debugger API values (such as variables, structs, and slices) into Starlark types, and exposes built-in functions like \dlv\_command\, \read\_file\, \write\_file\, and \append\_file\ to interact with the debugging session and the host filesystem.

pkg/terminal/starbind · high confidence

This change adds a new \service/dap\ package that implements the Debug Adapter Protocol (DAP) directly within Delve, allowing it to function as a DAP server for frontends like VS Code without a separate adaptor. The implementation includes the core server and session logic (\server.go\, \session.go\), configuration handling for launch/attach requests (\config.go\, \types.go\), command parsing for the DAP console (\command.go\), and error code definitions (\error\_ids.go\). It supports standard debugging modes (debug, test, exec, replay, core), variable inspection with handle-based references, and configuration options such as substitute paths and pprof labels.

service/dap · high confidence

The \pkg/config\ package now provides a structured configuration system that allows users to customize the Delve debugger's behavior and appearance via a YAML config file. This includes options for controlling source code display (line counts, arrow/keyword/string/number/comment/tab colors, and line colors), terminal prompt customization (prompt text and color), disassembly output (flavor selection), variable evaluation limits (max string length, array values, recursion depth, and timeout), and path substitution rules. The system also supports command aliases, debug info directory configuration, and specific display toggles like showing raw strings or DWARF location expressions.

pkg/config · high confidence

The package now includes a new \pkg/dwarf/reader\ module containing \reader.go\ and \variables.go\. The \Reader\ type provides utilities for navigating DWARF debug information, including seeking to specific entries, resolving type attributes (with optional typedef/pointer resolution), and locating named symbols. The \Variables\ function introduces configurable logic for determining variable visibility within lexical blocks, supporting flags to skip inlined subroutines, enforce strict declaration line checks, or identify captured closure variables.

pkg/dwarf/reader · high confidence

The eBPF tracing backend now supports capturing and reporting function input and return parameters. This change implements a header-and-parameter event ring buffer protocol to transmit trace data from the kernel to userspace, defines the necessary BPF structures and Go-side data types for parameter parsing, and adds build scripts and a Docker image to compile the eBPF objects.

pkg/proc/internal/ebpf · high confidence

The new \pkg/locspec\ package provides the core logic for parsing breakpoint location strings (such as file:line, function names, regexes, offsets, and addresses) and applying substitute-path rules to map source file paths. This includes support for Windows and Unix path formats, case-insensitive matching on Windows, and exact path matching, enabling consistent breakpoint resolution across different operating systems and build environments.

pkg/locspec · high confidence

The service/rpc2 package introduces a new RPC-based debugging API (version 2), providing both client and server implementations that communicate via JSON-RPC over TCP. This new API layer exposes debugger capabilities such as process state retrieval, command execution (continue, step, next, rewind), breakpoint management, and event handling, serving as the communication bridge for external clients connecting to the Delve debugger.

service/rpc2 · high confidence

The native debugger backend now supports creating core dumps and utilizing hardware breakpoints on Linux, FreeBSD, and Windows. On Linux, the backend reads process memory maps from /proc/pid/smaps and generates ELF notes (NT\_PRPSINFO, NT\_PRSTATUS, NT\_X86\_XSTATE) to capture full process state, including XSAVE areas for modern CPUs. FreeBSD gains core dump support via kinfo\_getvmmap, while Windows implements memory map retrieval using VirtualQueryEx. Additionally, x86/x86\_64 architectures now support hardware breakpoints via debug registers, with platform-specific stubs provided for architectures that do not support this feature.

pkg/proc/native · high confidence

The new \pkg/dwarf/dwarfbuilder\ package provides utilities to construct DWARF debug sections programmatically. It includes a \Builder\ type for assembling DWARF info and location lists, constants for DWARF forms and encodings, and helpers like \LocationBlock\ for encoding location expressions using LEB128.

pkg/dwarf/dwarfbuilder · high confidence

Added the \pkg/debugdetect\ package, which provides utilities to detect if a process is currently being debugged by a ptrace-based debugger (such as Delve, GDB, or LLDB). The package exposes \IsDebuggerAttached()\ to check the debugger status and \WaitForDebugger()\ to block execution until a debugger connects, supporting Linux, macOS, Windows, and FreeBSD. This enables applications to adapt their behavior during startup when a debugger is present.

pkg/debugdetect · high confidence

The new pkg/proc/linutil package provides shared utilities for the Linux native and core debug backends, introducing architecture-specific register wrappers for AMD64, I386, ARM64, Loong64, PPC64LE, and RISC-V64, along with helpers to parse ELF auxiliary vectors and dynamic linker structures.

pkg/proc/linutil · high confidence

The DWARF parsing logic has been extracted from the main debug/dwarf package into a new, dedicated \pkg/dwarf/godwarf\ package. This change introduces native support for DWARFv5 features, including the \debug\_addr\ section (parsed via \addr.go\) and compressed debug sections (handled in \sections.go\ with a workaround for Mach-O section name limitations). The package now provides a robust tree-based representation of DWARF entries (\tree.go\) that automatically resolves abstract origins and specifications, and includes comprehensive type definitions (\type.go\) with support for Go-specific attributes like \DW\_AT\_go\_package\_name\ and parametric type dictionaries. Helper utilities for buffer reading (\buf.go\) and synthetic type generation (\fakes.go\) are also included to support the debugger's internal type resolution.

pkg/dwarf/godwarf · high confidence

The debugger can now parse DWARF version 5 location lists (loclists) and debug address tables (debug\_addr). This change introduces new readers in the loclist package that handle the specific binary formats and opcodes defined in the DWARF v5 standard, allowing accurate variable location resolution for binaries compiled with DWARF 5 debug information.

pkg/dwarf/loclist · high confidence

The service/rpccommon package now provides a single entry point that listens on one port and automatically routes incoming connections to either the Debug Adapter Protocol (DAP) or the legacy JSON-RPC API based on the connection's initial bytes. This allows clients to connect to the same debugger instance using either protocol without requiring separate server configurations or ports.

service/rpccommon · high confidence

The vendored x86 assembly decoder in vendor/golang.org/x/arch/x86/x86asm has been updated to include comprehensive support for AVX, AVX2, and AVX-512 instruction sets. This change introduces new decoding logic for VEX and EVEX prefixes, adds generated instruction tables for a wide range of modern vector operations (such as KADDB, VADDPD, V4FMADDPS), and updates the syntax formatters (GNU, Intel, and Plan 9/Go) to correctly display these new instructions and their specific attributes like broadcast, zeroing, and rounding controls.

vendor/golang.org/x/arch/x86 · high confidence

The eBPF tracing backend in pkg/proc/internal/ebpf/bpf has been implemented with new C source files (trace.bpf.c) and a dummy Go file to satisfy vendoring requirements. The eBPF code introduces support for parsing function parameters of various types (strings, pointers, slices) by reading values from registers or the user stack, and submits these parameter events to a ring buffer for consumption by the debugger.

pkg/proc/internal/ebpf/bpf · high confidence

A new \sameuser\ package has been added to the service internals to enforce that local debugging connections (loopback) originate from the same UNIX user as the debugger. On Linux, the service now parses \/proc/net/tcp\ and \/proc/net/tcp6\ to verify the remote connection's UID against the local process UID, rejecting connections from different users to prevent unauthorized access. This check is skipped on non-Linux platforms where it is not implemented.

service/internal · high confidence

The DWARF debug line parsing logic has been reorganized into the new \pkg/dwarf/line\ package, separating the core state machine, prologue parsing, and utility functions into dedicated files (\line\_parser.go\, \state\_machine.go\, \parse\_util.go\). Additionally, the LEB128 encoding and decoding logic has been extracted into its own \pkg/dwarf/leb128\ package to improve modularity. This change also includes updated tests for the line parser and LEB128 utilities, ensuring the refactored components function correctly with existing debug data formats.

pkg/dwarf/line · high confidence

The process backend has been refactored to replace the previous architecture handling with a unified \Arch\ struct. This change consolidates architecture-specific logic—such as register mappings, breakpoint instructions, frame unwinding rules, and assembly decoding—into a single, extensible object. This improves code organization and makes it easier to support new architectures or modify existing ones by centralizing the configuration and behavior for each CPU architecture.

pkg/proc · high confidence

The \pkg/dwarf/frame\ package has been restructured to improve the parsing and execution of DWARF Call Frame Information (CFI). The new implementation introduces dedicated data structures for Common Information Entries (CIE) and Frame Description Entries (FDE), including support for \eh\_frame\ pointer encodings. It also adds handling for the \DW\_CFA\_GNU\_args\_size\ opcode and implements a state stack to correctly manage \DW\_CFA\_remember\_state\ and \DW\_CFA\_restore\_state\ instructions. These changes enhance the accuracy of stack unwinding and frame context reconstruction for debuggers.

pkg/dwarf/frame · high confidence

The dlv binary now automatically starts Go telemetry reporting (including crash reporting) on launch and ensures the CGO\_CFLAGS environment variable is set to -O0 -g if not already defined, preventing user overrides that could interfere with debugging. This change is implemented in the main entry point of the cmd/dlv package, which initializes the telemetry client and manages the build environment before executing the CLI commands.

cmd/dlv · high confidence

The gobuild package now uses randomized temporary filenames for debug binaries to avoid race conditions, and implements an exponential backoff retry loop when removing these binaries on Windows to prevent 'access denied' errors. Additionally, build arguments are now parsed to ensure the -C (change directory) flag is passed first to the Go command, and the package supports both string and string-list inputs for build flags.

pkg/gobuild · high confidence

The FreeBSD AMD64 register implementation now defers the retrieval of floating-point registers until they are explicitly requested. By introducing a \loadFpRegs\ callback and only invoking it when the \floatingPoint\ flag is true in the \Slice\ method, the debugger avoids unnecessary system calls and performance overhead during general register inspection, improving responsiveness when floating-point state is not needed.

pkg/proc/fbsdutil · high confidence

The internal logging implementation in pkg/logflags has been replaced with Go's standard log/slog package. This change updates the default log level to Error and introduces a LoggerFactory interface, allowing users or integrators to inject custom logger implementations via SetLoggerFactory. The new system supports structured logging with named layers (e.g., debugger, rpc, dap) and ensures consistent output formatting across the debugger.

pkg/logflags · high confidence

The expression evaluation logic in the debugger has been refactored to use a new stack-machine architecture located in the \pkg/proc/evalop\ package. This change introduces a new set of opcodes (defined in \ops.go\) and a compiler (\evalcompile.go\) that translates Go AST expressions into a sequence of stack-based instructions, replacing the previous evaluation approach. The new engine supports features such as pointer pinning for call injection, breakpoint hit count exposure in expressions, and optimized handling of struct literals and range-over-func statements, while also including a test to ensure all opcodes are exhaustively handled by the execution switch.

pkg/proc/evalop · high confidence

The service/api package has been restructured into distinct files (command.go, conversions.go, types.go, waitreason.go, shorten\_type.go) to improve maintainability. This change introduces a new \ShortenType\ utility that condenses verbose Go package paths in type names (e.g., \long/package/path/pkg.A\ becomes \pkg.A\) for cleaner API responses. Additionally, the \waitreason.go\ file has been updated to include the latest goroutine wait reason strings for Go 1.27, ensuring accurate status reporting for goroutines in newer Go versions.

service/api · high confidence

The debugger's breakpoint system has been refactored to support multiple overlapping breakpoints on a single address via a new 'Breaklet' structure, enabling more complex behaviors like deferred function tracing and stack watchpoints. Additionally, initial eBPF tracing support has been introduced, allowing the debugger to trace function parameters and return values using the cilium/ebpf library, with specific handling for goroutine IDs and parameter metadata. The variable pretty-printing logic has also been updated to support new formatting flags, such as shortening types and printing raw strings, improving the clarity of debug output.

github.com/go-delve/delve · high confidence

The \pkg/dwarf/regnum\ package now provides explicit, architecture-specific mappings between hardware registers and DWARF register numbers for amd64, arm64, i386, loong64, ppc64le, and riscv64. This change introduces dedicated source files for each supported architecture, ensuring that register names and numbers are correctly resolved according to their respective ABIs (such as System V AMD64, AArch64, and LoongArch). Users benefit from more accurate register identification and debugging output across these platforms, as the debugger can now reliably translate between internal DWARF indices and human-readable register names.

pkg/dwarf/regnum · high confidence

The debugger can now resolve inlined function calls in stripped binaries by parsing Go 1.20+ symbol table formats (go:func prefixes) and extracting inline tree data from the pclntab section. Additionally, the internal LRU cache implementation has been replaced with a custom, thread-safe generic version to remove external dependencies.

pkg/internal · high confidence

The vendored command-line editor library has been replaced from github.com/peterh/liner to github.com/go-delve/liner. This change updates the underlying implementation for interactive command-line input, history management, and tab completion used by the debugger's console, ensuring continued maintenance and compatibility with the Delve project's specific requirements.

vendor/github.com/go-delve · high confidence

The vendored \golang.org/x/arch/arm64/arm64asm\ package has been updated to a newer version, introducing new files for argument definitions, condition predicates, and decoding logic, along with a comprehensive JSON instruction table. This update improves the accuracy and coverage of ARM64 instruction decoding, which is utilized by native debuggers like Delve for analyzing ARM64 binaries on Linux.

vendor/golang.org/x/arch/arm64 · high confidence

The vendored RISC-V 64-bit architecture package (vendor/golang.org/x/arch/riscv64) has been updated to a newer version that includes comprehensive support for the RISC-V instruction set. This update adds the complete instruction decoding logic, operand definitions, and syntax formatting for GNU and Plan 9 assemblers. It specifically introduces support for vector instructions (RVV), compressed instructions (RVC), and a full set of control and status registers (CSRs), enabling accurate disassembly of modern RISC-V binaries.

vendor/golang.org/x/arch/riscv64 · high confidence

Delve now requires Go 1.25 or later to debug binaries and enforces a maximum supported Go version of 1.27. The version parser has been updated to correctly handle development builds (e.g., \devel go1.24\), release candidates with trailing suffixes (e.g., \go1.26rc1-X:nodwarf5\), and toolchain modifiers. Additionally, debugging executables compiled with DWARFv5 or later now strictly requires Delve to be built with Go 1.25.0 or later.

pkg/goversion · high confidence

The vendored copy of github.com/russross/blackfriday/v2 has been updated to a newer version. This brings in the latest source code, including updated HTML entity definitions, improved inline and block parsing logic, and updated build configuration files (such as .travis.yml and .gitignore). Users benefit from the bug fixes, security hardening, and feature improvements included in this upstream release of the Markdown processor.

vendor/github.com/russross · high confidence

The vendored Cobra library in vendor/github.com/spf13/cobra/doc has been updated to a newer version (v1.1.3). This update refreshes the internal logic for generating documentation in Markdown, ReStructured Text, YAML, and man page formats. For users who rely on these generated documentation files, this change ensures compatibility with the latest Cobra features and bug fixes, such as improved handling of command hierarchies and flag descriptions in the output.

vendor/github.com/spf13/cobra/doc · medium confidence

The vendored copy of the go-isatty library has been updated to include comprehensive, platform-specific implementations for detecting terminal file descriptors. This change adds distinct logic for BSD, Linux/AIX/ZOS, Windows, Solaris, Plan 9, and other environments (such as App Engine or WebAssembly), ensuring accurate terminal detection across all supported operating systems. For Windows, it specifically improves Cygwin/MSYS2 terminal detection by checking pipe names. This update ensures the application correctly identifies interactive terminals on a wider range of platforms.

vendor/github.com/mattn/go-isatty · high confidence

The vendored copy of the go-runewidth library has been updated. This change includes new platform-specific implementations for detecting East Asian locales (POSIX, Windows, App Engine, and JS) and updates to the Unicode width tables, which may affect how the application calculates the display width of strings containing CJK or emoji characters in terminal or UI contexts.

vendor/github.com/mattn/go-runewidth · high confidence

The vendored copy of the golang.org/x/sys package has been updated to a newer version. This brings in support for new system call interfaces, including dynamic CPU affinity handling on Linux, access to the ELF auxiliary vector, and enhanced assembly implementations for various architectures such as Z/OS and LoongArch.

vendor/golang.org/x/sys · high confidence

The vendored copy of the spf13/pflag library has been updated to a newer version. This update introduces new flag types for handling boolean functions (BoolFunc), slices of booleans (BoolSlice), and byte arrays in both hexadecimal and Base64 formats (BytesHex, BytesBase64). It also adds a Count flag type for incrementing values. Additionally, the update refines error handling by introducing specific error types such as NotExistError, ValueRequiredError, InvalidValueError, and InvalidSyntaxError, providing more detailed context for flag parsing issues. The FlagSet now supports an allowlist for parsing errors via ParseErrorsAllowlist, allowing users to ignore specific errors like unknown flags.

vendor/github.com/spf13/pflag · high confidence

The vendored github.com/creack/pty package has been updated to a newer version that adds support for additional operating systems and architectures. This update includes new platform-specific implementations for Solaris and DragonFly BSD, as well as generated type definitions for newer architectures like LoongArch64 (loong64) and RISC-V variants. The library now also includes build infrastructure for cross-compilation testing via Dockerfiles and scripts, ensuring compatibility across a wider range of Unix-like environments.

vendor/github.com/creack · high confidence

The version reporting mechanism has been updated to derive build details from Go's runtime/debug package instead of relying on static placeholders or Makefile variables. The \pkg/version\ package now reads the module path, version, and dependencies via \debug.ReadBuildInfo\, and automatically resolves the build identifier from the \vcs.revision\ (or legacy \gitrevision\) setting in the build metadata. This ensures that the \--verbose\ output and version strings accurately reflect the actual module state and commit hash when built as a Go module, replacing the previous \$Id$\ placeholder with the real revision hash.

pkg/version · high confidence

Added a new Go assembly fixture (\_fixtures/setymmreg) containing a simple function that performs multiple XOR operations on the AX register. This fixture supports the debugserver register set bug workaround in the GDB serial protocol by providing a controlled code pattern for testing register state handling.

_\fixtures/setymmreg · medium confidence

Added a new test fixture (\_fixtures/break) containing an assembly file (break\_amd64.s) and a Go main file (main.go) that invokes a single-byte software breakpoint instruction (0xcc). This fixture supports the fix for StepInstruction handling on 1-byte instructions with software breakpoints.

_\fixtures/break · high confidence

The DWARF location expression evaluator in pkg/dwarf/op now correctly distinguishes between logical right shift (DW\_OP\_shr) and arithmetic right shift (DW\_OP\_shra). Previously, negative values shifted with DW\_OP\_shra were handled incorrectly; the fix ensures that DW\_OP\_shra preserves the sign bit (arithmetic shift) while DW\_OP\_shr fills with zeros (logical shift), matching the DWARF specification. This change is verified by new tests in op\_test.go that explicitly check the behavior for negative shifted values.

pkg/dwarf/op · high confidence

Added a test fixture (\_fixtures/nopbreakpoint) containing a Go program and its assembly code to address breakpoint handling issues during resume. The fixture includes a 'compromised' function that explicitly uses a hardcoded NOP instruction (0x90) to ensure the assembler does not strip it, allowing for reliable testing of breakpoint behavior in the presence of no-operation instructions.

_\fixtures/nopbreakpoint · high confidence

Added a new fixture (\_fixtures/xmm0print) that demonstrates and validates the correct handling of large register values. The Go source defines a function calling an assembly routine (VPSLLQ36) which performs a bitwise left shift on YMM registers, and the assembly file implements this intrinsic. This change ensures that the tool's pretty-printing logic correctly formats these large register components without overflow or truncation errors.

_\fixtures/xmm0print · high confidence

Add CGO stack trace test fixture; Add nodisasm fixture for assembly testing; Added CGO test fixture for multi-architecture variable inspection; Added DAP test client utilities and auto-generated response assertions; Added assembly fixture for nil pointer dereference testing; Added buildtest fixture for verifying test execution context; Added fake debuginfod-find fixture for testing download behavior; Added fixture for debugging stripped non-Go binaries; Added fixture for issue \#1656 regarding thread restart instructions; Added fixture for postfix if breakpoint conditions; Added linker trampoline test fixture for ARM64; Added non-executable fixture file for launch detection testing; Added nongochild fixture for testing spawned process events; Added test fixture for DWARF 5 file reference handling; Added tests for process I/O redirection parsing; Added x86 floating-point and AVX register test fixture; New integration test suite for the Delve service API; New test support infrastructure for building and caching debug fixtures; Updated test fixtures for debugger integration tests.

The vendor directory now includes the go-md2man v2 library, which converts Markdown documents into roff (man page) format. This addition enables the product to generate manual pages from Markdown source files using the blackfriday parser.

vendor/github.com/cpuguy83 · high confidence

The vendored YAML parsing and encoding library has been migrated from the legacy gopkg.in/yaml.v3 path to the official go.yaml.in/yaml/v3 repository. This update replaces the previous vendor files with the new canonical source maintained by the YAML organization, ensuring continued support and alignment with the official Go YAML package while preserving the same v3 API for encoding and decoding YAML data.

vendor/go.yaml.in · high confidence

The project updates its Go module dependencies, including upgrading golang.org/x/sys to v0.46.0, golang.org/x/arch to v0.28.0, github.com/cilium/ebpf to v0.22.0, and github.com/google/go-dap to v0.12.0, while also adding golang.org/x/telemetry. Additionally, a new Maven-based configuration (\.teamcity/pom.xml\) is introduced to manage the TeamCity DSL scripts using Kotlin, establishing the build infrastructure for CI pipeline definitions.

(dependencies) · high confidence

The vendored go.starlark.net library has been updated, introducing a new 'time' module that exposes time-related functions and constants (such as now, parse\_duration, and from\_timestamp) to Starlark scripts. The update also incorporates a new mechanism for canceling Starlark threads, enhancing control over script execution. Additionally, the vendor directory now includes the library's LICENSE file and internal spell-checking utilities for improved error messages.

vendor/go.starlark.net · high confidence

The vendored golang.org/x/arch package has been updated to version 0.11.0. This update includes the addition of LICENSE and PATENTS files, ensuring proper attribution and patent licensing terms are present in the vendor directory.

vendor/golang.org/x/arch · high confidence

The vendored copy of the google/go-dap library has been updated to a newer version, bringing in updated protocol message types (such as StoppedEvent and ContinuedEvent bodies) and codec improvements for the Debug Adapter Protocol. This ensures the debugger client remains compatible with the latest DAP specification changes and improves JSON decoding robustness for debug sessions.

vendor/github.com/google · high confidence

The vendored copy of the \github.com/inconshreveable/mousetrap\ library has been updated to include its Apache 2.0 license, documentation, and platform-specific implementations. This allows the application to detect whether a Windows executable was launched by a user double-clicking in File Explorer (via \explorer.exe\) rather than from a command line, enabling more user-friendly error messages for CLI tools on Windows, while non-Windows platforms continue to return false.

vendor/github.com/inconshreveable · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 54 → 69 (+14.8)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 58 → 74 (+15.9)
• Architecture 100 → 97 (-2.1)
• Maturity 47 → 62 (+15.9)
• Readiness 62 → 76 (+14.4)
• Security 57 → 72 (+15.3)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (pkg/proc/eval.go)
• Duplicated block (10 lines × 2) (pkg/proc/fbsdutil/regs.go)
• Duplicated block (10 lines × 2) (pkg/proc/stack.go)
• Duplicated block (10 lines × 2) (pkg/proc/stack_sigtramp.go)
• Duplicated block (10 lines × 3) (service/debugger/debugger.go)
• Duplicated block (10 lines × 3) (service/rpc2/server.go)
• Duplicated block (11 lines × 2) (pkg/dwarf/parseutil.go)
• Duplicated block (11 lines × 2) (pkg/proc/arm64_disasm.go)
• Duplicated block (11 lines × 2) (pkg/proc/eval.go)
• Duplicated block (11 lines × 2) (pkg/proc/fbsdutil/regs.go)
• Duplicated block (11 lines × 4) (pkg/proc/amd64_arch.go)
• Duplicated block (11 lines × 5) (pkg/proc/linutil/regs_amd64_arch.go)
• Duplicated block (11 lines × 6) (pkg/proc/amd64_arch.go)
• Duplicated block (12 lines × 2) (pkg/dwarf/godwarf/addr.go)
• Duplicated block (12 lines × 2) (pkg/proc/dump.go)
• Duplicated block (12 lines × 2) (pkg/proc/gdbserial/gdbserver_conn.go)
• Duplicated block (12 lines × 2) (pkg/proc/gdbserial/rr.go)
• Duplicated block (12 lines × 2) (pkg/proc/linutil/regs_loong64_arch.go)
• …and 87 more

• ClassTooLong: BinaryInfo (pkg/proc/bininfo.go)
• ClassTooLong: Commands (pkg/terminal/command.go)
• ClassTooLong: Debugger (service/debugger/debugger.go)
• ClassTooLong: EvalScope (pkg/proc/eval.go)
• ClassTooLong: RPCServer (service/rpc2/server.go)
• ClassTooLong: Session (service/dap/server.go)
• ClassTooLong: Term (pkg/terminal/terminal.go)
• ClassTooLong: Variable (pkg/proc/variables.go)
• ClassTooLong: compileCtx (pkg/proc/evalop/evalcompile.go)
• ClassTooLong: gdbConn (pkg/proc/gdbserial/gdbserver_conn.go)
• ClassTooLong: gdbProcess (pkg/proc/gdbserial/gdbserver.go)
• ClassTooLong: stackIterator (pkg/proc/stack.go)
• Documentation: contradicts the code (Documentation/installation/README.md)
• Duplicated block (10 lines × 2) (pkg/proc/stack_sigtramp.go)
• Duplicated block (11 lines × 2) (pkg/dwarf/regnum/amd64.go)
• Duplicated block (11 lines × 2) (pkg/proc/arm64_disasm.go)
• Duplicated block (11 lines × 3) (pkg/proc/fbsdutil/regs.go)
• Duplicated block (11 lines × 5) (pkg/proc/amd64_arch.go)
• Duplicated block (11–12 lines × 3) (service/debugger/debugger.go)
• Duplicated block (11–13 lines × 4) (pkg/proc/linutil/regs_arm64_arch.go)
• …and 385 more

• 32 commits — 29 feature/other, 3 fixes

• pkg/proc — 12 commits
• .github/workflows — 5 commits
• (root) — 4 commits
• Documentation/cli — 2 commits
• service/dap — 2 commits
• _fixtures/cgotest.go — 1 commit
• _scripts/capslock_darwin_amd64-output.txt — 1 commit
• _scripts/test_linux.sh — 1 commit
• pkg/gobuild — 1 commit
• pkg/goversion — 1 commit
• pkg/terminal — 1 commit
• vendor/github.com — 1 commit

• fix: proc: fix range-over-func next test on linux/loong64 (#4441)
• fix: proc: fix TestCGlobal failure (#4451)
• fix: proc: fix infinite loop in mapIteratorSwiss.next (#4433)
• change: *: add scripts to setup / run eval fuzzer and run in CI (#4412)
• change: *: v1.27.2 (#4446)
• change: build(deps): bump github.com/cilium/ebpf from 0.11.0 to 0.22.0 (#4422)
• change: build: add plumber workflow security check (#4406)
• change: build: pin github actions to commit shas and declare workflow permissions (#4405)
• change: ci: fail early when a release is already published (#4408)
• change: ci: run the FreeBSD tests on GitHub Actions (#4432)
• change: ci: upgrade GitHub Actions and pin GoReleaser (#4427)
• change: ci: upload fuzz crashers as GitHub Actions artifacts (#4428)
• change: dap: add types command to list program types (#4439)
• change: debugger: close resumeNotify early with the halt command (#4425)
• change: docs: use singular information in CLI help (#4437)
• change: gobuild: keep -C first for test builds (#4444)
• change: goversion: format versioned development builds correctly (#4445)
• change: pkg/proc: defer pointer cast to syscall invoking function (#4414)
• change: proc,service: emit events while calling DownloadLibraryDebugInfo (#4438)
• change: proc,terminal,service: add timeout to expression evaluation (#4449)
• …and 12 more

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

go-delve/delve was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.