Copy disabled (too large)
Download .txt
Showing preview only (16,024K chars total). Download the full file to get everything.
Repository: go-delve/delve
Branch: master
Commit: 28c9219ffa8f
Files: 1451
Total size: 18.0 MB
Directory structure:
gitextract_w933engg/
├── .cirrus.yml
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── config.yml
│ │ └── issue_template.yml
│ └── workflows/
│ ├── release.yml
│ └── test-windows-arm64.yml
├── .gitignore
├── .goreleaser.yaml
├── .teamcity/
│ ├── pom.xml
│ └── settings.kts
├── CHANGELOG.md
├── CLAUDE.md
├── CONTRIBUTING.md
├── Documentation/
│ ├── AI/
│ │ └── AI_POLICY.md
│ ├── EditorIntegration.md
│ ├── KnownBugs.md
│ ├── README.md
│ ├── api/
│ │ ├── ClientHowto.md
│ │ ├── README.md
│ │ ├── dap/
│ │ │ └── README.md
│ │ └── json-rpc/
│ │ └── README.md
│ ├── backend_test_health.md
│ ├── cli/
│ │ ├── README.md
│ │ ├── cond.md
│ │ ├── config.md
│ │ ├── expr.md
│ │ ├── getting_started.md
│ │ ├── locspec.md
│ │ ├── starlark.md
│ │ └── substitutepath.md
│ ├── faq.md
│ ├── installation/
│ │ ├── README.md
│ │ ├── freebsd/
│ │ │ └── install.md
│ │ ├── linux/
│ │ │ └── install.md
│ │ ├── osx/
│ │ │ └── install.md
│ │ └── windows/
│ │ └── install.md
│ ├── internal/
│ │ ├── README.md
│ │ └── portnotes.md
│ └── usage/
│ ├── README.md
│ ├── dlv.md
│ ├── dlv_attach.md
│ ├── dlv_backend.md
│ ├── dlv_connect.md
│ ├── dlv_core.md
│ ├── dlv_dap.md
│ ├── dlv_debug.md
│ ├── dlv_exec.md
│ ├── dlv_log.md
│ ├── dlv_redirect.md
│ ├── dlv_replay.md
│ ├── dlv_run.md
│ ├── dlv_test.md
│ ├── dlv_trace.md
│ └── dlv_version.md
├── LICENSE
├── Makefile
├── README.md
├── _fixtures/
│ ├── amend_breakpoint.star
│ ├── asmnilptr/
│ │ ├── main.go
│ │ ├── main_386.s
│ │ ├── main_amd64.s
│ │ ├── main_arm64.s
│ │ ├── main_loong64.s
│ │ ├── main_ppc64le.s
│ │ └── main_riscv64.s
│ ├── backwardsiter.go
│ ├── badflags.go
│ ├── binarytrees.go
│ ├── bpcountstest.go
│ ├── bpfile
│ ├── bphitcountchain.go
│ ├── break/
│ │ ├── break_amd64.s
│ │ └── main.go
│ ├── break.go
│ ├── buildflagtest.go
│ ├── buildtest/
│ │ ├── __debug_bin2807893743
│ │ ├── main.go
│ │ └── main_test.go
│ ├── callme.go
│ ├── cat.go
│ ├── cgodisass.go
│ ├── cgosigsegvstack.go
│ ├── cgostacktest/
│ │ ├── hello.c
│ │ ├── hello.h
│ │ └── main.go
│ ├── cgotest.go
│ ├── chain_breakpoints.star
│ ├── changoroutines.go
│ ├── clientdo.go
│ ├── closurecontents.go
│ ├── condframe.go
│ ├── condperghitcount.go
│ ├── consts.go
│ ├── continuetestprog.go
│ ├── coreemptystring.go
│ ├── create_breakpoint_main.star
│ ├── databpcountstest.go
│ ├── databpeasy.go
│ ├── databpstack.go
│ ├── debug_line_benchmark_data
│ ├── debug_line_c_data
│ ├── debugdetect.go
│ ├── decllinetest.go
│ ├── defercall.go
│ ├── deferstack.go
│ ├── delvecatch.go
│ ├── dotpackagesiface.go
│ ├── doubleinline.go
│ ├── dwzcompression.go
│ ├── ebpf_trace.go
│ ├── ebpf_trace2.go
│ ├── ebpf_trace3.go
│ ├── echo_expr.star
│ ├── examinememory.go
│ ├── exit.init
│ ├── fake-debuginfod-find/
│ │ └── debuginfod-find
│ ├── fatalerror.go
│ ├── find_array.star
│ ├── fncall.go
│ ├── fputest/
│ │ ├── fputest.go
│ │ └── fputest_amd64.s
│ ├── genericbp.go
│ ├── genericintoiface.go
│ ├── godlopen/
│ │ ├── golib/
│ │ │ └── golib.go
│ │ └── main.c
│ ├── goroutineLabels.go
│ ├── goroutine_start_line.star
│ ├── goroutinebreak.go
│ ├── goroutinegroup.go
│ ├── goroutines-trace.go
│ ├── goroutinestackprog.go
│ ├── hcbpcountstest.go
│ ├── http_server.go
│ ├── ifaceembcall.go
│ ├── increment.go
│ ├── inlinestripped.go
│ ├── integrationprog.go
│ ├── internal/
│ │ ├── dir.io/
│ │ │ ├── dir.go
│ │ │ └── io.io/
│ │ │ └── io.go
│ │ ├── dir0/
│ │ │ ├── pkg/
│ │ │ │ └── main.go
│ │ │ └── renamedpackage/
│ │ │ └── main.go
│ │ ├── dir1/
│ │ │ └── pkg/
│ │ │ └── main.go
│ │ └── pluginsupport/
│ │ └── pluginsupport.go
│ ├── is sue239.go
│ ├── issue1101.go
│ ├── issue1264.go
│ ├── issue1374.go
│ ├── issue1432.go
│ ├── issue1469.go
│ ├── issue1531.go
│ ├── issue1549.go
│ ├── issue1598.go
│ ├── issue1601.go
│ ├── issue1615.go
│ ├── issue1656/
│ │ ├── main.go
│ │ └── main.s
│ ├── issue1795.go
│ ├── issue1817.go
│ ├── issue2023.go
│ ├── issue2078.go
│ ├── issue2086.go
│ ├── issue2113.go
│ ├── issue2138.go
│ ├── issue2162.go
│ ├── issue2319/
│ │ ├── README.txt
│ │ ├── asm-linux-amd64.s
│ │ ├── cfile-linux-amd64.syso
│ │ └── main.go
│ ├── issue262.go
│ ├── issue2896.go
│ ├── issue305.go
│ ├── issue3194.go
│ ├── issue3310.go
│ ├── issue332.go
│ ├── issue3548.go
│ ├── issue384.go
│ ├── issue387.go
│ ├── issue4000.go
│ ├── issue4051.go
│ ├── issue406.go
│ ├── issue4116.go
│ ├── issue419.go
│ ├── issue528.go
│ ├── issue561.go
│ ├── issue573.go
│ ├── issue594.go
│ ├── issue664.go
│ ├── issue683.go
│ ├── issue871.go
│ ├── issue877.go
│ ├── issue951.go
│ ├── leaf4.go
│ ├── leafcommon.go
│ ├── leafindrec.go
│ ├── leafrec.go
│ ├── leafregex.go
│ ├── linked_list.star
│ ├── livetestprog.go
│ ├── locationsUpperCase.go
│ ├── locationsprog.go
│ ├── locationsprog2.go
│ ├── locationsprog3.go
│ ├── locationsprog_generic.go
│ ├── longstrings.go
│ ├── loopprog.go
│ ├── math.go
│ ├── morestringarg.go
│ ├── multinamedreturns.go
│ ├── nestedbp.go
│ ├── nextcond.go
│ ├── nilptr.go
│ ├── nodisasm/
│ │ ├── main.go
│ │ └── nodisasm_amd64.s
│ ├── nomaindir/
│ │ └── file.go
│ ├── nongochild/
│ │ ├── child.bat
│ │ ├── child.sh
│ │ └── main.go
│ ├── nopbreakpoint/
│ │ ├── main.go
│ │ └── main.s
│ ├── notify-v2.go
│ ├── out_redirect.go
│ ├── panic.go
│ ├── panicex.go
│ ├── panicline.go
│ ├── parallel_next.go
│ ├── pkgrenames.go
│ ├── plugin1/
│ │ └── plugin1.go
│ ├── plugin2/
│ │ └── plugin2.go
│ ├── plugintest.go
│ ├── plugintest2.go
│ ├── pr1055.go
│ ├── rangeoverfunc.go
│ ├── readmem_json.go
│ ├── redirect-input.txt
│ ├── redirect.go
│ ├── reflecttypefncall.go
│ ├── restartargs.go
│ ├── retstack.go
│ ├── scopeescapevareval.go
│ ├── scopetest.go
│ ├── setiterator.go
│ ├── setymmreg/
│ │ ├── main.go
│ │ └── setymmreg_amd64.s
│ ├── sigchldprog.go
│ ├── sleep.go
│ ├── spawn.go
│ ├── spawnchild.go
│ ├── stacktraceprog.go
│ ├── stackwatchbug.go
│ ├── starlark_map_iteration.star
│ ├── stepintobug.go
│ ├── stepoutret.go
│ ├── stepshadow.go
│ ├── switch_to_main_goroutine.star
│ ├── test if path/
│ │ └── main.go
│ ├── test.c
│ ├── testRestartRequestRebuildFailFixture.go
│ ├── test_allow_on.star
│ ├── test_custom_cmd_continue.star
│ ├── test_custom_cmd_nested.star
│ ├── testargs.go
│ ├── testdeadlock.go
│ ├── testenv.go
│ ├── testenv2.go
│ ├── testfnpos1.go
│ ├── testfnpos2.go
│ ├── testinline.go
│ ├── testnextdefer.go
│ ├── testnextnethttp.go
│ ├── testnextprog.go
│ ├── testprog.go
│ ├── testrerecord.go
│ ├── testreturnaddress.go
│ ├── testruntimebreakpoint.go
│ ├── testshadow.go
│ ├── teststep.go
│ ├── teststepconcurrent.go
│ ├── teststepprog.go
│ ├── testthreads.go
│ ├── testtoggle.go
│ ├── testtracefns.go
│ ├── testunsafepointers.go
│ ├── testvariables.go
│ ├── testvariables2.go
│ ├── testvariables_generic.go
│ ├── testvariables_pointers_not_loaded.go
│ ├── testvariablescgo/
│ │ ├── test.c
│ │ └── testvariablescgo.go
│ ├── trace_backend_parity.go
│ ├── traceperf.go
│ ├── traceprog.go
│ ├── traceret.go
│ ├── waitfordebugger.go
│ ├── watchpointInterface.go
│ ├── watchpointInterfaceNil.go
│ ├── workdir.go
│ ├── xmm0print/
│ │ ├── main.go
│ │ └── main.s
│ └── zdebug_line_dwarf4
├── _scripts/
│ ├── capslock.sh
│ ├── capslock_darwin_amd64-output.txt
│ ├── capslock_darwin_arm64-output.txt
│ ├── capslock_linux_386-output.txt
│ ├── capslock_linux_amd64-output.txt
│ ├── capslock_linux_arm64-output.txt
│ ├── capslock_linux_ppc64le-output.txt
│ ├── capslock_linux_riscv64-output.txt
│ ├── capslock_windows_amd64-output.txt
│ ├── capslock_windows_arm64-output.txt
│ ├── gen-backend_test_health.go
│ ├── gen-capslock-all.go
│ ├── gen-cli-docs.go
│ ├── gen-faq-toc.go
│ ├── gen-opcodes.go
│ ├── gen-travis.go
│ ├── gen-usage-docs.go
│ ├── gencert.sh
│ ├── latestver.py
│ ├── make.go
│ ├── rtype-out.txt
│ ├── rtype.go
│ ├── staticcheck-out.txt
│ ├── test_linux.sh
│ ├── test_mac.sh
│ ├── test_windows.ps1
│ └── testsign
├── go.mod
├── go.sum
├── pkg/
│ ├── astutil/
│ │ └── astutil.go
│ ├── config/
│ │ ├── config.go
│ │ ├── split.go
│ │ └── split_test.go
│ ├── debugdetect/
│ │ ├── detect.go
│ │ ├── detect_darwin.go
│ │ ├── detect_freebsd.go
│ │ ├── detect_linux.go
│ │ ├── detect_test.go
│ │ ├── detect_windows.go
│ │ └── doc.go
│ ├── dwarf/
│ │ ├── dwarfbuilder/
│ │ │ ├── builder.go
│ │ │ ├── info.go
│ │ │ └── loc.go
│ │ ├── frame/
│ │ │ ├── entries.go
│ │ │ ├── entries_test.go
│ │ │ ├── parser.go
│ │ │ ├── parser_test.go
│ │ │ ├── table.go
│ │ │ └── testdata/
│ │ │ └── frame
│ │ ├── godwarf/
│ │ │ ├── addr.go
│ │ │ ├── buf.go
│ │ │ ├── fakes.go
│ │ │ ├── sections.go
│ │ │ ├── tree.go
│ │ │ ├── tree_test.go
│ │ │ └── type.go
│ │ ├── leb128/
│ │ │ ├── decode.go
│ │ │ ├── decode_test.go
│ │ │ ├── doc.go
│ │ │ ├── encode.go
│ │ │ └── encode_test.go
│ │ ├── line/
│ │ │ ├── line_parser.go
│ │ │ ├── line_parser_test.go
│ │ │ ├── parse_util.go
│ │ │ ├── state_machine.go
│ │ │ └── state_machine_test.go
│ │ ├── loclist/
│ │ │ ├── dwarf2_loclist.go
│ │ │ ├── dwarf5_loclist.go
│ │ │ └── loclist5_test.go
│ │ ├── op/
│ │ │ ├── op.go
│ │ │ ├── op_test.go
│ │ │ ├── opcodes.go
│ │ │ ├── opcodes.table
│ │ │ └── regs.go
│ │ ├── parseutil.go
│ │ ├── parseutil_test.go
│ │ ├── reader/
│ │ │ ├── reader.go
│ │ │ └── variables.go
│ │ └── regnum/
│ │ ├── amd64.go
│ │ ├── arm64.go
│ │ ├── i386.go
│ │ ├── loong64.go
│ │ ├── ppc64le.go
│ │ └── riscv64.go
│ ├── elfwriter/
│ │ ├── delve_core_notes.go
│ │ └── writer.go
│ ├── gobuild/
│ │ ├── defaultexe.go
│ │ ├── gobuild.go
│ │ └── gobuild_test.go
│ ├── goversion/
│ │ ├── compat.go
│ │ ├── go_version.go
│ │ └── version_test.go
│ ├── internal/
│ │ ├── gosym/
│ │ │ ├── additions.go
│ │ │ ├── pclntab.go
│ │ │ └── symtab.go
│ │ └── lru/
│ │ ├── lru.go
│ │ └── lru_test.go
│ ├── locspec/
│ │ ├── doc.go
│ │ ├── locations.go
│ │ └── locations_test.go
│ ├── logflags/
│ │ ├── logflags.go
│ │ ├── logflags_test.go
│ │ └── logger.go
│ ├── proc/
│ │ ├── amd64_arch.go
│ │ ├── amd64_disasm.go
│ │ ├── amd64util/
│ │ │ ├── debugregs.go
│ │ │ └── xsave.go
│ │ ├── arch.go
│ │ ├── arm64_arch.go
│ │ ├── arm64_disasm.go
│ │ ├── bininfo.go
│ │ ├── breakpoints.go
│ │ ├── core/
│ │ │ ├── core.go
│ │ │ ├── core_test.go
│ │ │ ├── delve_core.go
│ │ │ ├── linux_core.go
│ │ │ ├── minidump/
│ │ │ │ ├── fileflags_string.go
│ │ │ │ └── minidump.go
│ │ │ └── windows_amd64_minidump.go
│ │ ├── debuginfod/
│ │ │ └── debuginfod.go
│ │ ├── disasm.go
│ │ ├── doc.go
│ │ ├── dump.go
│ │ ├── dwarf_export_test.go
│ │ ├── dwarf_expr_test.go
│ │ ├── eval.go
│ │ ├── evalop/
│ │ │ ├── evalcompile.go
│ │ │ ├── evalop_test.go
│ │ │ └── ops.go
│ │ ├── fbsdutil/
│ │ │ └── regs.go
│ │ ├── fncall.go
│ │ ├── gdbserial/
│ │ │ ├── gdbserver.go
│ │ │ ├── gdbserver_conn.go
│ │ │ ├── gdbserver_unix.go
│ │ │ ├── gdbserver_windows.go
│ │ │ ├── rr.go
│ │ │ └── rr_test.go
│ │ ├── goroutine_cache.go
│ │ ├── i386_arch.go
│ │ ├── i386_disasm.go
│ │ ├── interface.go
│ │ ├── internal/
│ │ │ └── ebpf/
│ │ │ ├── bpf/
│ │ │ │ ├── dummy.go
│ │ │ │ ├── include/
│ │ │ │ │ ├── dummy.go
│ │ │ │ │ ├── function_vals.bpf.h
│ │ │ │ │ ├── trace.bpf.h
│ │ │ │ │ └── vmlinux.h
│ │ │ │ └── trace.bpf.c
│ │ │ ├── build/
│ │ │ │ ├── build-ebpf-builder-img.sh
│ │ │ │ ├── build-ebpf-objects.sh
│ │ │ │ └── ebpf-Dockerfile
│ │ │ ├── context.go
│ │ │ ├── dummy.go
│ │ │ ├── helpers.go
│ │ │ ├── helpers_disabled.go
│ │ │ ├── helpers_test.go
│ │ │ ├── testhelper/
│ │ │ │ └── testhelper.go
│ │ │ ├── trace_bpfel_x86.go
│ │ │ └── trace_bpfel_x86.o
│ │ ├── linutil/
│ │ │ ├── auxv.go
│ │ │ ├── doc.go
│ │ │ ├── dynamic.go
│ │ │ ├── regs_amd64_arch.go
│ │ │ ├── regs_arm64_arch.go
│ │ │ ├── regs_i386_arch.go
│ │ │ ├── regs_loong64_arch.go
│ │ │ ├── regs_ppc64le_arch.go
│ │ │ └── regs_riscv64_arch.go
│ │ ├── loong64_arch.go
│ │ ├── loong64_disasm.go
│ │ ├── macutil/
│ │ │ ├── rosetta_darwin.go
│ │ │ └── rosetta_other.go
│ │ ├── mapiter.go
│ │ ├── mem.go
│ │ ├── moduledata.go
│ │ ├── native/
│ │ │ ├── cpuid/
│ │ │ │ ├── xsave_x86.go
│ │ │ │ └── xsave_x86.s
│ │ │ ├── dump_freebsd.go
│ │ │ ├── dump_linux.go
│ │ │ ├── dump_linux_amd64.go
│ │ │ ├── dump_linux_other.go
│ │ │ ├── dump_other.go
│ │ │ ├── dump_windows_amd64.go
│ │ │ ├── exc.h
│ │ │ ├── exc_user_darwin.c
│ │ │ ├── exec_darwin.c
│ │ │ ├── exec_darwin.h
│ │ │ ├── followexec_other.go
│ │ │ ├── hwbreak_amd64.go
│ │ │ ├── hwbreak_other.go
│ │ │ ├── mach_exc.h
│ │ │ ├── mach_exc_user_darwin.c
│ │ │ ├── nonative_darwin.go
│ │ │ ├── proc.go
│ │ │ ├── proc_darwin.c
│ │ │ ├── proc_darwin.go
│ │ │ ├── proc_darwin.h
│ │ │ ├── proc_ebpf_linux.go
│ │ │ ├── proc_freebsd.go
│ │ │ ├── proc_linux.go
│ │ │ ├── proc_no_ebpf_linux.go
│ │ │ ├── proc_unix.go
│ │ │ ├── proc_windows.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_freebsd.go
│ │ │ ├── ptrace_freebsd_amd64.go
│ │ │ ├── ptrace_linux.go
│ │ │ ├── ptrace_linux_386.go
│ │ │ ├── ptrace_linux_64bit.go
│ │ │ ├── ptrace_linux_amd64.go
│ │ │ ├── register_linux_386.go
│ │ │ ├── registers_darwin_amd64.go
│ │ │ ├── registers_freebsd_amd64.go
│ │ │ ├── registers_linux_amd64.go
│ │ │ ├── registers_linux_arm64.go
│ │ │ ├── registers_linux_loong64.go
│ │ │ ├── registers_linux_ppc64le.go
│ │ │ ├── registers_linux_riscv64.go
│ │ │ ├── registers_windows.go
│ │ │ ├── support_sentinel.go
│ │ │ ├── support_sentinel_cgo_freebsd.go
│ │ │ ├── support_sentinel_darwin.go
│ │ │ ├── support_sentinel_freebsd.go
│ │ │ ├── support_sentinel_linux.go
│ │ │ ├── support_sentinel_windows.go
│ │ │ ├── syscall_windows.go
│ │ │ ├── syscall_windows_amd64.go
│ │ │ ├── syscall_windows_arm64.go
│ │ │ ├── threads.go
│ │ │ ├── threads_darwin.c
│ │ │ ├── threads_darwin.go
│ │ │ ├── threads_darwin.h
│ │ │ ├── threads_freebsd.go
│ │ │ ├── threads_hardware_singlestep_linux.go
│ │ │ ├── threads_linux.go
│ │ │ ├── threads_linux_386.go
│ │ │ ├── threads_linux_amd64.go
│ │ │ ├── threads_linux_arm64.go
│ │ │ ├── threads_linux_loong64.go
│ │ │ ├── threads_linux_ppc64le.go
│ │ │ ├── threads_linux_riscv64.go
│ │ │ ├── threads_windows.go
│ │ │ ├── threads_windows_amd64.go
│ │ │ ├── threads_windows_arm64.go
│ │ │ └── zsyscall_windows.go
│ │ ├── pclntab.go
│ │ ├── pe.go
│ │ ├── ppc64le_arch.go
│ │ ├── ppc64le_disasm.go
│ │ ├── proc_amd64_test.go
│ │ ├── proc_darwin_amd64_test.go
│ │ ├── proc_darwin_test.go
│ │ ├── proc_general_test.go
│ │ ├── proc_linux_test.go
│ │ ├── proc_test.go
│ │ ├── proc_unexported_test.go
│ │ ├── proc_unix_test.go
│ │ ├── redirect.go
│ │ ├── redirector_other.go
│ │ ├── redirector_windows.go
│ │ ├── registers.go
│ │ ├── riscv64_arch.go
│ │ ├── riscv64_disasm.go
│ │ ├── scope_test.go
│ │ ├── stack.go
│ │ ├── stack_sigtramp.go
│ │ ├── stackwatch.go
│ │ ├── stepping_test.go
│ │ ├── target.go
│ │ ├── target_exec.go
│ │ ├── target_group.go
│ │ ├── test/
│ │ │ └── support.go
│ │ ├── threads.go
│ │ ├── types.go
│ │ ├── variable_test.go
│ │ ├── variables.go
│ │ ├── variables_fuzz_test.go
│ │ ├── variables_test.go
│ │ ├── winutil/
│ │ │ ├── regs_amd64_arch.go
│ │ │ └── regs_arm64_arch.go
│ │ └── x86_disasm.go
│ ├── terminal/
│ │ ├── colorize/
│ │ │ ├── colorize.go
│ │ │ └── colorize_test.go
│ │ ├── command.go
│ │ ├── command_test.go
│ │ ├── config.go
│ │ ├── disasmprint.go
│ │ ├── docgen.go
│ │ ├── groups.go
│ │ ├── out.go
│ │ ├── out_unix.go
│ │ ├── out_windows.go
│ │ ├── starbind/
│ │ │ ├── conv.go
│ │ │ ├── conv_test.go
│ │ │ ├── repl.go
│ │ │ ├── starlark.go
│ │ │ └── starlark_mapping.go
│ │ ├── starlark.go
│ │ ├── starlark_test.go
│ │ ├── terminal.go
│ │ ├── terminal_other.go
│ │ ├── terminal_test.go
│ │ └── terminal_windows.go
│ └── version/
│ ├── buildinfo.go
│ └── version.go
├── service/
│ ├── api/
│ │ ├── command.go
│ │ ├── conversions.go
│ │ ├── prettyprint.go
│ │ ├── prettyprint_test.go
│ │ ├── shorten_type.go
│ │ ├── shorten_type_test.go
│ │ ├── types.go
│ │ └── waitreason.go
│ ├── client.go
│ ├── config.go
│ ├── dap/
│ │ ├── command.go
│ │ ├── config.go
│ │ ├── config_test.go
│ │ ├── daptest/
│ │ │ ├── client.go
│ │ │ └── resp.go
│ │ ├── error_ids.go
│ │ ├── handles.go
│ │ ├── server.go
│ │ ├── server_test.go
│ │ └── types.go
│ ├── debugger/
│ │ ├── debugger.go
│ │ ├── debugger_linux.go
│ │ ├── debugger_test.go
│ │ └── debugger_unix_test.go
│ ├── internal/
│ │ └── sameuser/
│ │ ├── doc.go
│ │ ├── sameuser.go
│ │ ├── sameuser_linux.go
│ │ └── sameuser_linux_test.go
│ ├── listenerpipe.go
│ ├── rpc2/
│ │ ├── client.go
│ │ └── server.go
│ ├── rpccallback.go
│ ├── rpccommon/
│ │ ├── server.go
│ │ └── suitablemethods.go
│ ├── server.go
│ └── test/
│ ├── common_test.go
│ └── integration2_test.go
└── vendor/
├── github.com/
│ ├── cilium/
│ │ └── ebpf/
│ │ ├── .clang-format
│ │ ├── .gitignore
│ │ ├── .golangci.yaml
│ │ ├── ARCHITECTURE.md
│ │ ├── CODE_OF_CONDUCT.md
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE
│ │ ├── MAINTAINERS.md
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── asm/
│ │ │ ├── alu.go
│ │ │ ├── alu_string.go
│ │ │ ├── doc.go
│ │ │ ├── func.go
│ │ │ ├── func_string.go
│ │ │ ├── instruction.go
│ │ │ ├── jump.go
│ │ │ ├── jump_string.go
│ │ │ ├── load_store.go
│ │ │ ├── load_store_string.go
│ │ │ ├── metadata.go
│ │ │ ├── opcode.go
│ │ │ ├── opcode_string.go
│ │ │ └── register.go
│ │ ├── attachtype_string.go
│ │ ├── btf/
│ │ │ ├── btf.go
│ │ │ ├── btf_types.go
│ │ │ ├── btf_types_string.go
│ │ │ ├── core.go
│ │ │ ├── doc.go
│ │ │ ├── ext_info.go
│ │ │ ├── format.go
│ │ │ ├── handle.go
│ │ │ ├── marshal.go
│ │ │ ├── strings.go
│ │ │ ├── traversal.go
│ │ │ ├── types.go
│ │ │ └── workarounds.go
│ │ ├── collection.go
│ │ ├── doc.go
│ │ ├── elf_reader.go
│ │ ├── info.go
│ │ ├── internal/
│ │ │ ├── align.go
│ │ │ ├── buffer.go
│ │ │ ├── cpu.go
│ │ │ ├── deque.go
│ │ │ ├── elf.go
│ │ │ ├── endian_be.go
│ │ │ ├── endian_le.go
│ │ │ ├── epoll/
│ │ │ │ └── poller.go
│ │ │ ├── errors.go
│ │ │ ├── feature.go
│ │ │ ├── io.go
│ │ │ ├── kconfig/
│ │ │ │ └── kconfig.go
│ │ │ ├── memoize.go
│ │ │ ├── output.go
│ │ │ ├── pinning.go
│ │ │ ├── platform.go
│ │ │ ├── prog.go
│ │ │ ├── statfs.go
│ │ │ ├── sys/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fd.go
│ │ │ │ ├── fd_trace.go
│ │ │ │ ├── mapflags_string.go
│ │ │ │ ├── ptr.go
│ │ │ │ ├── ptr_32_be.go
│ │ │ │ ├── ptr_32_le.go
│ │ │ │ ├── ptr_64.go
│ │ │ │ ├── signals.go
│ │ │ │ ├── syscall.go
│ │ │ │ └── types.go
│ │ │ ├── tracefs/
│ │ │ │ ├── kprobe.go
│ │ │ │ ├── probetype_string.go
│ │ │ │ └── uprobe.go
│ │ │ ├── unix/
│ │ │ │ ├── doc.go
│ │ │ │ ├── types_linux.go
│ │ │ │ └── types_other.go
│ │ │ ├── vdso.go
│ │ │ └── version.go
│ │ ├── link/
│ │ │ ├── cgroup.go
│ │ │ ├── doc.go
│ │ │ ├── iter.go
│ │ │ ├── kprobe.go
│ │ │ ├── kprobe_multi.go
│ │ │ ├── link.go
│ │ │ ├── netns.go
│ │ │ ├── perf_event.go
│ │ │ ├── program.go
│ │ │ ├── query.go
│ │ │ ├── raw_tracepoint.go
│ │ │ ├── socket_filter.go
│ │ │ ├── syscalls.go
│ │ │ ├── tracepoint.go
│ │ │ ├── tracing.go
│ │ │ ├── uprobe.go
│ │ │ └── xdp.go
│ │ ├── linker.go
│ │ ├── map.go
│ │ ├── marshalers.go
│ │ ├── prog.go
│ │ ├── ringbuf/
│ │ │ ├── doc.go
│ │ │ ├── reader.go
│ │ │ └── ring.go
│ │ ├── rlimit/
│ │ │ └── rlimit.go
│ │ ├── run-tests.sh
│ │ ├── syscalls.go
│ │ ├── types.go
│ │ └── types_string.go
│ ├── cosiner/
│ │ └── argv/
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── argv.go
│ │ ├── cmd.go
│ │ ├── parser.go
│ │ └── scanner.go
│ ├── cpuguy83/
│ │ └── go-md2man/
│ │ └── v2/
│ │ ├── LICENSE.md
│ │ └── md2man/
│ │ ├── debug.go
│ │ ├── md2man.go
│ │ └── roff.go
│ ├── creack/
│ │ └── pty/
│ │ ├── .gitignore
│ │ ├── Dockerfile.golang
│ │ ├── Dockerfile.riscv
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── asm_solaris_amd64.s
│ │ ├── doc.go
│ │ ├── ioctl.go
│ │ ├── ioctl_bsd.go
│ │ ├── ioctl_inner.go
│ │ ├── ioctl_legacy.go
│ │ ├── ioctl_solaris.go
│ │ ├── ioctl_unsupported.go
│ │ ├── mktypes.bash
│ │ ├── pty_darwin.go
│ │ ├── pty_dragonfly.go
│ │ ├── pty_freebsd.go
│ │ ├── pty_linux.go
│ │ ├── pty_netbsd.go
│ │ ├── pty_openbsd.go
│ │ ├── pty_solaris.go
│ │ ├── pty_unsupported.go
│ │ ├── run.go
│ │ ├── start.go
│ │ ├── start_windows.go
│ │ ├── test_crosscompile.sh
│ │ ├── winsize.go
│ │ ├── winsize_unix.go
│ │ ├── winsize_unsupported.go
│ │ ├── ztypes_386.go
│ │ ├── ztypes_amd64.go
│ │ ├── ztypes_arm.go
│ │ ├── ztypes_arm64.go
│ │ ├── ztypes_dragonfly_amd64.go
│ │ ├── ztypes_freebsd_386.go
│ │ ├── ztypes_freebsd_amd64.go
│ │ ├── ztypes_freebsd_arm.go
│ │ ├── ztypes_freebsd_arm64.go
│ │ ├── ztypes_freebsd_ppc64.go
│ │ ├── ztypes_freebsd_riscv64.go
│ │ ├── ztypes_loong64.go
│ │ ├── ztypes_mipsx.go
│ │ ├── ztypes_netbsd_32bit_int.go
│ │ ├── ztypes_openbsd_32bit_int.go
│ │ ├── ztypes_ppc.go
│ │ ├── ztypes_ppc64.go
│ │ ├── ztypes_ppc64le.go
│ │ ├── ztypes_riscvx.go
│ │ ├── ztypes_s390x.go
│ │ └── ztypes_sparcx.go
│ ├── derekparker/
│ │ └── trie/
│ │ └── v3/
│ │ ├── .gitignore
│ │ ├── LICENSE
│ │ ├── README.md
│ │ └── trie.go
│ ├── go-delve/
│ │ └── liner/
│ │ ├── COPYING
│ │ ├── README.md
│ │ ├── bsdinput.go
│ │ ├── common.go
│ │ ├── fallbackinput.go
│ │ ├── input.go
│ │ ├── input_darwin.go
│ │ ├── input_linux.go
│ │ ├── input_solaris.go
│ │ ├── input_windows.go
│ │ ├── line.go
│ │ ├── output.go
│ │ ├── output_solaris.go
│ │ ├── output_unix.go
│ │ ├── output_windows.go
│ │ ├── signal_unix.go
│ │ ├── signal_windows.go
│ │ ├── unixmode.go
│ │ ├── unixmode_solaris.go
│ │ └── width.go
│ ├── google/
│ │ └── go-dap/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── codec.go
│ │ ├── doc.go
│ │ ├── io.go
│ │ └── schematypes.go
│ ├── inconshreveable/
│ │ └── mousetrap/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── trap_others.go
│ │ └── trap_windows.go
│ ├── mattn/
│ │ ├── go-colorable/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── colorable_appengine.go
│ │ │ ├── colorable_others.go
│ │ │ ├── colorable_windows.go
│ │ │ ├── go.test.sh
│ │ │ └── noncolorable.go
│ │ ├── go-isatty/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── doc.go
│ │ │ ├── go.test.sh
│ │ │ ├── isatty_bsd.go
│ │ │ ├── isatty_others.go
│ │ │ ├── isatty_plan9.go
│ │ │ ├── isatty_solaris.go
│ │ │ ├── isatty_tcgets.go
│ │ │ └── isatty_windows.go
│ │ └── go-runewidth/
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── go.test.sh
│ │ ├── runewidth.go
│ │ ├── runewidth_appengine.go
│ │ ├── runewidth_js.go
│ │ ├── runewidth_posix.go
│ │ ├── runewidth_table.go
│ │ └── runewidth_windows.go
│ ├── rivo/
│ │ └── uniseg/
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── doc.go
│ │ ├── grapheme.go
│ │ └── properties.go
│ ├── russross/
│ │ └── blackfriday/
│ │ └── v2/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── block.go
│ │ ├── doc.go
│ │ ├── entities.go
│ │ ├── esc.go
│ │ ├── html.go
│ │ ├── inline.go
│ │ ├── markdown.go
│ │ ├── node.go
│ │ └── smartypants.go
│ └── spf13/
│ ├── cobra/
│ │ ├── .gitignore
│ │ ├── .golangci.yml
│ │ ├── .mailmap
│ │ ├── CONDUCT.md
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE.txt
│ │ ├── MAINTAINERS
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── active_help.go
│ │ ├── args.go
│ │ ├── bash_completions.go
│ │ ├── bash_completionsV2.go
│ │ ├── cobra.go
│ │ ├── command.go
│ │ ├── command_notwin.go
│ │ ├── command_win.go
│ │ ├── completions.go
│ │ ├── doc/
│ │ │ ├── man_docs.go
│ │ │ ├── md_docs.go
│ │ │ ├── rest_docs.go
│ │ │ ├── util.go
│ │ │ └── yaml_docs.go
│ │ ├── fish_completions.go
│ │ ├── flag_groups.go
│ │ ├── powershell_completions.go
│ │ ├── shell_completions.go
│ │ └── zsh_completions.go
│ └── pflag/
│ ├── .editorconfig
│ ├── .gitignore
│ ├── .golangci.yaml
│ ├── .travis.yml
│ ├── LICENSE
│ ├── README.md
│ ├── bool.go
│ ├── bool_func.go
│ ├── bool_slice.go
│ ├── bytes.go
│ ├── count.go
│ ├── duration.go
│ ├── duration_slice.go
│ ├── errors.go
│ ├── flag.go
│ ├── float32.go
│ ├── float32_slice.go
│ ├── float64.go
│ ├── float64_slice.go
│ ├── func.go
│ ├── golangflag.go
│ ├── int.go
│ ├── int16.go
│ ├── int32.go
│ ├── int32_slice.go
│ ├── int64.go
│ ├── int64_slice.go
│ ├── int8.go
│ ├── int_slice.go
│ ├── ip.go
│ ├── ip_slice.go
│ ├── ipmask.go
│ ├── ipnet.go
│ ├── ipnet_slice.go
│ ├── string.go
│ ├── string_array.go
│ ├── string_slice.go
│ ├── string_to_int.go
│ ├── string_to_int64.go
│ ├── string_to_string.go
│ ├── text.go
│ ├── time.go
│ ├── uint.go
│ ├── uint16.go
│ ├── uint32.go
│ ├── uint64.go
│ ├── uint8.go
│ └── uint_slice.go
├── go.starlark.net/
│ ├── LICENSE
│ ├── internal/
│ │ ├── compile/
│ │ │ ├── compile.go
│ │ │ └── serial.go
│ │ └── spell/
│ │ └── spell.go
│ ├── lib/
│ │ └── time/
│ │ └── time.go
│ ├── resolve/
│ │ ├── binding.go
│ │ └── resolve.go
│ ├── starlark/
│ │ ├── debug.go
│ │ ├── empty.s
│ │ ├── eval.go
│ │ ├── hashtable.go
│ │ ├── int.go
│ │ ├── int_generic.go
│ │ ├── int_posix64.go
│ │ ├── interp.go
│ │ ├── library.go
│ │ ├── profile.go
│ │ ├── unpack.go
│ │ └── value.go
│ ├── starlarkstruct/
│ │ ├── module.go
│ │ └── struct.go
│ └── syntax/
│ ├── grammar.txt
│ ├── options.go
│ ├── parse.go
│ ├── quote.go
│ ├── scan.go
│ ├── syntax.go
│ └── walk.go
├── go.yaml.in/
│ └── yaml/
│ └── v3/
│ ├── LICENSE
│ ├── NOTICE
│ ├── README.md
│ ├── apic.go
│ ├── decode.go
│ ├── emitterc.go
│ ├── encode.go
│ ├── parserc.go
│ ├── readerc.go
│ ├── resolve.go
│ ├── scannerc.go
│ ├── sorter.go
│ ├── writerc.go
│ ├── yaml.go
│ ├── yamlh.go
│ └── yamlprivateh.go
├── golang.org/
│ └── x/
│ ├── arch/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── arm64/
│ │ │ └── arm64asm/
│ │ │ ├── arg.go
│ │ │ ├── condition.go
│ │ │ ├── condition_util.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── inst.json
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ ├── loong64/
│ │ │ └── loong64asm/
│ │ │ ├── arg.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ ├── ppc64/
│ │ │ └── ppc64asm/
│ │ │ ├── decode.go
│ │ │ ├── doc.go
│ │ │ ├── field.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9.go
│ │ │ └── tables.go
│ │ ├── riscv64/
│ │ │ └── riscv64asm/
│ │ │ ├── arg.go
│ │ │ ├── csr_string.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ └── x86/
│ │ └── x86asm/
│ │ ├── Makefile
│ │ ├── decode.go
│ │ ├── gnu.go
│ │ ├── inst.go
│ │ ├── intel.go
│ │ ├── plan9x.go
│ │ └── tables.go
│ ├── exp/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── constraints/
│ │ │ └── constraints.go
│ │ ├── maps/
│ │ │ └── maps.go
│ │ └── slices/
│ │ ├── slices.go
│ │ ├── sort.go
│ │ ├── zsortfunc.go
│ │ └── zsortordered.go
│ ├── sync/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ └── errgroup/
│ │ ├── errgroup.go
│ │ ├── go120.go
│ │ └── pre_go120.go
│ ├── sys/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── unix/
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── affinity_linux.go
│ │ │ ├── aliases.go
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_bsd_386.s
│ │ │ ├── asm_bsd_amd64.s
│ │ │ ├── asm_bsd_arm.s
│ │ │ ├── asm_bsd_arm64.s
│ │ │ ├── asm_bsd_ppc64.s
│ │ │ ├── asm_bsd_riscv64.s
│ │ │ ├── asm_linux_386.s
│ │ │ ├── asm_linux_amd64.s
│ │ │ ├── asm_linux_arm.s
│ │ │ ├── asm_linux_arm64.s
│ │ │ ├── asm_linux_loong64.s
│ │ │ ├── asm_linux_mips64x.s
│ │ │ ├── asm_linux_mipsx.s
│ │ │ ├── asm_linux_ppc64x.s
│ │ │ ├── asm_linux_riscv64.s
│ │ │ ├── asm_linux_s390x.s
│ │ │ ├── asm_openbsd_mips64.s
│ │ │ ├── asm_solaris_amd64.s
│ │ │ ├── asm_zos_s390x.s
│ │ │ ├── bluetooth_linux.go
│ │ │ ├── bpxsvc_zos.go
│ │ │ ├── bpxsvc_zos.s
│ │ │ ├── cap_freebsd.go
│ │ │ ├── constants.go
│ │ │ ├── dev_aix_ppc.go
│ │ │ ├── dev_aix_ppc64.go
│ │ │ ├── dev_darwin.go
│ │ │ ├── dev_dragonfly.go
│ │ │ ├── dev_freebsd.go
│ │ │ ├── dev_linux.go
│ │ │ ├── dev_netbsd.go
│ │ │ ├── dev_openbsd.go
│ │ │ ├── dev_zos.go
│ │ │ ├── dirent.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── env_unix.go
│ │ │ ├── fcntl.go
│ │ │ ├── fcntl_darwin.go
│ │ │ ├── fcntl_linux_32bit.go
│ │ │ ├── fdset.go
│ │ │ ├── gccgo.go
│ │ │ ├── gccgo_c.c
│ │ │ ├── gccgo_linux_amd64.go
│ │ │ ├── ifreq_linux.go
│ │ │ ├── ioctl_linux.go
│ │ │ ├── ioctl_signed.go
│ │ │ ├── ioctl_unsigned.go
│ │ │ ├── ioctl_zos.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mmap_nomremap.go
│ │ │ ├── mremap.go
│ │ │ ├── pagesize_unix.go
│ │ │ ├── pledge_openbsd.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_ios.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── readdirent_getdents.go
│ │ │ ├── readdirent_getdirentries.go
│ │ │ ├── sockcmsg_dragonfly.go
│ │ │ ├── sockcmsg_linux.go
│ │ │ ├── sockcmsg_unix.go
│ │ │ ├── sockcmsg_unix_other.go
│ │ │ ├── sockcmsg_zos.go
│ │ │ ├── symaddr_zos_s390x.s
│ │ │ ├── syscall.go
│ │ │ ├── syscall_aix.go
│ │ │ ├── syscall_aix_ppc.go
│ │ │ ├── syscall_aix_ppc64.go
│ │ │ ├── syscall_bsd.go
│ │ │ ├── syscall_darwin.go
│ │ │ ├── syscall_darwin_amd64.go
│ │ │ ├── syscall_darwin_arm64.go
│ │ │ ├── syscall_darwin_libSystem.go
│ │ │ ├── syscall_dragonfly.go
│ │ │ ├── syscall_dragonfly_amd64.go
│ │ │ ├── syscall_freebsd.go
│ │ │ ├── syscall_freebsd_386.go
│ │ │ ├── syscall_freebsd_amd64.go
│ │ │ ├── syscall_freebsd_arm.go
│ │ │ ├── syscall_freebsd_arm64.go
│ │ │ ├── syscall_freebsd_riscv64.go
│ │ │ ├── syscall_hurd.go
│ │ │ ├── syscall_hurd_386.go
│ │ │ ├── syscall_illumos.go
│ │ │ ├── syscall_linux.go
│ │ │ ├── syscall_linux_386.go
│ │ │ ├── syscall_linux_alarm.go
│ │ │ ├── syscall_linux_amd64.go
│ │ │ ├── syscall_linux_amd64_gc.go
│ │ │ ├── syscall_linux_arm.go
│ │ │ ├── syscall_linux_arm64.go
│ │ │ ├── syscall_linux_gc.go
│ │ │ ├── syscall_linux_gc_386.go
│ │ │ ├── syscall_linux_gc_arm.go
│ │ │ ├── syscall_linux_gccgo_386.go
│ │ │ ├── syscall_linux_gccgo_arm.go
│ │ │ ├── syscall_linux_loong64.go
│ │ │ ├── syscall_linux_mips64x.go
│ │ │ ├── syscall_linux_mipsx.go
│ │ │ ├── syscall_linux_ppc.go
│ │ │ ├── syscall_linux_ppc64x.go
│ │ │ ├── syscall_linux_riscv64.go
│ │ │ ├── syscall_linux_s390x.go
│ │ │ ├── syscall_linux_sparc64.go
│ │ │ ├── syscall_netbsd.go
│ │ │ ├── syscall_netbsd_386.go
│ │ │ ├── syscall_netbsd_amd64.go
│ │ │ ├── syscall_netbsd_arm.go
│ │ │ ├── syscall_netbsd_arm64.go
│ │ │ ├── syscall_openbsd.go
│ │ │ ├── syscall_openbsd_386.go
│ │ │ ├── syscall_openbsd_amd64.go
│ │ │ ├── syscall_openbsd_arm.go
│ │ │ ├── syscall_openbsd_arm64.go
│ │ │ ├── syscall_openbsd_libc.go
│ │ │ ├── syscall_openbsd_mips64.go
│ │ │ ├── syscall_openbsd_ppc64.go
│ │ │ ├── syscall_openbsd_riscv64.go
│ │ │ ├── syscall_solaris.go
│ │ │ ├── syscall_solaris_amd64.go
│ │ │ ├── syscall_unix.go
│ │ │ ├── syscall_unix_gc.go
│ │ │ ├── syscall_unix_gc_ppc64x.go
│ │ │ ├── syscall_zos_s390x.go
│ │ │ ├── sysvshm_linux.go
│ │ │ ├── sysvshm_unix.go
│ │ │ ├── sysvshm_unix_other.go
│ │ │ ├── timestruct.go
│ │ │ ├── unveil_openbsd.go
│ │ │ ├── vgetrandom_linux.go
│ │ │ ├── vgetrandom_unsupported.go
│ │ │ ├── xattr_bsd.go
│ │ │ ├── zerrors_aix_ppc.go
│ │ │ ├── zerrors_aix_ppc64.go
│ │ │ ├── zerrors_darwin_amd64.go
│ │ │ ├── zerrors_darwin_arm64.go
│ │ │ ├── zerrors_dragonfly_amd64.go
│ │ │ ├── zerrors_freebsd_386.go
│ │ │ ├── zerrors_freebsd_amd64.go
│ │ │ ├── zerrors_freebsd_arm.go
│ │ │ ├── zerrors_freebsd_arm64.go
│ │ │ ├── zerrors_freebsd_riscv64.go
│ │ │ ├── zerrors_linux.go
│ │ │ ├── zerrors_linux_386.go
│ │ │ ├── zerrors_linux_amd64.go
│ │ │ ├── zerrors_linux_arm.go
│ │ │ ├── zerrors_linux_arm64.go
│ │ │ ├── zerrors_linux_loong64.go
│ │ │ ├── zerrors_linux_mips.go
│ │ │ ├── zerrors_linux_mips64.go
│ │ │ ├── zerrors_linux_mips64le.go
│ │ │ ├── zerrors_linux_mipsle.go
│ │ │ ├── zerrors_linux_ppc.go
│ │ │ ├── zerrors_linux_ppc64.go
│ │ │ ├── zerrors_linux_ppc64le.go
│ │ │ ├── zerrors_linux_riscv64.go
│ │ │ ├── zerrors_linux_s390x.go
│ │ │ ├── zerrors_linux_sparc64.go
│ │ │ ├── zerrors_netbsd_386.go
│ │ │ ├── zerrors_netbsd_amd64.go
│ │ │ ├── zerrors_netbsd_arm.go
│ │ │ ├── zerrors_netbsd_arm64.go
│ │ │ ├── zerrors_openbsd_386.go
│ │ │ ├── zerrors_openbsd_amd64.go
│ │ │ ├── zerrors_openbsd_arm.go
│ │ │ ├── zerrors_openbsd_arm64.go
│ │ │ ├── zerrors_openbsd_mips64.go
│ │ │ ├── zerrors_openbsd_ppc64.go
│ │ │ ├── zerrors_openbsd_riscv64.go
│ │ │ ├── zerrors_solaris_amd64.go
│ │ │ ├── zerrors_zos_s390x.go
│ │ │ ├── zptrace_armnn_linux.go
│ │ │ ├── zptrace_linux_arm64.go
│ │ │ ├── zptrace_mipsnn_linux.go
│ │ │ ├── zptrace_mipsnnle_linux.go
│ │ │ ├── zptrace_x86_linux.go
│ │ │ ├── zsymaddr_zos_s390x.s
│ │ │ ├── zsyscall_aix_ppc.go
│ │ │ ├── zsyscall_aix_ppc64.go
│ │ │ ├── zsyscall_aix_ppc64_gc.go
│ │ │ ├── zsyscall_aix_ppc64_gccgo.go
│ │ │ ├── zsyscall_darwin_amd64.go
│ │ │ ├── zsyscall_darwin_amd64.s
│ │ │ ├── zsyscall_darwin_arm64.go
│ │ │ ├── zsyscall_darwin_arm64.s
│ │ │ ├── zsyscall_dragonfly_amd64.go
│ │ │ ├── zsyscall_freebsd_386.go
│ │ │ ├── zsyscall_freebsd_amd64.go
│ │ │ ├── zsyscall_freebsd_arm.go
│ │ │ ├── zsyscall_freebsd_arm64.go
│ │ │ ├── zsyscall_freebsd_riscv64.go
│ │ │ ├── zsyscall_illumos_amd64.go
│ │ │ ├── zsyscall_linux.go
│ │ │ ├── zsyscall_linux_386.go
│ │ │ ├── zsyscall_linux_amd64.go
│ │ │ ├── zsyscall_linux_arm.go
│ │ │ ├── zsyscall_linux_arm64.go
│ │ │ ├── zsyscall_linux_loong64.go
│ │ │ ├── zsyscall_linux_mips.go
│ │ │ ├── zsyscall_linux_mips64.go
│ │ │ ├── zsyscall_linux_mips64le.go
│ │ │ ├── zsyscall_linux_mipsle.go
│ │ │ ├── zsyscall_linux_ppc.go
│ │ │ ├── zsyscall_linux_ppc64.go
│ │ │ ├── zsyscall_linux_ppc64le.go
│ │ │ ├── zsyscall_linux_riscv64.go
│ │ │ ├── zsyscall_linux_s390x.go
│ │ │ ├── zsyscall_linux_sparc64.go
│ │ │ ├── zsyscall_netbsd_386.go
│ │ │ ├── zsyscall_netbsd_amd64.go
│ │ │ ├── zsyscall_netbsd_arm.go
│ │ │ ├── zsyscall_netbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_386.go
│ │ │ ├── zsyscall_openbsd_386.s
│ │ │ ├── zsyscall_openbsd_amd64.go
│ │ │ ├── zsyscall_openbsd_amd64.s
│ │ │ ├── zsyscall_openbsd_arm.go
│ │ │ ├── zsyscall_openbsd_arm.s
│ │ │ ├── zsyscall_openbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_arm64.s
│ │ │ ├── zsyscall_openbsd_mips64.go
│ │ │ ├── zsyscall_openbsd_mips64.s
│ │ │ ├── zsyscall_openbsd_ppc64.go
│ │ │ ├── zsyscall_openbsd_ppc64.s
│ │ │ ├── zsyscall_openbsd_riscv64.go
│ │ │ ├── zsyscall_openbsd_riscv64.s
│ │ │ ├── zsyscall_solaris_amd64.go
│ │ │ ├── zsyscall_zos_s390x.go
│ │ │ ├── zsysctl_openbsd_386.go
│ │ │ ├── zsysctl_openbsd_amd64.go
│ │ │ ├── zsysctl_openbsd_arm.go
│ │ │ ├── zsysctl_openbsd_arm64.go
│ │ │ ├── zsysctl_openbsd_mips64.go
│ │ │ ├── zsysctl_openbsd_ppc64.go
│ │ │ ├── zsysctl_openbsd_riscv64.go
│ │ │ ├── zsysnum_darwin_amd64.go
│ │ │ ├── zsysnum_darwin_arm64.go
│ │ │ ├── zsysnum_dragonfly_amd64.go
│ │ │ ├── zsysnum_freebsd_386.go
│ │ │ ├── zsysnum_freebsd_amd64.go
│ │ │ ├── zsysnum_freebsd_arm.go
│ │ │ ├── zsysnum_freebsd_arm64.go
│ │ │ ├── zsysnum_freebsd_riscv64.go
│ │ │ ├── zsysnum_linux_386.go
│ │ │ ├── zsysnum_linux_amd64.go
│ │ │ ├── zsysnum_linux_arm.go
│ │ │ ├── zsysnum_linux_arm64.go
│ │ │ ├── zsysnum_linux_loong64.go
│ │ │ ├── zsysnum_linux_mips.go
│ │ │ ├── zsysnum_linux_mips64.go
│ │ │ ├── zsysnum_linux_mips64le.go
│ │ │ ├── zsysnum_linux_mipsle.go
│ │ │ ├── zsysnum_linux_ppc.go
│ │ │ ├── zsysnum_linux_ppc64.go
│ │ │ ├── zsysnum_linux_ppc64le.go
│ │ │ ├── zsysnum_linux_riscv64.go
│ │ │ ├── zsysnum_linux_s390x.go
│ │ │ ├── zsysnum_linux_sparc64.go
│ │ │ ├── zsysnum_netbsd_386.go
│ │ │ ├── zsysnum_netbsd_amd64.go
│ │ │ ├── zsysnum_netbsd_arm.go
│ │ │ ├── zsysnum_netbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_386.go
│ │ │ ├── zsysnum_openbsd_amd64.go
│ │ │ ├── zsysnum_openbsd_arm.go
│ │ │ ├── zsysnum_openbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_mips64.go
│ │ │ ├── zsysnum_openbsd_ppc64.go
│ │ │ ├── zsysnum_openbsd_riscv64.go
│ │ │ ├── zsysnum_zos_s390x.go
│ │ │ ├── ztypes_aix_ppc.go
│ │ │ ├── ztypes_aix_ppc64.go
│ │ │ ├── ztypes_darwin_amd64.go
│ │ │ ├── ztypes_darwin_arm64.go
│ │ │ ├── ztypes_dragonfly_amd64.go
│ │ │ ├── ztypes_freebsd_386.go
│ │ │ ├── ztypes_freebsd_amd64.go
│ │ │ ├── ztypes_freebsd_arm.go
│ │ │ ├── ztypes_freebsd_arm64.go
│ │ │ ├── ztypes_freebsd_riscv64.go
│ │ │ ├── ztypes_linux.go
│ │ │ ├── ztypes_linux_386.go
│ │ │ ├── ztypes_linux_amd64.go
│ │ │ ├── ztypes_linux_arm.go
│ │ │ ├── ztypes_linux_arm64.go
│ │ │ ├── ztypes_linux_loong64.go
│ │ │ ├── ztypes_linux_mips.go
│ │ │ ├── ztypes_linux_mips64.go
│ │ │ ├── ztypes_linux_mips64le.go
│ │ │ ├── ztypes_linux_mipsle.go
│ │ │ ├── ztypes_linux_ppc.go
│ │ │ ├── ztypes_linux_ppc64.go
│ │ │ ├── ztypes_linux_ppc64le.go
│ │ │ ├── ztypes_linux_riscv64.go
│ │ │ ├── ztypes_linux_s390x.go
│ │ │ ├── ztypes_linux_sparc64.go
│ │ │ ├── ztypes_netbsd_386.go
│ │ │ ├── ztypes_netbsd_amd64.go
│ │ │ ├── ztypes_netbsd_arm.go
│ │ │ ├── ztypes_netbsd_arm64.go
│ │ │ ├── ztypes_openbsd_386.go
│ │ │ ├── ztypes_openbsd_amd64.go
│ │ │ ├── ztypes_openbsd_arm.go
│ │ │ ├── ztypes_openbsd_arm64.go
│ │ │ ├── ztypes_openbsd_mips64.go
│ │ │ ├── ztypes_openbsd_ppc64.go
│ │ │ ├── ztypes_openbsd_riscv64.go
│ │ │ ├── ztypes_solaris_amd64.go
│ │ │ └── ztypes_zos_s390x.go
│ │ └── windows/
│ │ ├── aliases.go
│ │ ├── dll_windows.go
│ │ ├── env_windows.go
│ │ ├── eventlog.go
│ │ ├── exec_windows.go
│ │ ├── memory_windows.go
│ │ ├── mkerrors.bash
│ │ ├── mkknownfolderids.bash
│ │ ├── mksyscall.go
│ │ ├── race.go
│ │ ├── race0.go
│ │ ├── security_windows.go
│ │ ├── service.go
│ │ ├── setupapi_windows.go
│ │ ├── str.go
│ │ ├── syscall.go
│ │ ├── syscall_windows.go
│ │ ├── types_windows.go
│ │ ├── types_windows_386.go
│ │ ├── types_windows_amd64.go
│ │ ├── types_windows_arm.go
│ │ ├── types_windows_arm64.go
│ │ ├── zerrors_windows.go
│ │ ├── zknownfolderids_windows.go
│ │ └── zsyscall_windows.go
│ └── telemetry/
│ ├── .dockerignore
│ ├── .eslintrc.json
│ ├── .gitattributes
│ ├── .gitignore
│ ├── .prettierrc.json
│ ├── .stylelintrc.json
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── PATENTS
│ ├── README.md
│ ├── counter/
│ │ ├── counter.go
│ │ └── doc.go
│ ├── dir.go
│ ├── doc.go
│ ├── internal/
│ │ ├── config/
│ │ │ └── config.go
│ │ ├── configstore/
│ │ │ ├── download.go
│ │ │ └── download_windows.go
│ │ ├── counter/
│ │ │ ├── counter.go
│ │ │ ├── file.go
│ │ │ ├── parse.go
│ │ │ └── stackcounter.go
│ │ ├── crashmonitor/
│ │ │ ├── crash_go123.go
│ │ │ └── monitor.go
│ │ ├── mmap/
│ │ │ ├── mmap.go
│ │ │ ├── mmap_other.go
│ │ │ ├── mmap_unix.go
│ │ │ └── mmap_windows.go
│ │ ├── telemetry/
│ │ │ ├── dateonly.go
│ │ │ ├── dir.go
│ │ │ ├── proginfo.go
│ │ │ └── types.go
│ │ └── upload/
│ │ ├── Doc.txt
│ │ ├── date.go
│ │ ├── findwork.go
│ │ ├── reports.go
│ │ ├── run.go
│ │ └── upload.go
│ ├── mode.go
│ ├── npm
│ ├── npx
│ ├── package.json
│ ├── start.go
│ ├── start_posix.go
│ ├── start_windows.go
│ ├── tsconfig.json
│ └── types_alias.go
└── modules.txt
================================================
FILE CONTENTS
================================================
================================================
FILE: .cirrus.yml
================================================
env:
GOFLAGS: -mod=vendor
freebsd_instance:
image_family: freebsd-14-3
test_task:
install_script: pkg install -y go gcc git
test_script: make test
================================================
FILE: .gitattributes
================================================
pkg/version/version.go ident
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
================================================
FILE: .github/ISSUE_TEMPLATE/issue_template.yml
================================================
name: Bug Report
description: File a bug report.
body:
- type: input
id: delve_version
attributes:
label: What version of Delve are you using (`dlv version`)?
validations:
required: true
- type: input
id: go_version
attributes:
label: What version of Go are you using? (`go version`)?
validations:
required: true
- type: input
id: platform
attributes:
label: What operating system and processor architecture are you using?
validations:
required: true
- type: textarea
id: what
attributes:
label: Description
value: |
If this is about source listing not showing up (or breakpoints not being accepted) while running in a container please read our [FAQ](https://github.com/go-delve/delve/blob/master/Documentation/faq.md#substpath) first.
1. What did you do?
2. What did you expect to see?
3. What did you see instead?
Note: Please include any substantial examples (debug session output, stacktraces, etc) as linked gists.
================================================
FILE: .github/workflows/release.yml
================================================
name: Release
on:
push:
tags:
- 'v*'
workflow_dispatch:
inputs:
tag:
description: 'Git tag to release (e.g. v1.24.0). Required for non-dry-run releases.'
type: string
required: false
dry_run:
description: 'Dry run only (snapshot build, not published to GitHub Releases)'
type: boolean
default: true
# Cancel in-progress runs for the same ref.
concurrency:
group: "${{ github.ref }}-release"
cancel-in-progress: false
permissions:
contents: write # create GitHub Release and upload assets
id-token: write # cosign OIDC for keyless signing
jobs:
release:
runs-on: ubuntu-latest
steps:
- name: Validate tag input
if: github.event_name == 'workflow_dispatch' && inputs.dry_run == false && inputs.tag == ''
run: |
echo "::error::A tag must be specified for non-dry-run releases"
exit 1
- name: Checkout
uses: actions/checkout@v4
with:
fetch-depth: 0 # full history required for goreleaser release notes
ref: ${{ inputs.tag || github.ref }}
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version: stable
- name: Install cosign
uses: sigstore/cosign-installer@v3
- name: Run goreleaser (release)
if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && inputs.dry_run == false)
uses: goreleaser/goreleaser-action@v6
with:
version: ~> v2
args: release --clean
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
GORELEASER_CURRENT_TAG: ${{ inputs.tag || github.ref_name }}
- name: Run goreleaser (snapshot)
if: github.event_name == 'workflow_dispatch' && inputs.dry_run == true
uses: goreleaser/goreleaser-action@v6
with:
version: ~> v2
args: release --snapshot --clean
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: Upload snapshot artifacts
if: github.event_name == 'workflow_dispatch' && inputs.dry_run == true
uses: actions/upload-artifact@v4
with:
name: snapshot-dist
path: dist/
retention-days: 7
================================================
FILE: .github/workflows/test-windows-arm64.yml
================================================
name: Test Windows ARM64
on:
push:
pull_request:
branches: [master]
# Cancel existing runs if user makes another push.
concurrency:
group: "${{ github.ref }}-${{ github.workflow}}"
cancel-in-progress: ${{ github.event_name == 'pull_request' }}
jobs:
test-windows-arm64:
runs-on: windows-11-arm
timeout-minutes: 90
strategy:
fail-fast: false
matrix:
go-version: ["1.24", "1.25", "tip"]
steps:
- name: Checkout code
uses: actions/checkout@v5
- name: Run tests
run: _scripts/test_windows.ps1 -version go${{ matrix.go-version }} -arch arm64 -binDir $env:RUNNER_TOOL_CACHE
continue-on-error: ${{ matrix.go-version == 'tip' }}
================================================
FILE: .gitignore
================================================
**/*.test
.tags*
tags
.dbg_history
**/**/dlv
!cmd/dlv/
.vagrant
**/*.swp
localtests
.idea
*.iml
.teamcity/target
.vscode
.claude
dist/
================================================
FILE: .goreleaser.yaml
================================================
version: 2
project_name: dlv
before:
hooks:
- go mod download
builds:
- main: ./cmd/dlv
binary: dlv
# CGO is left at its default: enabled for native builds, automatically
# disabled by the Go toolchain when cross-compiling. This means linux/amd64
# release binaries are built with CGO on a linux/amd64 CI runner, while all
# cross-compiled targets (darwin, windows, linux/arm64, etc.) use pure Go.
goos:
- linux
- darwin
- windows
goarch:
- amd64
- arm64
- "386"
- ppc64le
ignore:
# darwin and windows only support amd64 and arm64 in this release config.
# riscv64 and loong64 are supported by Delve but excluded here because
# goreleaser cross-compilation toolchains for those targets are not yet
# available in standard CI environments.
- goos: darwin
goarch: "386"
- goos: darwin
goarch: ppc64le
- goos: windows
goarch: "386"
- goos: windows
goarch: ppc64le
ldflags:
- -X main.Build={{.FullCommit}}
archives:
- formats:
- tar.gz
format_overrides:
- goos: windows
formats:
- zip
name_template: "dlv_{{ .Version }}_{{ .Os }}_{{ .Arch }}"
checksum:
name_template: "checksums.txt"
algorithm: sha256
# Cosign keyless signing via Sigstore. Signing runs automatically in GitHub
# Actions with `id-token: write` permission — cosign v2 auto-detects the
# GitHub Actions OIDC identity. No private key or secret is required.
# To verify: cosign verify-blob --certificate <file>.cert --signature <file>.sig <file>
signs:
- cmd: cosign
certificate: "${artifact}.cert"
args:
- sign-blob
- "--output-certificate=${certificate}"
- "--output-signature=${signature}"
- "${artifact}"
- --yes
artifacts: checksum
output: true
release:
github:
owner: go-delve
name: delve
snapshot:
version_template: "{{ .Tag }}-next"
================================================
FILE: .teamcity/pom.xml
================================================
<?xml version="1.0"?>
<project>
<modelVersion>4.0.0</modelVersion>
<name>Delve Config DSL Script</name>
<groupId>Delve</groupId>
<artifactId>Delve_dsl</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.jetbrains.teamcity</groupId>
<artifactId>configs-dsl-kotlin-parent</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<repositories>
<repository>
<id>jetbrains-all</id>
<url>https://download.jetbrains.com/teamcity-repository</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
<repository>
<id>teamcity-server</id>
<url>https://delve.teamcity.com/app/dsl-plugins-repository</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>JetBrains</id>
<url>https://download.jetbrains.com/teamcity-repository</url>
</pluginRepository>
</pluginRepositories>
<build>
<sourceDirectory>${basedir}</sourceDirectory>
<plugins>
<plugin>
<artifactId>kotlin-maven-plugin</artifactId>
<groupId>org.jetbrains.kotlin</groupId>
<version>${kotlin.version}</version>
<configuration/>
<executions>
<execution>
<id>compile</id>
<phase>process-sources</phase>
<goals>
<goal>compile</goal>
</goals>
</execution>
<execution>
<id>test-compile</id>
<phase>process-test-sources</phase>
<goals>
<goal>test-compile</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.jetbrains.teamcity</groupId>
<artifactId>teamcity-configs-maven-plugin</artifactId>
<version>${teamcity.dsl.version}</version>
<configuration>
<format>kotlin</format>
<dstDir>target/generated-configs</dstDir>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.jetbrains.teamcity</groupId>
<artifactId>configs-dsl-kotlin-latest</artifactId>
<version>${teamcity.dsl.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.jetbrains.teamcity</groupId>
<artifactId>configs-dsl-kotlin-plugins-latest</artifactId>
<version>1.0-SNAPSHOT</version>
<type>pom</type>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-stdlib-jdk8</artifactId>
<version>${kotlin.version}</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.jetbrains.kotlin</groupId>
<artifactId>kotlin-script-runtime</artifactId>
<version>${kotlin.version}</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
================================================
FILE: .teamcity/settings.kts
================================================
import jetbrains.buildServer.configs.kotlin.AbsoluteId
import jetbrains.buildServer.configs.kotlin.BuildType
import jetbrains.buildServer.configs.kotlin.DslContext
import jetbrains.buildServer.configs.kotlin.Project
import jetbrains.buildServer.configs.kotlin.buildFeatures.PullRequests
import jetbrains.buildServer.configs.kotlin.buildFeatures.commitStatusPublisher
import jetbrains.buildServer.configs.kotlin.buildFeatures.golang
import jetbrains.buildServer.configs.kotlin.buildFeatures.pullRequests
import jetbrains.buildServer.configs.kotlin.buildSteps.dockerCommand
import jetbrains.buildServer.configs.kotlin.buildSteps.exec
import jetbrains.buildServer.configs.kotlin.buildSteps.powerShell
import jetbrains.buildServer.configs.kotlin.failureConditions.BuildFailureOnMetric
import jetbrains.buildServer.configs.kotlin.failureConditions.failOnMetricChange
import jetbrains.buildServer.configs.kotlin.project
import jetbrains.buildServer.configs.kotlin.triggers.schedule
import jetbrains.buildServer.configs.kotlin.triggers.vcs
import jetbrains.buildServer.configs.kotlin.version
/*
The settings script is an entry point for defining a TeamCity
project hierarchy. The script should contain a single call to the
project() function with a Project instance or an init function as
an argument.
VcsRoots, BuildTypes, Templates, and subprojects can be
registered inside the project using the vcsRoot(), buildType(),
template(), and subProject() methods respectively.
To debug settings scripts in command-line, run the
mvnDebug org.jetbrains.teamcity:teamcity-configs-maven-plugin:generate
command and attach your debugger to the port 8000.
To debug in IntelliJ Idea, open the 'Maven Projects' tool window (View
-> Tool Windows -> Maven Projects), find the generate task node
(Plugins -> teamcity-configs -> teamcity-configs:generate), the
'Debug' option is available in the context menu for the task.
*/
version = "2023.05"
val targets = arrayOf(
"linux/amd64/1.24",
"linux/amd64/1.25",
"linux/amd64/1.26",
"linux/amd64/tip",
"linux/386/1.26",
"linux/arm64/1.26",
"linux/arm64/tip",
"linux/ppc64le/1.26",
// "linux/riscv64/1.26", // needs exp.linuxriscv64 build tag, disabled due to CI issues
"windows/amd64/1.26",
"windows/amd64/tip",
"mac/amd64/1.26",
"mac/amd64/tip",
"mac/arm64/1.26",
"mac/arm64/tip"
)
project {
val tests = targets.map { target ->
val (os, arch, version) = target.split("/")
TestBuild(os, arch, version, AbsoluteId("Delve_${os}_${arch}_${version.replace('.', '_')}"))
}
tests.map { test ->
test.os
}.distinct().forEach { os ->
subProject(OSProject(os, tests.filter { test ->
test.os == os && test.version != "tip"
}))
}
subProject(TipProject(tests.filter { test ->
test.version == "tip"
}))
buildType(AggregatorBuild(tests.filter { test ->
test.version != "tip"
}))
params {
param("teamcity.ui.settings.readOnly", "true")
param("env.CI", "true")
}
}
class AggregatorBuild(tests: Collection<BuildType>) : BuildType({
name = "Aggregator"
type = Type.COMPOSITE
vcs {
root(DslContext.settingsRoot)
}
triggers {
vcs {
}
}
dependencies {
tests.forEach { test ->
snapshot(test) {
}
}
}
features {
pullRequests {
vcsRootExtId = "${DslContext.settingsRoot.id}"
provider = github {
authType = token {
token = "credentialsJSON:1312c856-0e13-4b04-8c40-ac26d4a5f700"
}
filterAuthorRole = PullRequests.GitHubRoleFilter.EVERYBODY
}
}
commitStatusPublisher {
vcsRootExtId = "${DslContext.settingsRoot.id}"
publisher = github {
githubUrl = "https://api.github.com"
authType = personalToken {
token = "credentialsJSON:1312c856-0e13-4b04-8c40-ac26d4a5f700"
}
}
param("github_oauth_user", "")
}
}
failureConditions {
executionTimeoutMin = 60
}
})
class TipProject(tests: List<TestBuild>) : Project({
id = AbsoluteId("Delve_tip")
name = "Tip"
tests.forEach { test ->
buildType(test)
}
})
class OSProject(os: String, tests: List<TestBuild>) : Project({
id = AbsoluteId("Delve_$os")
name = os.capitalize()
tests.map { test ->
test.arch
}.distinct().forEach { arch ->
subProject(ArchProject(os, arch, tests.filter { test ->
test.arch == arch
}))
}
})
class ArchProject(os: String, arch: String, tests: List<TestBuild>) : Project({
id = AbsoluteId("Delve_${os}_${arch}")
name = arch
tests.forEach { test ->
buildType(test)
}
})
class TestBuild(val os: String, val arch: String, val version: String, buildId: AbsoluteId) : BuildType({
id = buildId
name = if (version == "tip") "${os}_${arch}_tip" else version
vcs {
root(DslContext.settingsRoot)
branchFilter = if (version == "tip") {
"""
+:*
-:pull/*
""".trimIndent()
} else {
"+:*"
}
}
if (version == "tip") {
triggers {
schedule {
schedulingPolicy = daily {
hour = 23
}
withPendingChangesOnly = true
triggerBuild = always()
}
}
}
failureConditions {
executionTimeoutMin = 30
if (version != "tip") {
failOnMetricChange {
metric = BuildFailureOnMetric.MetricType.TEST_COUNT
units = BuildFailureOnMetric.MetricUnit.DEFAULT_UNIT
comparison = BuildFailureOnMetric.MetricComparison.LESS
compareTo = value()
}
}
}
steps {
when (os) {
"linux" -> {
val dockerArch = when (arch) {
"386" -> "i386"
"arm64" -> "arm64v8"
else -> {
arch
}
}
val dockerPlatformArch = when (arch) {
"arm64" -> "arm64/v8"
else -> {
dockerArch
}
}
val ubuntuVersion = when (arch) {
"riscv64" -> "24.04"
else -> "20.04"
}
dockerCommand {
name = "Pull Ubuntu"
commandType = other {
subCommand = "pull"
commandArgs = "$dockerArch/ubuntu:$ubuntuVersion"
}
}
dockerCommand {
name = "Test"
commandType = other {
subCommand = "run"
commandArgs = """
-v %teamcity.build.checkoutDir%:/delve
--env TEAMCITY_VERSION=${'$'}TEAMCITY_VERSION
--env CI=true
--privileged
--platform linux/$dockerPlatformArch
$dockerArch/ubuntu:$ubuntuVersion
/delve/_scripts/test_linux.sh ${"go$version"} $arch
""".trimIndent()
}
}
}
"windows" -> {
powerShell {
name = "Test"
scriptMode = file {
path = "_scripts/test_windows.ps1"
}
param("jetbrains_powershell_scriptArguments", "-version ${"go$version"} -arch $arch")
}
}
"mac" -> {
exec {
name = "Test"
path = "_scripts/test_mac.sh"
arguments = "${"go$version"} $arch %system.teamcity.build.tempDir%"
}
}
}
}
requirements {
when (arch) {
"386", "amd64" -> equals("teamcity.agent.jvm.os.arch", if (os == "mac") "x86_64" else "amd64")
"arm64" -> equals("teamcity.agent.jvm.os.arch", "aarch64")
"ppc64le" -> equals("teamcity.agent.jvm.os.arch", "ppc64le")
"riscv64" -> equals("teamcity.agent.jvm.os.arch", "riscv64")
"loong64" -> equals("teamcity.agent.jvm.os.arch", "loongarch64")
}
when (os) {
"linux" -> {
matches("teamcity.agent.jvm.os.family", "Linux")
}
"windows" -> {
matches("teamcity.agent.jvm.os.family", "Windows")
}
"mac" -> {
matches("teamcity.agent.jvm.os.family", "Mac OS")
}
}
}
features {
pullRequests {
vcsRootExtId = "${DslContext.settingsRoot.id}"
provider = github {
authType = token {
token = "credentialsJSON:1312c856-0e13-4b04-8c40-ac26d4a5f700"
}
filterAuthorRole = PullRequests.GitHubRoleFilter.EVERYBODY
}
}
golang {
testFormat = "json"
}
}
})
================================================
FILE: CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
This project adheres to Semantic Versioning.
## [1.26.1] 2026-03-03
### Added
- Support for debugging stripped non-Go binaries (#4263, @derekparker)
- Package for detecting debugger attachment (#4258, @derekparker)
- Starlark `append_file` built-in function (#4252, @sding3)
- DAP: Hit conditional breakpoint capability (#4230, @DrSergei)
- Detection and warning about trimpath (#4241, @aarzilli)
### Fixed
- Fix debuginfod download progress (#4270, @aarzilli)
- Fix sigpanics in swiss map iterator (#4261, @derekparker)
- Fix finding moduledata in Go 1.26+ (#4228, @derekparker)
- Fix goroutine leak and shutdown sequence for eBPF backend (#4231, @derekparker)
- Fix eBPF uprobe placement to skip function prologue (#4249, @derekparker)
- Fix `ProducerAfterOrEqual` comparison for devel builds (#4234, @typesanitizer)
- DAP: Better error messages when debugger can't be launched (#4264, @aarzilli)
- DAP: Reject most requests before launch/attach (#4240, @aarzilli)
- Propagate short type option when printing structs (#4235, @igadmg)
- Better error if process is already being debugged (#4242, @aarzilli)
- Print error when request body can't be decoded (#4247, @aarzilli)
- Parse rc version with trailing suffix (#4255, @alexsaezm)
### Changed
- Migrate from gopkg.in/yaml.v3 to go.yaml.in/yaml/v3 (#4257, @scop)
- Update waitReason switch for Go 1.27 (#4244, @typesanitizer)
- Downgrade riscv64 support (#4232, @derekparker)
- Miscellaneous code quality improvements (#4221, #4226, #4259, #4262, #4224, @derekparker, @aarzilli)
- Miscellaneous improvements to tests, documentation, and build configuration (#4250, #4254, #4248, #4265, @derekparker, @aarzilli, @stack1ng)
## [1.26.0] 2025-12-18
### Added
- Go 1.26 support (#4211, #4205, #4212, #4217, @aarzilli)
- Savestate command for terminal (#4045, @alexsaezm)
- DAP: Target command and follow-exec support (#4078, @Lslightly)
- DAP: Read memory request handler (#4083, @MistaTwista)
- DAP: Input/output redirection (#4178, @aarzilli)
- DAP: Suspended breakpoints support (#4075, @firelizzard18)
- DAP: Use exception breakpoints for predefined breakpoints (#4169, @aarzilli)
- Custom starlark commands can be used with on prefix (#4170, @derekparker)
- Shortcut syntax to access target variables in starlark (#4134, @aarzilli)
- Support for tracing defer function calls with follow option (#3978, @archanaravindar)
- Flag to retain trace directory after detach (#4091, @archanaravindar)
- Ability to cancel debuginfod downloads (#4123, @aarzilli)
- Process spawned event (#4171, @firelizzard18)
- Materialized breakpoint event for follow-exec mode (#4161, @aarzilli)
- Way to disable stop-on-error for breakpoint conditions (#4191, @aarzilli)
- Function call support on loong64 (#4114, @yelvens)
- Build argument logging (#4185, @pedia)
- Capslock check (#4106, @derekparker)
### Fixed
- DAP: Restart handling when compilation fails (#4215, @aarzilli)
- DAP: Disable string() field for address-less variables (#4214, @aarzilli)
- DAP: Race condition in tests (#4121, @derekparker)
- Gdbserial: Do not set detached if we kill the process (#4216, @aarzilli)
- Prevent trace killing attached process (#4164, @alex-emery)
- Trace /regexp/ should set ret breakpoints correctly (#4130, @aarzilli)
- Replay subcommand must keep trace directory (#4184, @lwintermelon)
- Nil pointer dereference when calling extra on a nil func (#4174, @aarzilli)
- Check that breakpoint exists in ClearBreakpoint (#4141, @aarzilli)
- Use address in ClearBreakpoint only when ID is 0 (#4168, @aarzilli)
- Return error when calling a non-ptr receiver method on a nil ptr (#4139, @aarzilli)
- Additional checks parsing g structs (#4140, @aarzilli)
- Remember that we attached in WaitFor attach mode (#4120, @aarzilli)
- Guard register logging from nil pointer dereferences (#4188, @aarzilli)
- Do not insist stmt is same line as entry in DWARF (#4186, @derekparker)
- Fix wait reason string table (#4182, @aarzilli)
- Workaround for non-unicode strings in Variables (#4082, @aarzilli)
- Fix ppc64le clause in support_sentinel_linux.go (#4129, @tshah14)
- Improve frame unwind context handling on loong64 (#4133, @yelvens)
### Changed
- Replace hashicorp/golang-lru with custom lru cache (#4196, @qmuntal)
- Update riscv64 support and add to test matrix (#4190, @lrzlin)
- Update riscv64 capslock file (#4210, @derekparker)
- Move things that use x/tools/go/packages to new repo (#3990, @aarzilli)
- Remove experimental build tags for Windows ARM64 (#4176, @gdams)
- Add Windows ARM64 workflow to CI (#4175, @gdams)
- Add linux/loong64 to TeamCity configuration (#4154, @yelvens)
- Set CI=true on a project level (#4156, @vietage)
- Hierarchical search for structMember or method (#4118, @wenxuan70)
- Update trie to v3.2.0 (#4131, @derekparker)
- Parallelize tests where possible (#4115, @derekparker)
- Modernize codebase with newer syntax and helpers (#4110, @derekparker)
- Miscellaneous improvements to tests and build configuration (#4096, #4135, #4145, #4157, #4163, #4198, #4202, #4111, #4122, #4124, #4209, @derekparker, @aarzilli)
- Miscellaneous code refactoring (#4159, #4173, #4201, @aarzilli)
## [1.25.2] 2025-08-26
### Added
* Added notifications for debuginfod downloads (#3980, @aarzilli)
### Fixed
* Fixed restart behavior of DAP server (#4068, @derekparker)
* Various fixes for loong64 backend (#4095, #4100, @yelvens)
* Miscellaneous minor bug fixes (#4067, #4090, #4089, @aarzilli)
### Changed
* Miscellaneous code quality improvements (#4088, @cui)
## [1.25.1] 2025-07-18
### Added
- Implement restart request for DAP (#4057, @derekparker)
### Fixed
- Fixed panic when trying to stacktrace an unreadable goroutine in DAP (#4056, @aarzilli)
- Fixed panic when trying to access value of unreadable string variables in DAP (#4055, @aarzilli)
- Fixed type cast between slices with the same element type (#4048, @aarzilli)
- Fixed closure captured variables visibility on closure's first line (#4049, @aarzilli)
- Fixed unknown DWARF opcodes causing panics (#4037, @aarzilli)
- Added missing response body close in DAP test (#4039, @alexandear)
- Fix panic in switchToGoroutineStacktrace (#4043, @derekparker)
### Changed
- Handle moving of direct interface flag in Go 1.26 (#4032, @randall77)
- Simplified tests using slices.Contains (#4040, @alexandear)
- Updated Go max support minor version and update golang.org/x/tools (#4046, @derekparker)
## [1.25.0] 2025-04-16
### Added
- Go 1.25 support (#4014, @aarzilli) (more work went into the 1.24.2 and earlier releases)
### Fixed
- Fixed several panics found via telemetry (#4026, #4018, #4017, #4015 @aarzilli)
- Fixed git hash in version output (#3987, @codeaucafe)
- Fix development version parsing (#3999, @aarzilli)
- Fix call injection in newer macOS versions (#3988, @aarzilli)
- Fix typo in goroutines help output (#4024, @jersey1dev)
### Changed
- Internal breakpoints (panic, throw) are excluded from DAP response (#4027, @ConradIrwin)
## [1.24.2] 2025-04-10
### Added
- Support for struct literals in expression evaluator (#3935, #3953, @aarzilli)
- Check to reject DWARFv5 executables if delve itself isn't built with 1.25 or later due to bugs in Go's standard library prior to 1.25 (#3943, #3961, @aarzilli)
### Fixed
- Support for macOS Sequoia 15.4 (#3966, @aarzilli)
- Race conditions with rr backend (#3971, #3973, #3963, @BronzeDeer, @aarzilli)
- Goroutine load with corrupted label maps (#3968, #3962, @hongyuh-hh)
- Breakpoint conditions on suspended breakpoints (#3938, @Lslightly)
### Changed
- Miscellaneous test and documentation fixes (#3979, #3952, #3954, #3955, #3951, @alexandear, @codesoap, @derekparker)
## [1.24.1] 2025-03-05
### Added
- Support for linux/loong64 in native backend (#3892, @yelvens)
- Support for watchpoints on interface values (#3922, #3924, @derekparker)
- Improved support for DWARFv5 (#3893, @aarzilli)
- Telemetry stack counters for internal errors (#3930, @aarzilli)
- Support for zed editor and allow args in DELVE_EDITOR (#3899, @derekparker)
### Fixed
- Fix uprobe address in ebpf implementation (#3894, @3u13r)
- Provide process events after launch in DAP (#3902, @shaunduncan)
- Use rr version to determine style of qRRCmd (#3921, @aarzilli)
- Better error message for breakpoints on stripped binaries (#3914, @aarzilli)
- Switch to goroutine stack if no progress on thread stack (#3898, @aarzilli)
- Handle wider registers in test (#3929, @derekparker)
### Changed
- Replace logrus with log/slog (#3918, @aarzilli)
- Remove uses of reflect.MethodByName from all of Delve (#3916, @aarzilli)
- Refactor sort.Sort to slices.SortFunc (#3880, @alexandear)
- Allow access to thread registers after a function call (#3908, @aarzilli)
- Remove riscv64 from TeamCity configuration (#3912, @aarzilli)
## [1.24.0] 2024-12-18
### Added
- Support for Go 1.24, particularly the new swiss table map implementation (#3882, #3879, #3838, @aarzilli)
- Import go telemetry and enable crash reporting (#3841, @hyangah)
- Enable stepping into coroutine (#3791, @aarzilli)
- Add raw examinemem dump (#3721, @aarzilli)
- Add linux-riscv64 support (experimental) (#3785, @lrzlin)
- Automatically guessing substitute-path config (#3781, @aarzilli)
- Print a message when the debuggee process exits while Delve in headless mode (#3870, @jakejx)
- Allow accessing closure captured variable as if they were struct fields (#3866, @aarzilli)
- Add dape to list of plugins (#3817, @jgarte)
### Fixed
- Fix step stuttering when entering range-over-func bodies (#3788, @aarzilli)
- Fix formatting of autogenerated documentation (#3836, @aarzilli)
- Fix issue on Windows when launching process while detached (#3867, @aarzilli)
- Fix handling of unsatisfiable breakpoints during restart (#3868, @aarzilli)
### Changed
- Update 'client-addr' to support Unix domain sockets (#3819, @n1lesh)
- Adds pointer pinning to call injection, improving function calls during debug session (#3787, @aarzilli)
- Allow modification of starlark structs returned by API (#3872, @aarzilli)
- API V1 has been removed following the deprecation from last version (#3881, @aarzilli)
## [1.23.1] 2024-09-23
Telemetry notice: starting with version 1.24.0 Delve will begin collecting opt-in telemetry data using the same mechanism used by the toolchain, see <https://github.com/golang/go/issues/68384>, <https://go.dev/doc/telemetry#background>, <https://github.com/go-delve/delve/issues/3815>.
### Fixed
- Debugging on macOS Sequoia (#3799, @aarzilli)
- Various bugs with range-over-func loops (#3808, #3788, @aarzilli)
- Reslice operator did not allow reslicing up to the slice's cap (#3796, @Jille)
- Starlark access to named constants (#3802, @arvidfm)
## [1.23.0] 2024-07-16
Deprecation notice: starting with the next version of Delve version 1 of the API will be removed. Version 2 was added in version 0.12.0 in 2017 and has been the recommended way to connect to Delve since.
### Added
- Support for Go 1.23, particularly the new range-over-func statement (#3663, #3697, #3736, #3738, #3750, #3755, #3763, #3778, @aarzilli)
- `next-instruction` command (#3671, @derekparker)
- Support reading captured variables of closure functions (#3682, @aarzilli)
- Breakpoint command `break` now allows adding a condition the a breakpoint with a postfix notation (`break <name> <locspec> if <condition>`) (#3693, #3702, @derekparker)
- When the `step` command is executed on `go funccall()` statements it will stop on the newly created goroutine (#3686, @aarzilli)
- Invocation of [rr](https://github.com/rr-debugger/rr/) when it is used as a backend can be now controlled with environment variables `$DELVE_RR_RECORD_FLAGS` and `$DELVE_RR_REPLAY_FLAGS` (#3726, @aarzilli)
- Added new suboption `--follow-calls` to trace command (#3594, @archanaravindar)
### Fixed
- Better behavior on stripped files (#3678, #3695, @aarzilli, @derekparker)
- Support rr version 5.7.0 and later (#3705, #3718, @howardjohn, @aarzilli)
- Watchpoints on newer versions of macOS (#3703, @derekparker)
- Bug related to watchpoints going out of scope (#3742, @aarzilli)
- Bug invoking debuginfod-find (#3762, @derekparker)
- Miscellaneus fixes (#3707, #3761, #3759, #3767, @scop, @jayantxie, @aarzilli, @zdyj3170101136)
### Changed
- Improved auto-completions for shells (#3696, #3699, @scop)
- Print more informations on tracepoint stops (#3675, #3712, @derekparker, @archanaravindar)
- Improved performance of the default macOS backend (#3715, @derekparker)
- When a breakpoint is hit on a headless instance of Delve while no clients are connected a message will be printed to stdout (#3632,#3747, @fatanugraha, @aarzilli)
- Miscellaneous code and documentation improvements (#3676, #3677, #3698, #3716, #3727, #3722, #3730, #3731, #3753, #3752, #3756, #3757, #3741, #3773, #3775, #3770, #3769, #3772, #3779, #3774, @alexandear, @aarzilli, @abbasudo, @jayantxie)
## [1.22.1] 2024-02-21
### Added
- `--listen` and `connect` now support Unix Domain Sockets (#3655, ##3658, @aarzilli)
- Paging for commands `print`, `vars`, `args` and `locals` (#3620, @aarzilli)
- Syntax highlighting for stacktraces and options to change the color of Delve's prompt (#3649, #3648, @aarzilli)
- Wait-for option for DAP's attach mode (#3656, @muggle-nil)
### Fixed
- Bug where Ctrl-Z was not sent to other processes in the same group as Delve (#3619, @aarzilli)
- Parsing of `/proc/net/tcp` when it has 10000 or more entries (#3660, @michaelmerg)
- Rare error when valuating expressions containing `runtime.frame(n)` inside breakpoint conditions (#3624, @aarzilli)
- Line number reported for the stack frame that caused a panic (#3638, @aarzilli)
- Building when dlv's executable already exists on macOS with a signing key already installed (#3639, @ardnew)
### Changed
- When evaluating an expression containing a reslice operation with constant bounds the entire resulting slice will be loaded (#3623, @aarzilli)
## [1.22.0] 2023-12-29
### Added
- Support for Go 1.22 (#3583, @aarzilli)
- Support for min and max builtins (#3530, @aarzilli)
- Expression evaluator can now reference previous frames (#3534, @derekparker)
- Better support for stripped binaries (#3549, #3577, #3597, @derekparker)
- Remove package paths from types returned by DAP (#3535, @stefanhaller)
- Show pprof labels in DAP (#3501, @stefanhaller)
### Fixed
- Fixes for signal routing with debugserver (#3541, @aarzilli)
- Clear substitute path rules cache every time the `config` command is used (#3567, @aarzilli)
- Fixes handling of hardcoded breakpoints after a manual stop (#3582, @aarzilli)
- Occasional close on closed channel panic in DAP (#3573, @aarzilli)
- Correctly reports exit code on Linux when a we receive a signal close to the program's exit (#3585, @aarzilli)
### Changed
- Type casts from slice to string and vice versa will now use the load configuration for the target type, which is more intuitive (#3596, @aarzilli)
- Miscellaneous improvements to documentation (#3531, #3555, #3556, #3562, #3564, #3575, #3576, @alexandear, @testwill)
## [1.21.2] 2023-10-30
### Added
- DAP: add concrete type to interface type (@suzmue, #3510)
- Support for VSCode in the edit command (@derekparker, #3524)
- Follow-mode support for Windows (@aarzilli, #3507)
### Fixed
- Fix bugs handling stdout/stderr in DAP (@hyangah, #3522)
- Fix bug with autogenerated wrappers for methods of generic types (@aarzilli, #3528)
### Changed
- Use Cgo instead of C code in the FreeBSD backend (@4a6f656c, #3529)
- Remove obsolete build tags (+build) (@alexandear, #3513)
## [1.21.1] 2023-10-3
### Added
- Support for linux/ppc64le (@alexsaezm)
- Enable debugging stripped mach-o (MacOS) binaries (@pgavlin)
- Enable function call injection for linux/ppc64le (@archanaravindar)
- Improved support for editors in 'edit' command (@derekparker)
- Early 1.22 support (@aarzilli)
- Add 'packages' command to list packages in compiled binary (@hyangah)
- Support debugging PIE binaries on linux/ppc64le (@archanaravindar)
- Add ability to list goroutines waiting on channel (@aarzilli)
- Add support for more argument / return type parsing in ebpf tracing backend (@derekparker)
- Add waitfor option to 'attach' command (@aarzilli)
### Fixed
- Fix memory leak in native Darwin backend CGO usage (@thechampagne)
- Fix hexadecimal printing of variables with symbolic const values (@aarzilli)
- Handle ctrl-c during tracing executing (@derekparker)
- Use a stack for restore/remember opcodes in DWARF CFI (@javierhonduco)
- Pass user specified '-C' argument first in gobuild flags (@aarzilli)
- Fix stacktraces on freebsd/amd64/go1.20 (@aarzilli)
- Fix PIE support on macOS (@aarzilli)
- Fix starlark slice unmarshaling (@andreimatei)
- Restore breakpoints set with line offsets on restart (@aarzilli)
- Check recursion level when printing pointers (@aarzilli)
- Fix FrameDescriptionEntries' append bug removing duplicates (@gocurr)
- Read context from sigtrampgo fixing cgo stack traces on 1.21 (@aarzilli)
### Changed
- Replace deprecated io/ioutil usage (@alexandear)
- Accept string list as launch requests buildFlags in DAP server (@hyangah)
- Strip package paths from symbols in callstack in DAP response (@stefanhaller)
- Update cilium/ebpf package (@aarzilli)
## [1.21.0] 2023-06-23
### Added
- Go 1.21 support (#3370, #3401, @aarzilli)
- Basic debug functionality for stripped executables (#3408, #3421, @derekparker)
- Core dumping on FreeBSD (#3305, @aarzilli)
- Ability to automatically attach to child processes when they are spawned (linux-only) (#3286, #3346, @aarzilli)
- Starlark scripts can now use the time module (#3375, @andreimatei)
- Online help for starlark interpreter (#3388, @aarzilli)
- `dlv trace` has a new option, `--timestamp`, that prints timestamps before every trace event (#3358, @spacewander)
### Fixed
- Stepping could hide normal breakpoint hits occurring simultaneously, in rare circumstances (#3287, @aarzilli)
- Internal error when defer locations can not be resolved (#3329, @aarzilli)
- Channels of certain types could be displayed incorrectly (#3362, @aarzilli)
- Formatted time wouldn't always be displayed when using DAP (#3349, @suzmue)
- Function call injection when parameters are in registers (#3365, @ZekeLu)
- Panic in Starlark interface when using partially loaded variables (#3386, @andreimatei)
- Use debug info directories configuration in `dlv trace` (#3405, @nozzy123nozzy)
- Updated DAP version (#3414, @suzmue)
### Changed
- Improved eBPF tracepoints (#3325, #3353, #3417, @chenhengqi, @derekparker)
- The name of the default output binary is now randomizes, which fixes some weird behavior when multiple instances of Delve are run simultaneously in the same directory (#3366, @aarzilli)
- Stderr of debuginfod-find is now suppressed (#3381, @fche)
- Better documentation for substitute-path (#3335, @aarzilli)
- `quit -c` will ask for confirmation when breakpoints still exist (#3398, @aarzilli)
- Miscellaneous improvements to documentation and tests (#3326, #3327, #3340, #3341, #3357, #3378, #3376, #3399, #3374, #3426, @alexandear, @cuishuang, @alexsaezm, @andreimatei)
## [1.20.2] 2023-04-05
### Added
- New flag --rr-onprocess-pid to replay command (#3281, @jcpowermac)
- Added documentation for watching arbitrary address (#3268, @felixge)
- Allow extracting a DWARF entry field (#3258, @brancz)
- Add SetLoggerFactory to terminal/logflags package (#3257, @blaubaer)
- New config option for tab printing when printing source code (#3243, @thockin)
- Added documentation for debugging Go runtime with Delve (#3234, @aarzilli)
### Fixed
- Fix printing boolean values in Starlark scripts (#3314, @vitalif)
- Fix infinite recursion in escapeCheck (#3311, @aarzilli)
- Support multiple functions with same name (#3297, @aarzilli)
- Handle end_seq in dwarf/line correctly (#3277, @derekparker)
- Fix calls into SYS_PROCESS_VM_READV/WRITEV syscalls (#3273, @aarzilli)
- Fix exit status for trace subcommand (#3263, @derekparker)
- Fix stripping DYLD_INSERT_LIBRARIES on macOS (#3245, @aviramha)
- Fix handling of list colors via config (#3240, @derekparker)
- Fixes to FreeBSD backend (#3224, @aarzilli)
### Changed
- Add limit to maximum time.Time we try and format (#3294, @aarzilli)
- Add fuzzing tests to expression evaluator and variable loader (#3293, @aarzilli)
- Removed some support for Go 1.12 and earlier (#3271, @aarzilli)
- Moved util functions to dwarf package (#3252, @alexandear)
- Attempt to load DW_AT_specification if present (#3247, @brancz)
- Match go test behavior when dlv test gets list of go files (#3232, @aarzilli)
- Populate Value field in pointer Variable (#3229, @andreimatei)
## [1.20.1] 2022-12-12
### Fixed
- Fix executing programs on macOS with most versions of debugserver installed (#3211, @aarzilli)
## [1.20.0] 2022-12-07
### Added
- Support for Go 1.20 (#3129, #3196, #3180, @cuiweixie, @qmuntal, @aarzilli)
- Support for Windows/arm64 (gated by a build tag) (#3063, #3198, #3200, @qmuntal)
- Compatibility with coredumpctl (#3195, @Foxboron)
### Fixed
- Improve evaluation of type casts (#3146, #3149, #3186, @aarzilli)
- DAP: Added type to response of EvaluateRequest (#3172, @gfszr)
- Cgo stacktraces on linux/arm64 (#3192, @derekparker)
- Debugserver crashes on recent versions of macOS when $DYLD_INSERT_LIBRARIES is set (#3181, @aviramha)
- Stacktraces and stepping on Go 1.19.2 and later on macOS (#3204, @aarzilli)
- Attaching to processes used by a different user on Windows (#3162, @aarzilli)
- Nil pointer dereference when current address is not part of a function (#3157, @aarzilli)
### Changed
- Change behavior of exec command so that it looks for the executable in the current directory (#3167, @derekparker)
- DAP shows full value when evaluating log messages (#3141, @suzmue)
- Wait time is no longer reported for parked goroutines (its value was always incorrect) (#3139, @aarzilli)
- Miscellaneous improvements to documentation and error messages (#3119, #3117, #3154, #3161, #3169, #3188, @aarzilli, @derekparker, @cuishuang, @Frederick888, @dlipovetsky)
## [1.9.1] 2022-08-23
### Added
- Add support for empty string in substitutePath (@RuijieC-dev)
- Support gnu_debuglink section (@aarzilli)
- Support exact matches in SubstitutePath (@eandre)
- Add ability to show disassembly instead of source code (@aarzilli)
- Add -per-g-hitcount to breakpoint conditions (@yangxikun)
### Fixed
- Ensure breakpoint map exists (@aarzilli)
- Use standard library to compute CRC for gnu_debuglink section (@aarzilli)
- Fix command to download Go version in CI (@derekparker)
- Do not panic reading bad G struct (@aarzilli)
- Fix parsing DWARFv5 file table (@derekparker)
- Improve trace subcommand output (@derekparker)
- Fix documentation for examinemem (@aarzilli)
- Fix step instruction on 1 byte instruction with software breakpoint (@qmuntal)
- Fix handling of function entry / return in ebpf tracing backend (@derekparker)
- Fix size of ebpf type for fn_addr (@derekparker)
### Changed
- Send large terminal output to pager (@aarzilli)
- Refactor windows backend framework (@qmuntal)
- Complete the dropping of CGO dependency for ebpf backend (@aarzilli)
- Limit disassembly range in DAP backend (@aarzilli)
## [1.9.0] 2022-07-06
### Added
- Support for Go 1.19 (#3038, #3031, #3009, @aarzilli)
- Autocomplete for local variables (#3004, @pippolo84)
- Support for function call injection on arm64 (#2996, @aarzilli)
### Fixed
- Ctrl-C handling on Windows (#3039, @aarzilli)
- Expressions accessing maps with string literals (#3036, @aarzilli)
- Occasional crash caused by race between manual stop and normal stop on macOS (#3021, @aarzilli)
- Pretty-print of register components (#3022, @aarzilli)
- Misc function call injection bugs (#3007, #3002, #3000, @aarzilli)
### Changed
- Improved FreeBSD port (#3019, #2972, #2981, #2982, @4a6f656c)
- Misc test fixes (#3011, #2995, #2979, @polinasok, @aarzilli)
- Misc documentation changes (#2998, #2991, @aarzilli, @polinasok)
- Better autogenerated function skip (#2975, @aarzilli)
## [1.8.3] 2022-04-25
### Added
- Pretty-print time.Time variables (@aarzilli)
- Better "could not open debug info" errors (@polinasok)
- DAP: Support --disable-aslr (@polinasok)
- DAP interface documentation improvements (@polinasok)
- CLI documentation improvements (@derekparker, @deathiop)
### Fixed
- DAP: offer disconnect/stop options for attach mode only (@polinasok)
- Fix godoc comments (@hitzhangjie)
- Allow low index == len in reslice expressions (@aarzilli)
- Fix leaky process when failing to debug stripped binaries in headless mode (@polinasok)
- Skip stepping into autogenerated functions for go1.18 (@aarzilli)
### Changed
- Drop support for building on Go < 1.10 (@aarzilli)
## [1.8.2] 2022-03-07
### Added
- Add '-clear' option for 'condition' command (@chainhelen)
- Support ctrl-Z for shell job control (@derekparker)
### Fixed
- Improve handling of hard coded breakpoints (@aarzilli)
- Better error messages for ambiguous function calls / type casts (@aarzilli)
- Fix crash when trying to open separate debug info (@aarzilli)
- Handle non-install dev tools on osx (@zchee)
### Changed
- Downgrade loadBuildID error to warning (@aarzilli)
- Require go-delve/liner in go.mod file instead of upstream version (@hyanhag)
## [1.8.1] 2022-02-07
### Added
- Downloading source code listings with debuginfod (@Foxboron)
- Added `transcript` command (@aarzilli)
- Enabled `dump` command on windows (@aarzilli)
- Env attribute in DAP launch requests (@hyangah)
- Better documentation for the DAP interface (@polinasok)
### Fixed
- Require argument for trace subcommand (@derekparker)
- Handling of inlined calls within inlined calls (@derekparker)
- Handling of DW_AT_inline attribute (@aarzilli)
- Set stop reason in StepInstruction (@suzmue)
### Changed
- The DAP interface will not create executables in the temp directory (@hyangah)
- When the `goroutines` command looks for the user frame it will exclude frames in internal and runtime/internal in addition to private runtime functions (@aarzilli)
- Breakpoints with hitcount conditions are automatically disabled when their condition can no longer be satisfied (@pippolo84)
- The commands `break` and `trace` will set a breakpoint on the current line if no argument is specified (@thockin)
- Miscellaneous documentation improvements (@chainhelen, @gareth-rees, @polinasok)
## [1.8.0] 2021-12-23
### Added
* Go 1.18 support
* Support for DWARF5 on Windows/MacOS (@aarzilli)
* Added more installation instructions to documentation (@polinasok)
* Allow for rewind to work after process exit with RR backend (@aarzilli)
* Added documentation on runtime.curg and runtime.frameoff in eval (@aarzilli)
* DAP: Expose sources command in evaluate request (@suzmue)
* DAP: Support Goroutine filters (@suzmue)
### Fixed
* Fix build version using buildinfo (@aarzilli)
* Fix crash when using deferred with no args (@kaddy-tom)
* DAP: Misc remote attach improvements (@polinasok)
### Changed
* Misc cleanup and refactoring (@aarzilli)
* Added option to disable invoking git during build (@herbygillot)
* Ignore 'pf' mappings during core dump creation (@aarzilli)
## [1.7.3] 2021-11-16
### Added
* Misc changes to prepare for Go 1.18 and generics (#2703, @2745, @aarzilli)
* Watchpoint support (disabled on Windows) (#2651, #2659, #2667, #2769, @aarzilli)
* Warn about listening to remote connections (#2721, @aarzilli)
* Support call injection with rr backend (#2740, @aarzilli)
* Support JSON-RPC and DAP on the same port from 'dlv debug/exec/test/attach' (#2755, @polinasok)
* DAP: Remote attach support (#2709, @polinasok)
* DAP: Multi-client support (#2731, #2737, #2781, @polinasok)
* DAP: Logpoints support (#2634, #2730, #2747, #2748, @suzmue)
* DAP: Disassembly view support (#2713, #2716, #2728, #2742, @suzmue)
* DAP: Support dlvCwd and use a temp file as default debug binary (#2660, #2734, @hyangah, @polinasok)
* DAP: Auto-resume execution when setting breakpoints while running (#2726, @suzmue)
* DAP: Add --client-addr flag to run dap with a predefined client (#2568, @hyangah)
* DAP: Log parsed and applied launch configs (#2732, @polinasok)
* DAP: Add option to hide system goroutines (#2743, @suzmue)
* DAP: Add support for special 'config' expressions (#2750, @suzmue)
### Fixed
* Return correct exit status from Halt command (#2674, @suzmue)
* Merge register data before writing to register (#2699, @mknyszek)
* Do not assign temp breakpoint IDs to avoid conflicts with user breakpoints (#2650, @aarzilli)
* Miscellaneous fixes for Windows native backend (#2736, @aarzilli)
* Return error when assigning between function variables (#2692, @aarzilli)
* Obey logflags config for LoadConfig warnings (#2701, @aarzilli, @suzmue)
* Workaround for debugserver register set bug (#2770, @aarzilli)
* DAP: Fix nil dereference when byte array cannot be converted to string (#2733, @polinasok)
* DAP: Fix data race for noDebugProcess.ProcessState (#2735, @polinasok)
### Changed
* Refine handling of version-too-old errors (#2684, #2712, @polinasok, @yang-wei)
* eBPF tracing backend return value parsing (#2704, @derekparker)
* Replace libbpfgo with cilium/ebpf (##2771, @derekparker)
* DAP: Merge Arguments and Locals scopes (#2717, @suzmue)
* DAP: Refine launch/attach error visibility (#2671, @polinasok)
* DAP: Server refactoring to separate listener and client session layers (#2729, @polinasok)
* DAP: Improve shutdown logic and test coverage (#2749, @polinasok)
## [1.7.2] 2021-09-21
### Added
* Documentation: Add notes on porting Delve to other architectures (@aarzilli)
* Add internal checks to ensure we're synched with Go runtime internals (@aarzilli)
* eBPF backend can parse goroutine info (@derekparker)
* Add support for debuginfo-find (@derekparker)
* Add MAKE arguments for GOOS / GOARCH (@cmol)
### Fixed
* Correctly check for 1.17 and regabi (@aarzilli)
* Print config output strings quoted (@aarzilli, @krobelus)
* Update check for system goroutines (@suzmue)
* DAP: Halt before detach in Stop (@polinasok)
* DAP: Do not send halt request if debuggee is not running (@suzmue)
### Changed
* Include selected goroutine in threads request (@suzmue)
* Remove individual OS install instructions (@gabriel-vasile)
* DAP: Show decimal / hex values for uint (@suzmue)
* Avoid bright colors in default syntax highlighting (@krobelus)
## [1.7.1] 2021-08-18
### Added
- *EXPERIMENTAL* Added support for eBPF based trace backend (@derekparker)
- Added fuzzy completion for the CLI for commands and breakpoint locations (@derekparker)
- Added stack watchpoints (@aarzilli)
- Added verbose version output (@hyangah)
- DAP: Support for replay and core modes (@Iggomez)
- DAP: Added ability to page stack frames (@suzmue)
- DAP: Added len as metadata for maps (@suzmue)
- DAP: Add 'backend' launch/attach attribute (@polinasok)
### Fixed
- Fix handling of runtime throws (@derekparker)
- DAP: Handle unexpected debugger termination (@polinasok)
### Changed
- Added configuration for Target to not clear stepping breakpoints (@suzmue)
- Ignore existing breakpoints for continue-until (@derekparker)
- Improve help output for examinemem (@derekparker)
- Clarify next-while-nexting error (@suzmue)
- DWARF improvements for additional opcodes (@aarzilli)
- Treat SIGTERM as server disconnect signal (@polinasok)
- Update Cobra lib to v1.1.3 (@hyangah)
- Improvements to 'on' command (@aarzilli)
- Terminal will now prompt when breakpoint is hit during next/step/stepout (@aarzilli)
- DAP: Ensure server is always headless and target foregrounded (@polinasok)
- DAP: Set hit breakpoint IDs (@suzmue)
## [1.7.0] 2021-07-19
### Added
- Go 1.17 support (@aarzilli, @mknyszek)
- Add new API and terminal command for setting watchpoints (@aarzilli)
- Add filtering and grouping to goroutines command (@aarzilli)
- Added support for hit count condition on breakpoints (@suzmue, @aarzilli)
- DAP server: Handle SetVariable requests (@hyangah)
- DAP server: Add clipboard support (@hyangah)
### Fixed
- DAP server: Several shutdown / disconnect fixes (@suzmue, @polinasok)
- DAP server: Clean output executable name on Windows (@hyangah)
- DAP server: Variables response must not have null variables array (@polinasok)
- Fix runtimeTypeToDIE setup (necessary for Go 1.17) (@aarzilli)
- Reenable CGO stacktrace test on arm64 (@derekparker)
- Fix incorrect integer casts in freebsd C backend (@dwagin)
- Ensure correct exit status reported on commands following process death (@derekparker)
- Misc flakey test fixes / test refactoring (@polinasok)
- Fix for frame parameter being ignored in ConvertEvalScope when no goroutine is found (@suzmue)
- Ensure ContinueOnce returns StopExited if process exited, otherwise return StopUnknown (@polinasok)
- Fix panic in RPC2.ListDynamicLibraries (@derekparker)
- Fix typo in flag passed to check if debugserver supports unmask_signals (@staugust)
### Changed
- DAP server: Add sameuser security check (@hyangah)
- DAP server: Changes to context-dependent load limits for string type (@hyangah, @polinasok)
- DAP server: Add paging for arrays, slices and maps (@suzmue)
- DAP server: Deemphasize internal runtime stack frames (@suzmue)
- DAP server: Add throw reason to exception information upon panic (@suzmue)
- DAP server: Set breakpoint hit ID (@suzmue)
- DAP server: Add string value of byte/rune slice as child (@suzmue)
- Documentation: Add viminspector to list of editor plugins (@aarzilli)
- Support for ZMM registers in gdbserial backend (@aarzilli)
- Remove support for stack barriers (@derekparker)
- Improve support for DWARF5 (@derekparker)
- Improve documentation (@derekparker, @aarzilli)
- Print message and exit if Delve detects it is running under Rosetta on M1 macs (@aarzilli)
- Drop official Go 1.14 support (@derekparker)
## [1.6.1] 2021-05-18
### Added
- Dump command: generate core dumps from within Delve (@aarzilli)
- Toggle command: toggle breakpoints on or off (@alexsaezm)
- DAP server improvements (@polinasok, @hyangah, @suzmue)
- Delve now parses and uses the .eh_frame section when available (@aarzilli)
- Add linespec argument to 'continue' command (@icholy)
- Add optional format argument to 'print' and 'display' commands (@aarzilli)
### Fixed
- Fixed file reference handling with DWARF5 compilation units (@thanm)
- Fix embedded field searching (@aarzilli)
- Fix off by one error reading core files (@aarzilli)
- Correctly read G address on linux/arm64
- Avoid double removal of temp built binary (@polinasok)
- Fix temp binary deletion race in DAP server (@polinasok)
- Fix shutdown related bugs in RPC server (@aarzilli)
- Fix crashes induced by RequestManualStop (@aarzilli)
- Fix handling of DW_OP_piece (@aarzilli)
- Correctly truncate the result of binary operations on integers (@aarzilli)
### Changed
- Dropped Go 1.13 support (@aarzilli)
- Improved documentation (@ChrisHines, @aarzilli, @becheran, @hedenface, @andreimatei, @ehershey , @hyangah)
- Allow examinememory to use an expression (@felixge)
- Improve gdb server check on newer ARM based macs (@oxisto)
- CPU registers can now be used in expressions (@aarzilli)
- DAP: Add type information to variables (@suzmue)
- DAP: Support setting breakpoints while target is running (@polinasok)
- DAP: Implement function breakpoints (@suzmue)
## [1.6.0] 2021-01-28
### Added
- Support for debugging darwin/arm64 (i.e. macOS on Apple Silicon) (#2285, @oxisto)
- Support for debugging Go1.16 (#2214, @aarzilli)
- DAP: support for attaching to a local process (#2260, @polinasok)
- DAP: fill the `evaluateName` field when returning variables, enabling "Add to Watch" and "Copy as Expression" features of VSCode (#2292, @polinasok)
- Added WaitSince, WaitReason to `service/api.Goroutine` and to the `goroutines` command (#2264, #2283, #2270, @dlsniper, @nd, @aarzilli)
- Syntax highlighting for Go code (#2294, @aarzilli)
- Added flag `CallReturn` to `service/api.Thread` to distinguish return values filled by a `stepOut` command from the ones filled by a `call` command (#2230, @aarzilli)
### Fixed
- Fix occasional "Access is denied" error when debugging on Windows (#2281, @nd)
- Register formatting on ARM64 (#2289, @dujinze)
- Miscellaneous bug fixes (#2232, #2255, #2280, #2286, #2291, #2309, #2293, @aarzilli, @polinasok, @hitzhangjie)
### Changed
- The `goroutines` command can be interrupted by pressing Ctrl-C (#2278, @aarzilli)
- Using a TeamCity instance provided by JetBrains for Continuous Integration (#2298, #2307, #2311, #2315, #2326, @artspb, @nd, @aarzilli, @derekparker)
- Improvements to documentation and error messages (#2266, #2265, #2273, #2299, @andreimatei, @hitzhangjie, @zamai, @polinasok)
## [1.5.1] 2020-12-09
### Added
- DAP: Scope and variable requests, including call injection (#2111, #2158, #2160, #2184, #2185, @polinasok)
- DAP: Support removing breakpoints and breakpoint conditions (#2188, @polinasok)
- DAP: Support next, stepIn, stepOut requests (#2143, @polinasok)
- DAP: Miscellaneous improvements (#2167, #2186, #2238, #2233, #2248, @eliben, @suzmue, @polinasok)
- Command line flag `-r` to redirect standard file descriptors of the target process (#2146, #2222, @aarzilli)
- `-size` flag for `examinemem` command (##2147, @hitzhangjie)
- Command line flag to disable ASLR (#2202, @aarzilli)
- Support for DWARFv5 loclists (#2097, @aarzilli)
### Fixed
- Support for Go version >= 1.15.4 (#2235, @aarzilli)
- Fix displaying AVX registers (#2139, @aarzilli)
- Panic during `next`, `step` when there is no current goroutine (#2164, @chainhelen)
- Reading a deferred call's arguments on linux/arm64 (#2210, @aarzilli)
- Miscellaneous bug fixes (#2135, #2131, #2142, #2140, #2127, #2113, #2172, #2181, #2195, #2193, #2220, #2179, #2206, #2223, @aarzilli)
### Changed
- `dlv test` switches to the package directory like `go test` does (#2128, @aarzilli)
- Delve will no longer resolve symbolic links when searching for split debug_info if the executable path is not /proc/pid/exe (#2170, @aarzilli)
- Starlark scripts can now be interrupted using Ctrl-C even if they are not making any API calls (#2149, @aarzilli)
- An error message will be displayed more prominently if a connection is rejected due to the `--only-same-user` flag (which is enabled by default) (#2211, @aarzilli)
- Substitute path rules are applied to the argument of `break` and `trace` (#2213, @aarzilli)
- The output of `xcode-select --print-path` will be used to determine the location of `debugserver` instead of a hardcoded path (#2229, @aaronsky)
- Improvements to documentation and error messages (#2148, #2154, #2196, #2228, @aurkenb, @pohzipohzi, @chainhelen, @andreimatei)
## [1.5.0] 2020-07-29
### Added
- Go 1.15 support (#2011, @aarzilli)
- Added the `reload` command that restarts the debugging session after recompiling the program (#1971, @alexsaezm)
- Better support for printing pointers in the C part of a cgo program (#1997, @aarzilli)
- Some support for DWARFv5 (#2090, @aarzilli)
### Fixed
- Fixed trace subcommand when the `-p` option is used (#2069, @chainhelen)
- Nil pointer dereference when printing tracepoints (#2071, @aarzilli)
- Internal debugger error when printing the goroutine list of a corrupted or truncated core file (#2070, @aarzilli)
- Do not corrupt the list of source files whenever a plugin (or dynamically loaded library) is loaded (#2075, @aarzilli)
- Fixed current file/line reported after a segfault on macOS that was wrong under certain circumstances (#2081, @aarzilli)
- Internal debugger error when reading global variables of types using unsupported debug_info features (#2105, #2106, #2110, @aarzilli, @b00f)
### Changed
- Support for stack trace requests in DAP and other DAP improvements (#2056, #2093, #2099, #2103, @polinasok)
- Delve will step inside a private runtime function call when it is already inside the runtime package (#2061, @aarzilli)
- Updated cosiner/argv dependency to v0.1.0 (#2088, @gadelkareem)
- Improvements to documentation and error messages (#2068, #2084, #2091, @aarzilli, @bhcleek, @letientai299)
## [1.4.1] 2020-05-22
### Added
- Support for linux/386 added (@chainhelen)
- DAP server initial release (@polinasok, @eliben, @hyangah)
- New command `examinemem` (or `x`) allows users to examine raw memory (@chainhelen)
- New command `display` allows users to print value of an expression every time the program stops (@aarzilli)
- New flag `--tty` allows users to supply a TTY for the debugged program to use (@derekparker)
- Coredump support added for Arm64 (@ossdev07)
- Ability to print goroutine labels (@aarzilli)
- Allow printing registers for arbitrary stack frames (@aarzilli)
- Add `disassemble-flavor` to config to specify assembly syntax (@chainhelen)
### Fixed
- Allow function calls on non-struct types (@derekparker)
- Dwarf line parsing bug fix (@klemens-morgenstern)
- Improved error message when building Delve on unsupported systems (@aarzilli)
- Improved error message when trying to execute a binary in an invalid format for host system (@derekparker)
- Fix panic in Delve when using `call` command with some invalid input (@chainhelen)
### Changed
- Improved output from `dlv trace` and `trace` REPL commands (@derekparker)
- Conditional breakpoint performance improvements (@aarzilli)
- Thread register loading performance improvement on gdbserial backend (@derekparker)
- Reduce default log level to error (@aarzilli)
- Linux memory read/write optimization using process_vm_read/write (@cuviper)
- Terminal output of commands divided into categories (@aarzilli)
- Use less permissive file settings on history file (@derekparker)
- Autogenerated interface method calls wrappers now automatically stepped through (@aarzilli)
## [1.4.0] 2020-02-11
### Added
- Support for Linux/ARM64 (#1733, #1780 @hengwu0, @tykcd996)
- Support for Go 1.14 (@aarzilli)
- Added an API call that can be used by Delve front-ends to map between package names and build paths (#1784, @aarzilli)
- Added a field to goroutine objects returned by the API listing the goroutine's pprof labels (#1836, @nd)
- Better support for inlined functions (#1717, #1742, #1807 @aarzilli)
### Fixed
- Fixed target program crash after step-instruction (#1738, @aarzilli)
- Fixed miscellaneus bugs related to debugging Position Independent Executables and plugins (#1775, @aarzilli)
- Always remove breakpoints during detach (#1772, @hengwu0)
- Fixed Delve's exit status after the program has ended (#1781, @derekparker)
- Fixed nil pointer dereference in FunctionReturnLocations (#1789, @aarzilli)
- Improved performance of `goroutines -t` command (#1830, @aarzilli)
- Fixed occasional "Access Denied" error during attach on Windows (#1826, @alexbrainman)
- Fixed parsing of the `disassemble` command (#1837, @chainhelen)
### Changed
- Check that local connections originate from the same User ID as the one that started Delve's instance (#1764, @stapelberg)
- Mapping between package names and package paths is done using the DW_AT_go_package_name where available (#1757, @aarzilli)
- Improvements to documentation and error messages (#1806, #1822, #1827, #1843, #1848, #1850, #1853 @spacewander, @chainhelen, @stigok)
- Miscellaneous code refactorings (#1746, #1777, #1834 @derekparker, @aarzilli)
## [1.3.2] 2019-10-21
### Added
- New example for starlark documentation (@aarzilli)
- Allow calls to optimized functions (@aarzilli)
- Option to bypass smart stacktraces (@aarzilli)
- Ability to call method of embedded field (@chainhelen)
- Added `make unininstall` command (@chainhelen)
- User can re-record recorded targets (@aarzilli)
### Fixed
- Fix version reporting (current latest tagged as 1.3.1, reporting 1.3.0) (@derekparker)
- Fix nil pointer deref on proc.GetG (@aarzilli)
- Better handling of DW_TAG_inlined_subroutine without debug_line info (@aarzilli)
- Fix panic on invalid config values (@TerrySolar)
- Fix debug_line state machine behavior with multi-sequence units (@aarzilli)
- Fix starlark iteration on maps > 64 entries (@alxn)
- debug_frame parser fixed parsing augmentation (@chainhelen)
- Round TLS segment size to its alignment (@heschik)
### Changed
- Documentation bumped required Go version (@codekaup)
- Disassemble now works without a selected goroutine (@aarzilli)
- Correctly mark closure variables as shadowed (@aarzilli)
- Bump CI to use Go 1.13 (@aarzilli)
## [1.3.0] 2019-08-27
### Added
- Go 1.13 support (#1546, @aarzilli)
- Starlark scripting language in the command line client (#1466, #1605, @aarzilli, @derekparker)
- Initial support for FreeBSD (#1480, @rayrapetyan)
- Command line flag to continue process immediately after launch/attach (#1585, @briandealwis)
- Configuration option for the maximum recursion depth used when printing variables (#1626, @msaf1980)
- `next` command now takes a numerical option specifying how many times it should be repeated (#1629, @jeremyfaller)
- Command line options to redirect logs to a file or file descriptor (#1525, @aarzilli)
- Ability to read goroutine ancestors if they are enabled by passing `GODEBUG="tracebackancestors=N"` (requires Go >= 1.11) (#1514, #1570, @aarzilli)
- Breakpoint autocompletion for the command line client (#1612, @qingyunha)
- Added reverse step-instruction command for rr backend (#1596, @dpapastamos)
- Support debugging programs using plugins on Linux with Go 1.12 or later (#1413, #1414, @aarzilli)
- Improved function call injection (#1503, #1504, #1548, #1591, #1602, @aarzilli)
- New variable flag to mark variables that have a fake or no-longer-valid address, because they are either stored in registers or in a stack frame that has been removed from the stack (#1619, @aarzilli)
- Support relative file paths when specifying breakpoint locations (#1478, @chainhelen)
- GetVersion API response now reports currently used backend (#1641, @aarzilli)
- `so` as alias for `stepout` (#1646, @stmuk)
### Fixed
- Fixed values of registers smaller than 64bit (#1583, @derekparker)
- Fixed reading maps with removed entries in Go 1.12 (#1532, @aarzilli)
- Fixed possible crash on Linux caused by function call injection (#1538, @aarzilli)
- Fixed errors reading DWARF sections (#1574, #1582, #1603, @aarzilli)
- Prompt to shutdown headless instance after the target process has exited (#1621, @briandealwis)
- Stacktraces when a SIGSEGV (or other signal) happens during a cgo call (#1647, @aarzilli)
- Error restarting program with next/step/stepout under some circumstances (#1657, @aarzilli)
- Other bug fixes (#1487, #1488, #1490, #1500, #1497, #1469, #1553, #1595, #1594, #1620, #1622, #1624, #1637, #1664, #1665, #1668, @derekparker, @aarzilli, @dpapastamos, @pjot726)
### Changed
- Delve will refuse to work with a version of Go that is either too old or too new (can be disabled with `--check-go-version=false`) (#1533, @aarzilli)
- When the value of a variable is determined to be a symbolic constant the numerical value of the symbolic constant will also be printed (#1530, @aarzilli)
- Catch fatal runtime errors (such as the deadlock detector triggering) automatically (#1502, @aarzilli)
- Replaced glide (which we weren't using anymore) with `go mod vendor` in make script (#1606, @derekparker)
- Removed support for reading interfaces in older versions (prior to 1.7) of Go (#1501, @aarzilli)
- Removed support for location expression "<fnname>:0" and associated API functionality (#1588, @aarzilli)
- Calling an unknown method through the JSON-RPC API will now return an error while previously it would simply be ignored (#1571, @aarzilli)
- Improved documentation and error messages (#1492, #1520, #1524, #1561, #1562, #1556, #1559, #1567, #1638, #1649, #1662, @derekparker, @Ladicle, @qaisjp, @justinclift, @tschundler, @two, @aarzilli, @dr2chase)
## [1.2.0] 2019-02-19
### Added
- Go 1.12 support
- Improved `trace` command to show return values and trace pre-built executables or tests (#1379, #1380, #1381, @derekparker)
- Windows Minidump support (#1386, #1387, #1402, @aarzilli)
- Better support for split DWARF symbol files (#1405, #1420, @derekparker, @slp)
- Function call support on macOS (#1324, @derekparker)
- `deferred` command to view the arguments of a deferred call (#1285, #1265, @aarzilli)
- Support for debugging Position Independent Executables (#1358, @aarzilli)
- Type conversions of byte and rune arrays into strings (#1372, @chainhelen)
- Configuration option (source-list-line-color) to change the color of line numbers in listings (#1364, @Russtopia)
- New expression `iface.(data)` to access the concrete value of interface variable `iface`, without having to write a full type assertion (#1340, @aarzilli)
- Support for specifying multiple source files as arguments for `debug`, `trace` and `test` (#1339, @chainhelen)
### Fixed
- Make `edit` command work with vim and neovim (#1451, @the4thamigo-uk)
- Support Linux kernels prior to 2.6.34 (i.e. without PTRACE_GETREGSET) (#1435, @aarzilli)
- Fixed `substitute-path` configuration option on Windows (#1418, @zavla)
- Better performance for ListGoroutines API call (#1440, #1408, @slp, @aarzilli)
- Better performance when loading the value of very large sparse maps (#1392, @aarzilli)
- Other bug fixes (#1377, #1384, #1429, #1434, #1445, @aarzilli)
### Changed
- Changes to where the configuration is stored, conforming to [XDG Base Directory Specification](https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html) with fallbacks to the current directory when calls to `user.Current` fail (#1455 @GregorioMartinez, @acshekhara1)
- Project moved from github.com/derekparker/delve to github.com/go-delve/delve (@derekparker)
- Switched dependency management to go.mod (@aarzilli, @derekparker, @zavla)
- New build scripts and support building on macOS without the native backend (@aarzilli, @kevin-cantwell)
- Tolerate corrupted memory when reading the goroutine list (#1354, @aarzilli)
- Improved documentation and error messages (@sbromberger, @aarzilli, @derekparker, @chainhelen, @dishmaev, @altimac)
## [1.1.0] 2018-08-15
### Added
- Go 1.11 support (@aarzilli)
- Improvements to Delve logging (@aarzilli, @derekparker)
- Show global variables in disassembly (@aarzilli)
- Support for inlined calls (@aarzilli, @derekparker, @jaym)
- Support dwz compressed debug symbols (@slp)
- Support for debug info in a separate file (@slp)
- Let target process access the tty when running in headless mode on linux/native and darwin/gdbserial (@aarzilli)
- Commands `up` and `down` (@yasushi-saito)
- Flag to print stacktrace of all goroutines (@acshekhara1)
- Command `edit` (@benc153)
- Allow headless instances to keep running without a connected client (@aarzilli)
- Add `StartLoc` to `api.Goroutine` containing the starting location of each goroutine (@aarzilli)
- Preliminary support for function call injection with Go 1.11 (@aarzilli)
- Ability to read list of deferred calls of a goroutine (@aarzilli)
### Fixed
- Fixed crashes when configuration file can not be created (@derekparker, @yuval-k, @aarzilli)
- Fixed reported location of the go statement of goroutines (@derekparker)
- Allow evaluation of constants specified without the full package path (@aarzilli)
- Fixed some integer arithmetic bugs in proc (@functionary)
- Respect load configuration after reslicing a map (@aarzilli)
- Fixed race condition between Halt and process death in the linux native backend (@aarzilli)
- Support core files generated by gdb (@psanford)
- Fixed evaluation of breakpoint conditions containing a single boolean variable (@aarzilli)
- Miscellaneous bugs in the debug_line state machine (@aarzilli)
### Changed
- Removed redundant/obsolete methods of proc.Process Halt and Kill, general cleanup of native backends (@aarzilli)
- Improved documentation (@giuscri, @jsoref, @Carpetsmoker, @PatrickSchuster, @aarzilli, @derekparker, @ramya-rao-a, @dlsniper)
- Workaround in the gdbserial backend for broken version 902 of debugserver (@aarzilli)
- Changed operators || and && to short-circuit the evaluation of their arguments, like in Go (@aarzilli)
- Mark shadowed arguments as shadowed (@aarzilli)
- Allow syntax "package/path".varname to specify the full package path of a variable, in case disambiguating between multiple packages with the same name is necessary (@aarzilli)
## [1.0.0] 2018-02-19
### Added
- Print DWARF location expression with `whatis` (@aarzilli)
- Use `DW_AT_producer` to warn about optimized code (@aarzilli)
- Use constants to describe variable value (@aarzilli)
- Use `DW_AT_decl_line` to determine variable visibility (@aarzilli)
- `-offsets` flag for `stack` command (@aarzilli)
- Support CGO stacktraces (@aarzilli)
- Disable optimizations in C compiler (@aarzilli)
- `--output` flag to configure output binary (@Carpetsmoker)
- Support `DW_OP_piece`, `DW_OP_regX`, `DW_OP_fbreg` (@aarzilli)
- Support `DW_LNE_define_file` (@aarzilli)
- Support more type casts (@aarzilli)
### Fixed
- Disable file path case normalization on OSX (@aarzilli)
- Support Mozilla RR 5.1.0 (@aarzilli)
- Terminal no longer crashes when process exits during `next` (@aarzilli)
- Fix TestCoreFPRegisters on Go 1.9 (@aarzilli)
- Avoid scanning system stack if it's not executing CGO (@aarzilli)
- Locspec "+0" should always evaluate to the current PC (@aarzilli)
- Handle `DW_LNE_end_of_sequence` correctly (@aarzilli)
- Top level interface variables may have 0 address (@aarzilli)
- Handle `DW_TAG_subprogram` with a nochildren abbrev (@aarzilli)
- StepBreakpoint handling (@aarzilli)
### Changed
- Documentation improvements (@grahamking)
- Removed limitation of exit notifications (@dlsniper)
- Use `go env GOPATH` for install path
- Disable test caching (@aarzilli)
- Disable `-a` and use `all=` for Go 1.10 building (@aarzilli)
- Automatically deref interfaces on member access (@aarzilli)
- Replace all uses of `gosymtab/gopclntab` with `.debug_line` section (@aarzilli)
## [1.0.0-rc.2] 2017-10-16
### Added
- Automatically print panic reason for unrecovered panics (@aarzilli)
- Propagate frame offset to clients (@aarzilli)
- Added vim-delve plugin to documentation (@sebdah)
- Floating point register support in core files (@aarzilli)
- Go 1.9 support, including lexical block support (@aarzilli)
- Added whatis and config commands (@aarzilli)
- Add FrameOffset field to api.Stackframe (@aarzilli)
### Fixed
- Better interoperation with debugserver on macOS (@aarzilli / @dlsniper)
- Fix behavior of next, step and stepout with recursive functions (@aarzilli)
- Parsing of maps with zero sized values (@aarzilli)
- Typo in the documentation of `types` command (@custa)
- Data races in tests (@aarzilli)
- Fixed SetBreakpoint in native and gdbserial to return the breakpoint if it already exists (@dlsniper)
- Return breakpoint if it already exists (@dlsniper)
- Collect breakpoint information on exit from next/stepout/step (@aarzilli)
- Fixed install instructions (@jacobvanorder)
- Make headless server quit when the client disconnects (@aarzilli)
- Store the correct concrete value for interface variables (previously we would always have a pointer type, even when the concrete value was not a pointer) (@aarzilli)
- Fix interface and slice equality with nil (@aarzilli)
- Fix file:line location specs when relative paths are in .debug_line (@hyangah)
- Fix behavior of next/step/stepout in several edge-cases (invalid return addresses, no current goroutine, after process exists, inside unknown code, inside assembly files) (@aarzilli)
- Make sure the debugged executable we generated is deleted after exit (@alexbrainman)
- Make sure rr trace directories are deleted when we delete the executable and after tests (@aarzilli)
- Return errors for commands sent after the target process exited instead of panicking (@derekparker)
- Fixed typo in clear-checkpoint documentation (@iamzhout)
### Changed
- Switched from godeps to glide (@derekparker)
- Better performance of linux native backend (@aarzilli)
- Collect breakpoints information if necessary after a next, step or stepout command (@aarzilli)
- Autodereference escaped variables (@aarzilli)
- Use runtime.tlsg to determine G struct offset (@heschik)
- Use os.StartProcess to implement Launch on windows (@alexbrainman)
- Escaped variables are dereferenced instead of being reported as &v (@aarzilli)
- Report errors when we fail to load the executable on attach (@aarzilli)
- Distinguish between nil and empty slices and maps both in the API and on the command line interface (@aarzilli)
- Skip deferred functions on next and stepout (as long as they are not called through a panic) (@aarzilli)
## [1.0.0-rc.1] 2017-05-05
### Added
- Added support for core files (@heschik)
- Added support for lldb-server and debugserver as backend, using debugserver by default on macOS (@aarzilli)
- Added support for Mozilla RR as backend (@aarzilli)
### Fixed
- Detach should correctly kill child process we created (@aarzilli)
- Correctly return error when reading/writing memory of exited process (@aarzilli)
- Fix race condition in test (@hyangah)
- Fix version extraction to support proposals (@allada)
- Tolerate spaces better after command prefixes (@aarzilli)
### Changed
- Updated Mac OSX install instructions (@aarzilli)
- Refactor of core code in proc (@aarzilli)
- Improve list command (@aarzilli)
## [0.12.2] 2017-04-13
### Fixed
- Fix infinite recursion with pointer loop (@aarzilli)
- Windows: Handle delayed events (@aarzilli)
- Fix Println call to be Printf (@derekparker)
- Fix build on OSX (@koichi)
- Mark malformed maps as unreadable instead of panicking (@aarzilli)
- Fixed broken benchmarks (@derekparker)
- Improve reliability of certain tests (@aarzilli)
### Added
- Go 1.8 Compatibility (@aarzilli)
- Add Go 1.8 to test matrix (@derekparker)
- Support NaN/Inf float values (@aarzilli)
- Handle absence of stack barriers in Go 1.9 (@drchase)
- Add gdlv to list of alternative UIs (@aarzilli)
### Changed
- Optimized 'trace' functionality (@aarzilli)
- Internal refactoring to support multiple backends, core dumps, and more (@aarzilli) [Still ongoing]
- Improve stacktraces (@aarzilli)
- Improved documentation for passing flags to debugged process (@njason)
## [0.12.1] 2017-01-11
### Fixed
- Fixed version output format.
## [0.12.0] 2017-01-11
### Added
- Added support for OSX 10.12.1 kernel update (@aarzilli)
- Added flag to set working directory (#650) (@rustyrobot)
- Added stepout command (@aarzilli)
- Implemented "attach" on Windows (@alexbrainman)
- Implemented next / step / step-instruction on parked goroutines (@aarzilli)
- Added support for App Engine (@dbenque)
- Go 1.7 support
- Added HomeBrew formula for installing on OSX.
- Delve now will break on unrecovered panics. (@aarzilli)
- Headless server can serve multiple clients.
- Conditional breakpoints have been implemented. (@aarzilli)
- Disassemble command has been implemented. (@aarzilli)
- Much improved documentation (still a ways to go).
### Changed
- Pretty printing: type of elements of interface slices are printed.
- Improvements in internal operation of "step" command.
- Allow quoting in build flags argument.
- "h" as alias for "help" command. (@stmuk)
### Fixed
- Improved prologue detection for large stack frames (#690) (@aarzilli)
- Fixed bugs involving stale executables during restart (#689) (@aarzilli)
- Various improvements to variable evaluation code (@aarzilli)
- Fix bug reading process comm name (@ggndnn)
- Add better detection for launching non executable files. (@aarzilli)
- Fix halt bug during tracing. (@aarzilli)
- Do not use escape codes on Windows when unsupported (@alexbrainman)
- Fixed path lookup logic on Windows. (@lukehoban)
## [0.11.0-alpha] 2016-01-26
### Added
- Windows support landed in master. Still work to be done, but 95% the way there. (@lukehoban)
- `step-instruction` command added, has same behavior of the old `step` command.
- (Backend) Implementation for conditional breakpoints, front end command coming soon. (@aarzilli)
- Implement expression evaluator, can now execute commands like `print i == 2`. (@aarzilli)
### Changed
- `step` command no longer steps single instruction but goes to next source line, stepping into functions.
- Refactor of `parseG` command for clarity and speed improvements.
- Optimize reading from target process memory with cache. (prefetch + parse) (@aarzilli)
- Shorten file paths in `trace` output.
- Added Git SHA to version output.
- Support function spec with partial package paths. (@aarzilli)
- Bunch of misc variable evaluation fixes (@aarzilli)
### Fixed
- Misc fixes in preparation for Go 1.6. (@aarzilli, @derekparker)
- Replace stdlib debug/dwarf with golang.org/x/debug/dwarf and fix Dwarf endian related parsing issues. (@aarzilli)
- Fix `goroutines` not working without an argument. (@aarzilli)
- Always clear temp breakpoints, even if normal breakpoint is hit. (@aarzilli)
- Infinite loading loop through maps. (@aarzilli)
- Fix OSX issues related to CGO memory corruption (array overrun in CGO). (@aarzilli)
- Fix OSX issue related to reporting multiple breakpoints hit at same time. (@aarzilli)
- Fix panic when using the `trace` subcommand.
## [0.10.0-alpha] 2015-10-04
### Added
- `set` command, allows user to set variable (currently only supports pointers / numeric values) (@aarzilli)
- All deps are vendored with Godeps and leveraging GO15VENDOREXPERIMENT
- `source` command and `--init` flag to run commands from a file (@aarzilli)
- `clearall` commands now take linespec (@kostya-sh)
- Support for multiple levels of struct nesting during variable eval (i.e. `print foo.bar.baz` now works) (@lukehoban)
### Changed
- Removed hardware assisted breakpoints (for now)
- Remove Go 1.4.2 on Travis builds
### Fixed
- Limit string sizes, be more tolerant of uninitialized memory (@aarzilli)
- `make` commands fixed for >= Go 1.5 on OSX
- Fixed bug where process would not be killed upon detach (@aarzilli)
- Fixed bug trying to detach/kill process that has already exited (@aarzilli)
- Support for "dumb" terminals (@dlsniper)
- Fix bug setting breakpoints at chanRecvAddrs (@aarzilli)
## [0.9.0-alpha] 2015-09-19
### Added
- Basic tab completion to terminal UI (@icholy)
- Added `-full` flag to stack command, prints local vars and function args (@aarzilli)
### Changed
- Output of threads and goroutines sorted by ID (@icholy)
- Performance improvement: cache parsed goroutines during halt (@icholy)
- Stack command no longer takes goroutine ID. Use scope prefix command instead (i.e. `goroutine <id> bt`)
### Fixed
- OSX: Fix hang when 'next'ing through highly parallel programs
- Absolute path confused as regexp in FindLocation (@aarzilli)
- Use sched.pc instead of gopc for goroutine location
- Exclude dead goroutines from `goroutines` command output (@icholy)
## [0.8.1-alpha] 2015-09-05
### Fixed
- OSX: Fix error setting breakpoint upon Delve startup.
## [0.8.0-alpha] 2015-09-05
### Added
- New command: 'frame'. Accepts a frame number and a command to execute in the context of that frame. (@aarzilli)
- New command: 'goroutine'. Accepts goroutine ID and optionally a command to execute within the context of that goroutine. (@aarzilli)
- New subcommand: 'exec'. Allows user to debug existing binary.
- Add config file and add config options for command aliases. (@tylerb)
### Changed
- Add Go 1.5 to travis list.
- Stop shortening file paths from API, shorten instead in terminal UI.
- Implemented several improvements for `next`ing through highly parallel programs.
- Visually align registers. (@paulsmith)
### Fixed
- Fixed output of 'goroutines' command.
- Stopped preserving temp breakpoints on restart.
- Added support for parsing multiple DWARF file tables. (@Omie)
## [0.7.0-alpha] 2015-08-14
### Added
- New command: 'list' (alias: 'ls'). Allows you to list the source code of either your current location, or a location that you describe via: file:line, line number (in current file), +/- offset or /regexp/. (@joeshaw)
- Added Travis-CI for continuous integration. Works for now, will eventually change.
- Ability to connect to headless server. When running Delve in headless mode (used previously only for editor integration), you now have the opportunity to connect to it from the command line with `dlv connect [addr]`. This will allow you to (insecurely) remotely debug an application. (@tylerb)
- Support for printing complex numeric types. (@ebfe)
### Changed
- Deprecate 'run' subcommand in favor of 'debug'. The 'run' subcommand now simply prints a warning, instructing the user to use the 'debug' command instead.
- All 'info' subcommands have been promoted to the top level. You can now simply run 'funcs', or 'sources' instead of 'info funcs', etc...
- Any command taking a location expression (i.e. break/trace/list) now support an updated linespec implementation. This allows you to describe the location you would like a breakpoint (etc..) set at in a more convenient way (@aarzilli).
### Fixed
- Improved support for CGO. (@aarzilli)
- Support for upcoming Go 1.5.
- Improve handling of soft signals on Darwin.
- EvalVariable evaluates package variables. (@aarzilli)
- Restart command now preserves breakpoints previously set.
- Track recurse level when eval'ing slices/arrays. (@aarzilli)
- Fix bad format string in cmd/dlv. (@moshee)
================================================
FILE: CLAUDE.md
================================================
# CLAUDE.md
This file provides guidance to Claude Code (claude.ai/code) when working
with code in this repository.
## Project Overview
Delve is a debugger for the Go programming language. This is a complex,
multi-layered system that requires understanding of debugging internals,
DWARF format, OS-specific process control, and Go runtime internals.
## Build and Test Commands
### Building
```bash
make build # Build dlv binary
make install # Install dlv to system
make uninstall # Remove dlv from system
```
### Testing
```bash
make test # Run all tests with vetting
make vet # Run Go vet with architecture tags
go test -run TestName ./pkg/... # Run specific test by name
go test ./pkg/proc # Run all pkg/proc tests
go test ./service/test # Run all integration tests
```
### eBPF Backend Development
```bash
make build-ebpf-image # Build Docker image for eBPF compilation
make build-ebpf-object # Compile eBPF C code to object files
```
The eBPF backend uses Docker to compile C code
(`pkg/proc/internal/ebpf/bpf/trace.bpf.c`) in a controlled environment,
producing architecture-specific `.o` files.
#### eBPF Testing
eBPF tests (TestTraceEBPF*) require elevated capabilities (CAP_BPF,
CAP_PERFMON, CAP_SYS_RESOURCE) and must be run with sudo:
```bash
# Run specific eBPF test
sudo go test -v -run TestTraceEBPF3 -count 1 ./cmd/dlv
# Run all eBPF tests
sudo go test -v -run TestTraceEBPF -count 1 ./cmd/dlv
# Run eBPF tests in Docker (useful when host lacks capabilities or for CI)
docker run --privileged -v "$(pwd)":/delve -w /delve \
-e GOFLAGS="-buildvcs=false" golang:1.24-bookworm \
go test -v -run TestTraceEBPF -count 1 ./cmd/dlv
# Suppress debug output
sudo go test -v -run TestTraceEBPF3 -count 1 ./cmd/dlv 2>&1 | \
grep -v "^DEBUG"
```
### Running Delve
```bash
dlv debug # Compile and debug current package
dlv test # Compile and debug tests
dlv attach <pid> # Attach to running process
dlv exec <binary> # Debug pre-compiled binary
dlv dap # Start Debug Adapter Protocol server
```
## Test-Driven Development (MANDATORY)
**CRITICAL**: All code changes MUST follow test-driven development (TDD).
This is not optional.
### Red-Green-Refactor Cycle
1. **RED** - Write a failing test first (must fail for the right reason)
2. **GREEN** - Write minimum code to pass the test
3. **REFACTOR** - Clean up while keeping tests green
4. **VERIFY** - Run full test suite before committing
### Mandatory TDD Rules
1. **NEVER write implementation code without a failing test first**
2. **NEVER commit code without tests**
3. **NEVER skip tests or mark them as skipped to make CI pass**
4. **NEVER disable existing tests** - fix them or fix the code
5. Each test should verify ONE specific behavior
6. Test names should describe the scenario being tested
### Example Workflow
```bash
# RED - Write failing test
go test -run TestEvaluateComplexType ./pkg/proc
# Output: FAIL - undefined: evaluateComplexType (EXPECTED)
# GREEN - Implement minimum code
go test -run TestEvaluateComplexType ./pkg/proc
# Output: PASS
# REFACTOR - Clean up
go test -run TestEvaluateComplexType ./pkg/proc
# Output: PASS (must stay green)
# VERIFY - Full suite
make test
```
### Where to Write Tests
- **Unit tests**: Co-locate with code (e.g., `pkg/proc/variables_test.go`
for `variables.go`)
- **Integration tests**: `service/test/` for end-to-end scenarios
- **Platform-specific tests**: Use build tags (e.g., `//go:build linux`)
- **Backend-specific tests**: Test each backend separately
- **Test fixtures**: Source code in `_fixtures/` (compiled during tests,
not pre-compiled binaries)
- **Finding fixtures directory**: Use `protest.FindFixturesDir()` from
`github.com/go-delve/delve/pkg/proc/test` instead of writing custom
fixture directory lookup code
### Test Quality Standards
- Test behavior, not implementation
- One assertion per test when possible (easier diagnosis)
- Clear naming: `Test<What>_<Scenario>_<ExpectedResult>`
- Use existing test utilities in `*_test.go` files
- Tests must be deterministic (no random values or race conditions)
### When TDD Seems Difficult
Difficulty writing tests first indicates: (1) function doing too much,
(2) tightly coupled dependencies, or (3) unclear requirements. **DO NOT
skip TDD** - the difficulty signals a design problem.
## Architecture Overview
Delve uses a **layered architecture** with clear separation of concerns:
```
CLI (cmd/dlv) → Cobra commands
↓
Service Layer (service/) → RPC2, DAP protocol implementations
↓
Debugger (service/debugger) → High-level debugging operations
↓
Process Abstraction (pkg/proc) → TargetGroup, Target, ProcessInternal
↓
Backend Implementations:
- pkg/proc/native/ → Direct OS debugging (ptrace, Windows APIs)
- pkg/proc/gdbserial/ → GDB remote protocol client
- pkg/proc/core/ → Core dump analysis
- pkg/proc/internal/ebpf/ → eBPF-based tracing (non-stop debugging)
```
### Process Abstraction (`pkg/proc`)
Core of Delve's architecture with **two-level interface design**:
- `Process` - Read-only public interface
- `ProcessInternal` - Internal interface with state-modifying operations
- `Target` - Wraps `ProcessInternal` with debugging state
- `TargetGroup` - Manages multiple processes (for exec following)
- `Thread` - OS thread abstraction
- `MemoryReadWriter` - Memory access abstraction
Backends are pluggable via `ProcessInternal` interface. When modifying
backends, changes usually apply to ALL implementations.
### Service Layer (`service/`)
- **`debugger/`** - `Debugger` struct wrapping `TargetGroup` with
high-level operations (launch, attach, breakpoints, stepping, variable
evaluation)
- **`rpc2/`** - JSON-RPC 2.0 server for remote clients
- **`dap/`** - Debug Adapter Protocol for IDE integration
- **`api/`** - Shared type definitions
### Binary Analysis
- **`pkg/dwarf/`** - Custom DWARF parser with Delve-specific features
- **`pkg/gobuild/`** - Go build system integration
- **`pkg/proc/BinaryInfo`** - Debug symbols, function entries, line tables
### Platform/Architecture Handling
Uses **filename-based conditional compilation**:
- OS-specific: `*_linux.go`, `*_darwin.go`, `*_windows.go`, `*_freebsd.go`
- Architecture-specific: `regs_amd64.go`, `regs_arm64.go`, etc.
- **DO NOT put platform-specific code in generic files**
- In most cases platform-specific code should only be added to the
`pkg/proc/native` and `pkg/proc/gdbserial` backends.
Supported: amd64, arm64, 386, ppc64le, riscv64, loong64
## Development Guidelines
### Code Organization
1. **OS/arch separation**: Use Go's filename-based conditional
compilation. Never put platform-specific code in generic files.
2. **Breakpoint types**: Two kinds exist:
- `LogicalBreakpoint` - User-visible (set at file:line or function)
- `Breakpoint` - Physical per target (multiple per logical breakpoint)
3. **Testing**: See "Test-Driven Development (MANDATORY)" section above.
### Working with DWARF
- Parsing in `pkg/dwarf/` with custom reader utilities
- Operations (expressions) in `pkg/dwarf/op/`
- Variable evaluation issues: check type reading
(`pkg/proc/variables.go`), DWARF expression evaluation
(`pkg/dwarf/op/`), and memory reading (`Process.Memory()`)
### Working with eBPF Backend
`pkg/proc/internal/ebpf/` is **fundamentally different**: uses **uprobes**
to trace function calls without stopping execution. C code compiles to
eBPF bytecode using Docker for reproducible builds. Manages goroutines for
event processing - be careful with shutdown.
Modifying eBPF code:
1. Edit `pkg/proc/internal/ebpf/bpf/trace.bpf.c`
2. Run `make build-ebpf-object`
3. Go code loads `.o` files using cilium/ebpf library
**Critical - Function Prologues**: Set breakpoints/uprobes at
`FirstPCAfterPrologue`, not `fn.Entry` (unless explicitly requested). Go's
stack-check prologue will re-trigger if set at `fn.Entry`.
### Commit Message Format
Use subsystem-based format from CONTRIBUTING.md:
```
<subsystem>: <what changed>
<why this change was made>
Fixes #<issue>
```
Subsystems: `proc`, `service`, `terminal`, `dwarf`, `native`, `dap`, `rpc2`,
`cmd/dlv`, etc.
**Subject line**: Max 70 characters, **Body**: Wrap at 80 characters
**Example**:
```
proc/internal/ebpf: fix goroutine leak and shutdown sequence
The eBPF event processing goroutines were not being properly cleaned up
on debugger shutdown, causing resource leaks. This adds proper context
cancellation and wait groups.
Fixes #1234
```
### Common Pitfalls
1. **Don't modify Process state directly** - Use `ProcessInternal` methods
for locking and state consistency
2. **Breakpoint insertion is backend-specific** - `native` uses software
breakpoints (INT3), `gdbserial` sends packets, `ebpf` uses uprobes
3. **Thread vs Goroutine** - Delve tracks both OS threads (`Thread`) and
Go goroutines (`G` struct). Most operations work on goroutines, not
threads.
4. **Memory safety** - Always handle errors when reading process memory.
Process may die, memory may be unmapped, or addresses invalid.
5. **Don't reparse DWARF sections** - `loadDebugInfoMaps` already
iterates all compile units. Add per-CU checks there instead of
making separate passes over `debug_info`.
## File Organization
```
delve/
├── cmd/dlv/ # CLI entry point and commands
├── pkg/
│ ├── proc/ # Core process abstraction
│ │ ├── native/ # OS-level debugging backends
│ │ ├── gdbserial/ # GDB remote protocol
│ │ ├── core/ # Core dump support
│ │ ├── internal/ebpf/ # eBPF tracing backend
│ │ └── *.go # Process interfaces and common logic
│ ├── dwarf/ # DWARF parsing and manipulation
│ ├── terminal/ # Interactive CLI
│ ├── config/ # Configuration (.delverc)
│ └── ... # Other utilities
├── service/
│ ├── debugger/ # High-level debugger API
│ ├── rpc2/ # JSON-RPC 2.0 server
│ ├── dap/ # Debug Adapter Protocol
│ └── api/ # Shared type definitions
├── _fixtures/ # Test source files (compiled during tests)
├── _scripts/ # Build helper scripts
└── Documentation/ # User and internal documentation
```
## Dependencies
Key external dependencies (see `go.mod`):
- `github.com/cilium/ebpf` - eBPF program loading
- `github.com/google/go-dap` - Debug Adapter Protocol
- `github.com/spf13/cobra` - CLI framework
- `golang.org/x/arch` - CPU architecture utilities
- `golang.org/x/sys` - System calls and OS interfaces
## Resources
- [Internal Architecture Slides](https://speakerdeck.com/aarzilli/internal-architecture-of-delve)
- [Porting Guide](Documentation/internal/portnotes.md)
- [API Documentation](Documentation/api)
- [How to Write a Delve Client](Documentation/api/ClientHowto.md)
================================================
FILE: CONTRIBUTING.md
================================================
# Contributing to Delve
Want to help contribute to Delve? Great! Any and all help is certainly appreciated, whether it's code, documentation, or spelling corrections.
If you are planning to contribute a significant change, please draft a design document (or start a conversation) and post it to the [developer mailing list](https://groups.google.com/forum/#!forum/delve-dev). This will allow other developers and users to discuss the proposed change.
## Filing issues
When filing an issue, make sure to answer these six questions:
1. What version of Delve are you using (`dlv version`)?
2. What version of Go are you using? (`go version`)?
3. What operating system and processor architecture are you using?
4. What did you do?
5. What did you expect to see?
6. What did you see instead?
## Contributing code
Fork this repo and create your own feature branch. Install all dependencies as documented in the README.
### Build prerequisites
- Go (see `go.mod` for minimum version)
- [goreleaser v2](https://goreleaser.com/install/) — required for `make build`
Install: `go install github.com/goreleaser/goreleaser/v2@latest`
### Guidelines
Consider the following guidelines when preparing to submit a patch:
* Follow standard Go conventions (document any new exported types, funcs, etc.., ensuring proper punctuation).
* Ensure that you test your code. Any patches sent in for new / fixed functionality must include tests in order to be merged into master.
* If you plan on making any major changes, create an issue before sending a patch. This will allow for proper discussion beforehand.
* Keep any os / arch specific code contained to os / arch specific files. Delve leverages Go's filename based conditional compilation, i.e do not put Linux specific functionality in a non Linux specific file.
### Format of the Commit Message
We follow a rough convention for commit messages that is designed to answer two
questions: what changed and why. The subject line should feature the what and
the body of the commit should describe the why.
```
terminal/command: Add 'list' command
This change adds the 'list' command which will print either your current
location, or the location that you specify using the Delve linespec.
Fixes #38
```
The format can be described more formally as follows:
```
<subsystem>: <what changed>
<BLANK LINE>
<why this change was made>
<BLANK LINE>
<footer>
```
The first line is the subject and should be no longer than 70 characters, the
second line is always blank, and other lines should be wrapped at 80 characters.
This allows the message to be easier to read on GitHub as well as in various
git tools.
## Code of Conduct
This project adopts the standard Go code of conduct: https://go.dev/conduct.
================================================
FILE: Documentation/AI/AI_POLICY.md
================================================
# AI Usage Policy
> **Attribution:** This policy is adapted from the
> [Ghostty project's AI_POLICY.md](https://github.com/ghostty-org/ghostty/blob/main/AI_POLICY.md).
> We are grateful to the Ghostty maintainers for providing a clear and
> thoughtful framework for AI usage in open source projects.
The Delve project has strict rules for AI usage:
- **All AI usage in any form must be disclosed.** You must state
the tool you used (e.g. Claude Code, Cursor, Amp) along with
the extent that the work was AI-assisted.
- **Pull requests created in any way by AI can only be for accepted issues.**
Drive-by pull requests that do not reference an accepted issue will be
closed. If AI isn't disclosed but a maintainer suspects its use, the
PR will be closed. If you want to share code for a non-accepted issue,
open a discussion or attach it to an existing discussion.
- **Pull requests created by AI must have been fully verified with
human use.** AI must not create hypothetically correct code that
hasn't been tested. Importantly, you must not allow AI to write
code for platforms or environments you don't have access to manually
test on.
- **Issues and discussions can use AI assistance but must have a full
human-in-the-loop.** This means that any content generated with AI
must have been reviewed _and edited_ by a human before submission.
AI is very good at being overly verbose and including noise that
distracts from the main point. Humans must do their research and
trim this down.
These rules apply only to outside contributions to Delve. Maintainers
are exempt from these rules and may use AI tools at their discretion;
they've proven themselves trustworthy to apply good judgment.
## There are Humans Here
Please remember that Delve is maintained by humans.
Every discussion, issue, and pull request is read and reviewed by
humans (and sometimes machines, too). It is a boundary point at which
people interact with each other and the work done. It is rude and
disrespectful to approach this boundary with low-effort, unqualified
work, since it puts the burden of validation on the maintainer.
In a perfect world, AI would produce high-quality, accurate work
every time. But today, that reality depends on the driver of the AI.
And today, most drivers of AI are just not good enough. So, until either
the people get better, the AI gets better, or both, we have to have
strict rules to protect maintainers.
## AI is Welcome Here
As a project, we welcome AI as a tool!
**Our reason for the AI policy is not due to an anti-AI stance**, but
instead intended to help produce high quality code and maintain code
quality and overall standards when using AI coding assistance. This policy
also gives a common framework to use and foster effective open source
collaboration in the era of AI Agentic coding.
I include this section to be transparent about the project's usage about
AI for people who may disagree with it, and to address the misconception
that this policy is anti-AI in nature.
================================================
FILE: Documentation/EditorIntegration.md
================================================
## Editor plugins
The following editor plugins for delve are available:
**Atom**
* [Go Debugger for Atom](https://github.com/lloiser/go-debug)
**Emacs**
* [Emacs plugin](https://github.com/benma/go-dlv.el/)
* [dap-mode](https://github.com/emacs-lsp/dap-mode#go-1)
* [dape](https://github.com/svaante/dape?tab=readme-ov-file#go---dlv)
**Goland**
* [JetBrains Goland](https://www.jetbrains.com/go)
**IntelliJ IDEA**
* [Golang Plugin for IntelliJ IDEA](https://plugins.jetbrains.com/plugin/9568-go)
**LiteIDE**
* [LiteIDE](https://github.com/visualfc/liteide)
**Vim**
* [vim-go](https://github.com/fatih/vim-go) (both Vim and Neovim)
* [vim-delve](https://github.com/sebdah/vim-delve) (both Vim and Neovim)
* [vim-godebug](https://github.com/jodosha/vim-godebug) (only Neovim)
* [vimspector](https://github.com/puremourning/vimspector/)
**VisualStudio Code**
* [Go for Visual Studio Code](https://github.com/golang/vscode-go)
**Sublime**
* [Go Debugger for Sublime](https://github.com/dishmaev/GoDebug)
## Alternative UIs
The following alternative UIs for delve are available:
* [Gdlv](https://github.com/aarzilli/gdlv)
* [Debugger](https://github.com/emad-elsaid/debugger)
================================================
FILE: Documentation/KnownBugs.md
================================================
# Known Bugs
- When Delve is compiled with versions of go prior to 1.7.0 it is not possible to set a breakpoint on a function in a remote package using the `Receiver.MethodName` syntax. See [Issue #528](https://github.com/go-delve/delve/issues/528).
- When running Delve on binaries compiled with a version of go prior to 1.9.0 `locals` will print all local variables, including ones that are out of scope, the shadowed flag will be applied arbitrarily. If there are multiple variables defined with the same name in the current function `print` will not be able to select the correct one for the current line.
- `reverse step` will not reverse step into functions called by deferred calls.
================================================
FILE: Documentation/README.md
================================================
# Delve Documentation
Documentation for the project will reside in this directory.
- [Installation](installation)
- [Usage](usage)
- [Command Line Interface](cli)
- [API](api)
- [Internal](internal)
- [Editor Integration and Alternative UI](EditorIntegration.md)
- [Known Bugs](KnownBugs.md)
================================================
FILE: Documentation/api/ClientHowto.md
================================================
# How to write a Delve client, an informal guide
## Spawning the backend
The `dlv` binary built by our `Makefile` contains both the backend and a
simple command line client. If you are writing your own client you will
probably want to run only the backend, you can do this by specifying the
`--headless` option, for example:
```
$ dlv --headless debug
```
The rest of the command line remains unchanged. You can use `debug`, `exec`,
`test`, etc... along with `--headless` and they will work. If this project
is part of a larger IDE integration then you probably have your own build
system and do not wish to offload this task to Delve, in that case it's
perfectly fine to always use the `dlv exec` command but do remember that:
1. Delve may not have all the information necessary to properly debug optimized binaries, so it is recommended to disable them via: `-gcflags='all=-N -l`.
2. your users *do want* to debug their tests so you should also provide some way to build the test executable (equivalent to `go test -c --gcflags='all=-N -l'`) and pass it to Delve.
It would also be nice for your users if you provided a way to attach to a running process, like `dlv attach` does.
Command line arguments that should be handed to the inferior process should be specified on dlv's command line after a "--" argument:
```
dlv exec --headless ./somebinary -- these arguments are for the inferior process
```
Specifying a static port number, like in the [README](//github.com/go-delve/delve/tree/master/Documentation/README.md) example, can be done using `--listen=127.0.0.1:portnumber`.
This will, however, cause problems if you actually spawn multiple instances of the debugger.
It's probably better to let Delve pick a random unused port number on its own. To do this do not specify any `--listen` option and read one line of output from dlv's stdout. If the first line emitted by dlv starts with "API server listening at: " then dlv started correctly and the rest of the line specifies the address that Delve is listening at.
The `--log-dest` option can be used to redirect the "API server listening at:" message to a file or to a file descriptor. If the flag is not specified, the message will be output to stdout while other log messages are output to stderr.
## Controlling the backend
Once you have a running headless instance you can connect to it and start sending commands. Delve's protocol is built on top of the [JSON-RPC 1.0 specification](https://www.jsonrpc.org/specification_v1).
The methods of a `service/rpc2.RPCServer` are exposed through this connection, to find out which requests you can send see the documentation of RPCServer on [Go Reference](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer).
### Example
Let's say you are trying to create a breakpoint. By looking at [Go Reference](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer) you'll find that there is a `CreateBreakpoint` method in `RPCServer`.
This method, like all other methods of RPCServer that you can call through the API, has two arguments: `args` and `out`: `args` contains all the input arguments of `CreateBreakpoint`, while `out` is what `CreateBreakpoint` will return to you.
The call that you could want to make, in pseudo-code, would be:
```
RPCServer.CreateBreakpoint(CreateBreakpointIn{ File: "/User/you/some/file.go", Line: 16 })
```
To actually send this request on the JSON-RPC connection you just have to convert the CreateBreakpointIn object to json and then wrap everything into a JSON-RPC envelope:
```
{"method":"RPCServer.CreateBreakpoint","params":[{"Breakpoint":{"file":"/User/you/some/file.go","line":16}}],"id":27}
```
Delve will respond by sending a response packet that will look like this:
```
{"id":27, "result": {"Breakpoint": {"id":3, "name":"", "addr":4538829, "file":"/User/you/some/file.go", "line":16, "functionName":"main.main", "Cond":"", "continue":false, "goroutine":false, "stacktrace":0, "LoadArgs":null, "LoadLocals":null, "hitCount":{}, "totalHitCount":0}}, "error":null}
```
## Selecting the API version
Delve currently supports two version of its API, APIv1 and APIv2. By default
a headless instance of `dlv` will serve APIv1 for backward-compatibility
with older clients, however new clients should use APIv2 as new features
will only be made available through version 2. The preferred method of
switching to APIv2 is to send the `RPCServer.SetApiVersion` command right
after connecting to the backend.
Alternatively the `--api-version=2` command line option can be used when
spawning the backend.
## Diagnostics
Just like any other program, both Delve and your client have bugs. To help
with determining where the problem is you should log the exchange of
messages between Delve and your client somehow.
If you don't want to do this yourself you can also pass the options `--log
--log-output=rpc` to Delve. In fact the `--log-output` has many useful
values and you should expose it to users, if possible, so that we can
diagnose problems that are hard to reproduce.
## Using RPCServer.Command
`Command` is probably the most important API entry point. It lets your
client stop (`Name == "halt"`) and resume (`Name == "continue"`) execution
of the inferior process.
The return value of `Command` is a `DebuggerState` object. If you lose the
DebuggerState object returned by your last call to `Command` you can ask for
a new copy with `RPCServer.State`.
### Dealing with simultaneous breakpoints
Since Go is a programming language with a big emphasis on concurrency and
parallelism it's possible that multiple goroutines will stop at a breakpoint
simultaneously. This may at first seem incredibly unlikely but you must
understand that between the time a breakpoint is triggered and the point
where the debugger finishes stopping all threads of the inferior process
thousands of CPU instructions have to be executed, which make simultaneous
breakpoint triggering not that unlikely.
You should signal to your user *all* the breakpoints that occur after
executing a command, not just the first one. To do this iterate through the
`Threads` array in `DebuggerState` and note all the threads that have a non
nil `Breakpoint` member.
### Special continue commands
In addition to "halt" and vanilla "continue" `Command` offers a few extra
flavours of continue that automatically set interesting temporary
breakpoints: "next" will continue until the next line of the program,
"stepout" will continue until the function returns, "step" is just like
"next" but it will step into function calls (but skip all calls to
unexported runtime functions).
All of "next", "step" and "stepout" operate on the selected goroutine. The
selected goroutine is described by the `SelectedGoroutine` field of
`DebuggerState`. Every time `Command` returns the selected goroutine will be
reset to the goroutine that triggered the breakpoint.
If multiple breakpoints are triggered simultaneously the selected goroutine
will be chosen randomly between the goroutines that are stopped at a
breakpoint. If a breakpoint is hit by a thread that is executing on the
system stack *there will be no selected goroutine*. If the "halt" command is
called *there may not be a selected goroutine*.
The selected goroutine can be changed using the "switchGoroutine" command.
If "switchGoroutine" is used to switch to a goroutine that's currently
parked SelectedGoroutine and CurrentThread will be mismatched. Always prefer
SelectedGoroutine over CurrentThread, you should ignore CurrentThread
entirely unless SelectedGoroutine is nil.
### Special continue commands and asynchronous breakpoints
Because of the way go internals work it is not possible for a debugger to
resume a single goroutine. Therefore it's possible that after executing a
next/step/stepout a goroutine other than the goroutine the next/step/stepout
was executed on will hit a breakpoint.
If this happens Delve will return a DebuggerState with NextInProgress set to
true. When this happens your client has two options:
* You can signal that a different breakpoint was hit and then automatically attempt to complete the next/step/stepout by calling `RPCServer.Command` with `Name == "continue"`
* You can abort the next/step/stepout operation using `RPCServer.CancelNext`.
It is important to note that while NextInProgress is true it is not possible
to call next/step/stepout again without using CancelNext first. There can
not be multiple next/step/stepout operations in progress at any time.
### RPCServer.Command and stale executable files
It's possible (albeit unfortunate) that your user will decide to change the
source of the program being executed in the debugger, while the debugger is
running. Because of this it would be advisable that your client check that
the executable is not stale every time `Command` returns and notify the user
that the executable being run is stale and line numbers may nor align
properly anymore.
You can do this bookkeeping yourself, but Delve can also help you with the
`LastModified` call that returns the LastModified time of the executable
file when Delve started it.
## Using RPCServer.CreateBreakpoint
The only two fields you probably want to fill of the Breakpoint argument of
CreateBreakpoint are File and Line. The file name should be the absolute
path to the file as the compiler saw it.
For example if the compiler saw this path:
```
/Users/you/go/src/something/something.go
```
But `/Users/you/go/src/something` is a symbolic link to
`/Users/you/projects/golang/something` the path *must* be specified as
`/Users/you/go/src/something/something.go` and
`/Users/you/projects/golang/something/something.go` will not be recognized
as valid.
If you want to let your users specify a breakpoint on a function selected
from a list of all functions you should specify the name of the function in
the FunctionName field of Breakpoint.
If you want to support the [same language as dlv's break and trace commands](//github.com/go-delve/delve/tree/master/Documentation/cli/locspec.md)
you should call RPCServer.FindLocation and
then use the returned slice of Location objects to create Breakpoints to
pass to CreateBreakpoint: just fill each Breakpoint.Addr with the
contents of the corresponding Location.PC.
## Looking into variables
There are several API entry points to evaluate variables in Delve:
* RPCServer.ListPackageVars returns all global variables in all packages
* PRCServer.ListLocalVars returns all local variables of a stack frame
* RPCServer.ListFunctionArgs returns all function arguments of a stack frame
* RPCServer.Eval evaluates an expression on a given stack frame
All those API calls take a LoadConfig argument. The LoadConfig specifies how
much of the variable's value should actually be loaded. Because of
LoadConfig a variable could be loaded incompletely, you should always notify
the user of this:
* For strings, arrays, slices *and structs* the load is incomplete if: `Variable.Len > len(Variable.Children)`. This can happen to structs even if LoadConfig.MaxStructFields is -1 when MaxVariableRecurse is reached.
* For maps the load is incomplete if: `Variable.Len > len(Variable.Children) / 2`
* For interfaces the load is incomplete if the only children has the onlyAddr attribute set to true.
### Loading more of a Variable
You can also give the user an option to continue loading an incompletely
loaded variable. To load a struct that wasn't loaded automatically evaluate
the expression returned by:
```
fmt.Sprintf("*(*%q)(%#x)", v.Type, v.Addr)
```
where v is the variable that was truncated.
To load more elements from an array, slice or string:
```
fmt.Sprintf("(*(*%q)(%#x))[%d:]", v.Type, v.Addr, len(v.Children))
```
To load more elements from a map:
```
fmt.Sprintf("(*(*%q)(%#x))[%d:]", v.Type, v.Addr, len(v.Children)/2)
```
All the evaluation API calls except ListPackageVars also take a EvalScope
argument, this specifies which stack frame you are interested in. If you
are interested in the topmost stack frame of the current goroutine (or
thread) use: `EvalScope{ GoroutineID: -1, Frame: 0 }`.
More information on the expression language interpreted by RPCServer.Eval
can be found [here](//github.com/go-delve/delve/tree/master/Documentation/cli/expr.md).
### Variable shadowing
Let's assume you are debugging a piece of code that looks like this:
```
for i := 0; i < N; i++ {
for i := 0; i < M; i++ {
f(i) // <-- debugger is stopped here
}
}
```
The response to a ListLocalVars request will list two variables named `i`,
because at that point in the code two variables named `i` exist and are in
scope. Only one (the innermost one), however, is visible to the user. The
other one is *shadowed*.
Delve will tell you which variable is shadowed through the `Flags` field of
the `Variable` object. If `Flags` has the `VariableShadowed` bit set then
the variable in question is shadowed.
Users of your client should be able to distinguish between shadowed and
non-shadowed variables.
## Gracefully ending the debug session
To ensure that Delve cleans up after itself by deleting the `debug` or `debug.test` binary it creates
and killing any processes spawned by the program being debugged, the `Detach` command needs to be called.
In case you are disconnecting a running program, ensure to halt the program before trying to detach.
## Testing the Client
A set of [example programs is
available](https://github.com/aarzilli/delve_client_testing) to test corner
cases in handling breakpoints and displaying data structures. Follow the
instructions in the README.txt file.
================================================
FILE: Documentation/api/README.md
================================================
# Server/Client API Documentation
Delve exposes two API interfaces, JSON-RPC and DAP, so that frontends other than the built-in [terminal client](../cli/README.md), such as [IDEs and editors](../EditorIntegration.md), can interact with Delve programmatically. The [JSON-RPC API](json-rpc/README.md) is used by the [terminal client](../cli/README.md), and will always stay up to date in lockstep regardless of new features. The [DAP API](dap/README.md) is a popular generic API already in use by many [tools](https://microsoft.github.io/debug-adapter-protocol/implementors/tools/).
## Usage
In order to run Delve in "API mode", simply invoke with one of the standard commands, providing the `--headless` flag, like so:
```
$ dlv debug --headless --api-version=2 --log --log-output=debugger,dap,rpc --listen=127.0.0.1:8181
```
This will start the debugger in a non-interactive mode, listening on the specified address, and will enable logging. The logging flags as well as the server address are optional, of course.
Optionally, you may also specify the `--accept-multiclient` flag if you would like to connect multiple JSON-RPC or DAP clients to the API.
You can connect to the headless debugger from Delve itself using the `connect` subcommand:
```
$ dlv connect 127.0.0.1:8181
```
This can be useful for remote debugging.
## API Interfaces
Delve has been architected in such a way as to allow multiple client/server implementations. All of the "business logic" as it were is abstracted away from the actual client/server implementations, allowing for easy implementation of new API interfaces.
### Current API Interfaces
- [JSON-RPC](json-rpc/README.md)
- [DAP](dap/README.md)
================================================
FILE: Documentation/api/dap/README.md
================================================
# DAP Interface
Delve exposes a [DAP](https://microsoft.github.io/debug-adapter-protocol/overview) API interface.
This interface is served over a streaming TCP socket using `dlv` server in one of the two headless modes:
1. [`dlv dap`](../../usage/dlv_dap.md) - starts a single-use DAP-only server that waits for a client to specify launch/attach configuration for starting the debug session.
2. `dlv --headless <command> <debuggee>` - starts a general server, enters a debug session for the specified debuggee and waits for a [JSON-RPC](../json-rpc/README.md) or a [DAP](https://microsoft.github.io/debug-adapter-protocol/overview) remote-attach client to begin interactive debugging. Can be used in multi-client mode with the following options:
* `--accept-multiclient` - use to support connections from multiple clients
* `--continue` - use to resume debuggee execution as soon as server session starts
See [Launch and Attach Configurations](#launch-and-attach-configurations) for more usage details of these two options.
The primary user of this mode is [VS Code Go](https://github.com/golang/vscode-go). Please see its
detailed [debugging documentation](https://github.com/golang/vscode-go/blob/master/docs/debugging.md) for additional information.
## Debug Adapter Protocol
[DAP](https://microsoft.github.io/debug-adapter-protocol/specification) is a general debugging protocol supported by many [tools](https://microsoft.github.io/debug-adapter-protocol/implementors/tools/) and [programming languages](https://microsoft.github.io/debug-adapter-protocol/implementors/adapters/). We tailored it to Go specifics, such as mapping [threads request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Threads) to communicate goroutines and [exceptionInfo request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_ExceptionInfo) to support panics and fatal errors.
See [dap.Server.handleRequest](https://github.com/go-delve/delve/search?q=handleRequest) and capabilities set in [dap.Server.onInitializeRequest](https://github.com/go-delve/delve/search?q=onInitializeRequest) for an up-to-date list of supported requests and options.
## Launch and Attach Configurations
In addition to the general [DAP spec](https://microsoft.github.io/debug-adapter-protocol/specification), the server supports the following implementation-specific configuration options for starting the debug session:
<table border=1>
<tr><th>request<th>mode<th>required<th colspan=9>optional<th></tr>
<tr><td rowspan=5>launch<br><a href="https://pkg.go.dev/github.com/go-delve/delve/service/dap#LaunchConfig">godoc</a>
<td>debug<td>program <td>dlvCwd<td>env<td>backend<td>args<td>cwd<td>buildFlags<td>output<td>noDebug
<td rowspan=7>
substitutePath<br>
stopOnEntry<br>
stackTraceDepth<br>
showGlobalVariables<br>
showRegisters<br>
showPprofLabels<br>
hideSystemGoroutines<br>
goroutineFilters
</tr>
<tr>
<td>test<td>program <td>dlvCwd<td>env<td>backend<td>args<td>cwd<td>buildFlags<td>output<td>noDebug</tr>
<tr>
<td>exec<td>program <td>dlvCwd<td>env<td>backend<td>args<td>cwd<td> <td> <td>noDebug</tr>
<tr>
<td>core<td>program<br>corefilePath<td>dlvCwd<td>env<td> <td> <td> <td> <td> <td> </tr>
<tr>
<td>replay<td>traceDirPath <td>dlvCwd<td>env<td> <td> <td> <td> <td> <td> </tr>
<tr><td rowspan=2>attach<br><a href="https://pkg.go.dev/github.com/go-delve/delve/service/dap#AttachConfig">godoc</a>
<td>local<td>processId <td> <td> <td>backend<td> <td> <td> <td> <td> </tr>
<tr>
<td>remote<td> <td> <td> <td> <td> <td> <td> <td> <td> </tr>
</table>
Not all of the configurations are supported by each of the two available DAP servers:
<table border=1>
<tr>
<th>request<th>"mode":<th>`dlv dap`<th>`dlv --headless` <th> Description <th> Typical Client Usage
</tr>
<tr>
<td>launch<td>"debug"<br>"test"<br>"exec"<br>"replay"<br>"core"<td>supported<td>NOT supported <td> Tells the `dlv dap` server to launch the specified target and start debugging it.
<td rowspan=2>The client would launch the `dlv dap` server for the user or allow them to specify `host:port` of an external (a.k.a. remote) server.
<tr>
<td>attach<td>"local"<td>supported<td>NOT supported<td>Tells the `dlv dap` server to attach to an existing process local to the server.
</tr>
<tr>
<td>attach<td>"remote"<td>NOT supported<td>supported<td>Tells the `dlv --headless` server that it is expected to already be debugging a target specified as part of its command-line invocation.
<td>The client would expect `host:port` specification of an external (a.k.a. remote) server that the user already started with target <a href="https://github.com/go-delve/delve/blob/master/Documentation/usage/README.md">command and args</a>.
</tr>
</table>
## Disconnect and Shutdown
### Single-Client Mode
When used with `dlv dap` or `dlv --headless --accept-multiclient=false` (default), the DAP server will shut itself down at the end of the debug session, when the client sends a [disconnect request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect). If the debuggee was launched, it will be taken down as well. If the debuggee was attached to, `terminateDebuggee` option will be respected.
When the program terminates, we send a [terminated event](https://microsoft.github.io/debug-adapter-protocol/specification#Events_Terminated), which is expected to trigger a [disconnect request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect) from the client for a session and a server shutdown. The [restart request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Restart) is supported.
The server also shuts down in case of a client connection error or SIGTERM signal, taking down a launched process, but letting an attached process continue.
Pressing Ctrl-C on the terminal where a headless server is running sends SIGINT to the debuggee, foregrounded in headless mode to support debugging interactive programs.
### Multi-Client Mode
When used with `dlv --headless --accept-multiclient=true`, the DAP server will honor the multi-client mode when a client [disconnects](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect) or client connection fails. The server will remain running and ready for a new client connection, and the debuggee will remain in whatever state it was at the time of disconnect - running or halted. Once [`suspendDebuggee`](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect) option is supported by frontends like VS Code ([vscode/issues/134412](https://github.com/microsoft/vscode/issues/134412)), we will update the server to offer this as a way to specify debuggee state on disconnect.
The client may request full shutdown of the server and the debuggee with [`terminateDebuggee`](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Disconnect) option.
The server shuts down in response to a SIGTERM signal, taking down a launched process, but letting an attached process continue.
Pressing Ctrl-C on the terminal where a headless server is running sends SIGINT to the debuggee, foregrounded in headless mode to support debugging interactive programs.
## Debugger Output
The debugger always logs one of the following on start-up to stdout:
* `dlv dap`:
* `DAP server listening at: <host>:<port>`
* `dlv --headless`:
* `API server listening at: <host>:<port>`
This can be used to confirm that server start-up succeeded.
The server uses [output events](https://microsoft.github.io/debug-adapter-protocol/specification#Events_Output) to communicate errors and select status messages to the client. For example:
```
Step interrupted by a breakpoint. Use 'Continue' to resume the original step command.
invalid command: Unable to step while the previous step is interrupted by a breakpoint.
Use 'Continue' to resume the original step command.
Detaching and terminating target process
```
More detailed logging can be enabled with `--log --log-output=dap` as part of the [`dlv` command](../../usage/dlv.md).
It will record the server-side DAP message traffic. For example,
```
2022-01-04T00:27:57-08:00 debug layer=dap [<- from client]{"seq":1,"type":"request","command":"initialize","arguments":{"clientID":"vscode","clientName":"Visual Studio Code","adapterID":"go","locale":"en-us","linesStartAt1":true,"columnsStartAt1":true,"pathFormat":"path","supportsVariableType":true,"supportsVariablePaging":true,"supportsRunInTerminalRequest":true,"supportsMemoryReferences":true,"supportsProgressReporting":true,"supportsInvalidatedEvent":true}}
2022-01-04T00:27:57-08:00 debug layer=dap [-> to client]{"seq":0,"type":"response","request_seq":1,"success":true,"command":"initialize","body":{"supportsConfigurationDoneRequest":true,"supportsFunctionBreakpoints":true,"supportsConditionalBreakpoints":true,"supportsEvaluateForHovers":true,"supportsSetVariable":true,"supportsExceptionInfoRequest":true,"supportTerminateDebuggee":true,"supportsDelayedStackTraceLoading":true,"supportsLogPoints":true,"supportsDisassembleRequest":true,"supportsClipboardContext":true,"supportsSteppingGranularity":true,"supportsInstructionBreakpoints":true}}
2022-01-04T00:27:57-08:00 debug layer=dap [<- from client]{"seq":2,"type":"request","command":"launch","arguments":{"name":"Launch file","type":"go","request":"launch","mode":"debug","program":"./temp.go","hideSystemGoroutines":true,"__buildDir":"/Users/polina/go/src","__sessionId":"2ad0f0c1-a1fd-4fff-9fff-b8bc9a933fe5"}}
2022-01-04T00:27:57-08:00 debug layer=dap parsed launch config: {
"mode": "debug",
"program": "./temp.go",
"backend": "default",
"stackTraceDepth": 50,
"hideSystemGoroutines": true
}
...
```
This logging is written to stderr and is not forwarded via
[output events](https://microsoft.github.io/debug-adapter-protocol/specification#Events_Output).
## Debuggee Output
Debuggee's stdout and stderr are written to stdout and stderr respectfully and are not forwarded via
[output events](https://microsoft.github.io/debug-adapter-protocol/specification#Events_Output).
## Versions
The initial DAP support was released in [v1.6.1](https://github.com/go-delve/delve/releases/tag/v1.6.1) with many additional improvements in subsequent versions. The [remote attach](https://github.com/go-delve/delve/issues/2328) support was added in [v1.7.3](https://github.com/go-delve/delve/releases/tag/v1.7.3). The [restart request](https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Restart) support was added in [v1.25.1](https://github.com/go-delve/delve/releases/tag/v1.25.1).
The DAP API changes are backward-compatible as all new features are opt-in only. To update to a new [DAP version](https://microsoft.github.io/debug-adapter-protocol/changelog) and import a new DAP feature into delve,
one must first update the [go-dap](https://github.com/google/go-dap) dependency.
<!--- TODO:
- most requests are handled synchronously and block
- hence many commands not supported when running, but setting breakpoints is
--->
================================================
FILE: Documentation/api/json-rpc/README.md
================================================
# JSON-RPC interface
Delve exposes a [JSON-RPC](https://www.jsonrpc.org/specification_v1) API interface.
Note that this JSON-RPC interface is served over a streaming socket, *not* over HTTP.
# API versions
Delve currently only supports v2 of its API. Support for v1 was dropped in version v1.24.0 of Delve.
# API version 2 documentation
All the methods of the type `service/rpc2.RPCServer` can be called using JSON-RPC, the documentation for these calls is [available on godoc](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer).
Note that all exposed methods take one single input parameter (usually called `args`) of a struct type and also return a result of a struct type. Also note that the method name should be prefixed with `RPCServer.` in JSON-RPC.
# Example
Your client wants to set a breakpoint on the function `main.main`.
The first step will be calling the method `FindLocation` with `Scope = api.EvalScope{ GoroutineID: -1, Frame: 0}` and `Loc = "main.main"`. The JSON-RPC request packet should look like this:
```
{"method":"RPCServer.FindLocation","params":[{"Scope":{"GoroutineID":-1,"Frame":0},"Loc":"main.main"}],"id":2}
```
the response packet will look like this:
```
{"id":2,"result":{"Locations":[{"pc":4199019,"file":"/home/a/temp/callme/callme.go","line":31,"function":{"name":"main.main","value":4198992,"type":84,"goType":0}}]},"error":null}
```
Now your client should call the method `CreateBreakpoint` and specify `4199019` (the `pc` field in the response object) as the target address:
```
{"method":"RPCServer.CreateBreakpoint","params":[{"Breakpoint":{"addr":4199019}}],"id":3}
```
if this request is successful your client will receive the following response:
```
{"id":3,"result":{"Breakpoint":{"id":1,"name":"","addr":4199019,"file":"/home/a/temp/callme/callme.go","line":31,"functionName":"main.main","Cond":"","continue":false,"goroutine":false,"stacktrace":0,"LoadArgs":null,"LoadLocals":null,"hitCount":{},"totalHitCount":0}},"error":null}
```
================================================
FILE: Documentation/backend_test_health.md
================================================
Tests skipped by each supported backend:
* 386 skipped = 11
* 1 broken
* 3 broken - cgo stacktraces
* 6 not implemented
* 1 not working due to optimizations
* arm64 skipped = 1
* 1 broken - global variable symbolication
* darwin skipped = 5
* 4 follow exec not implemented on macOS
* 1 waitfor implementation is delegated to debugserver
* darwin/arm64 skipped = 1
* 1 broken - cgo stacktraces
* darwin/lldb skipped = 1
* 1 upstream issue
* freebsd skipped = 15
* 2 flaky
* 4 follow exec not implemented on freebsd
* 7 not implemented
* 2 not working on freebsd
* linux/386 skipped = 2
* 2 not working on linux/386
* linux/386/pie skipped = 1
* 1 broken
* linux/loong64 skipped = 1
* 1 not working on linux/loong64
* linux/ppc64le skipped = 3
* 1 broken - cgo stacktraces
* 2 not working on linux/ppc64le when -gcflags=-N -l is passed
* linux/ppc64le/native skipped = 1
* 1 broken in linux ppc64le
* linux/ppc64le/native/pie skipped = 3
* 3 broken - pie mode
* linux/riscv64 skipped = 1
* 1 not working on linux/riscv64
* loong64 skipped = 7
* 1 broken - global variable symbolication
* 6 not implemented
* pie skipped = 2
* 2 upstream issue - https://github.com/golang/go/issues/29322
* ppc64le skipped = 14
* 6 broken
* 1 broken - global variable symbolication
* 7 not implemented
* riscv64 skipped = 6
* 1 broken - global variable symbolication
* 5 not implemented
* windows skipped = 9
* 1 broken
* 2 not working on windows
* 6 see https://github.com/go-delve/delve/issues/2768
* windows/arm64 skipped = 3
* 2 broken - cgo stacktraces
* 1 flaky
================================================
FILE: Documentation/cli/README.md
================================================
# Configuration and Command History
If `$XDG_CONFIG_HOME` is set, then configuration and command history files are located in `$XDG_CONFIG_HOME/dlv`. Otherwise, they are located in `$HOME/.config/dlv` on Linux and `$HOME/.dlv` on other systems.
The configuration file `config.yml` contains all the configurable options and their default values ([config.yml documentation](./config.md)). The command history is stored in `.dbg_history`.
# Commands
## Running the program
Command | Description
--------|------------
[call](#call) | Resumes process, injecting a function call (EXPERIMENTAL!!!)
[continue](#continue) | Run until breakpoint or program termination.
[next](#next) | Step over to next source line.
[next-instruction](#next-instruction) | Single step a single cpu instruction, skipping function calls.
[rebuild](#rebuild) | Rebuild the target executable and restarts it. It does not work if the executable was not built by delve.
[restart](#restart) | Restart process.
[rev](#rev) | Reverses the execution of the target program for the command specified.
[rewind](#rewind) | Run backwards until breakpoint or start of recorded history.
[step](#step) | Single step through program.
[step-instruction](#step-instruction) | Single step a single cpu instruction.
[stepout](#stepout) | Step out of the current function.
## Manipulating breakpoints
Command | Description
--------|------------
[break](#break) | Sets a breakpoint.
[breakpoints](#breakpoints) | Print out info for active breakpoints.
[clear](#clear) | Deletes breakpoint.
[clearall](#clearall) | Deletes multiple breakpoints.
[condition](#condition) | Set breakpoint condition.
[on](#on) | Executes a command when a breakpoint is hit.
[toggle](#toggle) | Toggles on or off a breakpoint.
[trace](#trace) | Set tracepoint.
[watch](#watch) | Set watchpoint.
## Viewing program variables and memory
Command | Description
--------|------------
[args](#args) | Print function arguments.
[display](#display) | Print value of an expression every time the program stops.
[examinemem](#examinemem) | Examine raw memory at the given address.
[locals](#locals) | Print local variables.
[print](#print) | Evaluate an expression.
[regs](#regs) | Print contents of CPU registers.
[set](#set) | Changes the value of a variable.
[vars](#vars) | Print package variables.
[whatis](#whatis) | Prints type of an expression.
## Listing and switching between threads and goroutines
Command | Description
--------|------------
[goroutine](#goroutine) | Shows or changes current goroutine
[goroutines](#goroutines) | List program goroutines.
[thread](#thread) | Switch to the specified thread.
[threads](#threads) | Print out info for every traced thread.
## Viewing the call stack and selecting frames
Command | Description
--------|------------
[deferred](#deferred) | Executes command in the context of a deferred call.
[down](#down) | Move the current frame down.
[frame](#frame) | Set the current frame, or execute command on a different frame.
[stack](#stack) | Print stack trace.
[up](#up) | Move the current frame up.
## Other commands
Command | Description
--------|------------
[check](#check) | Creates a checkpoint at the current position.
[checkpoints](#checkpoints) | Print out info for existing checkpoints.
[clear-checkpoint](#clear-checkpoint) | Deletes checkpoint.
[config](#config) | Changes configuration parameters.
[disassemble](#disassemble) | Disassembler.
[dump](#dump) | Creates a core dump from the current process state
[edit](#edit) | Open where you are in $DELVE_EDITOR or $EDITOR
[exit](#exit) | Exit the debugger.
[funcs](#funcs) | Print list of functions.
[help](#help) | Prints the help message.
[libraries](#libraries) | List loaded dynamic libraries.
[list](#list) | Show source code.
[packages](#packages) | Print list of packages.
[source](#source) | Executes a file containing a list of delve commands
[sources](#sources) | Print list of source files.
[target](#target) | Manages child process debugging.
[transcript](#transcript) | Appends command output to a file.
[types](#types) | Print list of types
## args
Print function arguments.
[goroutine <n>] [frame <m>] args [-v] [<regex>]
If regex is specified only function arguments with a name matching it will be returned. If -v is specified more information about each function argument will be shown.
## break
Sets a breakpoint.
break [name] [locspec] [if <condition>]
Locspec is a location specifier in the form of:
* *<address> Specifies the location of memory address address. address can be specified as a decimal, hexadecimal or octal number
* <filename>:<line> Specifies the line in filename. filename can be the partial path to a file or even just the base name as long as the expression remains unambiguous.
* <line> Specifies the line in the current file
* +<offset> Specifies the line offset lines after the current one
* -<offset> Specifies the line offset lines before the current one
* <function>[:<line>] Specifies the line inside function.
The full syntax for function is <package>.(*<receiver type>).<function name> however the only required element is the function name,
everything else can be omitted as long as the expression remains unambiguous. For setting a breakpoint on an init function (ex: main.init),
the <filename>:<line> syntax should be used to break in the correct init function at the correct location.
* /<regex>/ Specifies the location of all the functions matching regex
If locspec is omitted a breakpoint will be set on the current line.
If you would like to assign a name to the breakpoint you can do so with the form:
break mybpname main.go:4
Finally, you can assign a condition to the newly created breakpoint by using the 'if' postfix form, like so:
break main.go:55 if i == 5
Alternatively you can set a condition on a breakpoint after created by using the 'on' command.
See also: "help on", "help cond" and "help clear"
Aliases: b
## breakpoints
Print out info for active breakpoints.
breakpoints [-a] [-save <filename>]
Specifying -a prints all physical breakpoint, including internal breakpoints.
Speciftying -save <filename> saves all breakpoints to the specified file in a format that can be loaded later using the 'source' command.
Aliases: bp
## call
Resumes process, injecting a function call (EXPERIMENTAL!!!)
call [-unsafe] <function call expression>
Current limitations:
- only pointers to stack-allocated objects can be passed as argument.
- only some automatic type conversions are supported.
- functions can only be called on running goroutines that are not
executing the runtime.
- the current goroutine needs to have at least 256 bytes of free space on
the stack.
- functions can only be called when the goroutine is stopped at a safe
point.
- calling a function will resume execution of all goroutines.
- only supported on linux's native backend.
## check
Creates a checkpoint at the current position.
checkpoint [note]
The "note" is arbitrary text that can be used to identify the checkpoint, if it is not specified it defaults to the current filename:line position.
Aliases: checkpoint
## checkpoints
Print out info for existing checkpoints.
## clear
Deletes breakpoint.
clear <breakpoint name or id>
## clear-checkpoint
Deletes checkpoint.
clear-checkpoint <id>
Aliases: clearcheck
## clearall
Deletes multiple breakpoints.
clearall [<locspec>]
If called with the locspec argument it will delete all the breakpoints matching the locspec. If locspec is omitted all breakpoints are deleted.
## condition
Set breakpoint condition.
condition <breakpoint name or id> <boolean expression>.
condition -hitcount <breakpoint name or id> <operator> <argument>.
condition -per-g-hitcount <breakpoint name or id> <operator> <argument>.
condition -clear <breakpoint name or id>.
Specifies that the breakpoint, tracepoint or watchpoint should break only if the boolean expression is true.
See [Documentation/cli/expr.md](//github.com/go-delve/delve/tree/master/Documentation/cli/expr.md) for a description of supported expressions and [Documentation/cli/cond.md](//github.com/go-delve/delve/tree/master/Documentation/cli/cond.md) for a description of how breakpoint conditions are evaluated.
With the -hitcount option a condition on the breakpoint hit count can be set, the following operators are supported
condition -hitcount bp > n
condition -hitcount bp >= n
condition -hitcount bp < n
condition -hitcount bp <= n
condition -hitcount bp == n
condition -hitcount bp != n
condition -hitcount bp % n
The -per-g-hitcount option works like -hitcount, but use per goroutine hitcount to compare with n.
With the -clear option a condition on the breakpoint can removed.
The '% n' form means we should stop at the breakpoint when the hitcount is a multiple of n.
Examples:
cond 2 i == 10 breakpoint 2 will stop when variable i equals 10
cond name runtime.curg.goid == 5 breakpoint 'name' will stop only on goroutine 5
cond -clear 2 the condition on breakpoint 2 will be removed
Aliases: cond
## config
Changes configuration parameters.
config -list
Show all configuration parameters.
config -save
Saves the configuration file to disk, overwriting the current configuration file.
config <parameter> <value>
Changes the value of simple configuration parameters.
Use 'help config <parameter>' for more informations on specific configuration options.
## continue
Run until breakpoint or program termination.
continue [<locspec>]
Optional locspec argument allows you to continue until a specific location is reached. The program will halt if a breakpoint is hit before reaching the specified location.
For example:
continue main.main
continue encoding/json.Marshal
Aliases: c
## deferred
Executes command in the context of a deferred call.
deferred <n> <command>
Executes the specified command (print, args, locals) in the context of the n-th deferred call in the current frame.
## disassemble
Disassembler.
[goroutine <n>] [frame <m>] disassemble [-a <start> <end>] [-l <locspec>]
If no argument is specified the function being executed in the selected stack frame will be executed.
-a <start> <end> disassembles the specified address range
-l <locspec> disassembles the specified function
Aliases: disass
## display
Print value of an expression every time the program stops.
display -a [%format] <expression>
display -d <number>
The '-a' option adds an expression to the list of expression printed every time the program stops. The '-d' option removes the specified expression from the list.
If display is called without arguments it will print the value of all expression in the list.
## down
Move the current frame down.
down [<m>]
down [<m>] <command>
Move the current frame down by <m>. The second form runs the command on the given frame.
## dump
Creates a core dump from the current process state
dump <output file>
The core dump is always written in ELF, even on systems (windows, macOS) where this is not customary. For environments other than linux/amd64 threads and registers are dumped in a format that only Delve can read back.
## edit
Open where you are in $DELVE_EDITOR or $EDITOR
edit [locspec]
If locspec is omitted edit will open the current source file in the editor, otherwise it will open the specified location.
Aliases: ed
## examinemem
Examine raw memory at the given address.
Examine memory:
examinemem [-fmt <format>] [-count|-len <count>] [-size <size>] <address>
examinemem [-fmt <format>] [-count|-len <count>] [-size <size>] -x <expression>
Format represents the data format and the value is one of this list (default hex): bin(binary), oct(octal), dec(decimal), hex(hexadecimal) and raw.
Length is the number of bytes (default 1) and must be less than or equal to 1000.
Address is the memory location of the target to examine. Please note '-len' is deprecated by '-count and -size'.
Expression can be an integer expression or pointer value of the memory location to examine.
For example:
x -fmt hex -count 20 -size 1 0xc00008af38
x -fmt hex -count 20 -size 1 -x 0xc00008af38 + 8
x -fmt hex -count 20 -size 1 -x &myVar
x -fmt hex -count 20 -size 1 -x myPtrVar
Aliases: x
## exit
Exit the debugger.
exit [-c]
When connected to a headless instance started with the --accept-multiclient, pass -c to resume the execution of the target process before disconnecting.
Aliases: quit q
## frame
Set the current frame, or execute command on a different frame.
frame <m>
frame <m> <command>
The first form sets frame used by subsequent commands such as "print" or "set".
The second form runs the command on the given frame.
## funcs
Print list of functions.
funcs [<regex>]
If regex is specified only the functions matching it will be returned.
## goroutine
Shows or changes current goroutine
goroutine
goroutine <id>
goroutine <id> <command>
Called without arguments it will show information about the current goroutine.
Called with a single argument it will switch to the specified goroutine.
Called with more arguments it will execute a command on the specified goroutine.
Aliases: gr
## goroutines
List program goroutines.
goroutines [-u|-r|-g|-s] [-t [depth]] [-l] [-with loc expr] [-without loc expr] [-group argument] [-chan expr] [-exec command]
Print out info for every goroutine. The flag controls what information is shown along with each goroutine:
-u displays location of topmost stackframe in user code (default)
-r displays location of topmost stackframe (including frames inside private runtime functions)
-g displays location of go instruction that created the goroutine
-s displays location of the start function
-t displays goroutine's stacktrace (an optional depth value can be specified, default: 10)
-l displays goroutine's labels
If no flag is specified the default is -u, i.e. the first frame within the first 30 frames that is not executing a runtime private function.
FILTERING
If -with or -without are specified only goroutines that match the given condition are returned.
To only display goroutines where the specified location contains (or does not contain, for -without and -wo) expr as a substring, use:
goroutines -with (userloc|curloc|goloc|startloc) expr
goroutines -w (userloc|curloc|goloc|startloc) expr
goroutines -without (userloc|curloc|goloc|startloc) expr
goroutines -wo (userloc|curloc|goloc|startloc) expr
Where:
userloc: filter by the location of the topmost stackframe in user code
curloc: filter by the location of the topmost stackframe (including frames inside private runtime functions)
goloc: filter by the location of the go instruction that created the goroutine
startloc: filter by the location of the start function
To only display goroutines that have (or do not have) the specified label key and value, use:
goroutines -with label key=value
goroutines -without label key=value
To only display goroutines that have (or do not have) the specified label key, use:
goroutines -with label key
goroutines -without label key
To only display goroutines that are running (or are not running) on a OS thread, use:
goroutines -with running
goroutines -without running
To only display user (or runtime) goroutines, use:
goroutines -with user
goroutines -without user
CHANNELS
To only show goroutines waiting to send to or receive from a specific channel use:
goroutines -chan expr
Note that 'expr' must not contain spaces.
GROUPING
goroutines -group (userloc|curloc|goloc|startloc|running|user)
Where:
userloc: groups goroutines by the location of the topmost stackframe in user code
curloc: groups goroutines by the location of the topmost stackframe
goloc: groups goroutines by the location of the go instruction that created the goroutine
startloc: groups goroutines by the location of the start function
running: groups goroutines by whether they are running or not
user: groups goroutines by whether they are user or runtime goroutines
Groups goroutines by the given location, running status or user classification, up to 5 goroutines per group will be displayed as well as the total number of goroutines in the group.
goroutines -group label key
Groups goroutines by the value of the label with the specified key.
EXEC
goroutines -exec <command>
Runs the command on every goroutine.
Aliases: grs
## help
Prints the help message.
help [command]
Type "help" followed by the name of a command for more information about it.
Aliases: h
## libraries
List loaded dynamic libraries.
libraries [-d N]
If used with the -d option it will re-attempt to download the debug symbols for library N, using debuginfod-find.
## list
Show source code.
[goroutine <n>] [frame <m>] list [<locspec>]
Show source around current point or provided locspec.
For example:
frame 1 list 69
list testvariables.go:10000
list main.main:30
list 40
Aliases: ls l
## locals
Print local variables.
[goroutine <n>] [frame <m>] locals [-v] [<regex>]
The name of variables that are shadowed in the current scope will be shown in parenthesis.
If regex is specified only local variables with a name matching it will be returned. If -v is specified more information about each local variable will be shown.
## next
Step over to next source line.
next [count]
Optional [count] argument allows you to skip multiple lines.
Aliases: n
## next-instruction
Single step a single cpu instruction, skipping function calls.
Aliases: ni nexti
## on
Executes a command when a breakpoint is hit.
on <breakpoint name or id> <command>
on <breakpoint name or id> -edit
Supported commands: print, stack, goroutine, trace and cond.
All custom starlark commands can also be used with the 'on' prefix. See [Documentation/cli/starlark.md](//github.com/go-delve/delve/tree/master/Documentation/cli/starlark.md) for more information.
To convert a breakpoint into a tracepoint use:
on <breakpoint name or id> trace
The command 'on <bp> cond <cond-arguments>' is equivalent to 'cond <bp> <cond-arguments>'.
The command 'on x -edit' can be used to edit the list of commands executed when the breakpoint is hit.
## packages
Print list of packages.
packages [<regex>]
If regex is specified only the packages matching it will be returned.
## print
Evaluate an expression.
[goroutine <n>] [frame <m>] print [%format] <expression>
See [Documentation/cli/expr.md](//github.com/go-delve/delve/tree/master/Documentation/cli/expr.md) for a description of supported expressions.
The optional format argument is a format specifier, like the ones used by the fmt package. For example "print %x v" will print v as an hexadecimal number.
Aliases: p
## rebuild
Rebuild the target executable and restarts it. It does not work if the executable was not built by delve.
## regs
Print contents of CPU registers.
regs [-a]
Argument -a shows more registers. Individual registers can also be displayed by 'print' and 'display'. See [Documentation/cli/expr.md](//github.com/go-delve/delve/tree/master/Documentation/cli/expr.md).
## restart
Restart process.
For recorded targets the command takes the following forms:
restart resets to the start of the recording
restart [checkpoint] resets the recording to the given checkpoint
restart -r [newargv...] [redirects...] re-records the target process
For live targets the command takes the following forms:
restart [newargv...] [redirects...] restarts the process
If newargv is omitted the process is restarted (or re-recorded) with the same argument vector.
If -noargs is specified instead, the argument vector is cleared.
A list of file redirections can be specified after the new argument list to override the redirections defined using the '--redirect' command line option. A syntax similar to Unix shells is used:
<input.txt redirects the standard input of the target process from input.txt
>output.txt redirects the standard output of the target process to output.txt
2>error.txt redirects the standard error of the target process to error.txt
Aliases: r
## rev
Reverses the execution of the target program for the command specified.
Currently, rev next, step, step-instruction and stepout commands are supported.
## rewind
Run backwards until breakpoint or start of recorded history.
Aliases: rw
## set
Changes the value of a variable.
[goroutine <n>] [frame <m>] set <variable> = <value>
See [Documentation/cli/expr.md](//github.com/go-delve/delve/tree/master/Documentation/cli/expr.md) for a description of supported expressions. Only numerical variables and pointers can be changed.
## source
Executes a file containing a list of delve commands
source <path>
If path ends with the .star extension it will be interpreted as a starlark script. See [Documentation/cli/starlark.md](//github.com/go-delve/delve/tree/master/Documentation/cli/starlark.md) for the syntax.
If path is a single '-' character an interactive starlark interpreter will start instead. Type 'exit' to exit.
## sources
Print list of source files.
sources [<regex>]
If regex is specified only the source files matching it will be returned.
## stack
Print stack trace.
[goroutine <n>] [frame <m>] stack [<depth>] [-full] [-offsets] [-defer] [-a <n>] [-adepth <depth>] [-mode <mode>]
-full every stackframe is decorated with the value of its local variables and arguments.
-offsets prints frame offset of each frame.
-defer prints deferred function call stack for each frame.
-a <n> prints stacktrace of n ancestors of the selected goroutine (target process must have tracebackancestors enabled)
-adepth <depth> configures depth of ancestor stacktrace
-mode <mode> specifies the stacktrace mode, possible values are:
normal - attempts to automatically switch between cgo frames and go frames
simple - disables automatic switch between cgo and go
fromg - starts from the registers stored in the runtime.g struct
Aliases: bt
## step
Single step through program.
Aliases: s
## step-instruction
Single step a single cpu instruction.
Aliases: si stepi
## stepout
Step out of the current function.
Aliases: so
## target
Manages child process debugging.
target follow-exec [-on [regex]] [-off]
Enables or disables follow exec mode. When follow exec mode Delve will automatically attach to new child processes executed by the target process. An optional regular expression can be passed to 'target follow-exec', only child processes with a command line matching the regular expression will be followed.
target list
List currently attached processes.
target switch [pid]
Switches to the specified process.
## thread
Switch to the specified thread.
thread <id>
Aliases: tr
## threads
Print out info for every traced thread.
## toggle
Toggles on or off a breakpoint.
toggle <breakpoint name or id>
## trace
Set tracepoint.
trace [name] [locspec]
A tracepoint is a breakpoint that does not stop the execution of the program, instead when the tracepoint is hit a notification is displayed. See [Documentation/cli/locspec.md](//github.com/go-delve/delve/tree/master/Documentation/cli/locspec.md) for the syntax of locspec. If locspec is omitted a tracepoint will be set on the current line.
See also: "help on", "help cond" and "help clear"
Aliases: t
## transcript
Appends command output to a file.
transcript [-t] [-x] <output file>
transcript -off
Output of Delve's command is appended to the specified output file. If '-t' is specified and the output file exists it is truncated. If '-x' is specified output to stdout is suppressed instead.
Using the -off option disables the transcript.
## types
Print list of types
types [<regex>]
If regex is specified only the types matching it will be returned.
## up
Move the current frame up.
up [<m>]
up [<m>] <command>
Move the current frame up by <m>. The second form runs the command on the given frame.
## vars
Print package variables.
vars [-v] [<regex>]
If regex is specified only package variables with a name matching it will be returned. If -v is specified more information about each package variable will be shown.
## watch
Set watchpoint.
watch [-r|-w|-rw] <expr>
-r stops when the memory location is read
-w stops when the memory location is written
-rw stops when the memory location is read or written
The memory location is specified with the same expression language used by 'print', for example:
watch v
watch -w *(*int)(0x1400007c018)
will watch the address of variable 'v' and writes to an int at addr '0x1400007c018'.
Note that writes that do not change the value of the watched memory address might not be reported.
See also: "help print".
## whatis
Prints type of an expression.
whatis <expression>
================================================
FILE: Documentation/cli/cond.md
================================================
# Breakpoint conditions
Breakpoints have two conditions:
* The normal condition, which is specified using the command `cond <breakpoint> <expr>` (or by setting the Cond field when amending a breakpoint via the API), is any [expression](expr.md) which evaluates to true or false.
* The hitcount condition, which is specified `cond <breakpoint> -hitcount <operator> <number>` (or by setting the HitCond field when amending a breakpoint via the API), is a constraint on the number of times the breakpoint has been hit.
When a breakpoint location is encountered during the execution of the program, the debugger will:
* Evaluate the normal condition
* Stop if there is an error while evaluating the normal condition
* If the normal condition evaluates to true the hit count is incremented
* Evaluate the hitcount condition
* If the hitcount condition is also satisfied stop the execution at the breakpoint
================================================
FILE: Documentation/cli/config.md
================================================
# Configuration
The configuration file `config.yml` is found in `$XDG_CONFIG_HOME/dlv` if `$XDG_CONFIG_HOME` is set, if it isn't set it will be in `$HOME/.config/dlv` on Linux and `$HOME/.dlv` in other operating systems.
The following options are available:
Option | Description
-------|------------
aliases | Map fo command aliases `command: [ "alias1", "alias2" ]`.
debug-info-directories | List of directories to use when searching for separate debug info files.
disassemble-flavor | Disassembler syntax. Can be 'intel', 'gun' or 'go'.
max-array-values | Maximum number of array values when printing variables.
max-string-len | Maximum string length used when printing variables.
max-variable-recurse | Maximum number of nested struct members when printing variables.
position | Controls how the current position in the program is displayed (source | disassembly | default).
prompt | Controls Delve's command line prompt. Use `help config prompt` for documentation on the available escape codes.
prompt-color | Prompt color, as a terminal escape sequence.
show-location-expr | If true the 'whatis' command will print the DWARF location expression of its argument.
source-list-arrow-color | Source list arrow color, as a terminal escape sequence.
source-list-comment-color | Source list comment color, as a terminal escape sequence.
source-list-keyword-color | Source list keyword color, as a terminal escape sequence.
source-list-line-color | Source list line-number color, as a terminal escape sequence.
source-list-line-count | Number of lines to list above and below the cursor when printing source code.
source-list-number-color | Source list number color, as a terminal escape sequence.
source-list-string-color | Source list string color, as a terminal escape sequence.
source-list-tab-color | Source list tab color, as a terminal escape sequence.
stacktrace-basename-color | Color for the base name in paths in the stack trace, as a terminal escape sequence.
stacktrace-function-color | Color for function names in the stack trace, as a terminal escape sequence.
substitute-path | Path substitution rules, a list of `{ from: path, to: path }` pairs.
tab | Changes what is printed when a tab character is encountered in source code.
trace-show-timestamp | If true timestamps are shown in the trace output.
================================================
FILE: Documentation/cli/expr.md
================================================
# Expressions
Delve can evaluate a subset of go expression language, specifically the following features are supported:
- All (binary and unary) on basic types except <-, ++ and --
- Comparison operators on any type
- Type casts between numeric types
- Type casts of integer constants into any pointer type and vice versa
- Type casts between string, []byte and []rune
- Struct member access (i.e. `somevar.memberfield`)
- Slicing and indexing operators on arrays, slices and strings
- Map access
- Pointer dereference
- Calls to builtin functions: `cap`, `len`, `complex`, `imag` and `real`
- Type assertion on interface variables (i.e. `somevar.(concretetype)`)
# Nesting limit
When delve evaluates a memory address it will automatically return the value of nested struct members, array and slice items and dereference pointers.
However to limit the size of the output evaluation will be limited to two levels deep. Beyond two levels only the address of the item will be returned, for example:
```
(dlv) print c1
main.cstruct {
pb: *struct main.bstruct {
a: (*main.astruct)(0xc82000a430),
},
sa: []*main.astruct len: 3, cap: 3, [
*(*main.astruct)(0xc82000a440),
*(*main.astruct)(0xc82000a450),
*(*main.astruct)(0xc82000a460),
],
}
```
To see the contents of the first item of the slice `c1.sa` there are two possibilities:
1. Execute `print c1.sa[0]`
2. Use the address directly, executing: `print *(*main.astruct)(0xc82000a440)`
# Elements limit
For arrays, slices, strings and maps delve will only return a maximum of 64 elements at a time:
```
(dlv) print ba
[]int len: 200, cap: 200, [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,...+136 more]
```
To see more values use the slice operator:
```
(dlv) print ba[64:]
[]int len: 136, cap: 136, [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,...+72 more]
```
For this purpose delve allows use of the slice operator on maps, `m[64:]` will return the key/value pairs of map `m` that follow the first 64 key/value pairs (note that delve iterates over maps using a fixed ordering).
These limits can be configured with `max-string-len` and `max-array-values`. See [config](https://github.com/go-delve/delve/tree/master/Documentation/cli#config) for usage.
# Interfaces
Interfaces will be printed using the following syntax:
```
<interface name>(<concrete type>) <value>
```
For example:
```
(dlv) p iface1
(dlv) p iface1
interface {}(*struct main.astruct) *{A: 1, B: 2}
(dlv) p iface2
interface {}(*struct string) *"test"
(dlv) p err1
error(*struct main.astruct) *{A: 1, B: 2}
```
To use the contents of an interface variable use a type assertion:
```
(dlv) p iface1.(*main.astruct).B
2
```
Or just use the special `.(data)` type assertion:
```
(dlv) p iface1.(data).B
2
```
If the contents of the interface variable are a struct or a pointer to struct the fields can also be accessed directly:
```
(dlv) p iface1.B
2
```
# Specifying package paths
Packages with the same name can be disambiguated by using the full package path. For example, if the application imports two packages, `some/package` and `some/other/package`, both defining a variable `A`, the two variables can be accessed using this syntax:
```
(dlv) p "some/package".A
(dlv) p "some/other/package".A
```
# Pointers in Cgo
Char pointers are always treated as NUL terminated strings, both indexing and the slice operator can be applied to them. Other C pointers can also be used similarly to Go slices, with indexing and the slice operator. In both of these cases it is up to the user to respect array bounds.
# Special Features
## Special Variables
Delve defines two special variables:
* `runtime.curg` evaluates to the 'g' struct for the current goroutine, in particular `runtime.curg.goid` is the goroutine id of the current goroutine.
* `runtime.frameoff` is the offset of the frame's base address from the bottom of the stack.
* `delve.bphitcount[X]` is the total hitcount for breakpoint X, which can be either an ID or the breakpoint name as a string.
## Access to variables from previous frames
Variables from previous frames (i.e. stack frames other than the top of the stack) can be referred using the following notation `runtime.frame(n).name` which is the variable called 'name' on the n-th frame from the top of the stack.
## CPU Registers
The name of a CPU register, in all uppercase letters, will resolve to the value of that CPU register in the current frame. For example on AMD64 the expression `RAX` will evaluate to the value of the RAX register.
Register names are shadowed by both local and global variables, so if a local variable called "RAX" exists, the `RAX` expression will evaluate to it instead of the CPU register.
Register names can optionally be prefixed by any number of underscore characters, so `RAX`, `_RAX`, `__RAX`, etc... can all be used to refer to the same RAX register and, in absence of shadowing from other variables, will all evaluate to the same value.
Registers of 64bits or less are returned as uint64 variables. Larger registers are returned as strings of hexadecimal digits.
Because many architectures have SIMD registers that can be used by the application in different ways the following syntax is also available:
* `REGNAME.intN` returns the register REGNAME as an array of intN elements.
* `REGNAME.uintN` returns the register REGNAME as an array of uintN elements.
* `REGNAME.floatN` returns the register REGNAME as an array of floatN elements.
In all cases N must be a power of 2.
================================================
FILE: Documentation/cli/getting_started.md
================================================
# Getting Started
Delve aims to be a very simple and powerful tool, but can be confusing if you're
not used to using a source level debugger in a compiled language. This document
will provide all the information you need to get started debugging your Go
programs.
## Debugging 'main' packages
The first CLI subcommand we will explore is `debug`. This subcommand can be run
without arguments if you're in the same directory as your `main` package,
otherwise it optionally accepts a package path.
For example given this project layout:
```
github.com/me/foo
├── cmd
│ └── foo
│ └── main.go
└── pkg
└── baz
├── bar.go
└── bar_test.go
```
If you are in the directory `github.com/me/foo/cmd/foo` you can simply run `dlv debug`
from the command line. From anywhere else, say the project root, you can simply
provide the package: `dlv debug github.com/me/foo/cmd/foo`. To pass flags to your program
separate them with `--`: `dlv debug github.com/me/foo/cmd/foo -- -arg1 value`.
Invoking that command will cause Delve to compile the program in a way most
suitable for debugging, then it will execute and attach to the program and begin
a debug session. Now, when the debug session has first started you are at the
very beginning of the program's initialization. To get to someplace more useful
you're going to want to set a breakpoint or two and continue execution to that
point.
For example, to continue execution to your program's `main` function:
```
$ dlv debug github.com/me/foo/cmd/foo
Type 'help' for list of commands.
(dlv) break main.main
Breakpoint 1 set at 0x49ecf3 for main.main() ./test.go:5
(dlv) continue
> main.main() ./test.go:5 (hits goroutine(1):1 total:1) (PC: 0x49ecf3)
1: package main
2:
3: import "fmt"
4:
=> 5: func main() {
6: fmt.Println("delve test")
7: }
(dlv)
```
## Debugging tests
Given the same directory structure as above you can debug your code by executing
your test suite. For this you can use the `dlv test` subcommand, which takes the
same optional package path as `dlv debug`, and will also build the current
package if not given any argument.
```
$ dlv test github.com/me/foo/pkg/baz
Type 'help' for list of commands.
(dlv) funcs test.Test*
/home/me/go/src/github.com/me/foo/pkg/baz/test.TestHi
(dlv) break TestHi
Breakpoint 1 set at 0x536513 for /home/me/go/src/github.com/me/foo/pkg/baz/test.TestHi() ./test_test.go:5
(dlv) continue
> /home/me/go/src/github.com/me/foo/pkg/baz/test.TestHi() ./bar_test.go:5 (hits goroutine(5):1 total:1) (PC: 0x536513)
1: package baz
2:
3: import "testing"
4:
=> 5: func TestHi(t *testing.T) {
6: t.Fatal("implement me!")
7: }
(dlv)
```
As you can see, we began debugging the test binary, found our test function via
the `funcs` command which takes a regexp to filter the list of functions, set a
breakpoint and then continued execution until we hit that breakpoint.
For more information on subcommands you can use, type `dlv help`, and once in a
debug session you can see all of the commands available to you by typing `help`
at any time.
================================================
FILE: Documentation/cli/locspec.md
================================================
# Location Specifiers
Several delve commands take a program location as an argument, the syntax accepted by this commands is:
* `*<address>` Specifies the location of memory address *address*. *address* can be specified as a decimal, hexadecimal or octal number
* `<filename>:<line>` Specifies the line *line* in *filename*. *filename* can be the partial path to a file or even just the base name as long as the expression remains unambiguous.
* `<line>` Specifies the line *line* in the current file
* `+<offset>` Specifies the line *offset* lines after the current one
* `-<offset>` Specifies the line *offset* lines before the current one
* `<function>[:<line>]` Specifies the line *line* inside *function*. The full syntax for *function* is `<package>.(*<receiver type>).<function name>` however the only required element is the function name, everything else can be omitted as long as the expression remains unambiguous. For setting a breakpoint on an init function (ex: main.init), the `<filename>:<line>` syntax should be used to break in the correct init function at the correct location.
* `/<regex>/` Specifies the location of all the functions matching *regex*
================================================
FILE: Documentation/cli/starlark.md
================================================
# Introduction
Passing a file with the .star extension to the `source` command will cause delve to interpret it as a starlark script.
Starlark is a dialect of python, a [specification of its syntax can be found here](https://github.com/google/starlark-go/blob/master/doc/spec.md).
In addition to the normal starlark built-ins delve defines [a number of global functions](#Starlark-built-ins) that can be used to interact with the debugger.
After the file has been evaluated delve will bind any function starting with `command_` to a command-line command: for example `command_goroutines_wait_reason` will be bound to `goroutines_wait_reason`.
Then if a function named `main` exists it will be executed.
Global functions with a name that begins with a capital letter will be available to other scripts.
# Starlark built-ins
<!-- BEGIN MAPPING TABLE -->
Function | API Call
---------|---------
amend_breakpoint(Breakpoint) | Equivalent to API call [AmendBreakpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.AmendBreakpoint)
ancestors(GoroutineID, NumAncestors, Depth) | Equivalent to API call [Ancestors](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Ancestors)
attached_to_existing_process() | Equivalent to API call [AttachedToExistingProcess](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.AttachedToExistingProcess)
build_id() | Equivalent to API call [BuildID](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.BuildID)
cancel_next() | Equivalent to API call [CancelNext](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.CancelNext)
checkpoint(Where) | Equivalent to API call [Checkpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Checkpoint)
clear_breakpoint(Id, Name) | Equivalent to API call [ClearBreakpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ClearBreakpoint)
clear_checkpoint(ID) | Equivalent to API call [ClearCheckpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ClearCheckpoint)
raw_command(Name, ThreadID, GoroutineID, ReturnInfoLoadConfig, Expr, WithEvents, UnsafeCall) | Equivalent to API call [Command](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Command)
create_breakpoint(Breakpoint, LocExpr, SubstitutePathRules, Suspended) | Equivalent to API call [CreateBreakpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.CreateBreakpoint)
create_ebpf_tracepoint(FunctionName) | Equivalent to API call [CreateEBPFTracepoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.CreateEBPFTracepoint)
create_watchpoint(Scope, Expr, Type) | Equivalent to API call [CreateWatchpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.CreateWatchpoint)
debug_info_directories(Set, List) | Equivalent to API call [DebugInfoDirectories](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.DebugInfoDirectories)
detach(Kill) | Equivalent to API call [Detach](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Detach)
disassemble(Scope, StartPC, EndPC, Flavour) | Equivalent to API call [Disassemble](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Disassemble)
dump_cancel() | Equivalent to API call [DumpCancel](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.DumpCancel)
dump_start(Destination) | Equivalent to API call [DumpStart](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.DumpStart)
dump_wait(Wait) | Equivalent to API call [DumpWait](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.DumpWait)
eval(Scope, Expr, Cfg) | Equivalent to API call [Eval](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Eval)
examine_memory(Address, Length) | Equivalent to API call [ExamineMemory](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ExamineMemory)
find_location(Scope, Loc, IncludeNonExecutableLines, SubstitutePathRules) | Equivalent to API call [FindLocation](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.FindLocation)
follow_exec(Enable, Regex) | Equivalent to API call [FollowExec](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.FollowExec)
follow_exec_enabled() | Equivalent to API call [FollowExecEnabled](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.FollowExecEnabled)
function_return_locations(FnName) | Equivalent to API call [FunctionReturnLocations](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.FunctionReturnLocations)
get_breakpoint(Id, Name) | Equivalent to API call [GetBreakpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.GetBreakpoint)
get_buffered_tracepoints() | Equivalent to API call [GetBufferedTracepoints](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.GetBufferedTracepoints)
get_thread(Id) | Equivalent to API call [GetThread](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.GetThread)
guess_substitute_path(Args) | Equivalent to API call [GuessSubstitutePath](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.GuessSubstitutePath)
is_multiclient() | Equivalent to API call [IsMulticlient](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.IsMulticlient)
last_modified() | Equivalent to API call [LastModified](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.LastModified)
breakpoints(All) | Equivalent to API call [ListBreakpoints](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListBreakpoints)
checkpoints() | Equivalent to API call [ListCheckpoints](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListCheckpoints)
dynamic_libraries() | Equivalent to API call [ListDynamicLibraries](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListDynamicLibraries)
function_args(Scope, Cfg) | Equivalent to API call [ListFunctionArgs](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListFunctionArgs)
functions(Filter, FollowCalls) | Equivalent to API call [ListFunctions](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListFunctions)
goroutines(Start, Count, Filters, GoroutineGroupingOptions, EvalScope) | Equivalent to API call [ListGoroutines](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListGoroutines)
local_vars(Scope, Cfg) | Equivalent to API call [ListLocalVars](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListLocalVars)
package_vars(Filter, Cfg) | Equivalent to API call [ListPackageVars](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListPackageVars)
packages_build_info(IncludeFiles, Filter) | Equivalent to API call [ListPackagesBuildInfo](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListPackagesBuildInfo)
registers(ThreadID, IncludeFp, Scope) | Equivalent to API call [ListRegisters](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListRegisters)
sources(Filter) | Equivalent to API call [ListSources](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListSources)
targets() | Equivalent to API call [ListTargets](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListTargets)
threads() | Equivalent to API call [ListThreads](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListThreads)
types(Filter) | Equivalent to API call [ListTypes](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ListTypes)
process_pid() | Equivalent to API call [ProcessPid](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ProcessPid)
recorded() | Equivalent to API call [Recorded](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Recorded)
restart(Position, ResetArgs, NewArgs, Rerecord, Rebuild, NewRedirects) | Equivalent to API call [Restart](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Restart)
set_expr(Scope, Symbol, Value) | Equivalent to API call [Set](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Set)
stacktrace(Id, Depth, Full, Defers, Opts, Cfg, Skip) | Equivalent to API call [Stacktrace](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Stacktrace)
state(NonBlocking) | Equivalent to API call [State](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.State)
toggle_breakpoint(Id, Name) | Equivalent to API call [ToggleBreakpoint](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.ToggleBreakpoint)
dlv_command(command) | Executes the specified command as if typed at the dlv_prompt
read_file(path) | Reads the file as a string
write_file(path, contents) | Writes string to a file
cur_scope() | Returns the current evaluation scope
default_load_config() | Returns the current default load configuration
<!-- END MAPPING TABLE -->
In addition to these built-ins, the [time](https://pkg.go.dev/go.starlark.net/lib/time#pkg-variables) library from the starlark-go project is also available to scripts.
## Should I use raw_command or dlv_command?
There are two ways to resume the execution of the target program:
raw_command("continue")
dlv_command("continue")
The first one maps to the API call [Command](https://pkg.go.dev/github.com/go-delve/delve/service/rpc2#RPCServer.Command). As such all the caveats explained in the [Client HowTo](../api/ClientHowto.md).
The latter is equivalent to typing `continue` to the `(dlv)` command line and should do what you expect.
In general `dlv_command("continue")` should be preferred, unless the behavior you wish to produces diverges significantly from that of the command line's `continue`.
# Creating new commands
Any global function with a name starting with `command_` will be made available as a command line command. If the function has a single argument named `args` all arguments passed on the command line will be passed to the function as a single string.
Otherwise arguments passed on the command line are interpreted as starlark expressions. See the [expression arguments](#expression-arguments) example.
If the command function has a doc string it will be used as a help message.
## Using custom commands with the `on` prefix
All custom starlark commands can be used with the `on` command (see `help on`) to execute when a breakpoint is hit:
```python
def command_my_trace(args):
"""Custom trace command that executes when a breakpoint is hit."""
print("Tracing:", args)
```
You can use this command like this:
```
(dlv) break main.go:10
(dlv) on 1 my_trace
```
# Working with variables
Variables of the target program can be accessed using `local_vars`, `function_args` or the `eval` functions. Each variable will be returned as a [Variable](https://pkg.go.dev/github.com/go-delve/delve/service/api#Variable) struct, with one special field: `Value`.
As a convenience a special global object exists, called `tgt`: evaluating `tgt.varname` is equivalent to evaluating `eval(None, "varname").Variable.Value`.
## Variable.Value
The `Value` field will return the value of the target variable converted to a starlark value:
* integers, floating point numbers and strings are represented by equivalent starlark values
* structs are represented as starlark dictionaries
* slices and arrays are represented by starlark lists
* maps are represented by starlark dicts
* pointers and interfaces are represented by a one-element starlark list containing the value they point to
For example, given this variable in the target program:
```go
type astruct struct {
A int
B int
}
s2 := []astruct{{1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10}, {11, 12}, {13, 14}, {15, 16}}
```
The following is possible:
```
>>> s2 = eval(None, "s2").Variable
>>> s2.Value[0] # access of a slice item by index
main.astruct {A: 1, B: 2}
>>> a = s2.Value[1]
>>> a.Value.A # access to a struct field
3
>>> a.Value.A + 10 # arithmetic on the value of s2[1].X
13
>>> a.Value["B"] # access to a struct field, using dictionary syntax
4
```
For more examples see the [linked list example](#Print-all-elements-of-a-linked-list) below.
# Examples
## Listing goroutines and making custom commands
Create a `goroutine_start_line` command that prints the starting line of each goroutine, sets `gsl` as an alias:
```python
def command_goroutine_start_line(args):
gs = goroutines().Goroutines
for g in gs:
line = read_file(g.StartLoc.File).splitlines()[g.StartLoc.Line-1].strip()
print(g.ID, "\t", g.StartLoc.File + ":" + str(g.StartLoc.Line), "\t", line)
def main():
dlv_command("config alias goroutine_start_line gsl")
```
Use it like this:
```
(dlv) source goroutine_start_line.star
(dlv) goroutine_start_line
1 /usr/local/go/src/runtime/proc.go:110 func main() {
2 /usr/local/go/src/runtime/proc.go:242 func forcegchelper() {
17 /usr/local/go/src/runtime/mgcsweep.go:64 func bgsweep(c chan int) {
18 /usr/local/go/src/runtime/mfinal.go:161 func runfinq() {
(dlv) gsl
1 /usr/local/go/src/runtime/proc.go:110 func main() {
2 /usr/local/go/src/runtime/proc.go:242 func forcegchelper() {
17 /usr/local/go/src/runtime/mgcsweep.go:64 func bgsweep(c chan int) {
18 /usr/local/go/src/runtime/mfinal.go:161 func runfinq() {
```
## Expression arguments
After evaluating this script:
```python
def command_echo(args):
print(args)
def command_echo_expr(a, b, c):
print("a", a, "b", b, "c", c)
```
The first command, `echo`, takes its arguments as a single string, while for `echo_expr` it will be possible to pass starlark expression as arguments:
```
(dlv) echo 2+2, 2-1, 2*3
"2+2, 2-1, 2*3"
(dlv) echo_expr 2+2, 2-1, 2*3
a 4 b 1 c 6
```
## Creating breakpoints
Set a breakpoint on all private methods of package `main`:
```python
def main():
for f in functions().Funcs:
v = f.split('.')
if len(v) != 2:
continue
if v[0] != "main":
continue
if v[1][0] >= 'a' and v[1][0] <= 'z':
create_breakpoint({ "FunctionName": f, "Line": -1 }) # see documentation of RPCServer.CreateBreakpoint
```
## Switching goroutines
Create a command, `switch_to_main_goroutine`, that searches for a goroutine running a function in the main package and switches to it:
```python
def command_switch_to_main_goroutine(args):
for g in goroutines().Goroutines:
if g.currentLoc.function != None and g.currentLoc.function.name.startswith("main."):
print("switching to:", g.id)
raw_command("switchGoroutine", GoroutineID=g.id)
break
```
## Listing goroutines
Create a command, "goexcl", that lists all goroutines excluding the ones stopped on a specified function.
```python
def command_goexcl(args):
"""Prints all goroutines not stopped in the function passed as argument."""
excluded = 0
start = 0
while start >= 0:
gr = goroutines(start, 10)
start = gr.Nextg
for g in gr.Goroutines:
fn = g.UserCurrentLoc.Function
if fn == None:
print("Goroutine", g.ID, "User:", g.UserCurrentLoc.File, g.UserCurrentLoc.Line)
elif fn.Name_ != args:
print("Goroutine", g.ID, "User:", g.UserCurrentLoc.File, g.UserCurrentLoc.Line, fn.Name_)
else:
excluded = excluded + 1
print("Excluded", excluded, "goroutines")
```
Usage:
```
(dlv) goexcl main.somefunc
```
prints all goroutines that are not stopped inside `main.somefunc`.
## Repeatedly executing the target until a breakpoint is hit.
Repeatedly call continue and restart until the target hits a breakpoint.
```python
def command_flaky(args):
"Repeatedly runs program until a breakpoint is hit"
while True:
if dlv_command("continue") == None:
break
dlv_command("restart")
```
## Print all elements of a linked list
```python
def command_linked_list(args):
"""Prints the contents of a linked list.
linked_list <var_name> <next_field_name> <max_depth>
Prints up to max_depth elements of the linked list variable 'var_name' using 'next_field_name' as the name of the link field.
"""
var_name, next_field_name, max_depth = args.split(" ")
max_depth = int(max_depth)
next_name = var_name
v = eval(None, var_name).Variable.Value
for i in range(0, max_depth):
print(str(i)+":",v)
if v[0] == None:
break
v = v[next_field_name]
```
## Find an array element matching a predicate
```python
def command_find_array(arr, pred):
"""Calls pred for each element of the array or slice 'arr' returns the index of the first element for which pred returns true.
find_arr <arr> <pred>
Example use (find the first element of slice 's2' with field A equal to 5):
find_arr "s2", lambda x: x.A == 5
"""
arrv = eval(None, arr).Variable
for i in range(0, arrv.Len):
v = arrv.Value[i]
if pred(v):
print("found", i)
return
print("not found")
```
## Rerunning a program until it fails or hits a breakpoint
```python
def command_flaky(args):
"Continues and restarts the target program repeatedly (re-recording it on the rr backend), until a breakpoint is hit"
count = 1
while True:
if dlv_command("continue") == None:
break
print("restarting", count, "...")
count = count+1
restart(Rerecord=True)
```
## Passing a struct as an argument
Struct literals can be passed to built-ins as Starlark dictionaries. For example, the following snippet passes
in an [api.EvalScope](https://pkg.go.dev/github.com/go-delve/delve/service/api#EvalScope)
and [api.LoadConfig](https://pkg.go.dev/github.com/go-delve/delve/service/api#LoadConfig)
to the `eval` built-in. `None` can be passed for optional arguments, and
trailing optional arguments can be elided completely.
```python
var = eval(
{"GoroutineID": 42, "Frame": 5},
"myVar",
{"FollowPointers":True, "MaxVariableRecurse":2, "MaxStringLen":100, "MaxArrayValues":10, "MaxStructFields":100}
)
```
## Chain breakpoints
Chain a number of breakpoints such that breakpoint n+1 is only hit after breakpoint n is hit:
```python
def command_breakchain(*args):
v = args.split(" ")
bp = get_breakpoint(int(v[0]), "").Breakpoint
bp.HitCond = "== 1"
amend_breakpoint(bp)
for i in range(1, len(v)):
bp = get_breakpoint(int(v[i]), "").Breakpoint
if i != len(v)-1:
bp.HitCond = "== 1"
bp.Cond = "delve.bphitcount[" + v[i-1] + "] > 0"
amend_breakpoint(bp)
```
To be used as `chain 1 2 3` where `1`, `2`, and `3` are IDs of breakpoints to chain together.
================================================
FILE: Documentation/cli/substitutepath.md
================================================
## Path substitution configuration
Normally Delve finds the path to the source code that was used to produce an executable by looking at the debug symbols of the executable.
However, under [some circumstances](../faq.md#substpath), the paths that end up inside the executable will be different from the paths to the source code on the machine that is running the debugger. If that is the case Delve will need extra configuration to convert the paths stored inside the executable to paths in your local filesystem.
This configuration is done by specifying a list of path substitution rules.
The path substitution code is SubstitutePath in pkg/locspec/locations.go.
### Where are path substitution rules specified
#### Delve command line client
The command line client reads the path substitution rules from Delve's YAML configuration file located at `$XDG_CONFIG_HOME/dlv/config.yml` or `.dlv/config.yml` inside the home directory on Windows.
The `substitute-path` entry should look like this:
```
substitute-path:
- {from: "/compiler/machine/directory", to: "/debugger/machine/directory"}
- {from: "", to: "/mapping/for/relative/paths"}
```
If you are starting a headless instance of Delve and connecting to it through `dlv connect` the configuration file that is used is the one that runs `dlv connect`.
When Delve needs to convert a path P found inside the executable file into a path in the local filesystem it will scan through the list of rules looking for the first one where P starts with the from-path and replace from-path with to-path.
Empty paths in both from-path and to-path are special, they represent relative paths:
- `(from="" to="/home/user/project/src")` converts all relative paths in the executable to absolute paths in `/home/user/project/src`
- `(from="/build/dir" to="")` converts all paths in the executable that start with `/build/dir` into relative paths.
The rules can also be modified while Delve is running by using the [config substitute-path command](./README.md#config):
```
(dlv) config substitute-path /from/path /to/path
```
Double quotes can be used to specify paths that contain spaces, or to specify empty paths:
```
(dlv) config substitute-path "/path containing spaces/" /path-without-spaces/
(dlv) config substitute-path /make/this/path/relative ""
```
#### DAP server
If you connect to Delve using the DAP protocol then the substitute path rules are specified using the substitutePath option in [launch.json](https://github.com/golang/vscode-go/blob/master/docs/debugging.md#launchjson-attributes). **Note that `from` and `to` have reversed meaning here.**
```
"substitutePath": [
{ "from": "/debugger/machine/directory", "to": "/compiler/machine/directory" }
]
```
When Delve needs to convert a path P found in the local filesystem into a path inside the executable file it will scan through the list of rules looking for the first one where P starts with from-path and replace from-path with to-path.
Empty paths in both from-path and to-path are special, they represent relative paths:
- `(from="/home/user/project/src" to="")` converts all relative paths in the executable to absolute paths in `/home/user/project/src`
- `(from="" to="/build/dir")` converts all paths in the executable that start with `/build/dir` into relative paths.
The [debug console](https://github.com/golang/vscode-go/blob/master/docs/debugging.md#dlv-command-from-debug-console) can also be used to modify the path substitution list:
```
dlv config substitutePath /debugger/machine/directory /compiler/machine/directory
```
================================================
FILE: Documentation/faq.md
================================================
## Frequently Asked Questions
<!-- BEGIN TOC -->
* [I'm getting an error while compiling Delve / unsupported architectures and OSs](#unsupportedplatforms)
* [How do I use Delve with Docker?](#docker)
* [How can I use Delve to debug a CLI application?](#ttydebug)
* [How can I use Delve for remote debugging?](#remote)
* [Can not set breakpoints or see source listing in a complicated debugging environment](#substpath)
* [Using Delve to debug the Go runtime](#runtime)
<!-- END TOC -->
### <a name="unsupportedplatforms"></a> I'm getting an error while compiling Delve / unsupported architectures and OSs
The most likely cause of this is that you are running an unsupported Operating System or architecture.
Currently Delve supports (GOOS / GOARCH):
* linux / amd64 (86x64)
* linux / arm64 (AARCH64)
* linux / 386
* windows / amd64
* windows / arm64
* darwin (macOS) / amd64
There is no planned ETA for support of other architectures or operating systems. Bugs tracking requested support are:
- [32bit ARM support](https://github.com/go-delve/delve/issues/328)
- [PowerPC support](https://github.com/go-delve/delve/issues/1564)
- [OpenBSD](https://github.com/go-delve/delve/issues/1477)
See also: [backend test health](backend_test_health.md).
### <a name="docker"></a> How do I use Delve with Docker?
When running the container you should pass the `--security-opt=seccomp:unconfined` option to Docker. You can start a headless instance of Delve inside the container like this:
```
dlv exec --headless --listen :4040 /path/to/executable
```
And then connect to it from outside the container:
```
dlv connect :4040
```
The program will not start executing until you connect to Delve and send the `continue` command. If you want the program to start immediately you can do that by passing the `--continue` and `--accept-multiclient` o
gitextract_w933engg/
├── .cirrus.yml
├── .gitattributes
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── config.yml
│ │ └── issue_template.yml
│ └── workflows/
│ ├── release.yml
│ └── test-windows-arm64.yml
├── .gitignore
├── .goreleaser.yaml
├── .teamcity/
│ ├── pom.xml
│ └── settings.kts
├── CHANGELOG.md
├── CLAUDE.md
├── CONTRIBUTING.md
├── Documentation/
│ ├── AI/
│ │ └── AI_POLICY.md
│ ├── EditorIntegration.md
│ ├── KnownBugs.md
│ ├── README.md
│ ├── api/
│ │ ├── ClientHowto.md
│ │ ├── README.md
│ │ ├── dap/
│ │ │ └── README.md
│ │ └── json-rpc/
│ │ └── README.md
│ ├── backend_test_health.md
│ ├── cli/
│ │ ├── README.md
│ │ ├── cond.md
│ │ ├── config.md
│ │ ├── expr.md
│ │ ├── getting_started.md
│ │ ├── locspec.md
│ │ ├── starlark.md
│ │ └── substitutepath.md
│ ├── faq.md
│ ├── installation/
│ │ ├── README.md
│ │ ├── freebsd/
│ │ │ └── install.md
│ │ ├── linux/
│ │ │ └── install.md
│ │ ├── osx/
│ │ │ └── install.md
│ │ └── windows/
│ │ └── install.md
│ ├── internal/
│ │ ├── README.md
│ │ └── portnotes.md
│ └── usage/
│ ├── README.md
│ ├── dlv.md
│ ├── dlv_attach.md
│ ├── dlv_backend.md
│ ├── dlv_connect.md
│ ├── dlv_core.md
│ ├── dlv_dap.md
│ ├── dlv_debug.md
│ ├── dlv_exec.md
│ ├── dlv_log.md
│ ├── dlv_redirect.md
│ ├── dlv_replay.md
│ ├── dlv_run.md
│ ├── dlv_test.md
│ ├── dlv_trace.md
│ └── dlv_version.md
├── LICENSE
├── Makefile
├── README.md
├── _fixtures/
│ ├── amend_breakpoint.star
│ ├── asmnilptr/
│ │ ├── main.go
│ │ ├── main_386.s
│ │ ├── main_amd64.s
│ │ ├── main_arm64.s
│ │ ├── main_loong64.s
│ │ ├── main_ppc64le.s
│ │ └── main_riscv64.s
│ ├── backwardsiter.go
│ ├── badflags.go
│ ├── binarytrees.go
│ ├── bpcountstest.go
│ ├── bpfile
│ ├── bphitcountchain.go
│ ├── break/
│ │ ├── break_amd64.s
│ │ └── main.go
│ ├── break.go
│ ├── buildflagtest.go
│ ├── buildtest/
│ │ ├── __debug_bin2807893743
│ │ ├── main.go
│ │ └── main_test.go
│ ├── callme.go
│ ├── cat.go
│ ├── cgodisass.go
│ ├── cgosigsegvstack.go
│ ├── cgostacktest/
│ │ ├── hello.c
│ │ ├── hello.h
│ │ └── main.go
│ ├── cgotest.go
│ ├── chain_breakpoints.star
│ ├── changoroutines.go
│ ├── clientdo.go
│ ├── closurecontents.go
│ ├── condframe.go
│ ├── condperghitcount.go
│ ├── consts.go
│ ├── continuetestprog.go
│ ├── coreemptystring.go
│ ├── create_breakpoint_main.star
│ ├── databpcountstest.go
│ ├── databpeasy.go
│ ├── databpstack.go
│ ├── debug_line_benchmark_data
│ ├── debug_line_c_data
│ ├── debugdetect.go
│ ├── decllinetest.go
│ ├── defercall.go
│ ├── deferstack.go
│ ├── delvecatch.go
│ ├── dotpackagesiface.go
│ ├── doubleinline.go
│ ├── dwzcompression.go
│ ├── ebpf_trace.go
│ ├── ebpf_trace2.go
│ ├── ebpf_trace3.go
│ ├── echo_expr.star
│ ├── examinememory.go
│ ├── exit.init
│ ├── fake-debuginfod-find/
│ │ └── debuginfod-find
│ ├── fatalerror.go
│ ├── find_array.star
│ ├── fncall.go
│ ├── fputest/
│ │ ├── fputest.go
│ │ └── fputest_amd64.s
│ ├── genericbp.go
│ ├── genericintoiface.go
│ ├── godlopen/
│ │ ├── golib/
│ │ │ └── golib.go
│ │ └── main.c
│ ├── goroutineLabels.go
│ ├── goroutine_start_line.star
│ ├── goroutinebreak.go
│ ├── goroutinegroup.go
│ ├── goroutines-trace.go
│ ├── goroutinestackprog.go
│ ├── hcbpcountstest.go
│ ├── http_server.go
│ ├── ifaceembcall.go
│ ├── increment.go
│ ├── inlinestripped.go
│ ├── integrationprog.go
│ ├── internal/
│ │ ├── dir.io/
│ │ │ ├── dir.go
│ │ │ └── io.io/
│ │ │ └── io.go
│ │ ├── dir0/
│ │ │ ├── pkg/
│ │ │ │ └── main.go
│ │ │ └── renamedpackage/
│ │ │ └── main.go
│ │ ├── dir1/
│ │ │ └── pkg/
│ │ │ └── main.go
│ │ └── pluginsupport/
│ │ └── pluginsupport.go
│ ├── is sue239.go
│ ├── issue1101.go
│ ├── issue1264.go
│ ├── issue1374.go
│ ├── issue1432.go
│ ├── issue1469.go
│ ├── issue1531.go
│ ├── issue1549.go
│ ├── issue1598.go
│ ├── issue1601.go
│ ├── issue1615.go
│ ├── issue1656/
│ │ ├── main.go
│ │ └── main.s
│ ├── issue1795.go
│ ├── issue1817.go
│ ├── issue2023.go
│ ├── issue2078.go
│ ├── issue2086.go
│ ├── issue2113.go
│ ├── issue2138.go
│ ├── issue2162.go
│ ├── issue2319/
│ │ ├── README.txt
│ │ ├── asm-linux-amd64.s
│ │ ├── cfile-linux-amd64.syso
│ │ └── main.go
│ ├── issue262.go
│ ├── issue2896.go
│ ├── issue305.go
│ ├── issue3194.go
│ ├── issue3310.go
│ ├── issue332.go
│ ├── issue3548.go
│ ├── issue384.go
│ ├── issue387.go
│ ├── issue4000.go
│ ├── issue4051.go
│ ├── issue406.go
│ ├── issue4116.go
│ ├── issue419.go
│ ├── issue528.go
│ ├── issue561.go
│ ├── issue573.go
│ ├── issue594.go
│ ├── issue664.go
│ ├── issue683.go
│ ├── issue871.go
│ ├── issue877.go
│ ├── issue951.go
│ ├── leaf4.go
│ ├── leafcommon.go
│ ├── leafindrec.go
│ ├── leafrec.go
│ ├── leafregex.go
│ ├── linked_list.star
│ ├── livetestprog.go
│ ├── locationsUpperCase.go
│ ├── locationsprog.go
│ ├── locationsprog2.go
│ ├── locationsprog3.go
│ ├── locationsprog_generic.go
│ ├── longstrings.go
│ ├── loopprog.go
│ ├── math.go
│ ├── morestringarg.go
│ ├── multinamedreturns.go
│ ├── nestedbp.go
│ ├── nextcond.go
│ ├── nilptr.go
│ ├── nodisasm/
│ │ ├── main.go
│ │ └── nodisasm_amd64.s
│ ├── nomaindir/
│ │ └── file.go
│ ├── nongochild/
│ │ ├── child.bat
│ │ ├── child.sh
│ │ └── main.go
│ ├── nopbreakpoint/
│ │ ├── main.go
│ │ └── main.s
│ ├── notify-v2.go
│ ├── out_redirect.go
│ ├── panic.go
│ ├── panicex.go
│ ├── panicline.go
│ ├── parallel_next.go
│ ├── pkgrenames.go
│ ├── plugin1/
│ │ └── plugin1.go
│ ├── plugin2/
│ │ └── plugin2.go
│ ├── plugintest.go
│ ├── plugintest2.go
│ ├── pr1055.go
│ ├── rangeoverfunc.go
│ ├── readmem_json.go
│ ├── redirect-input.txt
│ ├── redirect.go
│ ├── reflecttypefncall.go
│ ├── restartargs.go
│ ├── retstack.go
│ ├── scopeescapevareval.go
│ ├── scopetest.go
│ ├── setiterator.go
│ ├── setymmreg/
│ │ ├── main.go
│ │ └── setymmreg_amd64.s
│ ├── sigchldprog.go
│ ├── sleep.go
│ ├── spawn.go
│ ├── spawnchild.go
│ ├── stacktraceprog.go
│ ├── stackwatchbug.go
│ ├── starlark_map_iteration.star
│ ├── stepintobug.go
│ ├── stepoutret.go
│ ├── stepshadow.go
│ ├── switch_to_main_goroutine.star
│ ├── test if path/
│ │ └── main.go
│ ├── test.c
│ ├── testRestartRequestRebuildFailFixture.go
│ ├── test_allow_on.star
│ ├── test_custom_cmd_continue.star
│ ├── test_custom_cmd_nested.star
│ ├── testargs.go
│ ├── testdeadlock.go
│ ├── testenv.go
│ ├── testenv2.go
│ ├── testfnpos1.go
│ ├── testfnpos2.go
│ ├── testinline.go
│ ├── testnextdefer.go
│ ├── testnextnethttp.go
│ ├── testnextprog.go
│ ├── testprog.go
│ ├── testrerecord.go
│ ├── testreturnaddress.go
│ ├── testruntimebreakpoint.go
│ ├── testshadow.go
│ ├── teststep.go
│ ├── teststepconcurrent.go
│ ├── teststepprog.go
│ ├── testthreads.go
│ ├── testtoggle.go
│ ├── testtracefns.go
│ ├── testunsafepointers.go
│ ├── testvariables.go
│ ├── testvariables2.go
│ ├── testvariables_generic.go
│ ├── testvariables_pointers_not_loaded.go
│ ├── testvariablescgo/
│ │ ├── test.c
│ │ └── testvariablescgo.go
│ ├── trace_backend_parity.go
│ ├── traceperf.go
│ ├── traceprog.go
│ ├── traceret.go
│ ├── waitfordebugger.go
│ ├── watchpointInterface.go
│ ├── watchpointInterfaceNil.go
│ ├── workdir.go
│ ├── xmm0print/
│ │ ├── main.go
│ │ └── main.s
│ └── zdebug_line_dwarf4
├── _scripts/
│ ├── capslock.sh
│ ├── capslock_darwin_amd64-output.txt
│ ├── capslock_darwin_arm64-output.txt
│ ├── capslock_linux_386-output.txt
│ ├── capslock_linux_amd64-output.txt
│ ├── capslock_linux_arm64-output.txt
│ ├── capslock_linux_ppc64le-output.txt
│ ├── capslock_linux_riscv64-output.txt
│ ├── capslock_windows_amd64-output.txt
│ ├── capslock_windows_arm64-output.txt
│ ├── gen-backend_test_health.go
│ ├── gen-capslock-all.go
│ ├── gen-cli-docs.go
│ ├── gen-faq-toc.go
│ ├── gen-opcodes.go
│ ├── gen-travis.go
│ ├── gen-usage-docs.go
│ ├── gencert.sh
│ ├── latestver.py
│ ├── make.go
│ ├── rtype-out.txt
│ ├── rtype.go
│ ├── staticcheck-out.txt
│ ├── test_linux.sh
│ ├── test_mac.sh
│ ├── test_windows.ps1
│ └── testsign
├── go.mod
├── go.sum
├── pkg/
│ ├── astutil/
│ │ └── astutil.go
│ ├── config/
│ │ ├── config.go
│ │ ├── split.go
│ │ └── split_test.go
│ ├── debugdetect/
│ │ ├── detect.go
│ │ ├── detect_darwin.go
│ │ ├── detect_freebsd.go
│ │ ├── detect_linux.go
│ │ ├── detect_test.go
│ │ ├── detect_windows.go
│ │ └── doc.go
│ ├── dwarf/
│ │ ├── dwarfbuilder/
│ │ │ ├── builder.go
│ │ │ ├── info.go
│ │ │ └── loc.go
│ │ ├── frame/
│ │ │ ├── entries.go
│ │ │ ├── entries_test.go
│ │ │ ├── parser.go
│ │ │ ├── parser_test.go
│ │ │ ├── table.go
│ │ │ └── testdata/
│ │ │ └── frame
│ │ ├── godwarf/
│ │ │ ├── addr.go
│ │ │ ├── buf.go
│ │ │ ├── fakes.go
│ │ │ ├── sections.go
│ │ │ ├── tree.go
│ │ │ ├── tree_test.go
│ │ │ └── type.go
│ │ ├── leb128/
│ │ │ ├── decode.go
│ │ │ ├── decode_test.go
│ │ │ ├── doc.go
│ │ │ ├── encode.go
│ │ │ └── encode_test.go
│ │ ├── line/
│ │ │ ├── line_parser.go
│ │ │ ├── line_parser_test.go
│ │ │ ├── parse_util.go
│ │ │ ├── state_machine.go
│ │ │ └── state_machine_test.go
│ │ ├── loclist/
│ │ │ ├── dwarf2_loclist.go
│ │ │ ├── dwarf5_loclist.go
│ │ │ └── loclist5_test.go
│ │ ├── op/
│ │ │ ├── op.go
│ │ │ ├── op_test.go
│ │ │ ├── opcodes.go
│ │ │ ├── opcodes.table
│ │ │ └── regs.go
│ │ ├── parseutil.go
│ │ ├── parseutil_test.go
│ │ ├── reader/
│ │ │ ├── reader.go
│ │ │ └── variables.go
│ │ └── regnum/
│ │ ├── amd64.go
│ │ ├── arm64.go
│ │ ├── i386.go
│ │ ├── loong64.go
│ │ ├── ppc64le.go
│ │ └── riscv64.go
│ ├── elfwriter/
│ │ ├── delve_core_notes.go
│ │ └── writer.go
│ ├── gobuild/
│ │ ├── defaultexe.go
│ │ ├── gobuild.go
│ │ └── gobuild_test.go
│ ├── goversion/
│ │ ├── compat.go
│ │ ├── go_version.go
│ │ └── version_test.go
│ ├── internal/
│ │ ├── gosym/
│ │ │ ├── additions.go
│ │ │ ├── pclntab.go
│ │ │ └── symtab.go
│ │ └── lru/
│ │ ├── lru.go
│ │ └── lru_test.go
│ ├── locspec/
│ │ ├── doc.go
│ │ ├── locations.go
│ │ └── locations_test.go
│ ├── logflags/
│ │ ├── logflags.go
│ │ ├── logflags_test.go
│ │ └── logger.go
│ ├── proc/
│ │ ├── amd64_arch.go
│ │ ├── amd64_disasm.go
│ │ ├── amd64util/
│ │ │ ├── debugregs.go
│ │ │ └── xsave.go
│ │ ├── arch.go
│ │ ├── arm64_arch.go
│ │ ├── arm64_disasm.go
│ │ ├── bininfo.go
│ │ ├── breakpoints.go
│ │ ├── core/
│ │ │ ├── core.go
│ │ │ ├── core_test.go
│ │ │ ├── delve_core.go
│ │ │ ├── linux_core.go
│ │ │ ├── minidump/
│ │ │ │ ├── fileflags_string.go
│ │ │ │ └── minidump.go
│ │ │ └── windows_amd64_minidump.go
│ │ ├── debuginfod/
│ │ │ └── debuginfod.go
│ │ ├── disasm.go
│ │ ├── doc.go
│ │ ├── dump.go
│ │ ├── dwarf_export_test.go
│ │ ├── dwarf_expr_test.go
│ │ ├── eval.go
│ │ ├── evalop/
│ │ │ ├── evalcompile.go
│ │ │ ├── evalop_test.go
│ │ │ └── ops.go
│ │ ├── fbsdutil/
│ │ │ └── regs.go
│ │ ├── fncall.go
│ │ ├── gdbserial/
│ │ │ ├── gdbserver.go
│ │ │ ├── gdbserver_conn.go
│ │ │ ├── gdbserver_unix.go
│ │ │ ├── gdbserver_windows.go
│ │ │ ├── rr.go
│ │ │ └── rr_test.go
│ │ ├── goroutine_cache.go
│ │ ├── i386_arch.go
│ │ ├── i386_disasm.go
│ │ ├── interface.go
│ │ ├── internal/
│ │ │ └── ebpf/
│ │ │ ├── bpf/
│ │ │ │ ├── dummy.go
│ │ │ │ ├── include/
│ │ │ │ │ ├── dummy.go
│ │ │ │ │ ├── function_vals.bpf.h
│ │ │ │ │ ├── trace.bpf.h
│ │ │ │ │ └── vmlinux.h
│ │ │ │ └── trace.bpf.c
│ │ │ ├── build/
│ │ │ │ ├── build-ebpf-builder-img.sh
│ │ │ │ ├── build-ebpf-objects.sh
│ │ │ │ └── ebpf-Dockerfile
│ │ │ ├── context.go
│ │ │ ├── dummy.go
│ │ │ ├── helpers.go
│ │ │ ├── helpers_disabled.go
│ │ │ ├── helpers_test.go
│ │ │ ├── testhelper/
│ │ │ │ └── testhelper.go
│ │ │ ├── trace_bpfel_x86.go
│ │ │ └── trace_bpfel_x86.o
│ │ ├── linutil/
│ │ │ ├── auxv.go
│ │ │ ├── doc.go
│ │ │ ├── dynamic.go
│ │ │ ├── regs_amd64_arch.go
│ │ │ ├── regs_arm64_arch.go
│ │ │ ├── regs_i386_arch.go
│ │ │ ├── regs_loong64_arch.go
│ │ │ ├── regs_ppc64le_arch.go
│ │ │ └── regs_riscv64_arch.go
│ │ ├── loong64_arch.go
│ │ ├── loong64_disasm.go
│ │ ├── macutil/
│ │ │ ├── rosetta_darwin.go
│ │ │ └── rosetta_other.go
│ │ ├── mapiter.go
│ │ ├── mem.go
│ │ ├── moduledata.go
│ │ ├── native/
│ │ │ ├── cpuid/
│ │ │ │ ├── xsave_x86.go
│ │ │ │ └── xsave_x86.s
│ │ │ ├── dump_freebsd.go
│ │ │ ├── dump_linux.go
│ │ │ ├── dump_linux_amd64.go
│ │ │ ├── dump_linux_other.go
│ │ │ ├── dump_other.go
│ │ │ ├── dump_windows_amd64.go
│ │ │ ├── exc.h
│ │ │ ├── exc_user_darwin.c
│ │ │ ├── exec_darwin.c
│ │ │ ├── exec_darwin.h
│ │ │ ├── followexec_other.go
│ │ │ ├── hwbreak_amd64.go
│ │ │ ├── hwbreak_other.go
│ │ │ ├── mach_exc.h
│ │ │ ├── mach_exc_user_darwin.c
│ │ │ ├── nonative_darwin.go
│ │ │ ├── proc.go
│ │ │ ├── proc_darwin.c
│ │ │ ├── proc_darwin.go
│ │ │ ├── proc_darwin.h
│ │ │ ├── proc_ebpf_linux.go
│ │ │ ├── proc_freebsd.go
│ │ │ ├── proc_linux.go
│ │ │ ├── proc_no_ebpf_linux.go
│ │ │ ├── proc_unix.go
│ │ │ ├── proc_windows.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_freebsd.go
│ │ │ ├── ptrace_freebsd_amd64.go
│ │ │ ├── ptrace_linux.go
│ │ │ ├── ptrace_linux_386.go
│ │ │ ├── ptrace_linux_64bit.go
│ │ │ ├── ptrace_linux_amd64.go
│ │ │ ├── register_linux_386.go
│ │ │ ├── registers_darwin_amd64.go
│ │ │ ├── registers_freebsd_amd64.go
│ │ │ ├── registers_linux_amd64.go
│ │ │ ├── registers_linux_arm64.go
│ │ │ ├── registers_linux_loong64.go
│ │ │ ├── registers_linux_ppc64le.go
│ │ │ ├── registers_linux_riscv64.go
│ │ │ ├── registers_windows.go
│ │ │ ├── support_sentinel.go
│ │ │ ├── support_sentinel_cgo_freebsd.go
│ │ │ ├── support_sentinel_darwin.go
│ │ │ ├── support_sentinel_freebsd.go
│ │ │ ├── support_sentinel_linux.go
│ │ │ ├── support_sentinel_windows.go
│ │ │ ├── syscall_windows.go
│ │ │ ├── syscall_windows_amd64.go
│ │ │ ├── syscall_windows_arm64.go
│ │ │ ├── threads.go
│ │ │ ├── threads_darwin.c
│ │ │ ├── threads_darwin.go
│ │ │ ├── threads_darwin.h
│ │ │ ├── threads_freebsd.go
│ │ │ ├── threads_hardware_singlestep_linux.go
│ │ │ ├── threads_linux.go
│ │ │ ├── threads_linux_386.go
│ │ │ ├── threads_linux_amd64.go
│ │ │ ├── threads_linux_arm64.go
│ │ │ ├── threads_linux_loong64.go
│ │ │ ├── threads_linux_ppc64le.go
│ │ │ ├── threads_linux_riscv64.go
│ │ │ ├── threads_windows.go
│ │ │ ├── threads_windows_amd64.go
│ │ │ ├── threads_windows_arm64.go
│ │ │ └── zsyscall_windows.go
│ │ ├── pclntab.go
│ │ ├── pe.go
│ │ ├── ppc64le_arch.go
│ │ ├── ppc64le_disasm.go
│ │ ├── proc_amd64_test.go
│ │ ├── proc_darwin_amd64_test.go
│ │ ├── proc_darwin_test.go
│ │ ├── proc_general_test.go
│ │ ├── proc_linux_test.go
│ │ ├── proc_test.go
│ │ ├── proc_unexported_test.go
│ │ ├── proc_unix_test.go
│ │ ├── redirect.go
│ │ ├── redirector_other.go
│ │ ├── redirector_windows.go
│ │ ├── registers.go
│ │ ├── riscv64_arch.go
│ │ ├── riscv64_disasm.go
│ │ ├── scope_test.go
│ │ ├── stack.go
│ │ ├── stack_sigtramp.go
│ │ ├── stackwatch.go
│ │ ├── stepping_test.go
│ │ ├── target.go
│ │ ├── target_exec.go
│ │ ├── target_group.go
│ │ ├── test/
│ │ │ └── support.go
│ │ ├── threads.go
│ │ ├── types.go
│ │ ├── variable_test.go
│ │ ├── variables.go
│ │ ├── variables_fuzz_test.go
│ │ ├── variables_test.go
│ │ ├── winutil/
│ │ │ ├── regs_amd64_arch.go
│ │ │ └── regs_arm64_arch.go
│ │ └── x86_disasm.go
│ ├── terminal/
│ │ ├── colorize/
│ │ │ ├── colorize.go
│ │ │ └── colorize_test.go
│ │ ├── command.go
│ │ ├── command_test.go
│ │ ├── config.go
│ │ ├── disasmprint.go
│ │ ├── docgen.go
│ │ ├── groups.go
│ │ ├── out.go
│ │ ├── out_unix.go
│ │ ├── out_windows.go
│ │ ├── starbind/
│ │ │ ├── conv.go
│ │ │ ├── conv_test.go
│ │ │ ├── repl.go
│ │ │ ├── starlark.go
│ │ │ └── starlark_mapping.go
│ │ ├── starlark.go
│ │ ├── starlark_test.go
│ │ ├── terminal.go
│ │ ├── terminal_other.go
│ │ ├── terminal_test.go
│ │ └── terminal_windows.go
│ └── version/
│ ├── buildinfo.go
│ └── version.go
├── service/
│ ├── api/
│ │ ├── command.go
│ │ ├── conversions.go
│ │ ├── prettyprint.go
│ │ ├── prettyprint_test.go
│ │ ├── shorten_type.go
│ │ ├── shorten_type_test.go
│ │ ├── types.go
│ │ └── waitreason.go
│ ├── client.go
│ ├── config.go
│ ├── dap/
│ │ ├── command.go
│ │ ├── config.go
│ │ ├── config_test.go
│ │ ├── daptest/
│ │ │ ├── client.go
│ │ │ └── resp.go
│ │ ├── error_ids.go
│ │ ├── handles.go
│ │ ├── server.go
│ │ ├── server_test.go
│ │ └── types.go
│ ├── debugger/
│ │ ├── debugger.go
│ │ ├── debugger_linux.go
│ │ ├── debugger_test.go
│ │ └── debugger_unix_test.go
│ ├── internal/
│ │ └── sameuser/
│ │ ├── doc.go
│ │ ├── sameuser.go
│ │ ├── sameuser_linux.go
│ │ └── sameuser_linux_test.go
│ ├── listenerpipe.go
│ ├── rpc2/
│ │ ├── client.go
│ │ └── server.go
│ ├── rpccallback.go
│ ├── rpccommon/
│ │ ├── server.go
│ │ └── suitablemethods.go
│ ├── server.go
│ └── test/
│ ├── common_test.go
│ └── integration2_test.go
└── vendor/
├── github.com/
│ ├── cilium/
│ │ └── ebpf/
│ │ ├── .clang-format
│ │ ├── .gitignore
│ │ ├── .golangci.yaml
│ │ ├── ARCHITECTURE.md
│ │ ├── CODE_OF_CONDUCT.md
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE
│ │ ├── MAINTAINERS.md
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── asm/
│ │ │ ├── alu.go
│ │ │ ├── alu_string.go
│ │ │ ├── doc.go
│ │ │ ├── func.go
│ │ │ ├── func_string.go
│ │ │ ├── instruction.go
│ │ │ ├── jump.go
│ │ │ ├── jump_string.go
│ │ │ ├── load_store.go
│ │ │ ├── load_store_string.go
│ │ │ ├── metadata.go
│ │ │ ├── opcode.go
│ │ │ ├── opcode_string.go
│ │ │ └── register.go
│ │ ├── attachtype_string.go
│ │ ├── btf/
│ │ │ ├── btf.go
│ │ │ ├── btf_types.go
│ │ │ ├── btf_types_string.go
│ │ │ ├── core.go
│ │ │ ├── doc.go
│ │ │ ├── ext_info.go
│ │ │ ├── format.go
│ │ │ ├── handle.go
│ │ │ ├── marshal.go
│ │ │ ├── strings.go
│ │ │ ├── traversal.go
│ │ │ ├── types.go
│ │ │ └── workarounds.go
│ │ ├── collection.go
│ │ ├── doc.go
│ │ ├── elf_reader.go
│ │ ├── info.go
│ │ ├── internal/
│ │ │ ├── align.go
│ │ │ ├── buffer.go
│ │ │ ├── cpu.go
│ │ │ ├── deque.go
│ │ │ ├── elf.go
│ │ │ ├── endian_be.go
│ │ │ ├── endian_le.go
│ │ │ ├── epoll/
│ │ │ │ └── poller.go
│ │ │ ├── errors.go
│ │ │ ├── feature.go
│ │ │ ├── io.go
│ │ │ ├── kconfig/
│ │ │ │ └── kconfig.go
│ │ │ ├── memoize.go
│ │ │ ├── output.go
│ │ │ ├── pinning.go
│ │ │ ├── platform.go
│ │ │ ├── prog.go
│ │ │ ├── statfs.go
│ │ │ ├── sys/
│ │ │ │ ├── doc.go
│ │ │ │ ├── fd.go
│ │ │ │ ├── fd_trace.go
│ │ │ │ ├── mapflags_string.go
│ │ │ │ ├── ptr.go
│ │ │ │ ├── ptr_32_be.go
│ │ │ │ ├── ptr_32_le.go
│ │ │ │ ├── ptr_64.go
│ │ │ │ ├── signals.go
│ │ │ │ ├── syscall.go
│ │ │ │ └── types.go
│ │ │ ├── tracefs/
│ │ │ │ ├── kprobe.go
│ │ │ │ ├── probetype_string.go
│ │ │ │ └── uprobe.go
│ │ │ ├── unix/
│ │ │ │ ├── doc.go
│ │ │ │ ├── types_linux.go
│ │ │ │ └── types_other.go
│ │ │ ├── vdso.go
│ │ │ └── version.go
│ │ ├── link/
│ │ │ ├── cgroup.go
│ │ │ ├── doc.go
│ │ │ ├── iter.go
│ │ │ ├── kprobe.go
│ │ │ ├── kprobe_multi.go
│ │ │ ├── link.go
│ │ │ ├── netns.go
│ │ │ ├── perf_event.go
│ │ │ ├── program.go
│ │ │ ├── query.go
│ │ │ ├── raw_tracepoint.go
│ │ │ ├── socket_filter.go
│ │ │ ├── syscalls.go
│ │ │ ├── tracepoint.go
│ │ │ ├── tracing.go
│ │ │ ├── uprobe.go
│ │ │ └── xdp.go
│ │ ├── linker.go
│ │ ├── map.go
│ │ ├── marshalers.go
│ │ ├── prog.go
│ │ ├── ringbuf/
│ │ │ ├── doc.go
│ │ │ ├── reader.go
│ │ │ └── ring.go
│ │ ├── rlimit/
│ │ │ └── rlimit.go
│ │ ├── run-tests.sh
│ │ ├── syscalls.go
│ │ ├── types.go
│ │ └── types_string.go
│ ├── cosiner/
│ │ └── argv/
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── argv.go
│ │ ├── cmd.go
│ │ ├── parser.go
│ │ └── scanner.go
│ ├── cpuguy83/
│ │ └── go-md2man/
│ │ └── v2/
│ │ ├── LICENSE.md
│ │ └── md2man/
│ │ ├── debug.go
│ │ ├── md2man.go
│ │ └── roff.go
│ ├── creack/
│ │ └── pty/
│ │ ├── .gitignore
│ │ ├── Dockerfile.golang
│ │ ├── Dockerfile.riscv
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── asm_solaris_amd64.s
│ │ ├── doc.go
│ │ ├── ioctl.go
│ │ ├── ioctl_bsd.go
│ │ ├── ioctl_inner.go
│ │ ├── ioctl_legacy.go
│ │ ├── ioctl_solaris.go
│ │ ├── ioctl_unsupported.go
│ │ ├── mktypes.bash
│ │ ├── pty_darwin.go
│ │ ├── pty_dragonfly.go
│ │ ├── pty_freebsd.go
│ │ ├── pty_linux.go
│ │ ├── pty_netbsd.go
│ │ ├── pty_openbsd.go
│ │ ├── pty_solaris.go
│ │ ├── pty_unsupported.go
│ │ ├── run.go
│ │ ├── start.go
│ │ ├── start_windows.go
│ │ ├── test_crosscompile.sh
│ │ ├── winsize.go
│ │ ├── winsize_unix.go
│ │ ├── winsize_unsupported.go
│ │ ├── ztypes_386.go
│ │ ├── ztypes_amd64.go
│ │ ├── ztypes_arm.go
│ │ ├── ztypes_arm64.go
│ │ ├── ztypes_dragonfly_amd64.go
│ │ ├── ztypes_freebsd_386.go
│ │ ├── ztypes_freebsd_amd64.go
│ │ ├── ztypes_freebsd_arm.go
│ │ ├── ztypes_freebsd_arm64.go
│ │ ├── ztypes_freebsd_ppc64.go
│ │ ├── ztypes_freebsd_riscv64.go
│ │ ├── ztypes_loong64.go
│ │ ├── ztypes_mipsx.go
│ │ ├── ztypes_netbsd_32bit_int.go
│ │ ├── ztypes_openbsd_32bit_int.go
│ │ ├── ztypes_ppc.go
│ │ ├── ztypes_ppc64.go
│ │ ├── ztypes_ppc64le.go
│ │ ├── ztypes_riscvx.go
│ │ ├── ztypes_s390x.go
│ │ └── ztypes_sparcx.go
│ ├── derekparker/
│ │ └── trie/
│ │ └── v3/
│ │ ├── .gitignore
│ │ ├── LICENSE
│ │ ├── README.md
│ │ └── trie.go
│ ├── go-delve/
│ │ └── liner/
│ │ ├── COPYING
│ │ ├── README.md
│ │ ├── bsdinput.go
│ │ ├── common.go
│ │ ├── fallbackinput.go
│ │ ├── input.go
│ │ ├── input_darwin.go
│ │ ├── input_linux.go
│ │ ├── input_solaris.go
│ │ ├── input_windows.go
│ │ ├── line.go
│ │ ├── output.go
│ │ ├── output_solaris.go
│ │ ├── output_unix.go
│ │ ├── output_windows.go
│ │ ├── signal_unix.go
│ │ ├── signal_windows.go
│ │ ├── unixmode.go
│ │ ├── unixmode_solaris.go
│ │ └── width.go
│ ├── google/
│ │ └── go-dap/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── codec.go
│ │ ├── doc.go
│ │ ├── io.go
│ │ └── schematypes.go
│ ├── inconshreveable/
│ │ └── mousetrap/
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── trap_others.go
│ │ └── trap_windows.go
│ ├── mattn/
│ │ ├── go-colorable/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── colorable_appengine.go
│ │ │ ├── colorable_others.go
│ │ │ ├── colorable_windows.go
│ │ │ ├── go.test.sh
│ │ │ └── noncolorable.go
│ │ ├── go-isatty/
│ │ │ ├── LICENSE
│ │ │ ├── README.md
│ │ │ ├── doc.go
│ │ │ ├── go.test.sh
│ │ │ ├── isatty_bsd.go
│ │ │ ├── isatty_others.go
│ │ │ ├── isatty_plan9.go
│ │ │ ├── isatty_solaris.go
│ │ │ ├── isatty_tcgets.go
│ │ │ └── isatty_windows.go
│ │ └── go-runewidth/
│ │ ├── .travis.yml
│ │ ├── LICENSE
│ │ ├── README.md
│ │ ├── go.test.sh
│ │ ├── runewidth.go
│ │ ├── runewidth_appengine.go
│ │ ├── runewidth_js.go
│ │ ├── runewidth_posix.go
│ │ ├── runewidth_table.go
│ │ └── runewidth_windows.go
│ ├── rivo/
│ │ └── uniseg/
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── doc.go
│ │ ├── grapheme.go
│ │ └── properties.go
│ ├── russross/
│ │ └── blackfriday/
│ │ └── v2/
│ │ ├── .gitignore
│ │ ├── .travis.yml
│ │ ├── LICENSE.txt
│ │ ├── README.md
│ │ ├── block.go
│ │ ├── doc.go
│ │ ├── entities.go
│ │ ├── esc.go
│ │ ├── html.go
│ │ ├── inline.go
│ │ ├── markdown.go
│ │ ├── node.go
│ │ └── smartypants.go
│ └── spf13/
│ ├── cobra/
│ │ ├── .gitignore
│ │ ├── .golangci.yml
│ │ ├── .mailmap
│ │ ├── CONDUCT.md
│ │ ├── CONTRIBUTING.md
│ │ ├── LICENSE.txt
│ │ ├── MAINTAINERS
│ │ ├── Makefile
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ ├── active_help.go
│ │ ├── args.go
│ │ ├── bash_completions.go
│ │ ├── bash_completionsV2.go
│ │ ├── cobra.go
│ │ ├── command.go
│ │ ├── command_notwin.go
│ │ ├── command_win.go
│ │ ├── completions.go
│ │ ├── doc/
│ │ │ ├── man_docs.go
│ │ │ ├── md_docs.go
│ │ │ ├── rest_docs.go
│ │ │ ├── util.go
│ │ │ └── yaml_docs.go
│ │ ├── fish_completions.go
│ │ ├── flag_groups.go
│ │ ├── powershell_completions.go
│ │ ├── shell_completions.go
│ │ └── zsh_completions.go
│ └── pflag/
│ ├── .editorconfig
│ ├── .gitignore
│ ├── .golangci.yaml
│ ├── .travis.yml
│ ├── LICENSE
│ ├── README.md
│ ├── bool.go
│ ├── bool_func.go
│ ├── bool_slice.go
│ ├── bytes.go
│ ├── count.go
│ ├── duration.go
│ ├── duration_slice.go
│ ├── errors.go
│ ├── flag.go
│ ├── float32.go
│ ├── float32_slice.go
│ ├── float64.go
│ ├── float64_slice.go
│ ├── func.go
│ ├── golangflag.go
│ ├── int.go
│ ├── int16.go
│ ├── int32.go
│ ├── int32_slice.go
│ ├── int64.go
│ ├── int64_slice.go
│ ├── int8.go
│ ├── int_slice.go
│ ├── ip.go
│ ├── ip_slice.go
│ ├── ipmask.go
│ ├── ipnet.go
│ ├── ipnet_slice.go
│ ├── string.go
│ ├── string_array.go
│ ├── string_slice.go
│ ├── string_to_int.go
│ ├── string_to_int64.go
│ ├── string_to_string.go
│ ├── text.go
│ ├── time.go
│ ├── uint.go
│ ├── uint16.go
│ ├── uint32.go
│ ├── uint64.go
│ ├── uint8.go
│ └── uint_slice.go
├── go.starlark.net/
│ ├── LICENSE
│ ├── internal/
│ │ ├── compile/
│ │ │ ├── compile.go
│ │ │ └── serial.go
│ │ └── spell/
│ │ └── spell.go
│ ├── lib/
│ │ └── time/
│ │ └── time.go
│ ├── resolve/
│ │ ├── binding.go
│ │ └── resolve.go
│ ├── starlark/
│ │ ├── debug.go
│ │ ├── empty.s
│ │ ├── eval.go
│ │ ├── hashtable.go
│ │ ├── int.go
│ │ ├── int_generic.go
│ │ ├── int_posix64.go
│ │ ├── interp.go
│ │ ├── library.go
│ │ ├── profile.go
│ │ ├── unpack.go
│ │ └── value.go
│ ├── starlarkstruct/
│ │ ├── module.go
│ │ └── struct.go
│ └── syntax/
│ ├── grammar.txt
│ ├── options.go
│ ├── parse.go
│ ├── quote.go
│ ├── scan.go
│ ├── syntax.go
│ └── walk.go
├── go.yaml.in/
│ └── yaml/
│ └── v3/
│ ├── LICENSE
│ ├── NOTICE
│ ├── README.md
│ ├── apic.go
│ ├── decode.go
│ ├── emitterc.go
│ ├── encode.go
│ ├── parserc.go
│ ├── readerc.go
│ ├── resolve.go
│ ├── scannerc.go
│ ├── sorter.go
│ ├── writerc.go
│ ├── yaml.go
│ ├── yamlh.go
│ └── yamlprivateh.go
├── golang.org/
│ └── x/
│ ├── arch/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── arm64/
│ │ │ └── arm64asm/
│ │ │ ├── arg.go
│ │ │ ├── condition.go
│ │ │ ├── condition_util.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── inst.json
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ ├── loong64/
│ │ │ └── loong64asm/
│ │ │ ├── arg.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ ├── ppc64/
│ │ │ └── ppc64asm/
│ │ │ ├── decode.go
│ │ │ ├── doc.go
│ │ │ ├── field.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9.go
│ │ │ └── tables.go
│ │ ├── riscv64/
│ │ │ └── riscv64asm/
│ │ │ ├── arg.go
│ │ │ ├── csr_string.go
│ │ │ ├── decode.go
│ │ │ ├── gnu.go
│ │ │ ├── inst.go
│ │ │ ├── plan9x.go
│ │ │ └── tables.go
│ │ └── x86/
│ │ └── x86asm/
│ │ ├── Makefile
│ │ ├── decode.go
│ │ ├── gnu.go
│ │ ├── inst.go
│ │ ├── intel.go
│ │ ├── plan9x.go
│ │ └── tables.go
│ ├── exp/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── constraints/
│ │ │ └── constraints.go
│ │ ├── maps/
│ │ │ └── maps.go
│ │ └── slices/
│ │ ├── slices.go
│ │ ├── sort.go
│ │ ├── zsortfunc.go
│ │ └── zsortordered.go
│ ├── sync/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ └── errgroup/
│ │ ├── errgroup.go
│ │ ├── go120.go
│ │ └── pre_go120.go
│ ├── sys/
│ │ ├── LICENSE
│ │ ├── PATENTS
│ │ ├── unix/
│ │ │ ├── .gitignore
│ │ │ ├── README.md
│ │ │ ├── affinity_linux.go
│ │ │ ├── aliases.go
│ │ │ ├── asm_aix_ppc64.s
│ │ │ ├── asm_bsd_386.s
│ │ │ ├── asm_bsd_amd64.s
│ │ │ ├── asm_bsd_arm.s
│ │ │ ├── asm_bsd_arm64.s
│ │ │ ├── asm_bsd_ppc64.s
│ │ │ ├── asm_bsd_riscv64.s
│ │ │ ├── asm_linux_386.s
│ │ │ ├── asm_linux_amd64.s
│ │ │ ├── asm_linux_arm.s
│ │ │ ├── asm_linux_arm64.s
│ │ │ ├── asm_linux_loong64.s
│ │ │ ├── asm_linux_mips64x.s
│ │ │ ├── asm_linux_mipsx.s
│ │ │ ├── asm_linux_ppc64x.s
│ │ │ ├── asm_linux_riscv64.s
│ │ │ ├── asm_linux_s390x.s
│ │ │ ├── asm_openbsd_mips64.s
│ │ │ ├── asm_solaris_amd64.s
│ │ │ ├── asm_zos_s390x.s
│ │ │ ├── bluetooth_linux.go
│ │ │ ├── bpxsvc_zos.go
│ │ │ ├── bpxsvc_zos.s
│ │ │ ├── cap_freebsd.go
│ │ │ ├── constants.go
│ │ │ ├── dev_aix_ppc.go
│ │ │ ├── dev_aix_ppc64.go
│ │ │ ├── dev_darwin.go
│ │ │ ├── dev_dragonfly.go
│ │ │ ├── dev_freebsd.go
│ │ │ ├── dev_linux.go
│ │ │ ├── dev_netbsd.go
│ │ │ ├── dev_openbsd.go
│ │ │ ├── dev_zos.go
│ │ │ ├── dirent.go
│ │ │ ├── endian_big.go
│ │ │ ├── endian_little.go
│ │ │ ├── env_unix.go
│ │ │ ├── fcntl.go
│ │ │ ├── fcntl_darwin.go
│ │ │ ├── fcntl_linux_32bit.go
│ │ │ ├── fdset.go
│ │ │ ├── gccgo.go
│ │ │ ├── gccgo_c.c
│ │ │ ├── gccgo_linux_amd64.go
│ │ │ ├── ifreq_linux.go
│ │ │ ├── ioctl_linux.go
│ │ │ ├── ioctl_signed.go
│ │ │ ├── ioctl_unsigned.go
│ │ │ ├── ioctl_zos.go
│ │ │ ├── mkall.sh
│ │ │ ├── mkerrors.sh
│ │ │ ├── mmap_nomremap.go
│ │ │ ├── mremap.go
│ │ │ ├── pagesize_unix.go
│ │ │ ├── pledge_openbsd.go
│ │ │ ├── ptrace_darwin.go
│ │ │ ├── ptrace_ios.go
│ │ │ ├── race.go
│ │ │ ├── race0.go
│ │ │ ├── readdirent_getdents.go
│ │ │ ├── readdirent_getdirentries.go
│ │ │ ├── sockcmsg_dragonfly.go
│ │ │ ├── sockcmsg_linux.go
│ │ │ ├── sockcmsg_unix.go
│ │ │ ├── sockcmsg_unix_other.go
│ │ │ ├── sockcmsg_zos.go
│ │ │ ├── symaddr_zos_s390x.s
│ │ │ ├── syscall.go
│ │ │ ├── syscall_aix.go
│ │ │ ├── syscall_aix_ppc.go
│ │ │ ├── syscall_aix_ppc64.go
│ │ │ ├── syscall_bsd.go
│ │ │ ├── syscall_darwin.go
│ │ │ ├── syscall_darwin_amd64.go
│ │ │ ├── syscall_darwin_arm64.go
│ │ │ ├── syscall_darwin_libSystem.go
│ │ │ ├── syscall_dragonfly.go
│ │ │ ├── syscall_dragonfly_amd64.go
│ │ │ ├── syscall_freebsd.go
│ │ │ ├── syscall_freebsd_386.go
│ │ │ ├── syscall_freebsd_amd64.go
│ │ │ ├── syscall_freebsd_arm.go
│ │ │ ├── syscall_freebsd_arm64.go
│ │ │ ├── syscall_freebsd_riscv64.go
│ │ │ ├── syscall_hurd.go
│ │ │ ├── syscall_hurd_386.go
│ │ │ ├── syscall_illumos.go
│ │ │ ├── syscall_linux.go
│ │ │ ├── syscall_linux_386.go
│ │ │ ├── syscall_linux_alarm.go
│ │ │ ├── syscall_linux_amd64.go
│ │ │ ├── syscall_linux_amd64_gc.go
│ │ │ ├── syscall_linux_arm.go
│ │ │ ├── syscall_linux_arm64.go
│ │ │ ├── syscall_linux_gc.go
│ │ │ ├── syscall_linux_gc_386.go
│ │ │ ├── syscall_linux_gc_arm.go
│ │ │ ├── syscall_linux_gccgo_386.go
│ │ │ ├── syscall_linux_gccgo_arm.go
│ │ │ ├── syscall_linux_loong64.go
│ │ │ ├── syscall_linux_mips64x.go
│ │ │ ├── syscall_linux_mipsx.go
│ │ │ ├── syscall_linux_ppc.go
│ │ │ ├── syscall_linux_ppc64x.go
│ │ │ ├── syscall_linux_riscv64.go
│ │ │ ├── syscall_linux_s390x.go
│ │ │ ├── syscall_linux_sparc64.go
│ │ │ ├── syscall_netbsd.go
│ │ │ ├── syscall_netbsd_386.go
│ │ │ ├── syscall_netbsd_amd64.go
│ │ │ ├── syscall_netbsd_arm.go
│ │ │ ├── syscall_netbsd_arm64.go
│ │ │ ├── syscall_openbsd.go
│ │ │ ├── syscall_openbsd_386.go
│ │ │ ├── syscall_openbsd_amd64.go
│ │ │ ├── syscall_openbsd_arm.go
│ │ │ ├── syscall_openbsd_arm64.go
│ │ │ ├── syscall_openbsd_libc.go
│ │ │ ├── syscall_openbsd_mips64.go
│ │ │ ├── syscall_openbsd_ppc64.go
│ │ │ ├── syscall_openbsd_riscv64.go
│ │ │ ├── syscall_solaris.go
│ │ │ ├── syscall_solaris_amd64.go
│ │ │ ├── syscall_unix.go
│ │ │ ├── syscall_unix_gc.go
│ │ │ ├── syscall_unix_gc_ppc64x.go
│ │ │ ├── syscall_zos_s390x.go
│ │ │ ├── sysvshm_linux.go
│ │ │ ├── sysvshm_unix.go
│ │ │ ├── sysvshm_unix_other.go
│ │ │ ├── timestruct.go
│ │ │ ├── unveil_openbsd.go
│ │ │ ├── vgetrandom_linux.go
│ │ │ ├── vgetrandom_unsupported.go
│ │ │ ├── xattr_bsd.go
│ │ │ ├── zerrors_aix_ppc.go
│ │ │ ├── zerrors_aix_ppc64.go
│ │ │ ├── zerrors_darwin_amd64.go
│ │ │ ├── zerrors_darwin_arm64.go
│ │ │ ├── zerrors_dragonfly_amd64.go
│ │ │ ├── zerrors_freebsd_386.go
│ │ │ ├── zerrors_freebsd_amd64.go
│ │ │ ├── zerrors_freebsd_arm.go
│ │ │ ├── zerrors_freebsd_arm64.go
│ │ │ ├── zerrors_freebsd_riscv64.go
│ │ │ ├── zerrors_linux.go
│ │ │ ├── zerrors_linux_386.go
│ │ │ ├── zerrors_linux_amd64.go
│ │ │ ├── zerrors_linux_arm.go
│ │ │ ├── zerrors_linux_arm64.go
│ │ │ ├── zerrors_linux_loong64.go
│ │ │ ├── zerrors_linux_mips.go
│ │ │ ├── zerrors_linux_mips64.go
│ │ │ ├── zerrors_linux_mips64le.go
│ │ │ ├── zerrors_linux_mipsle.go
│ │ │ ├── zerrors_linux_ppc.go
│ │ │ ├── zerrors_linux_ppc64.go
│ │ │ ├── zerrors_linux_ppc64le.go
│ │ │ ├── zerrors_linux_riscv64.go
│ │ │ ├── zerrors_linux_s390x.go
│ │ │ ├── zerrors_linux_sparc64.go
│ │ │ ├── zerrors_netbsd_386.go
│ │ │ ├── zerrors_netbsd_amd64.go
│ │ │ ├── zerrors_netbsd_arm.go
│ │ │ ├── zerrors_netbsd_arm64.go
│ │ │ ├── zerrors_openbsd_386.go
│ │ │ ├── zerrors_openbsd_amd64.go
│ │ │ ├── zerrors_openbsd_arm.go
│ │ │ ├── zerrors_openbsd_arm64.go
│ │ │ ├── zerrors_openbsd_mips64.go
│ │ │ ├── zerrors_openbsd_ppc64.go
│ │ │ ├── zerrors_openbsd_riscv64.go
│ │ │ ├── zerrors_solaris_amd64.go
│ │ │ ├── zerrors_zos_s390x.go
│ │ │ ├── zptrace_armnn_linux.go
│ │ │ ├── zptrace_linux_arm64.go
│ │ │ ├── zptrace_mipsnn_linux.go
│ │ │ ├── zptrace_mipsnnle_linux.go
│ │ │ ├── zptrace_x86_linux.go
│ │ │ ├── zsymaddr_zos_s390x.s
│ │ │ ├── zsyscall_aix_ppc.go
│ │ │ ├── zsyscall_aix_ppc64.go
│ │ │ ├── zsyscall_aix_ppc64_gc.go
│ │ │ ├── zsyscall_aix_ppc64_gccgo.go
│ │ │ ├── zsyscall_darwin_amd64.go
│ │ │ ├── zsyscall_darwin_amd64.s
│ │ │ ├── zsyscall_darwin_arm64.go
│ │ │ ├── zsyscall_darwin_arm64.s
│ │ │ ├── zsyscall_dragonfly_amd64.go
│ │ │ ├── zsyscall_freebsd_386.go
│ │ │ ├── zsyscall_freebsd_amd64.go
│ │ │ ├── zsyscall_freebsd_arm.go
│ │ │ ├── zsyscall_freebsd_arm64.go
│ │ │ ├── zsyscall_freebsd_riscv64.go
│ │ │ ├── zsyscall_illumos_amd64.go
│ │ │ ├── zsyscall_linux.go
│ │ │ ├── zsyscall_linux_386.go
│ │ │ ├── zsyscall_linux_amd64.go
│ │ │ ├── zsyscall_linux_arm.go
│ │ │ ├── zsyscall_linux_arm64.go
│ │ │ ├── zsyscall_linux_loong64.go
│ │ │ ├── zsyscall_linux_mips.go
│ │ │ ├── zsyscall_linux_mips64.go
│ │ │ ├── zsyscall_linux_mips64le.go
│ │ │ ├── zsyscall_linux_mipsle.go
│ │ │ ├── zsyscall_linux_ppc.go
│ │ │ ├── zsyscall_linux_ppc64.go
│ │ │ ├── zsyscall_linux_ppc64le.go
│ │ │ ├── zsyscall_linux_riscv64.go
│ │ │ ├── zsyscall_linux_s390x.go
│ │ │ ├── zsyscall_linux_sparc64.go
│ │ │ ├── zsyscall_netbsd_386.go
│ │ │ ├── zsyscall_netbsd_amd64.go
│ │ │ ├── zsyscall_netbsd_arm.go
│ │ │ ├── zsyscall_netbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_386.go
│ │ │ ├── zsyscall_openbsd_386.s
│ │ │ ├── zsyscall_openbsd_amd64.go
│ │ │ ├── zsyscall_openbsd_amd64.s
│ │ │ ├── zsyscall_openbsd_arm.go
│ │ │ ├── zsyscall_openbsd_arm.s
│ │ │ ├── zsyscall_openbsd_arm64.go
│ │ │ ├── zsyscall_openbsd_arm64.s
│ │ │ ├── zsyscall_openbsd_mips64.go
│ │ │ ├── zsyscall_openbsd_mips64.s
│ │ │ ├── zsyscall_openbsd_ppc64.go
│ │ │ ├── zsyscall_openbsd_ppc64.s
│ │ │ ├── zsyscall_openbsd_riscv64.go
│ │ │ ├── zsyscall_openbsd_riscv64.s
│ │ │ ├── zsyscall_solaris_amd64.go
│ │ │ ├── zsyscall_zos_s390x.go
│ │ │ ├── zsysctl_openbsd_386.go
│ │ │ ├── zsysctl_openbsd_amd64.go
│ │ │ ├── zsysctl_openbsd_arm.go
│ │ │ ├── zsysctl_openbsd_arm64.go
│ │ │ ├── zsysctl_openbsd_mips64.go
│ │ │ ├── zsysctl_openbsd_ppc64.go
│ │ │ ├── zsysctl_openbsd_riscv64.go
│ │ │ ├── zsysnum_darwin_amd64.go
│ │ │ ├── zsysnum_darwin_arm64.go
│ │ │ ├── zsysnum_dragonfly_amd64.go
│ │ │ ├── zsysnum_freebsd_386.go
│ │ │ ├── zsysnum_freebsd_amd64.go
│ │ │ ├── zsysnum_freebsd_arm.go
│ │ │ ├── zsysnum_freebsd_arm64.go
│ │ │ ├── zsysnum_freebsd_riscv64.go
│ │ │ ├── zsysnum_linux_386.go
│ │ │ ├── zsysnum_linux_amd64.go
│ │ │ ├── zsysnum_linux_arm.go
│ │ │ ├── zsysnum_linux_arm64.go
│ │ │ ├── zsysnum_linux_loong64.go
│ │ │ ├── zsysnum_linux_mips.go
│ │ │ ├── zsysnum_linux_mips64.go
│ │ │ ├── zsysnum_linux_mips64le.go
│ │ │ ├── zsysnum_linux_mipsle.go
│ │ │ ├── zsysnum_linux_ppc.go
│ │ │ ├── zsysnum_linux_ppc64.go
│ │ │ ├── zsysnum_linux_ppc64le.go
│ │ │ ├── zsysnum_linux_riscv64.go
│ │ │ ├── zsysnum_linux_s390x.go
│ │ │ ├── zsysnum_linux_sparc64.go
│ │ │ ├── zsysnum_netbsd_386.go
│ │ │ ├── zsysnum_netbsd_amd64.go
│ │ │ ├── zsysnum_netbsd_arm.go
│ │ │ ├── zsysnum_netbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_386.go
│ │ │ ├── zsysnum_openbsd_amd64.go
│ │ │ ├── zsysnum_openbsd_arm.go
│ │ │ ├── zsysnum_openbsd_arm64.go
│ │ │ ├── zsysnum_openbsd_mips64.go
│ │ │ ├── zsysnum_openbsd_ppc64.go
│ │ │ ├── zsysnum_openbsd_riscv64.go
│ │ │ ├── zsysnum_zos_s390x.go
│ │ │ ├── ztypes_aix_ppc.go
│ │ │ ├── ztypes_aix_ppc64.go
│ │ │ ├── ztypes_darwin_amd64.go
│ │ │ ├── ztypes_darwin_arm64.go
│ │ │ ├── ztypes_dragonfly_amd64.go
│ │ │ ├── ztypes_freebsd_386.go
│ │ │ ├── ztypes_freebsd_amd64.go
│ │ │ ├── ztypes_freebsd_arm.go
│ │ │ ├── ztypes_freebsd_arm64.go
│ │ │ ├── ztypes_freebsd_riscv64.go
│ │ │ ├── ztypes_linux.go
│ │ │ ├── ztypes_linux_386.go
│ │ │ ├── ztypes_linux_amd64.go
│ │ │ ├── ztypes_linux_arm.go
│ │ │ ├── ztypes_linux_arm64.go
│ │ │ ├── ztypes_linux_loong64.go
│ │ │ ├── ztypes_linux_mips.go
│ │ │ ├── ztypes_linux_mips64.go
│ │ │ ├── ztypes_linux_mips64le.go
│ │ │ ├── ztypes_linux_mipsle.go
│ │ │ ├── ztypes_linux_ppc.go
│ │ │ ├── ztypes_linux_ppc64.go
│ │ │ ├── ztypes_linux_ppc64le.go
│ │ │ ├── ztypes_linux_riscv64.go
│ │ │ ├── ztypes_linux_s390x.go
│ │ │ ├── ztypes_linux_sparc64.go
│ │ │ ├── ztypes_netbsd_386.go
│ │ │ ├── ztypes_netbsd_amd64.go
│ │ │ ├── ztypes_netbsd_arm.go
│ │ │ ├── ztypes_netbsd_arm64.go
│ │ │ ├── ztypes_openbsd_386.go
│ │ │ ├── ztypes_openbsd_amd64.go
│ │ │ ├── ztypes_openbsd_arm.go
│ │ │ ├── ztypes_openbsd_arm64.go
│ │ │ ├── ztypes_openbsd_mips64.go
│ │ │ ├── ztypes_openbsd_ppc64.go
│ │ │ ├── ztypes_openbsd_riscv64.go
│ │ │ ├── ztypes_solaris_amd64.go
│ │ │ └── ztypes_zos_s390x.go
│ │ └── windows/
│ │ ├── aliases.go
│ │ ├── dll_windows.go
│ │ ├── env_windows.go
│ │ ├── eventlog.go
│ │ ├── exec_windows.go
│ │ ├── memory_windows.go
│ │ ├── mkerrors.bash
│ │ ├── mkknownfolderids.bash
│ │ ├── mksyscall.go
│ │ ├── race.go
│ │ ├── race0.go
│ │ ├── security_windows.go
│ │ ├── service.go
│ │ ├── setupapi_windows.go
│ │ ├── str.go
│ │ ├── syscall.go
│ │ ├── syscall_windows.go
│ │ ├── types_windows.go
│ │ ├── types_windows_386.go
│ │ ├── types_windows_amd64.go
│ │ ├── types_windows_arm.go
│ │ ├── types_windows_arm64.go
│ │ ├── zerrors_windows.go
│ │ ├── zknownfolderids_windows.go
│ │ └── zsyscall_windows.go
│ └── telemetry/
│ ├── .dockerignore
│ ├── .eslintrc.json
│ ├── .gitattributes
│ ├── .gitignore
│ ├── .prettierrc.json
│ ├── .stylelintrc.json
│ ├── CONTRIBUTING.md
│ ├── LICENSE
│ ├── PATENTS
│ ├── README.md
│ ├── counter/
│ │ ├── counter.go
│ │ └── doc.go
│ ├── dir.go
│ ├── doc.go
│ ├── internal/
│ │ ├── config/
│ │ │ └── config.go
│ │ ├── configstore/
│ │ │ ├── download.go
│ │ │ └── download_windows.go
│ │ ├── counter/
│ │ │ ├── counter.go
│ │ │ ├── file.go
│ │ │ ├── parse.go
│ │ │ └── stackcounter.go
│ │ ├── crashmonitor/
│ │ │ ├── crash_go123.go
│ │ │ └── monitor.go
│ │ ├── mmap/
│ │ │ ├── mmap.go
│ │ │ ├── mmap_other.go
│ │ │ ├── mmap_unix.go
│ │ │ └── mmap_windows.go
│ │ ├── telemetry/
│ │ │ ├── dateonly.go
│ │ │ ├── dir.go
│ │ │ ├── proginfo.go
│ │ │ └── types.go
│ │ └── upload/
│ │ ├── Doc.txt
│ │ ├── date.go
│ │ ├── findwork.go
│ │ ├── reports.go
│ │ ├── run.go
│ │ └── upload.go
│ ├── mode.go
│ ├── npm
│ ├── npx
│ ├── package.json
│ ├── start.go
│ ├── start_posix.go
│ ├── start_windows.go
│ ├── tsconfig.json
│ └── types_alias.go
└── modules.txt
Showing preview only (7,018K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (92373 symbols across 1033 files)
FILE: _fixtures/asmnilptr/main.go
function asmFunc (line 5) | func asmFunc(*int) int
function main (line 7) | func main() {
FILE: _fixtures/backwardsiter.go
function backwards (line 8) | func backwards(s []int) func(func(int) bool) {
function main (line 18) | func main() {
FILE: _fixtures/badflags.go
function g (line 8) | func g() {
function main (line 11) | func main() {
FILE: _fixtures/binarytrees.go
function main (line 25) | func main() {
function bottomUpTree (line 76) | func bottomUpTree(item, depth int) *Node {
type Node (line 86) | type Node struct
method ItemCheck (line 91) | func (self *Node) ItemCheck() int {
FILE: _fixtures/bpcountstest.go
function demo (line 10) | func demo(id int, wait *sync.WaitGroup) {
function main (line 20) | func main() {
FILE: _fixtures/bphitcountchain.go
function breakfunc1 (line 5) | func breakfunc1() {
function breakfunc2 (line 9) | func breakfunc2() {
function breakfunc3 (line 13) | func breakfunc3() {
function main (line 17) | func main() {
FILE: _fixtures/break.go
function main (line 3) | func main() {
FILE: _fixtures/break/main.go
function asmBrk (line 3) | func asmBrk()
function main (line 5) | func main() {
FILE: _fixtures/buildflagtest.go
function main (line 9) | func main() {
FILE: _fixtures/buildtest/main.go
function main (line 5) | func main() {
FILE: _fixtures/buildtest/main_test.go
function TestMain (line 8) | func TestMain(m *testing.M) {
function TestCurrentDirectory (line 12) | func TestCurrentDirectory(t *testing.T) {
FILE: _fixtures/callme.go
function callme (line 5) | func callme(i int) {
constant nBytes (line 9) | nBytes = 10
function callme2 (line 12) | func callme2() {
function callme3 (line 19) | func callme3() {
function main (line 23) | func main() {
FILE: _fixtures/cat.go
function main (line 9) | func main() {
FILE: _fixtures/cgodisass.go
function main (line 11) | func main() {
FILE: _fixtures/cgosigsegvstack.go
function main (line 15) | func main() {
FILE: _fixtures/cgostacktest/hello.c
function helloworld_pt2 (line 23) | void helloworld_pt2(int x) {
function helloworld (line 28) | void helloworld(int x) {
function helloworld_pt4 (line 32) | void helloworld_pt4(int x) {
function helloworld_pt3 (line 37) | void helloworld_pt3(int x) {
FILE: _fixtures/cgostacktest/main.go
function main (line 11) | func main() {
function helloWorld (line 17) | func helloWorld(x C.int) {
function helloWorldS (line 21) | func helloWorldS(x C.int) {
function helloWorld2 (line 27) | func helloWorld2(x C.int) {
FILE: _fixtures/cgotest.go
function main (line 12) | func main() {
FILE: _fixtures/changoroutines.go
function main (line 8) | func main() {
function sendToChan (line 20) | func sendToChan(name string, ch chan<- int) {
function recvFromChan (line 24) | func recvFromChan(ch <-chan int) {
FILE: _fixtures/clientdo.go
function main (line 8) | func main() {
FILE: _fixtures/closurecontents.go
function makeAcc (line 8) | func makeAcc(scale int) func(x int) int {
function main (line 16) | func main() {
FILE: _fixtures/condframe.go
function callme (line 5) | func callme() {
function callme2 (line 11) | func callme2() {
function main (line 15) | func main() {
FILE: _fixtures/condperghitcount.go
function main (line 8) | func main() {
FILE: _fixtures/consts.go
type ConstType (line 9) | type ConstType
constant constZero (line 12) | constZero ConstType = iota
constant constOne (line 13) | constOne
constant constTwo (line 14) | constTwo
constant constThree (line 15) | constThree
type BitFieldType (line 18) | type BitFieldType
constant bitZero (line 21) | bitZero BitFieldType = 1 << iota
constant bitOne (line 22) | bitOne
constant bitTwo (line 23) | bitTwo
constant bitThree (line 24) | bitThree
constant bitFour (line 25) | bitFour
function main (line 28) | func main() {
FILE: _fixtures/continuetestprog.go
function sleepytime (line 8) | func sleepytime() {
function sayhi (line 12) | func sayhi() {
function main (line 16) | func main() {
FILE: _fixtures/coreemptystring.go
function main (line 3) | func main() {
FILE: _fixtures/databpcountstest.go
function demo (line 11) | func demo(id int, wait *sync.WaitGroup) {
function main (line 21) | func main() {
FILE: _fixtures/databpeasy.go
function main (line 13) | func main() { // Position 0
function f (line 38) | func f(done chan struct{}) {
function waitfunc (line 44) | func waitfunc(i int, wg *sync.WaitGroup) {
FILE: _fixtures/databpstack.go
function f (line 8) | func f() {
function g (line 14) | func g(cnt int, p *int) {
function main (line 22) | func main() {
FILE: _fixtures/debugdetect.go
function main (line 10) | func main() {
FILE: _fixtures/decllinetest.go
function main (line 7) | func main() {
function f1 (line 14) | func f1(
FILE: _fixtures/defercall.go
function sampleFunction (line 5) | func sampleFunction() {
function callAndDeferReturn (line 9) | func callAndDeferReturn() {
function callAndPanic2 (line 15) | func callAndPanic2() {
function callAndPanic (line 21) | func callAndPanic() {
function main (line 26) | func main() {
FILE: _fixtures/deferstack.go
function f1 (line 5) | func f1() {
function f2 (line 8) | func f2(a int8, b int32) {
function f3 (line 11) | func f3() {
function call1 (line 14) | func call1() {
function call2 (line 20) | func call2() {
function call3 (line 26) | func call3() {
function main (line 30) | func main() {
FILE: _fixtures/delvecatch.go
function main (line 5) | func main() {
FILE: _fixtures/dotpackagesiface.go
function main (line 10) | func main() {
FILE: _fixtures/doubleinline.go
type Rectangle (line 9) | type Rectangle struct
method Height (line 11) | func (r *Rectangle) Height() int {
method Width (line 16) | func (r *Rectangle) Width() int {
method Area (line 20) | func (r *Rectangle) Area() int { return r.Height() * r.Width() }
function main (line 22) | func main() {
FILE: _fixtures/dwzcompression.go
function main (line 11) | func main() {
FILE: _fixtures/ebpf_trace.go
function callme (line 5) | func callme(i int) int {
function main (line 12) | func main() {
FILE: _fixtures/ebpf_trace2.go
function main (line 8) | func main() {
function tracedFunction (line 20) | func tracedFunction(x int64) {
FILE: _fixtures/ebpf_trace3.go
function main (line 8) | func main() {
function tracedFunction (line 21) | func tracedFunction(x int64, b bool, r byte) {
FILE: _fixtures/examinememory.go
function main (line 8) | func main() {
FILE: _fixtures/fatalerror.go
function main (line 3) | func main() {
FILE: _fixtures/fncall.go
function callstacktrace (line 12) | func callstacktrace() (stacktrace string) {
function call0 (line 24) | func call0(a, b int) {
function call1 (line 28) | func call1(a, b int) int {
function call2 (line 33) | func call2(a, b int) (int, int) {
function callexit (line 38) | func callexit() {
function callpanic (line 43) | func callpanic() {
function callbreak (line 48) | func callbreak() {
function stringsJoin (line 53) | func stringsJoin(v []string, sep string) string {
function mul2 (line 60) | func mul2(x a2struct) int {
function mul2ptr (line 64) | func mul2ptr(x *a2struct) int {
type astruct (line 68) | type astruct struct
method VRcvr (line 76) | func (a astruct) VRcvr(x int) string {
method PRcvr (line 80) | func (pa *astruct) PRcvr(x int) string {
type a2struct (line 72) | type a2struct struct
type PRcvrable (line 84) | type PRcvrable interface
type VRcvrable (line 88) | type VRcvrable interface
function makeclos (line 94) | func makeclos(pa *astruct) func(int) string {
function escapeArg (line 105) | func escapeArg(pa2 *a2struct) {
function square (line 109) | func square(x int) int {
function intcallpanic (line 113) | func intcallpanic(a int) int {
function onetwothree (line 120) | func onetwothree(n int) []int {
function curriedAdd (line 124) | func curriedAdd(n int) func(int) int {
function getAStruct (line 130) | func getAStruct(n int) astruct {
function getAStructPtr (line 134) | func getAStructPtr(n int) *astruct {
function getVRcvrableFromAStruct (line 138) | func getVRcvrableFromAStruct(n int) VRcvrable {
function getPRcvrableFromAStructPtr (line 142) | func getPRcvrableFromAStructPtr(n int) PRcvrable {
function getVRcvrableFromAStructPtr (line 146) | func getVRcvrableFromAStructPtr(n int) VRcvrable {
function noreturncall (line 150) | func noreturncall(n int) {
type Base (line 154) | type Base struct
method Method (line 163) | func (b *Base) Method() int {
type Derived (line 158) | type Derived struct
type X (line 167) | type X
method CallMe (line 169) | func (_ X) CallMe() {
type X2 (line 173) | type X2
method CallMe (line 175) | func (_ X2) CallMe(i int) int {
function regabistacktest (line 179) | func regabistacktest(s1, s2, s3, s4, s5 string, n uint8) (string, string...
function regabistacktest2 (line 183) | func regabistacktest2(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10 int) (int,...
function regabistacktest3 (line 187) | func regabistacktest3(sargs [10]string, n uint8) (r [10]string, m uint8) {
function floatsum (line 195) | func floatsum(a, b float64) float64 {
type Issue2698 (line 199) | type Issue2698 struct
method String (line 206) | func (i Issue2698) String() string {
type Issue3364 (line 210) | type Issue3364 struct
method String (line 215) | func (i Issue3364) String() string {
type intpair (line 219) | type intpair struct
function main (line 229) | func main() {
FILE: _fixtures/fputest/fputest.go
function fputestsetup (line 8) | func fputestsetup(f64a, f64b, f64c, f64d float64, f32a, f32b, f32c, f32d...
function getCPUID70 (line 9) | func getCPUID70() (ebx, ecx uint32)
function main (line 11) | func main() {
FILE: _fixtures/genericbp.go
function testfn (line 5) | func testfn[T any](arg T) {
function main (line 9) | func main() {
FILE: _fixtures/genericintoiface.go
type Blah (line 5) | type Blah struct
method F (line 9) | func (b *Blah[T]) F(y T) {
type BlahInt (line 13) | type BlahInt interface
function callf (line 17) | func callf(b BlahInt) {
function main (line 22) | func main() {
FILE: _fixtures/godlopen/golib/golib.go
function GoFunction (line 6) | func GoFunction() int32 {
function main (line 10) | func main() {}
FILE: _fixtures/godlopen/main.c
function main (line 5) | int main(int argc, char **argv) {
FILE: _fixtures/goroutineLabels.go
function main (line 9) | func main() {
function f (line 18) | func f(ctx context.Context) {
FILE: _fixtures/goroutinebreak.go
constant N (line 5) | N = 10
function agoroutine (line 7) | func agoroutine(started chan<- struct{}, done chan<- struct{}, i int) {
function main (line 12) | func main() {
FILE: _fixtures/goroutinegroup.go
function sleepyfunc (line 11) | func sleepyfunc(wg *sync.WaitGroup, lbl string) {
function gopoint1 (line 17) | func gopoint1(wg *sync.WaitGroup, lbl string, f func(*sync.WaitGroup, st...
function gopoint2 (line 21) | func gopoint2(wg *sync.WaitGroup, lbl string, f func(*sync.WaitGroup, st...
function gopoint3 (line 25) | func gopoint3(wg *sync.WaitGroup, lbl string, f func(*sync.WaitGroup, st...
function gopoint4 (line 29) | func gopoint4(wg *sync.WaitGroup, lbl string, f func(*sync.WaitGroup, st...
function gopoint5 (line 33) | func gopoint5(wg *sync.WaitGroup, lbl string, f func(*sync.WaitGroup, st...
function startpoint1 (line 37) | func startpoint1(wg *sync.WaitGroup, lbl string) {
function startpoint2 (line 41) | func startpoint2(wg *sync.WaitGroup, lbl string) {
function startpoint3 (line 45) | func startpoint3(wg *sync.WaitGroup, lbl string) {
function startpoint4 (line 49) | func startpoint4(wg *sync.WaitGroup, lbl string) {
function startpoint5 (line 53) | func startpoint5(wg *sync.WaitGroup, lbl string) {
function main (line 57) | func main() {
FILE: _fixtures/goroutines-trace.go
function callme (line 8) | func callme(i int, s string) int {
function dostuff (line 13) | func dostuff(wg *sync.WaitGroup, lbl string) {
function main (line 22) | func main() {
FILE: _fixtures/goroutinestackprog.go
constant N (line 5) | N = 10
function agoroutine (line 7) | func agoroutine(started chan<- struct{}, done chan<- struct{}, i int) {
function stacktraceme (line 14) | func stacktraceme() {
function main (line 19) | func main() {
function func1 (line 37) | func func1(n int) {
function func2 (line 41) | func func2(n int) {
function func3 (line 45) | func func3(n int) {
FILE: _fixtures/hcbpcountstest.go
function demo (line 11) | func demo(id int, wait *sync.WaitGroup) {
function main (line 22) | func main() {
FILE: _fixtures/http_server.go
function main (line 8) | func main() {
FILE: _fixtures/ifaceembcall.go
type A (line 5) | type A struct
method PtrReceiver (line 18) | func (*A) PtrReceiver() string {
method NonPtrReceiver (line 22) | func (A) NonPtrReceiver() string {
type B (line 9) | type B struct
type Iface (line 13) | type Iface interface
function main (line 26) | func main() {
FILE: _fixtures/increment.go
function Increment (line 6) | func Increment(y uint) uint {
function main (line 16) | func main() {
FILE: _fixtures/inlinestripped.go
function callme (line 5) | func callme(i int) int {
function main (line 9) | func main() {
FILE: _fixtures/integrationprog.go
function sayhi (line 8) | func sayhi() {
function main (line 12) | func main() {
FILE: _fixtures/internal/dir.io/dir.go
type SomeType (line 3) | type SomeType struct
function SomeFunction (line 9) | func SomeFunction() {
FILE: _fixtures/internal/dir.io/io.io/io.go
type SomeOtherType (line 3) | type SomeOtherType struct
FILE: _fixtures/internal/dir0/pkg/main.go
type SomeType (line 5) | type SomeType struct
method AMethod (line 9) | func (s *SomeType) AMethod(x int) int {
method AnotherMethod (line 13) | func (s *SomeType) AnotherMethod(x int) int {
constant SomeConst (line 20) | SomeConst int = 2
FILE: _fixtures/internal/dir0/renamedpackage/main.go
type SomeType (line 3) | type SomeType struct
FILE: _fixtures/internal/dir1/pkg/main.go
type SomeType (line 5) | type SomeType struct
FILE: _fixtures/internal/pluginsupport/pluginsupport.go
type Something (line 3) | type Something interface
type SomethingElse (line 7) | type SomethingElse interface
FILE: _fixtures/is sue239.go
function fibonacci (line 7) | func fibonacci(n int, c chan int) {
function main (line 16) | func main() {
FILE: _fixtures/issue1101.go
function f (line 10) | func f(from string) {
function main (line 15) | func main() {
FILE: _fixtures/issue1264.go
function main (line 5) | func main() {
FILE: _fixtures/issue1374.go
function main (line 5) | func main() {
function getNum (line 10) | func getNum() int {
FILE: _fixtures/issue1432.go
type s (line 5) | type s struct
function main (line 9) | func main() {
FILE: _fixtures/issue1469.go
function main (line 5) | func main() {
FILE: _fixtures/issue1531.go
type W (line 8) | type W struct
function main (line 13) | func main() {
function testMaps (line 17) | func testMaps() {
FILE: _fixtures/issue1549.go
function main (line 8) | func main() {
FILE: _fixtures/issue1598.go
function main (line 3) | func main() {
function x (line 8) | func x() string {
FILE: _fixtures/issue1601.go
function main (line 18) | func main() {
FILE: _fixtures/issue1615.go
function f (line 13) | func f(s string) {
function main (line 17) | func main() {
FILE: _fixtures/issue1656/main.go
function compromised (line 9) | func compromised(n int64)
function skipped (line 12) | func skipped() {
function main (line 16) | func main() {
FILE: _fixtures/issue1795.go
function main (line 9) | func main() {
FILE: _fixtures/issue1817.go
function main (line 9) | func main() {
FILE: _fixtures/issue2023.go
function A (line 8) | func A() {
function main (line 12) | func main() {
FILE: _fixtures/issue2078.go
function main (line 3) | func main() {
function f (line 8) | func f(x *int) {
FILE: _fixtures/issue2086.go
type T (line 9) | type T struct
method m (line 11) | func (t T) m() { stop() }
function stop (line 13) | func stop() {
function main (line 18) | func main() { T{}.m() }
FILE: _fixtures/issue2113.go
function coroutine (line 9) | func coroutine(i int, start, finish *sync.WaitGroup) {
function main (line 25) | func main() {
FILE: _fixtures/issue2138.go
function main (line 7) | func main() {
FILE: _fixtures/issue2162.go
function main (line 5) | func main() {
FILE: _fixtures/issue2319/main.go
function cfunc (line 3) | func cfunc()
function main (line 5) | func main() {
FILE: _fixtures/issue262.go
function typicalFunction (line 5) | func typicalFunction() (res int) {
function main (line 14) | func main() {
FILE: _fixtures/issue2896.go
type Vehicle (line 4) | type Vehicle interface
type BMWS1000RR (line 10) | type BMWS1000RR struct
method Run (line 14) | func (a *BMWS1000RR) Run() {
function main (line 18) | func main() {
FILE: _fixtures/issue305.go
function main (line 3) | func main() {
FILE: _fixtures/issue3194.go
function main (line 11) | func main() {
function f (line 15) | func f() {
FILE: _fixtures/issue3310.go
function reflectFunc (line 11) | func reflectFunc(value reflect.Value) {
function main (line 15) | func main() {
FILE: _fixtures/issue332.go
function main (line 5) | func main() {
function changeMe (line 12) | func changeMe(z []string) {
FILE: _fixtures/issue3548.go
type Thing (line 7) | type Thing struct
method Test (line 11) | func (d *Thing) Test() bool {
function callit (line 15) | func callit(f func()) {
function main (line 19) | func main() {
FILE: _fixtures/issue384.go
function main (line 8) | func main() {
FILE: _fixtures/issue387.go
function dostuff (line 8) | func dostuff(id int, wg *sync.WaitGroup) {
function main (line 14) | func main() {
FILE: _fixtures/issue4000.go
function main (line 5) | func main() {
FILE: _fixtures/issue4051.go
function Hello (line 16) | func Hello(name string) string {
function f (line 22) | func f(i int) func() {
function main (line 28) | func main() {
FILE: _fixtures/issue406.go
type Blacklist (line 13) | type Blacklist
method String (line 35) | func (b Blacklist) String() (result string) {
type Source (line 16) | type Source
type Node (line 19) | type Node struct
type Src (line 27) | type Src struct
function ToBool (line 59) | func ToBool(s string) (b bool) {
function Get (line 73) | func Get(cfg string) {
function main (line 149) | func main() {
FILE: _fixtures/issue4116.go
type A (line 8) | type A struct
method Model (line 11) | func (a *A) Model() string {
type B (line 15) | type B struct
type A1 (line 20) | type A1 struct
type B1 (line 24) | type B1 struct
method X (line 28) | func (*B1) X() {}
type A2 (line 30) | type A2 struct
type B2 (line 34) | type B2 struct
method X (line 38) | func (*B2) X() {}
type C2 (line 40) | type C2 struct
type A3 (line 44) | type A3 struct
type B3 (line 48) | type B3 struct
method X (line 52) | func (b *B3) X() {}
type C3 (line 54) | type C3 struct
type TestX (line 58) | type TestX interface
type A4 (line 62) | type A4 struct
method X (line 65) | func (a *A4) X() {}
type B4 (line 67) | type B4 struct
type A5 (line 73) | type A5 struct
type B5 (line 77) | type B5 struct
type C5 (line 81) | type C5 struct
type A6 (line 88) | type A6 struct
type B7 (line 92) | type B7 struct
method X (line 95) | func (b *B7) X() {}
type A7 (line 97) | type A7 struct
type TestX1 (line 101) | type TestX1 interface
type B8 (line 105) | type B8 struct
method X (line 108) | func (*B8) X() {}
type A8 (line 110) | type A8 struct
type B9 (line 114) | type B9 struct
method X (line 117) | func (*B9) X() {}
type A9 (line 119) | type A9 struct
type B10 (line 123) | type B10 struct
type A10 (line 127) | type A10 struct
function main (line 131) | func main() {
FILE: _fixtures/issue419.go
function main (line 9) | func main() {
FILE: _fixtures/issue528.go
function main (line 8) | func main() {
FILE: _fixtures/issue561.go
function testfunction (line 5) | func testfunction() {
function main (line 9) | func main() {
FILE: _fixtures/issue573.go
function foo (line 17) | func foo(x, y int) (z int) { // c stops here
function main (line 23) | func main() {
FILE: _fixtures/issue594.go
function dontsegfault (line 8) | func dontsegfault() {
function main (line 18) | func main() {
FILE: _fixtures/issue664.go
function asdfasdf (line 3) | func asdfasdf() {
function main (line 12) | func main() {
FILE: _fixtures/issue683.go
function main (line 5) | func main() {
FILE: _fixtures/issue871.go
function main (line 8) | func main() {
FILE: _fixtures/issue877.go
function main (line 9) | func main() {
FILE: _fixtures/issue951.go
function main (line 8) | func main() {
function shadow (line 12) | func shadow(i int) {
FILE: _fixtures/leaf4.go
function D (line 5) | func D(i int) int {
function C (line 8) | func C(i int) int {
function B (line 12) | func B(i int) int {
function A (line 16) | func A(i int) int {
function main (line 19) | func main() {
FILE: _fixtures/leafcommon.go
function D (line 5) | func D(i int) int {
function C (line 8) | func C(i int) int {
function B (line 12) | func B(i int) int {
function A (line 15) | func A(i int) int {
function main (line 19) | func main() {
FILE: _fixtures/leafindrec.go
function B (line 5) | func B(i int) int {
function A (line 12) | func A(n int) int {
function main (line 19) | func main() {
FILE: _fixtures/leafrec.go
function A (line 5) | func A(i int, n int) int {
function main (line 13) | func main() {
FILE: _fixtures/leafregex.go
function callmed (line 5) | func callmed(i int) int {
function callmee (line 8) | func callmee(i int) int {
function callme2 (line 12) | func callme2(i int) int {
function callme (line 16) | func callme(i int) int {
function main (line 19) | func main() {
FILE: _fixtures/livetestprog.go
function printPid (line 10) | func printPid(pid int) {
function sayhi (line 14) | func sayhi() {
function main (line 18) | func main() {
FILE: _fixtures/locationsUpperCase.go
function main (line 5) | func main() {
FILE: _fixtures/locationsprog.go
type SomeType (line 8) | type SomeType struct
method String (line 14) | func (a *SomeType) String() string {
method SomeFunction (line 22) | func (a *SomeType) SomeFunction() {
type OtherType (line 11) | type OtherType struct
method String (line 18) | func (a *OtherType) String() string {
function anotherFunction (line 26) | func anotherFunction() {
function main (line 30) | func main() {
function init (line 42) | func init() {
FILE: _fixtures/locationsprog2.go
function afunction (line 8) | func afunction(s string) {
type someStruct (line 12) | type someStruct struct
method structfunc (line 16) | func (o *someStruct) structfunc(s2 string) {
function main (line 20) | func main() {
FILE: _fixtures/locationsprog3.go
function main (line 9) | func main() {
FILE: _fixtures/locationsprog_generic.go
type ParamReceiver (line 5) | type ParamReceiver struct
method Amethod (line 9) | func (r *ParamReceiver[T]) Amethod() {
function ParamFunc (line 13) | func ParamFunc[T any](arg T) {
function main (line 17) | func main() {
FILE: _fixtures/longstrings.go
function buildString (line 7) | func buildString(length int) string {
function main (line 15) | func main() {
FILE: _fixtures/loopprog.go
function loop (line 5) | func loop() {
function main (line 16) | func main() {
FILE: _fixtures/math.go
function main (line 7) | func main() {
FILE: _fixtures/morestringarg.go
function f (line 5) | func f(s, q string) {
function main (line 9) | func main() {
FILE: _fixtures/multinamedreturns.go
function ManyArgsWithNamedReturns (line 6) | func ManyArgsWithNamedReturns(a, b, c, d, e, f, g, h, i, j, k, l, m, n, ...
function main (line 27) | func main() {
FILE: _fixtures/nestedbp.go
function main (line 5) | func main() {
function a (line 11) | func a() {
function b (line 17) | func b() {
FILE: _fixtures/nextcond.go
function f1 (line 5) | func f1(x int) {
function main (line 8) | func main() {
FILE: _fixtures/nilptr.go
function main (line 3) | func main() {
FILE: _fixtures/nodisasm/main.go
function asmFunc (line 3) | func asmFunc()
function main (line 5) | func main() {
FILE: _fixtures/nomaindir/file.go
function AFunction (line 3) | func AFunction() {
FILE: _fixtures/nongochild/main.go
function main (line 10) | func main() {
FILE: _fixtures/nopbreakpoint/main.go
function compromised (line 9) | func compromised()
function skipped (line 11) | func skipped() {
function main (line 15) | func main() {
FILE: _fixtures/notify-v2.go
function main (line 10) | func main() {
FILE: _fixtures/out_redirect.go
function main (line 8) | func main() {
FILE: _fixtures/panic.go
function main (line 3) | func main() {
FILE: _fixtures/panicex.go
function F0 (line 3) | func F0() {
function F1 (line 10) | func F1() {
function F2 (line 14) | func F2() {
function F3 (line 18) | func F3() {
function F4 (line 22) | func F4() {
function main (line 26) | func main() {
FILE: _fixtures/panicline.go
function main (line 5) | func main() {
FILE: _fixtures/parallel_next.go
function sayhi (line 8) | func sayhi(n int, wg *sync.WaitGroup) {
function main (line 14) | func main() {
FILE: _fixtures/pkgrenames.go
function main (line 17) | func main() {
FILE: _fixtures/plugin1/plugin1.go
function Fn1 (line 5) | func Fn1() string {
function HelloFn (line 9) | func HelloFn(n int) string {
FILE: _fixtures/plugin2/plugin2.go
function Fn2 (line 8) | func Fn2() string {
type asomethingelse (line 12) | type asomethingelse struct
method Callback2 (line 16) | func (a *asomethingelse) Callback2(n, m int) float64 {
function TypesTest (line 22) | func TypesTest(s pluginsupport.Something) pluginsupport.SomethingElse {
function aIsNotNil (line 31) | func aIsNotNil(str string) {
FILE: _fixtures/plugintest.go
function must (line 10) | func must(err error) {
function main (line 16) | func main() {
FILE: _fixtures/plugintest2.go
type asomething (line 10) | type asomething struct
method Callback (line 14) | func (a *asomething) Callback(n int) int {
method String (line 18) | func (a *asomething) String() string {
function must (line 24) | func must(err error) {
function main (line 30) | func main() {
FILE: _fixtures/pr1055.go
function main (line 9) | func main() {
FILE: _fixtures/rangeoverfunc.go
function TestTrickyIterAll (line 24) | func TestTrickyIterAll() {
function TestTrickyIterAll2 (line 37) | func TestTrickyIterAll2() {
function TestBreak1 (line 46) | func TestBreak1() {
function TestBreak2 (line 63) | func TestBreak2() {
function TestMultiCont0 (line 81) | func TestMultiCont0() {
function TestPanickyIterator1 (line 110) | func TestPanickyIterator1() {
function TestPanickyIterator2 (line 125) | func TestPanickyIterator2() {
function TestPanickyIteratorWithNewDefer (line 149) | func TestPanickyIteratorWithNewDefer() {
function TestLongReturnWrapper (line 176) | func TestLongReturnWrapper() {
function TestLongReturn (line 181) | func TestLongReturn() {
function TestGotoA1 (line 192) | func TestGotoA1() {
function TestGotoB1 (line 211) | func TestGotoB1() {
function TestRecur (line 231) | func TestRecur(n int) {
function main (line 245) | func main() {
type Seq (line 260) | type Seq
type Seq2 (line 261) | type Seq2
type TrickyIterator (line 263) | type TrickyIterator struct
method iterAll (line 267) | func (ti *TrickyIterator) iterAll(s []int) Seq2[int, int] {
function OfSliceIndex (line 285) | func OfSliceIndex[T any, S ~[]T](s S) Seq2[int, T] {
function PanickyOfSliceIndex (line 297) | func PanickyOfSliceIndex[T any, S ~[]T](s S) Seq2[int, T] {
function VeryBadOfSliceIndex (line 311) | func VeryBadOfSliceIndex[T any, S ~[]T](s S) Seq2[int, T] {
FILE: _fixtures/readmem_json.go
function main (line 14) | func main() {
FILE: _fixtures/redirect.go
function main (line 10) | func main() {
FILE: _fixtures/reflecttypefncall.go
function reflectFunc (line 8) | func reflectFunc(value reflect.Value) {
function main (line 12) | func main() {
FILE: _fixtures/restartargs.go
function printArgs (line 10) | func printArgs(){
function main (line 14) | func main() {
FILE: _fixtures/retstack.go
function f (line 6) | func f() {
function g (line 10) | func g() int {
function main (line 15) | func main() {
FILE: _fixtures/scopeescapevareval.go
function main (line 8) | func main() {
FILE: _fixtures/scopetest.go
function f1 (line 3) | func f1(x int) {}
function f2 (line 4) | func f2(x int) {}
function f3 (line 5) | func f3(x int) {}
function f4 (line 6) | func f4(x int) {}
function f5 (line 7) | func f5(x int) {}
function f6 (line 8) | func f6(x int) {}
function gret1 (line 9) | func gret1(x int) int {
function gretbool (line 15) | func gretbool() bool {
function gret3 (line 20) | func gret3() (int, int, int) { return 0, 1, 2 }
function TestNestedFor (line 27) | func TestNestedFor() {
function TestOas2 (line 41) | func TestOas2() {
function TestIfElse (line 58) | func TestIfElse(x int) {
function TestSwitch (line 69) | func TestSwitch(in int) {
function TestTypeSwitch (line 85) | func TestTypeSwitch(iface interface{}) {
function TestSelectScope (line 95) | func TestSelectScope() {
function TestBlock (line 103) | func TestBlock() {
function TestDiscontiguousRanges (line 113) | func TestDiscontiguousRanges() {
function TestClosureScope (line 130) | func TestClosureScope() {
function TestClosureShadow (line 145) | func TestClosureShadow() {
function main (line 157) | func main() {
FILE: _fixtures/setiterator.go
function main (line 10) | func main() {
type Set (line 19) | type Set struct
function New (line 24) | func New[E comparable]() *Set[E] {
method All (line 29) | func (s *Set[E]) All() iter.Seq[E] {
method Add (line 42) | func (s *Set[E]) Add(v E) {
function PrintAllElements (line 46) | func PrintAllElements[E comparable](s *Set[E]) {
FILE: _fixtures/setymmreg/main.go
function asmFunc (line 3) | func asmFunc()
function main (line 5) | func main() {
FILE: _fixtures/sigchldprog.go
function main (line 10) | func main() {
FILE: _fixtures/sleep.go
function f (line 8) | func f() {
function main (line 17) | func main() {
FILE: _fixtures/spawn.go
function traceme1 (line 11) | func traceme1() {
function traceme2 (line 15) | func traceme2(n string) {
function traceme3 (line 19) | func traceme3() {
function main (line 23) | func main() {
FILE: _fixtures/spawnchild.go
function traceme5 (line 5) | func traceme5() {
function main (line 9) | func main() {
FILE: _fixtures/stacktraceprog.go
function stacktraceme (line 3) | func stacktraceme() {
function func1 (line 7) | func func1() {
function func2 (line 11) | func func2(f func()) {
function main (line 15) | func main() {
FILE: _fixtures/stackwatchbug.go
function multiRound (line 7) | func multiRound() {
function main (line 17) | func main() {
FILE: _fixtures/stepintobug.go
type T (line 3) | type T struct
method m1 (line 12) | func (t T) m1(x int) int {
function main (line 6) | func main() {
FILE: _fixtures/stepoutret.go
function stepout (line 5) | func stepout(n int) (str string, num int) {
function main (line 9) | func main() {
FILE: _fixtures/stepshadow.go
function main (line 8) | func main() {
function goroutineA (line 20) | func goroutineA(wg *sync.WaitGroup) {
function stacktraceme1 (line 27) | func stacktraceme1() {
function stacktraceme2 (line 30) | func stacktraceme2() {
FILE: _fixtures/test if path/main.go
function main (line 3) | func main() {
FILE: _fixtures/test.c
function main (line 3) | int main(void) {
FILE: _fixtures/testRestartRequestRebuildFailFixture.go
function main (line 7) | func main() {
FILE: _fixtures/testargs.go
function main (line 8) | func main() {
FILE: _fixtures/testdeadlock.go
function main (line 3) | func main() {
FILE: _fixtures/testenv.go
function main (line 9) | func main() {
FILE: _fixtures/testenv2.go
function main (line 9) | func main() {
FILE: _fixtures/testfnpos1.go
function f1 (line 5) | func f1() {
function f2 (line 9) | func f2() {
function main (line 13) | func main() {
FILE: _fixtures/testfnpos2.go
function f2 (line 5) | func f2() {
function f1 (line 9) | func f1() {
function main (line 13) | func main() {
FILE: _fixtures/testinline.go
function inlineThis (line 5) | func inlineThis(a int) int {
function initialize (line 10) | func initialize(a, b *int) {
function main (line 15) | func main() {
function f (line 24) | func f(x int) int {
FILE: _fixtures/testnextdefer.go
function main (line 5) | func main() {
FILE: _fixtures/testnextnethttp.go
function main (line 11) | func main() {
FILE: _fixtures/testnextprog.go
function sleepytime (line 9) | func sleepytime() {
function helloworld (line 13) | func helloworld() {
function testnext (line 17) | func testnext() {
function main (line 37) | func main() {
function testgoroutine (line 46) | func testgoroutine(foo int, d chan int) {
function init (line 50) | func init() {
FILE: _fixtures/testprog.go
function helloworld (line 9) | func helloworld() {
function sleepytime (line 13) | func sleepytime() {
function main (line 17) | func main() {
function init (line 24) | func init() {
FILE: _fixtures/testrerecord.go
function main (line 8) | func main() {
FILE: _fixtures/testreturnaddress.go
function doSomething (line 5) | func doSomething(wg *sync.WaitGroup) {
function main (line 9) | func main() {
FILE: _fixtures/testruntimebreakpoint.go
function main (line 8) | func main() {
FILE: _fixtures/testshadow.go
function main (line 8) | func main() {
FILE: _fixtures/teststep.go
function callme (line 8) | func callme() {
function main (line 12) | func main() {
FILE: _fixtures/teststepconcurrent.go
function Foo (line 13) | func Foo(x, y int) (z int) {
function Threads (line 19) | func Threads(fn func(x, y int) int) {
function main (line 32) | func main() {
FILE: _fixtures/teststepprog.go
function CallFn2 (line 5) | func CallFn2(x int) {
function CallFn (line 9) | func CallFn(x int, fn func(x int)) {
function CallEface (line 13) | func CallEface(eface interface{}) {
function main (line 19) | func main() {
FILE: _fixtures/testthreads.go
function anotherthread (line 8) | func anotherthread(wg *sync.WaitGroup) {
function main (line 14) | func main() {
FILE: _fixtures/testtoggle.go
function lineOne (line 7) | func lineOne() {
function lineTwo (line 11) | func lineTwo() {
function lineThree (line 15) | func lineThree() {
function main (line 19) | func main() {
FILE: _fixtures/testtracefns.go
function D (line 5) | func D(i int) int {
function C (line 8) | func C(i int) int {
function B (line 12) | func B(i int) int {
function A (line 15) | func A(i int) int {
function second (line 19) | func second(i int) int {
function first (line 26) | func first(n int) int {
function callmed (line 34) | func callmed(i int) int {
function callmee (line 37) | func callmee(i int) int {
function callme2 (line 41) | func callme2(i int) int {
function callme (line 45) | func callme(i int) int {
function F0 (line 49) | func F0() {
function F1 (line 56) | func F1() {
function F2 (line 60) | func F2() {
function F3 (line 64) | func F3() {
function F4 (line 68) | func F4() {
function swap (line 74) | func swap() {
function unnamedDefer (line 83) | func unnamedDefer() {
function formula (line 89) | func formula(op string) func(int, int) int {
function op (line 105) | func op() int {
function assign (line 111) | func assign(bar func()) {
function testfunc (line 114) | func testfunc() {
function dyn (line 119) | func dyn() {
function outer (line 125) | func outer() {
function nestDefer (line 129) | func nestDefer() {
function namedDeferLoop (line 133) | func namedDeferLoop(n int) {
function main (line 141) | func main() {
FILE: _fixtures/testunsafepointers.go
function main (line 8) | func main() {
FILE: _fixtures/testvariables.go
type FooBar (line 8) | type FooBar struct
type FooBar2 (line 14) | type FooBar2 struct
type Nest (line 19) | type Nest struct
function barfoo (line 24) | func barfoo() {
function foobar (line 30) | func foobar(baz string, bar FooBar) {
function main (line 72) | func main() {
FILE: _fixtures/testvariables2.go
type Byte (line 15) | type Byte
type String (line 16) | type String
type Uint32 (line 17) | type Uint32
type Int64 (line 18) | type Int64
type Bool (line 19) | type Bool
type Float64 (line 20) | type Float64
constant ByteConst (line 24) | ByteConst Byte = 255
constant StringConst (line 25) | StringConst String = "hi"
constant UintConst (line 26) | UintConst Uint32 = 42
constant IntConst (line 27) | IntConst Int64 = 9001
constant BoolConst (line 28) | BoolConst Bool = true
constant FloatConst (line 29) | FloatConst Float64 = 3.14
type astruct (line 32) | type astruct struct
method Error (line 90) | func (a *astruct) Error() string {
method NonPointerReceiverMethod (line 94) | func (a astruct) NonPointerReceiverMethod() {
type largestruct (line 37) | type largestruct struct
type astructName1 (line 42) | type astructName1
type astructName2 (line 43) | type astructName2
type bstruct (line 45) | type bstruct struct
method Error (line 98) | func (b *bstruct) Error() string {
type cstruct (line 49) | type cstruct struct
type a (line 54) | type a struct
type A (line 58) | type A struct
type C (line 62) | type C struct
type B (line 66) | type B struct
type D (line 73) | type D struct
function afunc (line 77) | func afunc(x int) int {
function afunc1 (line 81) | func afunc1(x int) {
function afunc2 (line 84) | func afunc2() int {
type functype (line 88) | type functype
type dstruct (line 102) | type dstruct struct
type maptype (line 106) | type maptype
type benchstruct (line 108) | type benchstruct struct
type Item (line 113) | type Item struct
type Menu (line 119) | type Menu
type truncatedMap (line 121) | type truncatedMap struct
type Cache (line 125) | type Cache struct
type Block (line 129) | type Block struct
type List (line 133) | type List struct
type T (line 138) | type T struct
type W1 (line 142) | type W1 struct
method M (line 146) | func (*W1) M() {}
type I (line 148) | type I interface
type W2 (line 150) | type W2 struct
type W3 (line 155) | type W3 struct
type W4 (line 160) | type W4 struct
type W5 (line 164) | type W5 struct
type ThreeInts (line 168) | type ThreeInts struct
type OnlyUsedInInterface (line 172) | type OnlyUsedInInterface struct
type Message (line 176) | type Message
type pptr (line 180) | type pptr
function main (line 182) | func main() {
FILE: _fixtures/testvariables_generic.go
type astruct (line 8) | type astruct struct
function testfn (line 12) | func testfn[T any, K comparable](arg1 T, arg2 K) {
function main (line 19) | func main() {
FILE: _fixtures/testvariables_pointers_not_loaded.go
function main (line 5) | func main() {
FILE: _fixtures/testvariablescgo/test.c
type align_check (line 23) | struct align_check {
function testfn (line 28) | void testfn(void) {
FILE: _fixtures/testvariablescgo/testvariablescgo.go
function main (line 9) | func main() {
FILE: _fixtures/trace_backend_parity.go
function allTypes (line 6) | func allTypes(i int64, u uint64, b bool, s string) int {
function main (line 11) | func main() {
FILE: _fixtures/traceperf.go
function PerfCheck (line 3) | func PerfCheck(i, a, b, c int) {
function main (line 8) | func main() {
FILE: _fixtures/traceprog.go
function callme (line 5) | func callme(i int) int {
function main (line 9) | func main() {
FILE: _fixtures/traceret.go
function fncall1 (line 5) | func fncall1() int {
function fncall2 (line 9) | func fncall2() int {
function main (line 13) | func main() {
FILE: _fixtures/waitfordebugger.go
function main (line 10) | func main() {
FILE: _fixtures/watchpointInterface.go
function main (line 9) | func main() {
FILE: _fixtures/watchpointInterfaceNil.go
function main (line 8) | func main() {
FILE: _fixtures/workdir.go
function main (line 8) | func main() {
FILE: _fixtures/xmm0print/main.go
function VPSLLQ36 (line 6) | func VPSLLQ36(src, dst *[4]uint64)
function main (line 8) | func main() {
FILE: _scripts/gen-backend_test_health.go
function process (line 16) | func process(path string, skipped map[string]map[string]int) {
function main (line 66) | func main() {
function skipOnArgs (line 107) | func skipOnArgs(args []ast.Expr) (reason string, conditions string) {
FILE: _scripts/gen-capslock-all.go
type Platform (line 14) | type Platform struct
constant colorRed (line 34) | colorRed = "\033[0;31m"
constant colorGreen (line 35) | colorGreen = "\033[0;32m"
constant colorYellow (line 36) | colorYellow = "\033[1;33m"
constant colorReset (line 37) | colorReset = "\033[0m"
function main (line 40) | func main() {
function generateCapslock (line 106) | func generateCapslock(platform Platform) error {
function findProjectRoot (line 134) | func findProjectRoot() string {
FILE: _scripts/gen-cli-docs.go
function main (line 14) | func main() {
FILE: _scripts/gen-faq-toc.go
function must (line 13) | func must(err error, fmtstr string, args ...interface{}) {
function usage (line 19) | func usage() {
type tocentry (line 26) | type tocentry struct
constant startOfToc (line 31) | startOfToc = "<!-- BEGIN TOC -->"
constant endOfToc (line 32) | endOfToc = "<!-- END TOC -->"
function spliceDocs (line 35) | func spliceDocs(docpath string, docs []byte, outpath string) {
function readtoc (line 68) | func readtoc(docpath string) []tocentry {
function writetoc (line 96) | func writetoc(tocentries []tocentry) []byte {
function main (line 104) | func main() {
FILE: _scripts/gen-opcodes.go
type Opcode (line 15) | type Opcode struct
function usage (line 22) | func usage() {
function main (line 28) | func main() {
FILE: _scripts/gen-travis.go
type arguments (line 15) | type arguments struct
type goVersion (line 19) | type goVersion struct
method dec (line 26) | func (v goVersion) dec() goVersion {
method MaxVersion (line 34) | func (v goVersion) MaxVersion() bool {
method DotX (line 38) | func (v goVersion) DotX() string {
method String (line 42) | func (v goVersion) String() string {
function main (line 46) | func main() {
FILE: _scripts/gen-usage-docs.go
constant defaultUsageDir (line 16) | defaultUsageDir = "./Documentation/usage"
function main (line 18) | func main() {
FILE: _scripts/latestver.py
function splitver (line 7) | def splitver(x):
FILE: _scripts/make.go
constant DelveMainPackagePath (line 19) | DelveMainPackagePath = "github.com/go-delve/delve/cmd/dlv"
function NewMakeCommands (line 30) | func NewMakeCommands() *cobra.Command {
function checkCert (line 135) | func checkCert() bool {
function checkCertCmd (line 164) | func checkCertCmd(cmd *cobra.Command, args []string) {
function strflatten (line 170) | func strflatten(v []interface{}) []string {
function executeq (line 185) | func executeq(env []string, cmd string, args ...interface{}) {
function execute (line 202) | func execute(cmd string, args ...interface{}) {
function executeEnv (line 208) | func executeEnv(env []string, cmd string, args ...interface{}) {
function quotemaybe (line 214) | func quotemaybe(args []string) []string {
function getoutput (line 223) | func getoutput(cmd string, args ...interface{}) string {
function isCodesigned (line 238) | func isCodesigned(path string) bool {
function codesign (line 247) | func codesign(path string) {
function installedExecutablePath (line 251) | func installedExecutablePath() string {
function canMacnative (line 262) | func canMacnative() bool {
function prepareMacnative (line 295) | func prepareMacnative() string {
function tagFlags (line 305) | func tagFlags(isTest bool) string {
function buildFlags (line 330) | func buildFlags() []string {
function testFlags (line 344) | func testFlags() []string {
function testCmd (line 365) | func testCmd(cmd *cobra.Command, args []string) {
function testStandard (line 393) | func testStandard() {
function testCmdIntl (line 443) | func testCmdIntl(testSet, testRegex, testBackend, testBuildMode string) {
function testSetToPackages (line 487) | func testSetToPackages(testSet string) []string {
function defaultBackend (line 508) | func defaultBackend() string {
function inpath (line 515) | func inpath(exe string) bool {
function allPackages (line 520) | func allPackages() []string {
function getBuildSHA (line 534) | func getBuildSHA() (string, error) {
function main (line 547) | func main() {
FILE: _scripts/rtype.go
constant magicCommentPrefix (line 89) | magicCommentPrefix = "+rtype"
constant gover (line 90) | gover = "go1."
type rtypeCmnt (line 99) | type rtypeCmnt struct
type checkVarType (line 107) | type checkVarType struct
method String (line 113) | func (c *checkVarType) String() string {
type checkFieldType (line 121) | type checkFieldType struct
method String (line 128) | func (c *checkFieldType) String() string {
type checkConstVal (line 133) | type checkConstVal struct
method String (line 146) | func (c *checkConstVal) String() string {
type firstMinor (line 140) | type firstMinor
method versionOk (line 142) | func (firstMinor firstMinor) versionOk(curminor int) bool {
function main (line 154) | func main() {
function setup (line 185) | func setup() {
function getRtypeCmnts (line 206) | func getRtypeCmnts(file *ast.File, cmntmap ast.CommentMap) []*rtypeCmnt {
function cleanupCommentText (line 262) | func cleanupCommentText(txt string) string {
function process (line 273) | func process(pkg *packages.Package, rtcmnt *rtypeCmnt, cmntmap ast.Comme...
function isProcVariableDecl (line 320) | func isProcVariableDecl(stmt ast.Stmt, tinfo *types.Info) *ast.Ident {
function isConstDecl (line 348) | func isConstDecl(toplevel ast.Decl, node ast.Node) *ast.Ident {
function isStringCaseClause (line 366) | func isStringCaseClause(stmt ast.Stmt) string {
function processProcVariableUses (line 388) | func processProcVariableUses(decl ast.Node, tinfo *types.Info, procVarId...
function findComment (line 474) | func findComment(slash token.Pos, rtcmnts []*rtypeCmnt) int {
function addCheckVarType (line 483) | func addCheckVarType(V, T string, pos token.Pos, firstMinor_ int) {
function addCheckFieldType (line 487) | func addCheckFieldType(S, F, T string, opt bool, pos token.Pos, firstMin...
function addCheckConstVal (line 493) | func addCheckConstVal(C string, V constant.Value, pos token.Pos, firstMi...
function report (line 498) | func report() {
function lookupPackage (line 543) | func lookupPackage(pkgmap map[string]*packages.Package, name string) *pa...
function lookupTypeDef (line 562) | func lookupTypeDef(pkgmap map[string]*packages.Package, typ string) type...
function check (line 573) | func check() {
function fieldTypeByName (line 680) | func fieldTypeByName(typ *types.Struct, name string) types.Type {
function findConst (line 690) | func findConst(pkgmap map[string]*packages.Package, Cs string) types.Obj...
function matchType (line 705) | func matchType(typ types.Type, T string) bool {
function typeStr (line 720) | func typeStr(typ types.Type) string {
function constValue (line 729) | func constValue(obj types.Object) constant.Value {
function printNode (line 733) | func printNode(fset *token.FileSet, n ast.Node) {
function exprToString (line 737) | func exprToString(t ast.Expr) string {
function relative (line 743) | func relative(s string) string {
function versionOkFilter (line 752) | func versionOkFilter[T interface{ versionOk(int) bool }](rules []T) []T {
FILE: pkg/astutil/astutil.go
function Eql (line 14) | func Eql(x, y ast.Expr) *ast.BinaryExpr {
function Sel (line 19) | func Sel(x ast.Expr, sel string) *ast.SelectorExpr {
function PkgVar (line 24) | func PkgVar(pkg, v string) *ast.SelectorExpr {
function Int (line 29) | func Int(n int64) *ast.BasicLit {
function And (line 34) | func And(x, y ast.Expr) ast.Expr {
function Or (line 42) | func Or(x, y ast.Expr) ast.Expr {
function ExprToString (line 50) | func ExprToString(t ast.Expr) string {
FILE: pkg/config/config.go
constant configDir (line 18) | configDir string = "dlv"
constant configDirHidden (line 19) | configDirHidden string = ".dlv"
constant configFile (line 20) | configFile string = "config.yml"
constant PositionSource (line 22) | PositionSource = "source"
constant PositionDisassembly (line 23) | PositionDisassembly = "disassembly"
constant PositionDefault (line 24) | PositionDefault = "default"
type SubstitutePathRule (line 28) | type SubstitutePathRule struct
type SubstitutePathRules (line 36) | type SubstitutePathRules
type Config (line 39) | type Config struct
method GetSourceListLineCount (line 190) | func (c *Config) GetSourceListLineCount() int {
method GetDisassembleFlavour (line 199) | func (c *Config) GetDisassembleFlavour() api.AssemblyFlavour {
function LoadConfig (line 214) | func LoadConfig() (*Config, error) {
function SaveConfig (line 268) | func SaveConfig(conf *Config) error {
function moveOldConfig (line 291) | func moveOldConfig() error {
function createDefaultConfig (line 315) | func createDefaultConfig(path string) (*os.File, error) {
function writeDefaultConfig (line 328) | func writeDefaultConfig(f *os.File) error {
function createConfigPath (line 406) | func createConfigPath() error {
function GetConfigFilePath (line 415) | func GetConfigFilePath(file string) (string, error) {
function hasOldConfig (line 429) | func hasOldConfig() (bool, error) {
function getUserHomeDir (line 448) | func getUserHomeDir() string {
function WriteConfigDocumentation (line 457) | func WriteConfigDocumentation(w io.Writer) {
FILE: pkg/config/split.go
function SplitQuotedFields (line 16) | func SplitQuotedFields(in string, quote rune) []string {
function ConfigureSetSimple (line 72) | func ConfigureSetSimple(rest string, cfgname string, field reflect.Value...
function ConfigureList (line 134) | func ConfigureList(w io.Writer, config any, tag string) {
function writeField (line 146) | func writeField(w io.Writer, field reflect.Value, fieldName string) {
type configureIterator (line 168) | type configureIterator struct
method Next (line 182) | func (it *configureIterator) Next() bool {
method Field (line 187) | func (it *configureIterator) Field() (name string, field reflect.Value) {
function IterateConfiguration (line 175) | func IterateConfiguration(conf any, tag string) *configureIterator {
function ConfigureListByName (line 196) | func ConfigureListByName(conf any, name, tag string) string {
function ConfigureFindFieldByName (line 212) | func ConfigureFindFieldByName(conf any, name, tag string) reflect.Value {
function Split2PartsBySpace (line 223) | func Split2PartsBySpace(s string) []string {
FILE: pkg/config/split_test.go
function TestSplitQuotedFields (line 7) | func TestSplitQuotedFields(t *testing.T) {
function TestSplitDoubleQuotedFields (line 25) | func TestSplitDoubleQuotedFields(t *testing.T) {
function TestConfigureListByName (line 77) | func TestConfigureListByName(t *testing.T) {
FILE: pkg/debugdetect/detect.go
function IsDebuggerAttached (line 14) | func IsDebuggerAttached() (bool, error) {
function WaitForDebugger (line 23) | func WaitForDebugger() error {
FILE: pkg/debugdetect/detect_darwin.go
constant pTracedFlag (line 13) | pTracedFlag = 0x00000800
constant kernProc (line 16) | kernProc = 14
constant kernProcPID (line 17) | kernProcPID = 1
function detectDebuggerAttached (line 20) | func detectDebuggerAttached() (bool, error) {
FILE: pkg/debugdetect/detect_freebsd.go
constant pTracedFlag (line 21) | pTracedFlag = 0x00000800
function detectDebuggerAttached (line 24) | func detectDebuggerAttached() (bool, error) {
FILE: pkg/debugdetect/detect_linux.go
function detectDebuggerAttached (line 13) | func detectDebuggerAttached() (bool, error) {
FILE: pkg/debugdetect/detect_test.go
function TestIntegration_NotAttached (line 15) | func TestIntegration_NotAttached(t *testing.T) {
function TestIntegration_WaitForDebugger (line 42) | func TestIntegration_WaitForDebugger(t *testing.T) {
function TestIntegration_Attached (line 86) | func TestIntegration_Attached(t *testing.T) {
FILE: pkg/debugdetect/detect_windows.go
function detectDebuggerAttached (line 12) | func detectDebuggerAttached() (bool, error) {
FILE: pkg/dwarf/dwarfbuilder/builder.go
type Builder (line 13) | type Builder struct
method Build (line 38) | func (b *Builder) Build() (abbrev, aranges, frame, info, line, pubname...
function New (line 21) | func New() *Builder {
FILE: pkg/dwarf/dwarfbuilder/info.go
type Form (line 14) | type Form
constant DW_FORM_addr (line 17) | DW_FORM_addr Form = 0x01
constant DW_FORM_block2 (line 18) | DW_FORM_block2 Form = 0x03
constant DW_FORM_block4 (line 19) | DW_FORM_block4 Form = 0x04
constant DW_FORM_data2 (line 20) | DW_FORM_data2 Form = 0x05
constant DW_FORM_data4 (line 21) | DW_FORM_data4 Form = 0x06
constant DW_FORM_data8 (line 22) | DW_FORM_data8 Form = 0x07
constant DW_FORM_string (line 23) | DW_FORM_string Form = 0x08
constant DW_FORM_block (line 24) | DW_FORM_block Form = 0x09
constant DW_FORM_block1 (line 25) | DW_FORM_block1 Form = 0x0a
constant DW_FORM_data1 (line 26) | DW_FORM_data1 Form = 0x0b
constant DW_FORM_flag (line 27) | DW_FORM_flag Form = 0x0c
constant DW_FORM_sdata (line 28) | DW_FORM_sdata Form = 0x0d
constant DW_FORM_strp (line 29) | DW_FORM_strp Form = 0x0e
constant DW_FORM_udata (line 30) | DW_FORM_udata Form = 0x0f
constant DW_FORM_ref_addr (line 31) | DW_FORM_ref_addr Form = 0x10
constant DW_FORM_ref1 (line 32) | DW_FORM_ref1 Form = 0x11
constant DW_FORM_ref2 (line 33) | DW_FORM_ref2 Form = 0x12
constant DW_FORM_ref4 (line 34) | DW_FORM_ref4 Form = 0x13
constant DW_FORM_ref8 (line 35) | DW_FORM_ref8 Form = 0x14
constant DW_FORM_ref_udata (line 36) | DW_FORM_ref_udata Form = 0x15
constant DW_FORM_indirect (line 37) | DW_FORM_indirect Form = 0x16
constant DW_FORM_sec_offset (line 38) | DW_FORM_sec_offset Form = 0x17
constant DW_FORM_exprloc (line 39) | DW_FORM_exprloc Form = 0x18
constant DW_FORM_flag_present (line 40) | DW_FORM_flag_present Form = 0x19
constant DW_FORM_ref_sig8 (line 41) | DW_FORM_ref_sig8 Form = 0x20
type Encoding (line 46) | type Encoding
constant DW_ATE_address (line 49) | DW_ATE_address Encoding = 0x01
constant DW_ATE_boolean (line 50) | DW_ATE_boolean Encoding = 0x02
constant DW_ATE_complex_float (line 51) | DW_ATE_complex_float Encoding = 0x03
constant DW_ATE_float (line 52) | DW_ATE_float Encoding = 0x04
constant DW_ATE_signed (line 53) | DW_ATE_signed Encoding = 0x05
constant DW_ATE_signed_char (line 54) | DW_ATE_signed_char Encoding = 0x06
constant DW_ATE_unsigned (line 55) | DW_ATE_unsigned Encoding = 0x07
constant DW_ATE_unsigned_char (line 56) | DW_ATE_unsigned_char Encoding = 0x08
constant DW_ATE_imaginary_float (line 57) | DW_ATE_imaginary_float Encoding = 0x09
constant DW_ATE_packed_decimal (line 58) | DW_ATE_packed_decimal Encoding = 0x0a
constant DW_ATE_numeric_string (line 59) | DW_ATE_numeric_string Encoding = 0x0b
constant DW_ATE_edited (line 60) | DW_ATE_edited Encoding = 0x0c
constant DW_ATE_signed_fixed (line 61) | DW_ATE_signed_fixed Encoding = 0x0d
constant DW_ATE_unsigned_fixed (line 62) | DW_ATE_unsigned_fixed Encoding = 0x0e
constant DW_ATE_decimal_float (line 63) | DW_ATE_decimal_float Encoding = 0x0f
constant DW_ATE_UTF (line 64) | DW_ATE_UTF Encoding = 0x10
constant DW_ATE_lo_user (line 65) | DW_ATE_lo_user Encoding = 0x80
constant DW_ATE_hi_user (line 66) | DW_ATE_hi_user Encoding = 0xff
type Address (line 70) | type Address
type tagDescr (line 72) | type tagDescr struct
type tagState (line 80) | type tagState struct
method TagOpen (line 87) | func (b *Builder) TagOpen(tag dwarf.Tag, name string) dwarf.Offset {
method SetHasChildren (line 103) | func (b *Builder) SetHasChildren() {
method TagClose (line 111) | func (b *Builder) TagClose() {
method Attr (line 125) | func (b *Builder) Attr(attr dwarf.Attr, val any) dwarf.Offset {
method PatchOffset (line 187) | func (b *Builder) PatchOffset(patchedOffset, patch dwarf.Offset) {
function sameTagDescr (line 194) | func sameTagDescr(a, b tagDescr) bool {
method abbrevFor (line 217) | func (b *Builder) abbrevFor(tag tagDescr) byte {
method makeAbbrevTable (line 228) | func (b *Builder) makeAbbrevTable() []byte {
method AddCompileUnit (line 252) | func (b *Builder) AddCompileUnit(name string, lowPC uint64) dwarf.Offset {
method AddSubprogram (line 262) | func (b *Builder) AddSubprogram(fnname string, lowpc, highpc uint64) dwa...
method AddVariable (line 272) | func (b *Builder) AddVariable(varname string, typ dwarf.Offset, loc any)...
method AddBaseType (line 283) | func (b *Builder) AddBaseType(typename string, encoding Encoding, byteSz...
method AddStructType (line 294) | func (b *Builder) AddStructType(typename string, byteSz uint16) dwarf.Of...
method AddMember (line 302) | func (b *Builder) AddMember(fieldname string, typ dwarf.Offset, memberLo...
method AddPointerType (line 311) | func (b *Builder) AddPointerType(typename string, typ dwarf.Offset) dwar...
FILE: pkg/dwarf/dwarfbuilder/loc.go
type LocEntry (line 11) | type LocEntry struct
function LocationBlock (line 19) | func LocationBlock(args ...any) []byte {
FILE: pkg/dwarf/frame/entries.go
type CommonInformationEntry (line 11) | type CommonInformationEntry struct
type FrameDescriptionEntry (line 28) | type FrameDescriptionEntry struct
method Cover (line 38) | func (fde *FrameDescriptionEntry) Cover(addr uint64) bool {
method Begin (line 43) | func (fde *FrameDescriptionEntry) Begin() uint64 {
method End (line 48) | func (fde *FrameDescriptionEntry) End() uint64 {
method Translate (line 53) | func (fde *FrameDescriptionEntry) Translate(delta uint64) {
method EstablishFrame (line 58) | func (fde *FrameDescriptionEntry) EstablishFrame(pc uint64) (*FrameCon...
type FrameDescriptionEntries (line 66) | type FrameDescriptionEntries
method FDEForPC (line 82) | func (fdes FrameDescriptionEntries) FDEForPC(pc uint64) (*FrameDescrip...
method Append (line 93) | func (fdes FrameDescriptionEntries) Append(otherFDEs FrameDescriptionE...
function newFrameIndex (line 68) | func newFrameIndex() FrameDescriptionEntries {
type ErrNoFDEForPC (line 73) | type ErrNoFDEForPC struct
method Error (line 77) | func (err *ErrNoFDEForPC) Error() string {
type ptrEnc (line 121) | type ptrEnc
method Supported (line 149) | func (ptrEnc ptrEnc) Supported() bool {
constant ptrEncAbs (line 124) | ptrEncAbs ptrEnc = 0x00
constant ptrEncOmit (line 125) | ptrEncOmit ptrEnc = 0xff
constant ptrEncUleb (line 126) | ptrEncUleb ptrEnc = 0x01
constant ptrEncUdata2 (line 127) | ptrEncUdata2 ptrEnc = 0x02
constant ptrEncUdata4 (line 128) | ptrEncUdata4 ptrEnc = 0x03
constant ptrEncUdata8 (line 129) | ptrEncUdata8 ptrEnc = 0x04
constant ptrEncSigned (line 130) | ptrEncSigned ptrEnc = 0x08
constant ptrEncSleb (line 131) | ptrEncSleb ptrEnc = 0x09
constant ptrEncSdata2 (line 132) | ptrEncSdata2 ptrEnc = 0x0a
constant ptrEncSdata4 (line 133) | ptrEncSdata4 ptrEnc = 0x0b
constant ptrEncSdata8 (line 134) | ptrEncSdata8 ptrEnc = 0x0c
constant ptrEncFlagsMask (line 136) | ptrEncFlagsMask ptrEnc = 0xf0
constant ptrEncPCRel (line 138) | ptrEncPCRel ptrEnc = 0x10
constant ptrEncTextRel (line 139) | ptrEncTextRel ptrEnc = 0x20
constant ptrEncDataRel (line 140) | ptrEncDataRel ptrEnc = 0x30
constant ptrEncFuncRel (line 141) | ptrEncFuncRel ptrEnc = 0x40
constant ptrEncAligned (line 142) | ptrEncAligned ptrEnc = 0x50
constant ptrEncIndirect (line 143) | ptrEncIndirect ptrEnc = 0x80
constant ptrEncSupportedFlags (line 145) | ptrEncSupportedFlags = ptrEncPCRel
FILE: pkg/dwarf/frame/entries_test.go
function ptrSizeByRuntimeArch (line 11) | func ptrSizeByRuntimeArch() int {
function TestFDEForPC (line 15) | func TestFDEForPC(t *testing.T) {
function TestAppend (line 60) | func TestAppend(t *testing.T) {
function BenchmarkFDEForPC (line 144) | func BenchmarkFDEForPC(b *testing.B) {
FILE: pkg/dwarf/frame/parser.go
type parsefunc (line 16) | type parsefunc
type parseContext (line 18) | type parseContext struct
method parsingEHFrame (line 58) | func (ctx *parseContext) parsingEHFrame() bool {
method cieEntry (line 62) | func (ctx *parseContext) cieEntry(cieid uint32) bool {
method offset (line 69) | func (ctx *parseContext) offset() int {
method readEncodedPtr (line 235) | func (ctx *parseContext) readEncodedPtr(addr uint64, buf leb128.Reader...
function Parse (line 38) | func Parse(data []byte, order binary.ByteOrder, staticBase uint64, ptrSi...
function parselength (line 73) | func parselength(ctx *parseContext) parsefunc {
function parseFDE (line 107) | func parseFDE(ctx *parseContext) parsefunc {
function addrSum (line 145) | func addrSum(base uint64, buf *bytes.Reader) uint64 {
function parseCIE (line 150) | func parseCIE(ctx *parseContext) parsefunc {
function DwarfEndian (line 273) | func DwarfEndian(infoSec []byte) binary.ByteOrder {
FILE: pkg/dwarf/frame/parser_test.go
function TestParseCIE (line 11) | func TestParseCIE(t *testing.T) {
function BenchmarkParse (line 44) | func BenchmarkParse(b *testing.B) {
FILE: pkg/dwarf/frame/table.go
type DWRule (line 13) | type DWRule struct
type FrameContext (line 21) | type FrameContext struct
method executeDwarfProgram (line 177) | func (frame *FrameContext) executeDwarfProgram() {
method ExecuteUntilPC (line 184) | func (frame *FrameContext) ExecuteUntilPC(instructions []byte) error {
type rowState (line 37) | type rowState struct
type stateStack (line 45) | type stateStack struct
method push (line 55) | func (stack *stateStack) push(state rowState) {
method pop (line 59) | func (stack *stateStack) pop() rowState {
function newStateStack (line 49) | func newStateStack() *stateStack {
constant DW_CFA_nop (line 67) | DW_CFA_nop = 0x0
constant DW_CFA_set_loc (line 68) | DW_CFA_set_loc = 0x01
constant DW_CFA_advance_loc1 (line 69) | DW_CFA_advance_loc1 = iota
constant DW_CFA_advance_loc2 (line 70) | DW_CFA_advance_loc2
constant DW_CFA_advance_loc4 (line 71) | DW_CFA_advance_loc4
constant DW_CFA_offset_extended (line 72) | DW_CFA_offset_extended
constant DW_CFA_restore_extended (line 73) | DW_CFA_restore_extended
constant DW_CFA_undefined (line 74) | DW_CFA_undefined
constant DW_CFA_same_value (line 75) | DW_CFA_same_value
constant DW_CFA_register (line 76) | DW_CFA_register
constant DW_CFA_remember_state (line 77) | DW_CFA_remember_state
constant DW_CFA_restore_state (line 78) | DW_CFA_restore_state
constant DW_CFA_def_cfa (line 79) | DW_CFA_def_cfa
constant DW_CFA_def_cfa_register (line 80) | DW_CFA_def_cfa_register
constant DW_CFA_def_cfa_offset (line 81) | DW_CFA_def_cfa_offset
constant DW_CFA_def_cfa_expression (line 82) | DW_CFA_def_cfa_expression
constant DW_CFA_expression (line 83) | DW_CFA_expression
constant DW_CFA_offset_extended_sf (line 84) | DW_CFA_offset_extended_sf
constant DW_CFA_def_cfa_sf (line 85) | DW_CFA_def_cfa_sf
constant DW_CFA_def_cfa_offset_sf (line 86) | DW_CFA_def_cfa_offset_sf
constant DW_CFA_val_offset (line 87) | DW_CFA_val_offset
constant DW_CFA_val_offset_sf (line 88) | DW_CFA_val_offset_sf
constant DW_CFA_val_expression (line 89) | DW_CFA_val_expression
constant DW_CFA_lo_user (line 90) | DW_CFA_lo_user = 0x1c
constant DW_CFA_hi_user (line 91) | DW_CFA_hi_user = 0x3f
constant DW_CFA_advance_loc (line 92) | DW_CFA_advance_loc = (0x1 << 6)
constant DW_CFA_offset (line 93) | DW_CFA_offset = (0x2 << 6)
constant DW_CFA_restore (line 94) | DW_CFA_restore = (0x3 << 6)
type Rule (line 98) | type Rule
constant RuleUndefined (line 101) | RuleUndefined Rule = iota
constant RuleSameVal (line 102) | RuleSameVal
constant RuleOffset (line 103) | RuleOffset
constant RuleValOffset (line 104) | RuleValOffset
constant RuleRegister (line 105) | RuleRegister
constant RuleExpression (line 106) | RuleExpression
constant RuleValExpression (line 107) | RuleValExpression
constant RuleArchitectural (line 108) | RuleArchitectural
constant RuleCFA (line 109) | RuleCFA
constant RuleFramePointer (line 110) | RuleFramePointer
constant low_6_offset (line 113) | low_6_offset = 0x3f
type instruction (line 115) | type instruction
function executeCIEInstructions (line 148) | func executeCIEInstructions(cie *CommonInformationEntry) *FrameContext {
function executeDwarfProgramUntilPC (line 167) | func executeDwarfProgramUntilPC(fde *FrameDescriptionEntry, pc uint64) *...
function executeDwarfInstruction (line 197) | func executeDwarfInstruction(frame *FrameContext) {
function lookupFunc (line 220) | func lookupFunc(instruction byte, buf *bytes.Buffer) instruction {
function advanceloc (line 250) | func advanceloc(frame *FrameContext) {
function advanceloc1 (line 260) | func advanceloc1(frame *FrameContext) {
function advanceloc2 (line 269) | func advanceloc2(frame *FrameContext) {
function advanceloc4 (line 276) | func advanceloc4(frame *FrameContext) {
function offset (line 283) | func offset(frame *FrameContext) {
function restore (line 297) | func restore(frame *FrameContext) {
function setloc (line 312) | func setloc(frame *FrameContext) {
function offsetextended (line 319) | func offsetextended(frame *FrameContext) {
function undefined (line 328) | func undefined(frame *FrameContext) {
function samevalue (line 333) | func samevalue(frame *FrameContext) {
function register (line 338) | func register(frame *FrameContext) {
function rememberstate (line 344) | func rememberstate(frame *FrameContext) {
function restorestate (line 349) | func restorestate(frame *FrameContext) {
function restoreextended (line 356) | func restoreextended(frame *FrameContext) {
function defcfa (line 367) | func defcfa(frame *FrameContext) {
function defcfaregister (line 376) | func defcfaregister(frame *FrameContext) {
function defcfaoffset (line 381) | func defcfaoffset(frame *FrameContext) {
function defcfasf (line 386) | func defcfasf(frame *FrameContext) {
function defcfaoffsetsf (line 395) | func defcfaoffsetsf(frame *FrameContext) {
function defcfaexpression (line 401) | func defcfaexpression(frame *FrameContext) {
function expression (line 411) | func expression(frame *FrameContext) {
function offsetextendedsf (line 421) | func offsetextendedsf(frame *FrameContext) {
function valoffset (line 430) | func valoffset(frame *FrameContext) {
function valoffsetsf (line 439) | func valoffsetsf(frame *FrameContext) {
function valexpression (line 448) | func valexpression(frame *FrameContext) {
function louser (line 458) | func louser(frame *FrameContext) {
function hiuser (line 462) | func hiuser(frame *FrameContext) {
FILE: pkg/dwarf/godwarf/addr.go
type DebugAddrSection (line 13) | type DebugAddrSection struct
method GetSubsection (line 40) | func (addr *DebugAddrSection) GetSubsection(addrBase uint64) *DebugAddr {
function ParseAddr (line 20) | func ParseAddr(data []byte) *DebugAddrSection {
type DebugAddr (line 48) | type DebugAddr struct
method Get (line 54) | func (addr *DebugAddr) Get(idx uint64) (uint64, error) {
FILE: pkg/dwarf/godwarf/buf.go
type buf (line 15) | type buf struct
method Uint8 (line 58) | func (b *buf) Uint8() uint8 {
method Varint (line 71) | func (b *buf) Varint() (c uint64, bits uint) {
method Uint (line 86) | func (b *buf) Uint() uint64 {
method Int (line 92) | func (b *buf) Int() int64 {
method AssertEmpty (line 102) | func (b *buf) AssertEmpty() {
method error (line 112) | func (b *buf) error(s string) {
type dataFormat (line 26) | type dataFormat interface
type unknownFormat (line 38) | type unknownFormat struct
method version (line 40) | func (u unknownFormat) version() int {
method dwarf64 (line 44) | func (u unknownFormat) dwarf64() (bool, bool) {
method addrsize (line 48) | func (u unknownFormat) addrsize() int {
function makeBuf (line 53) | func makeBuf(d *dwarf.Data, format dataFormat, name string, off dwarf.Of...
FILE: pkg/dwarf/godwarf/fakes.go
function FakeSliceType (line 10) | func FakeSliceType(fieldType Type) Type {
function FakeBasicType (line 27) | func FakeBasicType(name string, bitSize int) Type {
function FakePointerType (line 58) | func FakePointerType(typ Type, ptrSize int64) *PtrType {
FILE: pkg/dwarf/godwarf/sections.go
function GetDebugSectionElf (line 19) | func GetDebugSectionElf(f *elf.File, name string) ([]byte, error) {
function GetDebugSectionPE (line 40) | func GetDebugSectionPE(f *pe.File, name string) ([]byte, error) {
function peSectionData (line 56) | func peSectionData(sec *pe.Section) ([]byte, error) {
function GetDebugSectionMacho (line 72) | func GetDebugSectionMacho(f *macho.File, name string) ([]byte, error) {
function decompressMaybe (line 88) | func decompressMaybe(b []byte) ([]byte, error) {
FILE: pkg/dwarf/godwarf/tree.go
type Entry (line 13) | type Entry interface
type compositeEntry (line 18) | type compositeEntry
method Val (line 20) | func (ce compositeEntry) Val(attr dwarf.Attr) any {
method AttrField (line 27) | func (ce compositeEntry) AttrField(a dwarf.Attr) *dwarf.Field {
function LoadAbstractOriginAndSpecification (line 41) | func LoadAbstractOriginAndSpecification(entry *dwarf.Entry, aordr *dwarf...
function getAbstractOriginOrSpecification (line 66) | func getAbstractOriginOrSpecification(e *dwarf.Entry) (dwarf.Offset, boo...
type Tree (line 79) | type Tree struct
method resolveRanges (line 155) | func (n *Tree) resolveRanges(dw *dwarf.Data, staticBase uint64) error {
method resolveAbstractAndSpecificationEntries (line 250) | func (n *Tree) resolveAbstractAndSpecificationEntries(rdr *dwarf.Reade...
method ContainsPC (line 258) | func (n *Tree) ContainsPC(pc uint64) bool {
method Type (line 270) | func (n *Tree) Type(dw *dwarf.Data, index int, typeCache map[dwarf.Off...
function LoadTree (line 93) | func LoadTree(off dwarf.Offset, dw *dwarf.Data, staticBase uint64) (*Tre...
function EntryToTree (line 120) | func EntryToTree(entry *dwarf.Entry) *Tree {
function entryToTreeInternal (line 128) | func entryToTreeInternal(entry *dwarf.Entry) *Tree {
function loadTreeChildren (line 132) | func loadTreeChildren(e *dwarf.Entry, rdr *dwarf.Reader) ([]*Tree, error) {
function normalizeRanges (line 178) | func normalizeRanges(rngs [][2]uint64) [][2]uint64 {
function fuseRanges (line 219) | func fuseRanges(rngs1, rngs2 [][2]uint64) [][2]uint64 {
function rangesContains (line 228) | func rangesContains(rngs1, rngs2 [][2]uint64) bool {
function rangeContains (line 246) | func rangeContains(a, b [2]uint64) bool {
FILE: pkg/dwarf/godwarf/tree_test.go
function makeRanges (line 7) | func makeRanges(v ...uint64) [][2]uint64 {
function assertRanges (line 15) | func assertRanges(t *testing.T, out, tgt [][2]uint64) {
function TestNormalizeRanges (line 27) | func TestNormalizeRanges(t *testing.T) {
function TestRangeContains (line 36) | func TestRangeContains(t *testing.T) {
function TestRangesContains (line 63) | func TestRangesContains(t *testing.T) {
function TestContainsPC (line 95) | func TestContainsPC(t *testing.T) {
FILE: pkg/dwarf/godwarf/type.go
constant AttrGoKind (line 24) | AttrGoKind dwarf.Attr = 0x2900
constant AttrGoKey (line 25) | AttrGoKey dwarf.Attr = 0x2901
constant AttrGoElem (line 26) | AttrGoElem dwarf.Attr = 0x2902
constant AttrGoEmbeddedField (line 27) | AttrGoEmbeddedField dwarf.Attr = 0x2903
constant AttrGoRuntimeType (line 28) | AttrGoRuntimeType dwarf.Attr = 0x2904
constant AttrGoPackageName (line 29) | AttrGoPackageName dwarf.Attr = 0x2905
constant AttrGoDictIndex (line 30) | AttrGoDictIndex dwarf.Attr = 0x2906
constant AttrGoClosureOffset (line 31) | AttrGoClosureOffset dwarf.Attr = 0x2907
constant encAddress (line 36) | encAddress = 0x01
constant encBoolean (line 37) | encBoolean = 0x02
constant encComplexFloat (line 38) | encComplexFloat = 0x03
constant encFloat (line 39) | encFloat = 0x04
constant encSigned (line 40) | encSigned = 0x05
constant encSignedChar (line 41) | encSignedChar = 0x06
constant encUnsigned (line 42) | encUnsigned = 0x07
constant encUnsignedChar (line 43) | encUnsignedChar = 0x08
constant encImaginaryFloat (line 44) | encImaginaryFloat = 0x09
constant cyclicalTypeStop (line 47) | cyclicalTypeStop = "<cyclical>"
type recCheck (line 49) | type recCheck
method acquire (line 51) | func (recCheck recCheck) acquire(off dwarf.Offset) (release func()) {
function sizeAlignToSize (line 61) | func sizeAlignToSize(sz, align int64) int64 {
function sizeAlignToAlign (line 65) | func sizeAlignToAlign(sz, align int64) int64 {
type Type (line 71) | type Type interface
type CommonType (line 84) | type CommonType struct
method Common (line 92) | func (c *CommonType) Common() *CommonType { return c }
method Size (line 94) | func (c *CommonType) Size() int64 { return c...
method Align (line 95) | func (c *CommonType) Align() int64 { return c...
method sizeAlignIntl (line 96) | func (c *CommonType) sizeAlignIntl(recCheck) (int64, int64) { return c...
type BasicType (line 101) | type BasicType struct
method Basic (line 107) | func (t *BasicType) Basic() *BasicType { return t }
method String (line 109) | func (t *BasicType) String() string { return t.stringIntl(nil) }
method stringIntl (line 111) | func (t *BasicType) stringIntl(recCheck) string {
method Align (line 118) | func (t *BasicType) Align() int64 { return t.CommonType.ByteSize }
type CharType (line 121) | type CharType struct
type UcharType (line 126) | type UcharType struct
type IntType (line 131) | type IntType struct
type UintType (line 136) | type UintType struct
type FloatType (line 141) | type FloatType struct
type ComplexType (line 146) | type ComplexType struct
type BoolType (line 151) | type BoolType struct
type AddrType (line 156) | type AddrType struct
type UnspecifiedType (line 161) | type UnspecifiedType struct
type QualType (line 168) | type QualType struct
method String (line 174) | func (t *QualType) String() string { return t.stringIntl(make(recCheck...
method stringIntl (line 176) | func (t *QualType) stringIntl(recCheck recCheck) string {
method Size (line 185) | func (t *QualType) Size() int64 { return sizeAlignToSize(t.sizeAlignI...
method Align (line 186) | func (t *QualType) Align() int64 { return sizeAlignToAlign(t.sizeAlign...
method sizeAlignIntl (line 188) | func (t *QualType) sizeAlignIntl(recCheck recCheck) (int64, int64) {
type ArrayType (line 198) | type ArrayType struct
method String (line 205) | func (t *ArrayType) String() string { return t.stringIntl(make(recChec...
method stringIntl (line 207) | func (t *ArrayType) stringIntl(recCheck recCheck) string {
method Size (line 216) | func (t *ArrayType) Size() int64 { return sizeAlignToSize(t.sizeAlign...
method Align (line 217) | func (t *ArrayType) Align() int64 { return sizeAlignToAlign(t.sizeAlig...
method sizeAlignIntl (line 219) | func (t *ArrayType) sizeAlignIntl(recCheck recCheck) (int64, int64) {
type VoidType (line 233) | type VoidType struct
method String (line 237) | func (t *VoidType) String() string { return t.stringIntl(nil) }
method stringIntl (line 239) | func (t *VoidType) stringIntl(recCheck) string { return "void" }
type PtrType (line 242) | type PtrType struct
method String (line 247) | func (t *PtrType) String() string { return t.stringIntl(make(recCheck)) }
method stringIntl (line 249) | func (t *PtrType) stringIntl(recCheck recCheck) string {
type StructType (line 259) | type StructType struct
method String (line 278) | func (t *StructType) String() string { return t.stringIntl(make(recChe...
method stringIntl (line 280) | func (t *StructType) stringIntl(recCheck recCheck) string {
method Defn (line 287) | func (t *StructType) Defn(recCheck recCheck) string {
method Size (line 317) | func (t *StructType) Size() int64 { return sizeAlignToSize(t.sizeAlig...
method Align (line 318) | func (t *StructType) Align() int64 { return sizeAlignToAlign(t.sizeAli...
method sizeAlignIntl (line 320) | func (t *StructType) sizeAlignIntl(recCheck recCheck) (int64, int64) {
type StructField (line 268) | type StructField struct
type SliceType (line 334) | type SliceType struct
method String (line 339) | func (t *SliceType) String() string { return t.stringIntl(make(recChec...
method stringIntl (line 341) | func (t *SliceType) stringIntl(recCheck recCheck) string {
type StringType (line 355) | type StringType struct
method String (line 359) | func (t *StringType) String() string { return t.stringIntl(nil) }
method stringIntl (line 361) | func (t *StringType) stringIntl(recCheck recCheck) string {
type InterfaceType (line 369) | type InterfaceType struct
method String (line 373) | func (t *InterfaceType) String() string { return t.stringIntl(nil) }
method stringIntl (line 375) | func (t *InterfaceType) stringIntl(recCheck recCheck) string {
type EnumType (line 385) | type EnumType struct
method String (line 397) | func (t *EnumType) String() string { return t.stringIntl(nil) }
method stringIntl (line 399) | func (t *EnumType) stringIntl(recCheck recCheck) string {
type EnumValue (line 392) | type EnumValue struct
type FuncType (line 417) | type FuncType struct
method String (line 423) | func (t *FuncType) String() string { return t.stringIntl(make(recCheck...
method stringIntl (line 425) | func (t *FuncType) stringIntl(recCheck recCheck) string {
type DotDotDotType (line 447) | type DotDotDotType struct
method String (line 451) | func (t *DotDotDotType) String() string { return t.stringIntl(nil) }
method stringIntl (line 453) | func (t *DotDotDotType) stringIntl(recCheck recCheck) string { return ...
type TypedefType (line 456) | type TypedefType struct
method String (line 461) | func (t *TypedefType) String() string { return t.stringIntl(nil) }
method stringIntl (line 463) | func (t *TypedefType) stringIntl(recCheck recCheck) string { return t....
method Size (line 465) | func (t *TypedefType) Size() int64 { return sizeAlignToSize(t.sizeAli...
method Align (line 466) | func (t *TypedefType) Align() int64 { return sizeAlignToAlign(t.sizeAl...
method sizeAlignIntl (line 468) | func (t *TypedefType) sizeAlignIntl(recCheck recCheck) (int64, int64) {
type MapType (line 482) | type MapType struct
method String (line 488) | func (t *MapType) String() string { return t.stringIntl(make(recCheck)) }
method stringIntl (line 490) | func (t *MapType) stringIntl(recCheck recCheck) string {
type ChanType (line 503) | type ChanType struct
method String (line 508) | func (t *ChanType) String() string { return t.stringIntl(make(recCheck...
method stringIntl (line 510) | func (t *ChanType) stringIntl(recCheck recCheck) string {
type ParametricType (line 522) | type ParametricType struct
type UnsupportedType (line 529) | type UnsupportedType struct
method stringIntl (line 534) | func (t *UnsupportedType) stringIntl(recCheck) string {
method String (line 541) | func (t *UnsupportedType) String() string { return t.stringIntl(nil) }
function ReadType (line 544) | func ReadType(d *dwarf.Data, index int, off dwarf.Offset, typeCache map[...
function getKind (line 552) | func getKind(e *dwarf.Entry) reflect.Kind {
type delayedSize (line 557) | type delayedSize struct
function readType (line 564) | func readType(d *dwarf.Data, name string, r *dwarf.Reader, off dwarf.Off...
function zeroArray (line 1097) | func zeroArray(t Type) {
function ResolveTypedef (line 1109) | func ResolveTypedef(typ Type) Type {
FILE: pkg/dwarf/leb128/decode.go
type Reader (line 9) | type Reader interface
function DecodeUnsigned (line 17) | func DecodeUnsigned(buf Reader) (uint64, uint32) {
function DecodeSigned (line 50) | func DecodeSigned(buf Reader) (int64, uint32) {
FILE: pkg/dwarf/leb128/decode_test.go
function TestDecodeUnsigned (line 8) | func TestDecodeUnsigned(t *testing.T) {
function TestDecodeSigned (line 22) | func TestDecodeSigned(t *testing.T) {
FILE: pkg/dwarf/leb128/encode.go
function EncodeUnsigned (line 8) | func EncodeUnsigned(out io.ByteWriter, x uint64) {
function EncodeSigned (line 23) | func EncodeSigned(out io.ByteWriter, x int64) {
FILE: pkg/dwarf/leb128/encode_test.go
function TestEncodeUnsigned (line 8) | func TestEncodeUnsigned(t *testing.T) {
function TestEncodeSigned (line 27) | func TestEncodeSigned(t *testing.T) {
FILE: pkg/dwarf/line/line_parser.go
type DebugLinePrologue (line 14) | type DebugLinePrologue struct
type DebugLineInfo (line 28) | type DebugLineInfo struct
type FileEntry (line 56) | type FileEntry struct
type DebugLines (line 63) | type DebugLines
function ParseAll (line 66) | func ParseAll(data []byte, debugLineStr []byte, logfn func(string, ...an...
function Parse (line 82) | func Parse(compdir string, buf *bytes.Buffer, debugLineStr []byte, logfn...
function parseDebugLinePrologue (line 128) | func parseDebugLinePrologue(dbl *DebugLineInfo, buf *bytes.Buffer) {
function parseIncludeDirs2 (line 157) | func parseIncludeDirs2(info *DebugLineInfo, buf *bytes.Buffer) bool {
function parseIncludeDirs5 (line 176) | func parseIncludeDirs5(info *DebugLineInfo, buf *bytes.Buffer) bool {
function parseFileEntries2 (line 215) | func parseFileEntries2(info *DebugLineInfo, buf *bytes.Buffer) bool {
function readFileEntry (line 231) | func readFileEntry(info *DebugLineInfo, buf *bytes.Buffer, exitOnEmptyPa...
function pathIsAbs (line 268) | func pathIsAbs(s string) bool {
function parseFileEntries5 (line 279) | func parseFileEntries5(info *DebugLineInfo, buf *bytes.Buffer) bool {
FILE: pkg/dwarf/line/line_parser_test.go
function TestMain (line 26) | func TestMain(m *testing.M) {
function grabDebugLineSection (line 32) | func grabDebugLineSection(p string, t *testing.T) []byte {
constant lineBaseGo14 (line 61) | lineBaseGo14 int8 = -1
constant lineBaseGo18 (line 62) | lineBaseGo18 int8 = -4
constant lineRangeGo14 (line 63) | lineRangeGo14 uint8 = 4
constant lineRangeGo18 (line 64) | lineRangeGo18 uint8 = 10
constant versionGo14 (line 65) | versionGo14 uint16 = 2
constant versionGo111 (line 66) | versionGo111 uint16 = 3
constant versionGo125 (line 67) | versionGo125 uint16 = 5
constant opcodeBaseGo14 (line 68) | opcodeBaseGo14 uint8 = 10
constant opcodeBaseGo111 (line 69) | opcodeBaseGo111 uint8 = 11
function ptrSizeByRuntimeArch (line 72) | func ptrSizeByRuntimeArch() int {
function testDebugLinePrologueParser (line 76) | func testDebugLinePrologueParser(p string, t *testing.T) {
function TestUserFile (line 147) | func TestUserFile(t *testing.T) {
function TestDebugLinePrologueParser (line 156) | func TestDebugLinePrologueParser(t *testing.T) {
function BenchmarkLineParser (line 172) | func BenchmarkLineParser(b *testing.B) {
function loadBenchmarkData (line 190) | func loadBenchmarkData(tb testing.TB) DebugLines {
function BenchmarkStateMachine (line 204) | func BenchmarkStateMachine(b *testing.B) {
type pctolineEntry (line 218) | type pctolineEntry struct
method match (line 224) | func (entry *pctolineEntry) match(file string, line int) bool {
function setupTestPCToLine (line 231) | func setupTestPCToLine(t testing.TB, lineInfos DebugLines) ([]pctolineEn...
function runTestPCToLine (line 262) | func runTestPCToLine(t testing.TB, lineInfos DebugLines, entries []pctol...
function TestPCToLine (line 290) | func TestPCToLine(t *testing.T) {
function BenchmarkPCToLine (line 300) | func BenchmarkPCToLine(b *testing.B) {
function TestDebugLineC (line 310) | func TestDebugLineC(t *testing.T) {
function TestDebugLineDwarf4 (line 344) | func TestDebugLineDwarf4(t *testing.T) {
FILE: pkg/dwarf/line/parse_util.go
constant _DW_FORM_block (line 13) | _DW_FORM_block = 0x09
constant _DW_FORM_block1 (line 14) | _DW_FORM_block1 = 0x0a
constant _DW_FORM_block2 (line 15) | _DW_FORM_block2 = 0x03
constant _DW_FORM_block4 (line 16) | _DW_FORM_block4 = 0x04
constant _DW_FORM_data1 (line 17) | _DW_FORM_data1 = 0x0b
constant _DW_FORM_data2 (line 18) | _DW_FORM_data2 = 0x05
constant _DW_FORM_data4 (line 19) | _DW_FORM_data4 = 0x06
constant _DW_FORM_data8 (line 20) | _DW_FORM_data8 = 0x07
constant _DW_FORM_data16 (line 21) | _DW_FORM_data16 = 0x1e
constant _DW_FORM_flag (line 22) | _DW_FORM_flag = 0x0c
constant _DW_FORM_line_strp (line 23) | _DW_FORM_line_strp = 0x1f
constant _DW_FORM_sdata (line 24) | _DW_FORM_sdata = 0x0d
constant _DW_FORM_sec_offset (line 25) | _DW_FORM_sec_offset = 0x17
constant _DW_FORM_string (line 26) | _DW_FORM_string = 0x08
constant _DW_FORM_strp (line 27) | _DW_FORM_strp = 0x0e
constant _DW_FORM_strx (line 28) | _DW_FORM_strx = 0x1a
constant _DW_FORM_strx1 (line 29) | _DW_FORM_strx1 = 0x25
constant _DW_FORM_strx2 (line 30) | _DW_FORM_strx2 = 0x26
constant _DW_FORM_strx3 (line 31) | _DW_FORM_strx3 = 0x27
constant _DW_FORM_strx4 (line 32) | _DW_FORM_strx4 = 0x28
constant _DW_FORM_udata (line 33) | _DW_FORM_udata = 0x0f
constant _DW_LNCT_path (line 37) | _DW_LNCT_path = 0x1 + iota
constant _DW_LNCT_directory_index (line 38) | _DW_LNCT_directory_index
constant _DW_LNCT_timestamp (line 39) | _DW_LNCT_timestamp
constant _DW_LNCT_size (line 40) | _DW_LNCT_size
constant _DW_LNCT_MD5 (line 41) | _DW_LNCT_MD5
type formReader (line 46) | type formReader struct
method reset (line 80) | func (rdr *formReader) reset() {
method next (line 85) | func (rdr *formReader) next(buf *bytes.Buffer) bool {
method readBlock (line 183) | func (rdr *formReader) readBlock(buf *bytes.Buffer, n uint64) {
function readEntryFormat (line 63) | func readEntryFormat(buf *bytes.Buffer, logf func(string, ...any)) *form...
FILE: pkg/dwarf/line/state_machine.go
type Location (line 14) | type Location struct
type StateMachine (line 21) | type StateMachine struct
method copy (line 209) | func (sm *StateMachine) copy() *StateMachine {
method PCToLine (line 264) | func (sm *StateMachine) PCToLine(pc uint64) (string, int, bool) {
method next (line 397) | func (sm *StateMachine) next() error {
type opcodefn (line 53) | type opcodefn
constant DW_LNS_copy (line 57) | DW_LNS_copy = 1
constant DW_LNS_advance_pc (line 58) | DW_LNS_advance_pc = 2
constant DW_LNS_advance_line (line 59) | DW_LNS_advance_line = 3
constant DW_LNS_set_file (line 60) | DW_LNS_set_file = 4
constant DW_LNS_set_column (line 61) | DW_LNS_set_column = 5
constant DW_LNS_negate_stmt (line 62) | DW_LNS_negate_stmt = 6
constant DW_LNS_set_basic_block (line 63) | DW_LNS_set_basic_block = 7
constant DW_LNS_const_add_pc (line 64) | DW_LNS_const_add_pc = 8
constant DW_LNS_fixed_advance_pc (line 65) | DW_LNS_fixed_advance_pc = 9
constant DW_LNS_prologue_end (line 66) | DW_LNS_prologue_end = 10
constant DW_LNS_epilogue_begin (line 67) | DW_LNS_epilogue_begin = 11
constant DW_LNS_set_isa (line 68) | DW_LNS_set_isa = 12
constant DW_LINE_end_sequence (line 73) | DW_LINE_end_sequence = 1
constant DW_LINE_set_address (line 74) | DW_LINE_set_address = 2
constant DW_LINE_define_file (line 75) | DW_LINE_define_file = 3
constant DW_LINE_set_discriminator (line 76) | DW_LINE_set_discriminator = 4
function newStateMachine (line 101) | func newStateMachine(dbl *DebugLineInfo, instructions []byte, ptrSize in...
method defaultFile (line 126) | func (dbl *DebugLineInfo) defaultFile() string {
method AllPCsForFileLines (line 144) | func (lineInfo *DebugLineInfo) AllPCsForFileLines(f string, m map[int][]...
method AllPCsBetween (line 175) | func (lineInfo *DebugLineInfo) AllPCsBetween(begin, end uint64, excludeF...
method stateMachineForEntry (line 216) | func (lineInfo *DebugLineInfo) stateMachineForEntry(basePC uint64) (sm *...
method PCToLine (line 232) | func (lineInfo *DebugLineInfo) PCToLine(basePC, pc uint64) (string, int) {
method stateMachineFor (line 246) | func (lineInfo *DebugLineInfo) stateMachineFor(basePC, pc uint64) *State...
type PCStmt (line 299) | type PCStmt struct
method LineToPCs (line 305) | func (lineInfo *DebugLineInfo) LineToPCs(filename string, lineno int) []...
method PrologueEndPC (line 330) | func (lineInfo *DebugLineInfo) PrologueEndPC(start, end uint64) (pc uint...
method FirstStmt (line 359) | func (lineInfo *DebugLineInfo) FirstStmt(start, end uint64) (pc uint64, ...
method FirstFile (line 382) | func (lineInfo *DebugLineInfo) FirstFile() string {
function execSpecialOpcode (line 441) | func execSpecialOpcode(sm *StateMachine, instr byte) {
function execExtendedOpcode (line 453) | func execExtendedOpcode(sm *StateMachine, buf *bytes.Buffer) {
function copyfn (line 461) | func copyfn(sm *StateMachine, buf *bytes.Buffer) {
function advancepc (line 465) | func advancepc(sm *StateMachine, buf *bytes.Buffer) {
function advanceline (line 470) | func advanceline(sm *StateMachine, buf *bytes.Buffer) {
function setfile (line 476) | func setfile(sm *StateMachine, buf *bytes.Buffer) {
function setcolumn (line 494) | func setcolumn(sm *StateMachine, buf *bytes.Buffer) {
function negatestmt (line 499) | func negatestmt(sm *StateMachine, buf *bytes.Buffer) {
function setbasicblock (line 503) | func setbasicblock(sm *StateMachine, buf *bytes.Buffer) {
function constaddpc (line 507) | func constaddpc(sm *StateMachine, buf *bytes.Buffer) {
function fixedadvancepc (line 511) | func fixedadvancepc(sm *StateMachine, buf *bytes.Buffer) {
function endsequence (line 518) | func endsequence(sm *StateMachine, buf *bytes.Buffer) {
function setaddress (line 523) | func setaddress(sm *StateMachine, buf *bytes.Buffer) {
function setdiscriminator (line 531) | func setdiscriminator(sm *StateMachine, buf *bytes.Buffer) {
function definefile (line 535) | func definefile(sm *StateMachine, buf *bytes.Buffer) {
function prologueend (line 541) | func prologueend(sm *StateMachine, buf *bytes.Buffer) {
function epiloguebegin (line 545) | func epiloguebegin(sm *StateMachine, buf *bytes.Buffer) {
function setisa (line 549) | func setisa(sm *StateMachine, buf *bytes.Buffer) {
FILE: pkg/dwarf/line/state_machine_test.go
function slurpGzip (line 18) | func slurpGzip(path string) ([]byte, error) {
function TestGrafana (line 32) | func TestGrafana(t *testing.T) {
function checkCompileUnit (line 87) | func checkCompileUnit(t *testing.T, cuname string, lnrdr *dwarf.LineRead...
function TestMultipleSequences (line 125) | func TestMultipleSequences(t *testing.T) {
FILE: pkg/dwarf/loclist/dwarf2_loclist.go
type Reader (line 10) | type Reader interface
type Dwarf2Reader (line 16) | type Dwarf2Reader struct
method Empty (line 28) | func (rdr *Dwarf2Reader) Empty() bool {
method Seek (line 33) | func (rdr *Dwarf2Reader) Seek(off int) {
method Next (line 39) | func (rdr *Dwarf2Reader) Next(e *Entry) bool {
method Find (line 60) | func (rdr *Dwarf2Reader) Find(off int, staticBase, base, pc uint64, de...
method read (line 75) | func (rdr *Dwarf2Reader) read(sz int) []byte {
method oneAddr (line 81) | func (rdr *Dwarf2Reader) oneAddr() uint64 {
function NewDwarf2Reader (line 23) | func NewDwarf2Reader(data []byte, ptrSz int) *Dwarf2Reader {
type Entry (line 98) | type Entry struct
method BaseAddressSelection (line 105) | func (e *Entry) BaseAddressSelection() bool {
FILE: pkg/dwarf/loclist/dwarf5_loclist.go
type Dwarf5Reader (line 15) | type Dwarf5Reader struct
method Empty (line 46) | func (rdr *Dwarf5Reader) Empty() bool {
method Find (line 53) | func (rdr *Dwarf5Reader) Find(off int, staticBase, base, pc uint64, de...
function NewDwarf5Reader (line 21) | func NewDwarf5Reader(data []byte) *Dwarf5Reader {
type loclistsIterator (line 77) | type loclistsIterator struct
method next (line 104) | func (it *loclistsIterator) next() bool {
method readInstr (line 187) | func (it *loclistsIterator) readInstr() {
constant _DW_LLE_end_of_list (line 93) | _DW_LLE_end_of_list uint8 = 0x0
constant _DW_LLE_base_addressx (line 94) | _DW_LLE_base_addressx uint8 = 0x1
constant _DW_LLE_startx_endx (line 95) | _DW_LLE_startx_endx uint8 = 0x2
constant _DW_LLE_startx_length (line 96) | _DW_LLE_startx_length uint8 = 0x3
constant _DW_LLE_offset_pair (line 97) | _DW_LLE_offset_pair uint8 = 0x4
constant _DW_LLE_default_location (line 98) | _DW_LLE_default_location uint8 = 0x5
constant _DW_LLE_base_address (line 99) | _DW_LLE_base_address uint8 = 0x6
constant _DW_LLE_start_end (line 100) | _DW_LLE_start_end uint8 = 0x7
constant _DW_LLE_start_length (line 101) | _DW_LLE_start_length uint8 = 0x8
FILE: pkg/dwarf/loclist/loclist5_test.go
function TestLoclist5 (line 11) | func TestLoclist5(t *testing.T) {
FILE: pkg/dwarf/op/op.go
type Opcode (line 16) | type Opcode
type stackfn (line 20) | type stackfn
type ReadMemoryFunc (line 22) | type ReadMemoryFunc
type context (line 24) | type context struct
method closeLoc (line 176) | func (ctxt *context) closeLoc(opcode0 Opcode, piece Piece) error {
method jump (line 478) | func (ctxt *context) jump(n int16) error {
type Piece (line 36) | type Piece struct
type PieceKind (line 44) | type PieceKind
constant AddrPiece (line 47) | AddrPiece PieceKind = iota
constant RegPiece (line 48) | RegPiece
constant ImmPiece (line 49) | ImmPiece
constant arbitraryExecutionLimitFactor (line 58) | arbitraryExecutionLimitFactor = 10
function ExecuteStackProgram (line 63) | func ExecuteStackProgram(regs DwarfRegisters, instructions []byte, ptrSi...
function PrettyPrint (line 108) | func PrettyPrint(out io.Writer, instructions []byte, regnumToName func(u...
function callframecfa (line 207) | func callframecfa(opcode Opcode, ctxt *context) error {
function addr (line 215) | func addr(opcode Opcode, ctxt *context) error {
function plusuconsts (line 225) | func plusuconsts(opcode Opcode, ctxt *context) error {
function consts (line 232) | func consts(opcode Opcode, ctxt *context) error {
function framebase (line 238) | func framebase(opcode Opcode, ctxt *context) error {
function register (line 244) | func register(opcode Opcode, ctxt *context) error {
function bregister (line 254) | func bregister(opcode Opcode, ctxt *context) error {
function piece (line 269) | func piece(opcode Opcode, ctxt *context) error {
function literal (line 285) | func literal(opcode Opcode, ctxt *context) error {
function constnu (line 290) | func constnu(opcode Opcode, ctxt *context) error {
function constns (line 316) | func constns(opcode Opcode, ctxt *context) error {
function constu (line 344) | func constu(opcode Opcode, ctxt *context) error {
function dup (line 350) | func dup(_ Opcode, ctxt *context) error {
function drop (line 358) | func drop(_ Opcode, ctxt *context) error {
function pick (line 366) | func pick(opcode Opcode, ctxt *context) error {
function swap (line 384) | func swap(_ Opcode, ctxt *context) error {
function rot (line 392) | func rot(_ Opcode, ctxt *context) error {
function unaryop (line 400) | func unaryop(opcode Opcode, ctxt *context) error {
function binaryop (line 421) | func binaryop(opcode Opcode, ctxt *context) error {
function bool2int (line 471) | func bool2int(b bool) int64 {
function skip (line 490) | func skip(_ Opcode, ctxt *context) error {
function bra (line 496) | func bra(_ Opcode, ctxt *context) error {
function stackvalue (line 511) | func stackvalue(_ Opcode, ctxt *context) error {
function implicitvalue (line 520) | func implicitvalue(_ Opcode, ctxt *context) error {
function deref (line 530) | func deref(op Opcode, ctxt *context) error {
FILE: pkg/dwarf/op/op_test.go
function assertExprResult (line 8) | func assertExprResult(t *testing.T, expected int64, instructions []byte) {
function TestExecuteStackProgram (line 21) | func TestExecuteStackProgram(t *testing.T) {
function TestSignExtension (line 26) | func TestSignExtension(t *testing.T) {
function TestStackOps (line 34) | func TestStackOps(t *testing.T) {
function TestBra (line 41) | func TestBra(t *testing.T) {
FILE: pkg/dwarf/op/opcodes.go
constant DW_OP_addr (line 7) | DW_OP_addr Opcode = 0x03
constant DW_OP_deref (line 8) | DW_OP_deref Opcode = 0x06
constant DW_OP_const1u (line 9) | DW_OP_const1u Opcode = 0x08
constant DW_OP_const1s (line 10) | DW_OP_const1s Opcode = 0x09
constant DW_OP_const2u (line 11) | DW_OP_const2u Opcode = 0x0a
constant DW_OP_const2s (line 12) | DW_OP_const2s Opcode = 0x0b
constant DW_OP_const4u (line 13) | DW_OP_const4u Opcode = 0x0c
constant DW_OP_const4s (line 14) | DW_OP_const4s Opcode = 0x0d
constant DW_OP_const8u (line 15) | DW_OP_const8u Opcode = 0x0e
constant DW_OP_const8s (line 16) | DW_OP_const8s Opcode = 0x0f
constant DW_OP_constu (line 17) | DW_OP_constu Opcode = 0x10
constant DW_OP_consts (line 18) | DW_OP_consts Opcode = 0x11
constant DW_OP_dup (line 19) | DW_OP_dup Opcode = 0x12
constant DW_OP_drop (line 20) | DW_OP_drop Opcode = 0x13
constant DW_OP_over (line 21) | DW_OP_over Opcode = 0x14
constant DW_OP_pick (line 22) | DW_OP_pick Opcode = 0x15
constant DW_OP_swap (line 23) | DW_OP_swap Opcode = 0x16
constant DW_OP_rot (line 24) | DW_OP_rot Opcode = 0x17
constant DW_OP_xderef (line 25) | DW_OP_xderef Opcode = 0x18
constant DW_OP_abs (line 26) | DW_OP_abs Opcode = 0x19
constant DW_OP_and (line 27) | DW_OP_and Opcode = 0x1a
constant DW_OP_div (line 28) | DW_OP_div Opcode = 0x1b
constant DW_OP_minus (line 29) | DW_OP_minus Opcode = 0x1c
constant DW_OP_mod (line 30) | DW_OP_mod Opcode = 0x1d
constant DW_OP_mul (line 31) | DW_OP_mul Opcode = 0x1e
constant DW_OP_neg (line 32) | DW_OP_neg Opcode = 0x1f
constant DW_OP_not (line 33) | DW_OP_not Opcode = 0x20
constant DW_OP_or (line 34) | DW_OP_or Opcode = 0x21
constant DW_OP_plus (line 35) | DW_OP_plus Opcode = 0x22
constant DW_OP_plus_uconst (line 36) | DW_OP_plus_uconst Opcode = 0x23
constant DW_OP_shl (line 37) | DW_OP_shl Opcode = 0x24
constant DW_OP_shr (line 38) | DW_OP_shr Opcode = 0x25
constant DW_OP_shra (line 39) | DW_OP_shra Opcode = 0x26
constant DW_OP_xor (line 40) | DW_OP_xor Opcode = 0x27
constant DW_OP_bra (line 41) | DW_OP_bra Opcode = 0x28
constant DW_OP_eq (line 42) | DW_OP_eq Opcode = 0x29
constant DW_OP_ge (line 43) | DW_OP_ge Opcode = 0x2a
constant DW_OP_gt (line 44) | DW_OP_gt Opcode = 0x2b
constant DW_OP_le (line 45) | DW_OP_le Opcode = 0x2c
constant DW_OP_lt (line 46) | DW_OP_lt Opcode = 0x2d
constant DW_OP_ne (line 47) | DW_OP_ne Opcode = 0x2e
constant DW_OP_skip (line 48) | DW_OP_skip Opcode = 0x2f
constant DW_OP_lit0 (line 49) | DW_OP_lit0 Opcode = 0x30
constant DW_OP_lit1 (line 50) | DW_OP_lit1 Opcode = 0x31
constant DW_OP_lit2 (line 51) | DW_OP_lit2 Opcode = 0x32
constant DW_OP_lit3 (line 52) | DW_OP_lit3 Opcode = 0x33
constant DW_OP_lit4 (line 53) | DW_OP_lit4 Opcode = 0x34
constant DW_OP_lit5 (line 54) | DW_OP_lit5 Opcode = 0x35
constant DW_OP_lit6 (line 55) | DW_OP_lit6 Opcode = 0x36
constant DW_OP_lit7 (line 56) | DW_OP_lit7 Opcode = 0x37
constant DW_OP_lit8 (line 57) | DW_OP_lit8 Opcode = 0x38
constant DW_OP_lit9 (line 58) | DW_OP_lit9 Opcode = 0x39
constant DW_OP_lit10 (line 59) | DW_OP_lit10 Opcode = 0x3a
constant DW_OP_lit11 (line 60) | DW_OP_lit11 Opcode = 0x3b
constant DW_OP_lit12 (line 61) | DW_OP_lit12 Opcode = 0x3c
constant DW_OP_lit13 (line 62) | DW_OP_lit13 Opcode = 0x3d
constant DW_OP_lit14 (line 63) | DW_OP_lit14 Opcode = 0x3e
constant DW_OP_lit15 (line 64) | DW_OP_lit15 Opcode = 0x3f
constant DW_OP_lit16 (line 65) | DW_OP_lit16 Opcode = 0x40
constant DW_OP_lit17 (line 66) | DW_OP_lit17 Opcode = 0x41
constant DW_OP_lit18 (line 67) | DW_OP_lit18 Opcode = 0x42
constant DW_OP_lit19 (line 68) | DW_OP_lit19 Opcode = 0x43
constant DW_OP_lit20 (line 69) | DW_OP_lit20 Opcode = 0x44
constant DW_OP_lit21 (line 70) | DW_OP_lit21 Opcode = 0x45
constant DW_OP_lit22 (line 71) | DW_OP_lit22 Opcode = 0x46
constant DW_OP_lit23 (line 72) | DW_OP_lit23 Opcode = 0x47
constant DW_OP_lit24 (line 73) | DW_OP_lit24 Opcode = 0x48
constant DW_OP_lit25 (line 74) | DW_OP_lit25 Opcode = 0x49
constant DW_OP_lit26 (line 75) | DW_OP_lit26 Opcode = 0x4a
constant DW_OP_lit27 (line 76) | DW_OP_lit27 Opcode = 0x4b
constant DW_OP_lit28 (line 77) | DW_OP_lit28 Opcode = 0x4c
constant DW_OP_lit29 (line 78) | DW_OP_lit29 Opcode = 0x4d
constant DW_OP_lit30 (line 79) | DW_OP_lit30 Opcode = 0x4e
constant DW_OP_lit31 (line 80) | DW_OP_lit31 Opcode = 0x4f
constant DW_OP_reg0 (line 81) | DW_OP_reg0 Opcode = 0x50
constant DW_OP_reg1 (line 82) | DW_OP_reg1 Opcode = 0x51
constant DW_OP_reg2 (line 83) | DW_OP_reg2 Opcode = 0x52
constant DW_OP_reg3 (line 84) | DW_OP_reg3 Opcode = 0x53
constant DW_OP_reg4 (line 85) | DW_OP_reg4 Opcode = 0x54
constant DW_OP_reg5 (line 86) | DW_OP_reg5 Opcode = 0x55
constant DW_OP_reg6 (line 87) | DW_OP_reg6 Opcode = 0x56
constant DW_OP_reg7 (line 88) | DW_OP_reg7 Opcode = 0x57
constant DW_OP_reg8 (line 89) | DW_OP_reg8 Opcode = 0x58
constant DW_OP_reg9 (line 90) | DW_OP_reg9 Opcode = 0x59
constant DW_OP_reg10 (line 91) | DW_OP_reg10 Opcode = 0x5a
constant DW_OP_reg11 (line 92) | DW_OP_reg11 Opcode = 0x5b
constant DW_OP_reg12 (line 93) | DW_OP_reg12 Opcode = 0x5c
constant DW_OP_reg13 (line 94) | DW_OP_reg13 Opcode = 0x5d
constant DW_OP_reg14 (line 95) | DW_OP_reg14 Opcode = 0x5e
constant DW_OP_reg15 (line 96) | DW_OP_reg15 Opcode = 0x5f
constant DW_OP_reg16 (line 97) | DW_OP_reg16 Opcode = 0x60
constant DW_OP_reg17 (line 98) | DW_OP_reg17 Opcode = 0x61
constant DW_OP_reg18 (line 99) | DW_OP_reg18 Opcode = 0x62
constant DW_OP_reg19 (line 100) | DW_OP_reg19 Opcode = 0x63
constant DW_OP_reg20 (line 101) | DW_OP_reg20 Opcode = 0x64
constant DW_OP_reg21 (line 102) | DW_OP_reg21 Opcode = 0x65
constant DW_OP_reg22 (line 103) | DW_OP_reg22 Opcode = 0x66
constant DW_OP_reg23 (line 104) | DW_OP_reg23 Opcode = 0x67
constant DW_OP_reg24 (line 105) | DW_OP_reg24 Opcode = 0x68
constant DW_OP_reg25 (line 106) | DW_OP_reg25 Opcode = 0x69
constant DW_OP_reg26 (line 107) | DW_OP_reg26 Opcode = 0x6a
constant DW_OP_reg27 (line 108) | DW_OP_reg27 Opcode = 0x6b
constant DW_OP_reg28 (line 109) | DW_OP_reg28 Opcode = 0x6c
constant DW_OP_reg29 (line 110) | DW_OP_reg29 Opcode = 0x6d
constant DW_OP_reg30 (line 111) | DW_OP_reg30 Opcode = 0x6e
constant DW_OP_reg31 (line 112) | DW_OP_reg31 Opcode = 0x6f
constant DW_OP_breg0 (line 113) | DW_OP_breg0 Opcode = 0x70
constant DW_OP_breg1 (line 114) | DW_OP_breg1 Opcode = 0x71
constant DW_OP_breg2 (line 115) | DW_OP_breg2 Opcode = 0x72
constant DW_OP_breg3 (line 116) | DW_OP_breg3 Opcode = 0x73
constant DW_OP_breg4 (line 117) | DW_OP_breg4 Opcode = 0x74
constant DW_OP_breg5 (line 118) | DW_OP_breg5 Opcode = 0x75
constant DW_OP_breg6 (line 119) | DW_OP_breg6 Opcode = 0x76
constant DW_OP_breg7 (line 120) | DW_OP_breg7 Opcode = 0x77
constant DW_OP_breg8 (line 121) | DW_OP_breg8 Opcode = 0x78
constant DW_OP_breg9 (line 122) | DW_OP_breg9 Opcode = 0x79
constant DW_OP_breg10 (line 123) | DW_OP_breg10 Opcode = 0x7a
constant DW_OP_breg11 (line 124) | DW_OP_breg11 Opcode = 0x7b
constant DW_OP_breg12 (line 125) | DW_OP_breg12 Opcode = 0x7c
constant DW_OP_breg13 (line 126) | DW_OP_breg13 Opcode = 0x7d
constant DW_OP_breg14 (line 127) | DW_OP_breg14 Opcode = 0x7e
constant DW_OP_breg15 (line 128) | DW_OP_breg15 Opcode = 0x7f
constant DW_OP_breg16 (line 129) | DW_OP_breg16 Opcode = 0x80
constant DW_OP_breg17 (line 130) | DW_OP_breg17 Opcode = 0x81
constant DW_OP_breg18 (line 131) | DW_OP_breg18 Opcode = 0x82
constant DW_OP_breg19 (line 132) | DW_OP_breg19 Opcode = 0x83
constant DW_OP_breg20 (line 133) | DW_OP_breg20 Opcode = 0x84
constant DW_OP_breg21 (line 134) | DW_OP_breg21 Opcode = 0x85
constant DW_OP_breg22 (line 135) | DW_OP_breg22 Opcode = 0x86
constant DW_OP_breg23 (line 136) | DW_OP_breg23 Opcode = 0x87
constant DW_OP_breg24 (line 137) | DW_OP_breg24 Opcode = 0x88
constant DW_OP_breg25 (line 138) | DW_OP_breg25 Opcode = 0x89
constant DW_OP_breg26 (line 139) | DW_OP_breg26 Opcode = 0x8a
constant DW_OP_breg27 (line 140) | DW_OP_breg27 Opcode = 0x8b
constant DW_OP_breg28 (line 141) | DW_OP_breg28 Opcode = 0x8c
constant DW_OP_breg29 (line 142) | DW_OP_breg29 Opcode = 0x8d
constant DW_OP_breg30 (line 143) | DW_OP_breg30 Opcode = 0x8e
constant DW_OP_breg31 (line 144) | DW_OP_breg31 Opcode = 0x8f
constant DW_OP_regx (line 145) | DW_OP_regx Opcode = 0x90
constant DW_OP_fbreg (line 146) | DW_OP_fbreg Opcode = 0x91
constant DW_OP_bregx (line 147) | DW_OP_bregx Opcode = 0x92
constant DW_OP_piece (line 148) | DW_OP_piece Opcode = 0x93
constant DW_OP_deref_size (line 149) | DW_OP_deref_size Opcode = 0x94
constant DW_OP_xderef_size (line 150) | DW_OP_xderef_size Opcode = 0x95
constant DW_OP_nop (line 151) | DW_OP_nop Opcode = 0x96
constant DW_OP_push_object_address (line 152) | DW_OP_push_object_address Opcode = 0x97
constant DW_OP_call2 (line 153) | DW_OP_call2 Opcode = 0x98
constant DW_OP_call4 (line 154) | DW_OP_call4 Opcode = 0x99
constant DW_OP_call_ref (line 155) | DW_OP_call_ref Opcode = 0x9a
constant DW_OP_form_tls_address (line 156) | DW_OP_form_tls_address Opcode = 0x9b
constant DW_OP_call_frame_cfa (line 157) | DW_OP_call_frame_cfa Opcode = 0x9c
constant DW_OP_bit_piece (line 158) | DW_OP_bit_piece Opcode = 0x9d
constant DW_OP_implicit_value (line 159) | DW_OP_implicit_value Opcode = 0x9e
constant DW_OP_stack_value (line 160) | DW_OP_stack_value Opcode = 0x9f
FILE: pkg/dwarf/op/regs.go
type DwarfRegisters (line 9) | type DwarfRegisters struct
method SetLoadMoreCallback (line 50) | func (regs *DwarfRegisters) SetLoadMoreCallback(fn func()) {
method CurrentSize (line 56) | func (regs *DwarfRegisters) CurrentSize() int {
method Uint64Val (line 61) | func (regs *DwarfRegisters) Uint64Val(idx uint64) uint64 {
method Bytes (line 71) | func (regs *DwarfRegisters) Bytes(idx uint64) []byte {
method loadMore (line 84) | func (regs *DwarfRegisters) loadMore() {
method Reg (line 93) | func (regs *DwarfRegisters) Reg(idx uint64) *DwarfRegister {
method PC (line 106) | func (regs *DwarfRegisters) PC() uint64 {
method SP (line 110) | func (regs *DwarfRegisters) SP() uint64 {
method BP (line 114) | func (regs *DwarfRegisters) BP() uint64 {
method AddReg (line 119) | func (regs *DwarfRegisters) AddReg(idx uint64, reg *DwarfRegister) {
method ClearRegisters (line 129) | func (regs *DwarfRegisters) ClearRegisters() {
type DwarfRegister (line 28) | type DwarfRegister struct
method FillBytes (line 160) | func (reg *DwarfRegister) FillBytes() {
method Overwrite (line 172) | func (reg *DwarfRegister) Overwrite(reg2 *DwarfRegister) *DwarfRegister {
type RegisterChangeFunc (line 33) | type RegisterChangeFunc
function NewDwarfRegisters (line 36) | func NewDwarfRegisters(staticBase uint64, regs []*DwarfRegister, byteOrd...
function DwarfRegisterFromUint64 (line 136) | func DwarfRegisterFromUint64(v uint64) *DwarfRegister {
function DwarfRegisterFromBytes (line 140) | func DwarfRegisterFromBytes(bytes []byte) *DwarfRegister {
FILE: pkg/dwarf/parseutil.go
function ReadString (line 12) | func ReadString(data *bytes.Buffer) (string, error) {
function ReadUintRaw (line 22) | func ReadUintRaw(reader io.Reader, order binary.ByteOrder, ptrSize int) ...
function WriteUint (line 47) | func WriteUint(writer io.Writer, order binary.ByteOrder, ptrSize int, da...
function ReadDwarfLengthVersion (line 58) | func ReadDwarfLengthVersion(data []byte) (length uint64, dwarf64 bool, v...
constant _DW_UT_compile (line 100) | _DW_UT_compile = 0x1 + iota
constant _DW_UT_type (line 101) | _DW_UT_type
constant _DW_UT_partial (line 102) | _DW_UT_partial
constant _DW_UT_skeleton (line 103) | _DW_UT_skeleton
constant _DW_UT_split_compile (line 104) | _DW_UT_split_compile
constant _DW_UT_split_type (line 105) | _DW_UT_split_type
function ReadUnitVersions (line 109) | func ReadUnitVersions(data []byte) map[dwarf.Offset]uint8 {
FILE: pkg/dwarf/parseutil_test.go
function TestReadString (line 10) | func TestReadString(t *testing.T) {
FILE: pkg/dwarf/reader/reader.go
type Reader (line 12) | type Reader struct
method Seek (line 23) | func (reader *Reader) Seek(off dwarf.Offset) {
method SeekToEntry (line 29) | func (reader *Reader) SeekToEntry(entry *dwarf.Entry) error {
method AddrFor (line 37) | func (reader *Reader) AddrFor(name string, staticBase uint64, ptrSize ...
method SeekToType (line 58) | func (reader *Reader) SeekToType(entry *dwarf.Entry, resolveTypedefs b...
method NextType (line 92) | func (reader *Reader) NextType() (*dwarf.Entry, error) {
method SeekToTypeNamed (line 110) | func (reader *Reader) SeekToTypeNamed(name string) (*dwarf.Entry, erro...
method FindEntryNamed (line 131) | func (reader *Reader) FindEntryNamed(name string, member bool) (*dwarf...
method InstructionsForEntryNamed (line 168) | func (reader *Reader) InstructionsForEntryNamed(name string, member bo...
method InstructionsForEntry (line 186) | func (reader *Reader) InstructionsForEntry(entry *dwarf.Entry) ([]byte...
method NextMemberVariable (line 207) | func (reader *Reader) NextMemberVariable() (*dwarf.Entry, error) {
method NextPackageVariable (line 232) | func (reader *Reader) NextPackageVariable() (*dwarf.Entry, error) {
method NextCompileUnit (line 255) | func (reader *Reader) NextCompileUnit() (*dwarf.Entry, error) {
function New (line 18) | func New(data *dwarf.Data) *Reader {
function InlineStack (line 272) | func InlineStack(root *godwarf.Tree, pc uint64) []*godwarf.Tree {
function inlineStackInternal (line 293) | func inlineStackInternal(stack []*godwarf.Tree, n *godwarf.Tree, pc uint...
FILE: pkg/dwarf/reader/variables.go
type Variable (line 9) | type Variable struct
type VariablesFlags (line 20) | type VariablesFlags
constant VariablesOnlyVisible (line 23) | VariablesOnlyVisible VariablesFlags = 1 << iota
constant VariablesSkipInlinedSubroutines (line 24) | VariablesSkipInlinedSubroutines
constant VariablesTrustDeclLine (line 25) | VariablesTrustDeclLine
constant VariablesNoDeclLineCheck (line 26) | VariablesNoDeclLineCheck
constant VariablesOnlyCaptured (line 27) | VariablesOnlyCaptured
function Variables (line 35) | func Variables(root *godwarf.Tree, pc uint64, line int, flags VariablesF...
function variablesInternal (line 41) | func variablesInternal(v []Variable, root *godwarf.Tree, depth int, pc u...
FILE: pkg/dwarf/regnum/amd64.go
constant AMD64_Rax (line 14) | AMD64_Rax = 0
constant AMD64_Rdx (line 15) | AMD64_Rdx = 1
constant AMD64_Rcx (line 16) | AMD64_Rcx = 2
constant AMD64_Rbx (line 17) | AMD64_Rbx = 3
constant AMD64_Rsi (line 18) | AMD64_Rsi = 4
constant AMD64_Rdi (line 19) | AMD64_Rdi = 5
constant AMD64_Rbp (line 20) | AMD64_Rbp = 6
constant AMD64_Rsp (line 21) | AMD64_Rsp = 7
constant AMD64_R8 (line 22) | AMD64_R8 = 8
constant AMD64_R9 (line 23) | AMD64_R9 = 9
constant AMD64_R10 (line 24) | AMD64_R10 = 10
constant AMD64_R11 (line 25) | AMD64_R11 = 11
constant AMD64_R12 (line 26) | AMD64_R12 = 12
constant AMD64_R13 (line 27) | AMD64_R13 = 13
constant AMD64_R14 (line 28) | AMD64_R14 = 14
constant AMD64_R15 (line 29) | AMD64_R15 = 15
constant AMD64_Rip (line 30) | AMD64_Rip = 16
constant AMD64_XMM0 (line 31) | AMD64_XMM0 = 17
constant AMD64_ST0 (line 32) | AMD64_ST0 = 33
constant AMD64_Rflags (line 33) | AMD64_Rflags = 49
constant AMD64_Es (line 34) | AMD64_Es = 50
constant AMD64_Cs (line 35) | AMD64_Cs = 51
constant AMD64_Ss (line 36) | AMD64_Ss = 52
constant AMD64_Ds (line 37) | AMD64_Ds = 53
constant AMD64_Fs (line 38) | AMD64_Fs = 54
constant AMD64_Gs (line 39) | AMD64_Gs = 55
constant AMD64_Fs_base (line 40) | AMD64_Fs_base = 58
constant AMD64_Gs_base (line 41) | AMD64_Gs_base = 59
constant AMD64_MXCSR (line 42) | AMD64_MXCSR = 64
constant AMD64_CW (line 43) | AMD64_CW = 65
constant AMD64_SW (line 44) | AMD64_SW = 66
constant AMD64_XMM16 (line 45) | AMD64_XMM16 = 67
constant AMD64_K0 (line 46) | AMD64_K0 = 118
function AMD64MaxRegNum (line 146) | func AMD64MaxRegNum() uint64 {
function AMD64ToName (line 156) | func AMD64ToName(num uint64) string {
FILE: pkg/dwarf/regnum/arm64.go
constant ARM64_X0 (line 13) | ARM64_X0 = 0
constant ARM64_BP (line 14) | ARM64_BP = 29
constant ARM64_LR (line 15) | ARM64_LR = 30
constant ARM64_SP (line 16) | ARM64_SP = 31
constant ARM64_PC (line 17) | ARM64_PC = 32
constant ARM64_V0 (line 18) | ARM64_V0 = 64
constant _ARM64_MaxRegNum (line 19) | _ARM64_MaxRegNum = ARM64_V0 + 31
function ARM64ToName (line 22) | func ARM64ToName(num uint64) string {
function ARM64MaxRegNum (line 37) | func ARM64MaxRegNum() uint64 {
FILE: pkg/dwarf/regnum/i386.go
constant I386_Eax (line 14) | I386_Eax = 0
constant I386_Ecx (line 15) | I386_Ecx = 1
constant I386_Edx (line 16) | I386_Edx = 2
constant I386_Ebx (line 17) | I386_Ebx = 3
constant I386_Esp (line 18) | I386_Esp = 4
constant I386_Ebp (line 19) | I386_Ebp = 5
constant I386_Esi (line 20) | I386_Esi = 6
constant I386_Edi (line 21) | I386_Edi = 7
constant I386_Eip (line 22) | I386_Eip = 8
constant I386_Eflags (line 23) | I386_Eflags = 9
constant I386_ST0 (line 24) | I386_ST0 = 11
constant I386_XMM0 (line 25) | I386_XMM0 = 21
constant I386_Es (line 26) | I386_Es = 40
constant I386_Cs (line 27) | I386_Cs = 41
constant I386_Ss (line 28) | I386_Ss = 42
constant I386_Ds (line 29) | I386_Ds = 43
constant I386_Fs (line 30) | I386_Fs = 44
constant I386_Gs (line 31) | I386_Gs = 45
function I386MaxRegNum (line 86) | func I386MaxRegNum() int {
function I386ToName (line 96) | func I386ToName(num uint64) string {
FILE: pkg/dwarf/regnum/loong64.go
constant LOONG64_R0 (line 13) | LOONG64_R0 = 0
constant LOONG64_LR (line 14) | LOONG64_LR = 1
constant LOONG64_SP (line 15) | LOONG64_SP = 3
constant LOONG64_R22 (line 16) | LOONG64_R22 = 22
constant LOONG64_FP (line 17) | LOONG64_FP = LOONG64_R22
constant LOONG64_R31 (line 18) | LOONG64_R31 = 31
constant LOONG64_F0 (line 21) | LOONG64_F0 = 32
constant LOONG64_F31 (line 22) | LOONG64_F31 = 63
constant LOONG64_FCC0 (line 25) | LOONG64_FCC0 = 64
constant LOONG64_FCC7 (line 26) | LOONG64_FCC7 = 71
constant LOONG64_FCSR (line 28) | LOONG64_FCSR = 72
constant LOONG64_ERA (line 31) | LOONG64_ERA = 73
constant LOONG64_BADV (line 32) | LOONG64_BADV = 74
constant LOONG64_PC (line 35) | LOONG64_PC = LOONG64_ERA
constant _LOONG64_MaxRegNum (line 37) | _LOONG64_MaxRegNum = LOONG64_BADV
function LOONG64ToName (line 40) | func LOONG64ToName(num uint64) string {
function LOONG64MaxRegNum (line 65) | func LOONG64MaxRegNum() uint64 {
FILE: pkg/dwarf/regnum/ppc64le.go
constant PPC64LE_FIRST_GPR (line 12) | PPC64LE_FIRST_GPR = 0
constant PPC64LE_R0 (line 13) | PPC64LE_R0 = PPC64LE_FIRST_GPR
constant PPC64LE_LAST_GPR (line 14) | PPC64LE_LAST_GPR = 31
constant PPC64LE_FIRST_FPR (line 16) | PPC64LE_FIRST_FPR = 32
constant PPC64LE_F0 (line 17) | PPC64LE_F0 = PPC64LE_FIRST_FPR
constant PPC64LE_LAST_FPR (line 18) | PPC64LE_LAST_FPR = 63
constant PPC64LE_FIRST_VMX (line 20) | PPC64LE_FIRST_VMX = 77
constant PPC64LE_V0 (line 21) | PPC64LE_V0 = PPC64LE_FIRST_VMX
constant PPC64LE_LAST_VMX (line 22) | PPC64LE_LAST_VMX = 108
constant PPC64LE_FIRST_VSX (line 25) | PPC64LE_FIRST_VSX = 32
constant PPC64LE_VS0 (line 26) | PPC64LE_VS0 = PPC64LE_FIRST_VSX
constant PPC64LE_LAST_VSX (line 27) | PPC64LE_LAST_VSX = 63
constant PPC64LE_CR0 (line 29) | PPC64LE_CR0 = 0
constant PPC64LE_SP (line 31) | PPC64LE_SP = 1
constant PPC64LE_PC (line 32) | PPC64LE_PC = 12
constant PPC64LE_LR (line 33) | PPC64LE_LR = 65
function PPC64LEToName (line 36) | func PPC64LEToName(num uint64) string {
function PPC64LEMaxRegNum (line 63) | func PPC64LEMaxRegNum() uint64 {
function isGPR (line 67) | func isGPR(num uint64) bool {
function isFPR (line 71) | func isFPR(num uint64) bool {
function isVMX (line 75) | func isVMX(num uint64) bool {
function isVSX (line 79) | func isVSX(num uint64) bool {
FILE: pkg/dwarf/regnum/riscv64.go
constant RISCV64_X0 (line 10) | RISCV64_X0 = 0
constant RISCV64_LR (line 12) | RISCV64_LR = 1
constant RISCV64_SP (line 14) | RISCV64_SP = 2
constant RISCV64_GP (line 15) | RISCV64_GP = 3
constant RISCV64_TP (line 16) | RISCV64_TP = 4
constant RISCV64_T0 (line 17) | RISCV64_T0 = 5
constant RISCV64_T1 (line 18) | RISCV64_T1 = 6
constant RISCV64_T2 (line 19) | RISCV64_T2 = 7
constant RISCV64_S0 (line 20) | RISCV64_S0 = 8
constant RISCV64_FP (line 22) | RISCV64_FP = RISCV64_S0
constant RISCV64_S1 (line 23) | RISCV64_S1 = 9
constant RISCV64_A0 (line 24) | RISCV64_A0 = 10
constant RISCV64_A1 (line 25) | RISCV64_A1 = 11
constant RISCV64_A2 (line 26) | RISCV64_A2 = 12
constant RISCV64_A3 (line 27) | RISCV64_A3 = 13
constant RISCV64_A4 (line 28) | RISCV64_A4 = 14
constant RISCV64_A5 (line 29) | RISCV64_A5 = 15
constant RISCV64_A6 (line 30) | RISCV64_A6 = 16
constant RISCV64_A7 (line 31) | RISCV64_A7 = 17
constant RISCV64_S2 (line 32) | RISCV64_S2 = 18
constant RISCV64_S3 (line 33) | RISCV64_S3 = 19
constant RISCV64_S4 (line 34) | RISCV64_S4 = 20
constant RISCV64_S5 (line 35) | RISCV64_S5 = 21
constant RISCV64_S6 (line 36) | RISCV64_S6 = 22
constant RISCV64_S7 (line 37) | RISCV64_S7 = 23
constant RISCV64_S8 (line 38) | RISCV64_S8 = 24
constant RISCV64_S9 (line 39) | RISCV64_S9 = 25
constant RISCV64_S10 (line 40) | RISCV64_S10 = 26
constant RISCV64_S11 (line 42) | RISCV64_S11 = 27
constant RISCV64_T3 (line 43) | RISCV64_T3 = 28
constant RISCV64_T4 (line 44) | RISCV64_T4 = 29
constant RISCV64_T5 (line 45) | RISCV64_T5 = 30
constant RISCV64_T6 (line 46) | RISCV64_T6 = 31
constant RISCV64_X31 (line 48) | RISCV64_X31 = RISCV64_T6
constant RISCV64_F0 (line 51) | RISCV64_F0 = 32
constant RISCV64_F31 (line 52) | RISCV64_F31 = 63
constant RISCV64_PC (line 55) | RISCV64_PC = 65
constant _RISC64_MaxRegNum (line 57) | _RISC64_MaxRegNum = RISCV64_PC
function RISCV64ToName (line 60) | func RISCV64ToName(num uint64) string {
function RISCV64MaxRegNum (line 76) | func RISCV64MaxRegNum() uint64 {
FILE: pkg/elfwriter/delve_core_notes.go
constant DelveHeaderNoteType (line 4) | DelveHeaderNoteType = 0x444C5645
constant DelveThreadNodeType (line 5) | DelveThreadNodeType = 0x444C5654
constant DelveHeaderTargetPidPrefix (line 7) | DelveHeaderTargetPidPrefix = "Target Pid: "
constant DelveHeaderEntryPointPrefix (line 8) | DelveHeaderEntryPointPrefix = "Entry Point: "
FILE: pkg/elfwriter/writer.go
type WriteCloserSeeker (line 15) | type WriteCloserSeeker interface
type Writer (line 22) | type Writer struct
method WriteNotes (line 96) | func (w *Writer) WriteNotes(notes []Note) *elf.ProgHeader {
method WriteProgramHeaders (line 123) | func (w *Writer) WriteProgramHeaders() {
method WriteSectionHeaders (line 147) | func (w *Writer) WriteSectionHeaders() {
method Here (line 200) | func (w *Writer) Here() int64 {
method Align (line 210) | func (w *Writer) Align(align int64) {
method Write (line 218) | func (w *Writer) Write(buf []byte) {
method u16 (line 225) | func (w *Writer) u16(n uint16) {
method u32 (line 232) | func (w *Writer) u32(n uint32) {
method u64 (line 239) | func (w *Writer) u64(n uint64) {
type Note (line 36) | type Note struct
function New (line 43) | func New(w WriteCloserSeeker, fhdr *elf.FileHeader) *Writer {
FILE: pkg/gobuild/defaultexe.go
function DefaultDebugBinaryPath (line 12) | func DefaultDebugBinaryPath(name string) string {
FILE: pkg/gobuild/gobuild.go
function Remove (line 19) | func Remove(path string) {
function GoBuild (line 38) | func GoBuild(debugname string, pkgs []string, buildflags any) error {
function GoBuildCombinedOutput (line 45) | func GoBuildCombinedOutput(debugname string, pkgs []string, buildflags a...
function GoTestBuild (line 55) | func GoTestBuild(debugname string, pkgs []string, buildflags any) error {
function GoTestBuildCombinedOutput (line 62) | func GoTestBuildCombinedOutput(debugname string, pkgs []string, buildfla...
function goBuildArgs (line 70) | func goBuildArgs(debugname string, pkgs []string, buildflags string, isT...
function goBuildArgs2 (line 95) | func goBuildArgs2(debugname string, pkgs []string, buildflags any, isTes...
function gocommandRun (line 115) | func gocommandRun(command string, args ...string) error {
function gocommandCombinedOutput (line 122) | func gocommandCombinedOutput(command string, args ...string) (string, []...
function gocommandExecCmd (line 128) | func gocommandExecCmd(command string, args ...string) (string, *exec.Cmd) {
FILE: pkg/gobuild/gobuild_test.go
function TestGoBuildArgsDashC (line 10) | func TestGoBuildArgsDashC(t *testing.T) {
FILE: pkg/goversion/compat.go
function Compatible (line 26) | func Compatible(dwarfVer uint8, producer string, warnonly bool) error {
FILE: pkg/goversion/go_version.go
type GoVersion (line 13) | type GoVersion struct
method AfterOrEqual (line 191) | func (v *GoVersion) AfterOrEqual(b GoVersion) bool {
method IsOldDevel (line 215) | func (v *GoVersion) IsOldDevel() bool {
method IsDevelBuild (line 220) | func (v *GoVersion) IsDevelBuild() bool {
method String (line 224) | func (v *GoVersion) String() string {
constant betaStart (line 22) | betaStart = -1000
constant betaEnd (line 23) | betaEnd = -2000
constant versionedDevel (line 24) | versionedDevel = -3000
function betaRev (line 27) | func betaRev(beta int) int {
function rcRev (line 31) | func rcRev(rc int) int {
function Parse (line 40) | func Parse(ver string) (GoVersion, bool) {
constant goVersionPrefix (line 246) | goVersionPrefix = "go version "
function Installed (line 249) | func Installed() (GoVersion, bool) {
function VersionAfterOrEqual (line 267) | func VersionAfterOrEqual(version string, major, minor int) bool {
function VersionAfterOrEqualRev (line 274) | func VersionAfterOrEqualRev(version string, major, minor, rev int) bool {
constant producerVersionPrefix (line 282) | producerVersionPrefix = "Go cmd/compile "
function ProducerAfterOrEqual (line 286) | func ProducerAfterOrEqual(producer string, major, minor int) bool {
function ParseProducer (line 294) | func ParseProducer(producer string) GoVersion {
FILE: pkg/goversion/version_test.go
function parseVer (line 8) | func parseVer(t *testing.T, verStr string) GoVersion {
function versionAfterOrEqual (line 16) | func versionAfterOrEqual(t *testing.T, verStr string, ver GoVersion) {
function versionAfterOrEqual2 (line 25) | func versionAfterOrEqual2(t *testing.T, verStr1, verStr2 string) {
function versionEqual (line 34) | func versionEqual(t *testing.T, verStr string, ver GoVersion) {
function TestParseVersionStringAfterOrEqual (line 43) | func TestParseVersionStringAfterOrEqual(t *testing.T) {
function TestParseVersionStringEqual (line 70) | func TestParseVersionStringEqual(t *testing.T) {
function TestRoundtrip (line 88) | func TestRoundtrip(t *testing.T) {
function TestInstalled (line 106) | func TestInstalled(t *testing.T) {
FILE: pkg/internal/gosym/additions.go
constant funcSymNameGo119Lower (line 16) | funcSymNameGo119Lower string = "go.func.*"
constant funcSymNameGo120 (line 17) | funcSymNameGo120 string = "go:func.*"
constant pcdata_InlTreeIndex (line 22) | pcdata_InlTreeIndex = 2
constant funcdata_InlTree (line 23) | funcdata_InlTree = 3
type parsed (line 37) | type parsed struct
function parsePrerelease (line 46) | func parsePrerelease(v string) (t, rest string, ok bool) {
function GoTagToSemver (line 75) | func GoTagToSemver(tag string) string {
function parseBuild (line 106) | func parseBuild(v string) (t, rest string, ok bool) {
function parseInt (line 129) | func parseInt(v string) (t, rest string, ok bool) {
function isIdentChar (line 145) | func isIdentChar(c byte) bool {
function parse (line 149) | func parse(v string) (p parsed, ok bool) {
function isBadNum (line 204) | func isBadNum(v string) bool {
function nextIdent (line 211) | func nextIdent(x string) (dx, rest string) {
function isNum (line 218) | func isNum(v string) bool {
function MajorMinor (line 229) | func MajorMinor(v string) string {
function compareInt (line 241) | func compareInt(x, y string) int {
function comparePrerelease (line 257) | func comparePrerelease(x, y string) int {
function Compare (line 325) | func Compare(v, w string) int {
method InlineTree (line 353) | func (t *LineTable) InlineTree(f *Func, goFuncValue, baseAddr uint64, pr...
function FuncSymName (line 398) | func FuncSymName(goVersion string) string {
function GetFuncSymName (line 411) | func GetFuncSymName() string {
type InlinedCall (line 416) | type InlinedCall struct
type rawInlinedCall112 (line 424) | type rawInlinedCall112 struct
type rawInlinedCall120 (line 436) | type rawInlinedCall120 struct
method npcdata (line 444) | func (f funcData) npcdata() uint32 { return f.field(7) }
method nfuncdata (line 445) | func (f funcData) nfuncdata(numFuncFields uint32) uint32 {
method funcdataOffset (line 449) | func (f funcData) funcdataOffset(i uint8, numFuncFields uint32) uint32 {
method fieldOffset (line 466) | func (f funcData) fieldOffset(n uint32) uint32 {
method pcdataOffset (line 476) | func (f funcData) pcdataOffset(i uint8, numFuncFields uint32) uint32 {
method maxInlineTreeIndexValue (line 489) | func (t *LineTable) maxInlineTreeIndexValue(info funcData, numFuncFields...
type inlTree (line 506) | type inlTree struct
FILE: pkg/internal/gosym/pclntab.go
type version (line 11) | type version
constant verUnknown (line 14) | verUnknown version = iota
constant ver11 (line 15) | ver11
constant ver12 (line 16) | ver12
constant ver116 (line 17) | ver116
constant ver118 (line 18) | ver118
constant ver120 (line 19) | ver120
type LineTable (line 35) | type LineTable struct
method parse (line 70) | func (t *LineTable) parse(targetPC uint64, targetLine int) (b []byte, ...
method slice (line 104) | func (t *LineTable) slice(pc uint64) *LineTable {
method PCToLine (line 112) | func (t *LineTable) PCToLine(pc uint64) int {
method LineToPC (line 124) | func (t *LineTable) LineToPC(line int, maxpc uint64) uint64 {
method isGo12 (line 155) | func (t *LineTable) isGo12() bool {
method uintptr (line 169) | func (t *LineTable) uintptr(b []byte) uint64 {
method parsePclnTab (line 177) | func (t *LineTable) parsePclnTab() {
method go12Funcs (line 276) | func (t *LineTable) go12Funcs() []Func {
method findFunc (line 319) | func (t *LineTable) findFunc(pc uint64) funcData {
method readvarint (line 332) | func (t *LineTable) readvarint(pp *[]byte) uint32 {
method funcName (line 348) | func (t *LineTable) funcName(off uint32) string {
method stringFrom (line 359) | func (t *LineTable) stringFrom(arr []byte, off uint32) string {
method string (line 370) | func (t *LineTable) string(off uint32) string {
method functabFieldSize (line 375) | func (t *LineTable) functabFieldSize() int {
method funcTab (line 383) | func (t *LineTable) funcTab() funcTab {
method funcData (line 428) | func (t *LineTable) funcData(i uint32) funcData {
method step (line 469) | func (t *LineTable) step(p *[]byte, pc *uint64, val *int32, first bool...
method pcvalue (line 489) | func (t *LineTable) pcvalue(off uint32, entry, targetpc uint64) int32 {
method findFileLine (line 507) | func (t *LineTable) findFileLine(entry uint64, filetab, linetab uint32...
method go12PCToLine (line 548) | func (t *LineTable) go12PCToLine(pc uint64) (line int) {
method go12PCToFile (line 564) | func (t *LineTable) go12PCToFile(pc uint64) (file string) {
method go12LineToPC (line 595) | func (t *LineTable) go12LineToPC(file string, line int) (pc uint64) {
method initFileMap (line 631) | func (t *LineTable) initFileMap() {
method go12MapFiles (line 657) | func (t *LineTable) go12MapFiles(m map[string]*Obj, obj *Obj) {
constant oldQuantum (line 68) | oldQuantum = 1
function NewLineTable (line 140) | func NewLineTable(data []byte, text uint64) *LineTable {
constant go12magic (line 161) | go12magic = 0xfffffffb
constant go116magic (line 162) | go116magic = 0xfffffffa
constant go118magic (line 163) | go118magic = 0xfffffff0
constant go120magic (line 164) | go120magic = 0xfffffff1
type funcTab (line 389) | type funcTab struct
method Count (line 395) | func (f funcTab) Count() int {
method pc (line 400) | func (f funcTab) pc(i int) uint64 {
method funcOff (line 409) | func (f funcTab) funcOff(i int) uint64 {
method uint (line 414) | func (f funcTab) uint(b []byte) uint64 {
type funcData (line 422) | type funcData struct
method IsZero (line 434) | func (f funcData) IsZero() bool {
method entryPC (line 439) | func (f *funcData) entryPC() uint64 {
method nameOff (line 449) | func (f funcData) nameOff() uint32 { return f.field(1) }
method deferreturn (line 450) | func (f funcData) deferreturn() uint32 { return f.field(3) }
method pcfile (line 451) | func (f funcData) pcfile() uint32 { return f.field(5) }
method pcln (line 452) | func (f funcData) pcln() uint32 { return f.field(6) }
method cuOffset (line 453) | func (f funcData) cuOffset() uint32 { return f.field(8) }
method field (line 458) | func (f funcData) field(n uint32) uint32 {
constant disableRecover (line 671) | disableRecover = true
FILE: pkg/internal/gosym/symtab.go
type Sym (line 21) | type Sym struct
method Static (line 32) | func (s *Sym) Static() bool { return s.Type >= 'a' }
method nameWithoutInst (line 39) | func (s *Sym) nameWithoutInst() string {
method PackageName (line 54) | func (s *Sym) PackageName() string {
method ReceiverName (line 77) | func (s *Sym) ReceiverName() string {
method BaseName (line 99) | func (s *Sym) BaseName() string {
type Func (line 118) | type Func struct
function ProgContaining (line 138) | func ProgContaining(elfFile *elf.File, addr uint64) *elf.Prog {
function SegmentContaining (line 147) | func SegmentContaining(exe *macho.File, addr uint64) *macho.Segment {
type Obj (line 167) | type Obj struct
method lineFromAline (line 650) | func (o *Obj) lineFromAline(aline int) (string, int) {
method alineFromLine (line 685) | func (o *Obj) alineFromLine(path string, line int) (int, error) {
type Table (line 180) | type Table struct
method GetInlineTree (line 131) | func (T *Table) GetInlineTree(f *Func, goFuncVal, baseaddr uint64, pro...
method PCToFunc (line 538) | func (t *Table) PCToFunc(pc uint64) *Func {
method PCToLine (line 557) | func (t *Table) PCToLine(pc uint64) (file string, line int, fn *Func) {
method LineToPC (line 573) | func (t *Table) LineToPC(file string, line int) (pc uint64, fn *Func, ...
method LookupSym (line 601) | func (t *Table) LookupSym(name string) *Sym {
method LookupFunc (line 617) | func (t *Table) LookupFunc(name string) *Func {
method SymByAddr (line 628) | func (t *Table) SymByAddr(addr uint64) *Sym {
type sym (line 187) | type sym struct
function walksymtab (line 200) | func walksymtab(data []byte, fn func(sym) error) error {
function NewTable (line 348) | func NewTable(symtab []byte, pcln *LineTable) (*Table, error) {
type UnknownFileError (line 725) | type UnknownFileError
method Error (line 727) | func (e UnknownFileError) Error() string { return "unknown file: " + s...
type UnknownLineError (line 732) | type UnknownLineError struct
method Error (line 737) | func (e *UnknownLineError) Error() string {
type DecodingError (line 743) | type DecodingError struct
method Error (line 749) | func (e *DecodingError) Error() string {
FILE: pkg/internal/lru/lru.go
type Cache (line 8) | type Cache struct
type entry (line 14) | type entry struct
function NewCache (line 20) | func NewCache[K comparable, V any](capacity int) *Cache[K, V] {
method Add (line 31) | func (c *Cache[K, V]) Add(key K, value V) {
method Get (line 55) | func (c *Cache[K, V]) Get(key K) (V, bool) {
FILE: pkg/internal/lru/lru_test.go
function TestCache_ZeroCapacity (line 9) | func TestCache_ZeroCapacity(t *testing.T) {
function TestCacheNoEviction (line 19) | func TestCacheNoEviction(t *testing.T) {
function TestCacheEviction (line 40) | func TestCacheEviction(t *testing.T) {
function TestCacheUpdate (line 64) | func TestCacheUpdate(t *testing.T) {
function TestCacheOrder (line 75) | func TestCacheOrder(t *testing.T) {
FILE: pkg/locspec/locations.go
constant maxFindLocationCandidates (line 19) | maxFindLocationCandidates = 5
type LocationSpec (line 22) | type LocationSpec interface
type ErrLocationNotFound (line 28) | type ErrLocationNotFound struct
method Error (line 32) | func (err *ErrLocationNotFound) Error() string {
type NormalLocationSpec (line 38) | type NormalLocationSpec struct
method FileMatch (line 334) | func (loc *NormalLocationSpec) FileMatch(path string) bool {
method Find (line 381) | func (loc *NormalLocationSpec) Find(t *proc.Target, processArgs []stri...
method findFuncCandidates (line 445) | func (loc *NormalLocationSpec) findFuncCandidates(bi *proc.BinaryInfo,...
type RegexLocationSpec (line 46) | type RegexLocationSpec struct
method Find (line 280) | func (loc *RegexLocationSpec) Find(t *proc.Target, _ []string, scope *...
type AddrLocationSpec (line 52) | type AddrLocationSpec struct
method Find (line 301) | func (loc *AddrLocationSpec) Find(t *proc.Target, _ []string, scope *p...
type OffsetLocationSpec (line 58) | type OffsetLocationSpec struct
method Find (line 626) | func (loc *OffsetLocationSpec) Find(t *proc.Target, _ []string, scope ...
type LineLocationSpec (line 63) | type LineLocationSpec struct
method Find (line 652) | func (loc *LineLocationSpec) Find(t *proc.Target, _ []string, scope *p...
type FuncLocationSpec (line 68) | type FuncLocationSpec struct
method Match (line 243) | func (spec *FuncLocationSpec) Match(sym *proc.Function, packageMap map...
function Parse (line 77) | func Parse(locStr string) (LocationSpec, error) {
function parseLocationSpecDefault (line 119) | func parseLocationSpecDefault(locStr, rest string) (LocationSpec, error) {
function readRegex (line 159) | func readRegex(in string) (rx string, rest string) {
function parseFuncLocationSpec (line 184) | func parseFuncLocationSpec(in string) *FuncLocationSpec {
function stripReceiverDecoration (line 231) | func stripReceiverDecoration(in string) string {
function packageMatch (line 269) | func packageMatch(specPkg, symPkg string, packageMap map[string][]string...
function tryMatchRelativePathByProc (line 338) | func tryMatchRelativePathByProc(expr, debugname, file string) bool {
function partialPathMatch (line 342) | func partialPathMatch(expr, path string) bool {
function partialPackageMatch (line 351) | func partialPackageMatch(expr, path string) bool {
type AmbiguousLocationError (line 360) | type AmbiguousLocationError struct
method Error (line 366) | func (ale AmbiguousLocationError) Error() string {
function isAbs (line 490) | func isAbs(path string) bool {
function windowsAbsPath (line 498) | func windowsAbsPath(path string) bool {
function hasPathSeparatorSuffix (line 510) | func hasPathSeparatorSuffix(path string) bool {
function hasPathSeparatorPrefix (line 514) | func hasPathSeparatorPrefix(path string) bool {
function pickSeparator (line 518) | func pickSeparator(to string) string {
function joinPath (line 532) | func joinPath(to, rest string) string {
function SubstitutePath (line 562) | func SubstitutePath(path string, rules [][2]string) string {
function addressesToLocation (line 618) | func addressesToLocation(addrs []uint64) api.Location {
function regexFilterFuncs (line 670) | func regexFilterFuncs(filter string, allFuncs []proc.Function) ([]string...
FILE: pkg/locspec/locations_test.go
function parseLocationSpecNoError (line 7) | func parseLocationSpecNoError(t *testing.T, locstr string) LocationSpec {
function assertNormalLocationSpec (line 15) | func assertNormalLocationSpec(t *testing.T, locstr string, tgt NormalLoc...
function TestFunctionLocationParsing (line 44) | func TestFunctionLocationParsing(t *testing.T) {
function assertSubstitutePathEqual (line 71) | func assertSubstitutePathEqual(t *testing.T, expected string, substitute...
function TestSubstitutePathUnix (line 78) | func TestSubstitutePathUnix(t *testing.T) {
function TestSubstitutePathWindows (line 99) | func TestSubstitutePathWindows(t *testing.T) {
type tRule (line 120) | type tRule struct
type tCase (line 125) | type tCase struct
function platformCases (line 131) | func platformCases() []tCase {
function TestSubstitutePath (line 187) | func TestSubstitutePath(t *testing.T) {
FILE: pkg/logflags/logflags.go
function makeLogger (line 36) | func makeLogger(flag bool, attrs ...interface{}) Logger {
function Any (line 58) | func Any() bool {
function GdbWire (line 64) | func GdbWire() bool {
function GdbWireLogger (line 69) | func GdbWireLogger() Logger {
function Debugger (line 74) | func Debugger() bool {
function DebuggerLogger (line 79) | func DebuggerLogger() Logger {
function LLDBServerOutput (line 85) | func LLDBServerOutput() bool {
function DebugLineErrors (line 91) | func DebugLineErrors() bool {
function DebugLineLogger (line 96) | func DebugLineLogger() Logger {
function RPC (line 101) | func RPC() bool {
function RPCLogger (line 106) | func RPCLogger() Logger {
function rpcLogger (line 111) | func rpcLogger(flag bool) Logger {
function DAP (line 116) | func DAP() bool {
function DAPLogger (line 121) | func DAPLogger() Logger {
function FnCall (line 126) | func FnCall() bool {
function FnCallLogger (line 130) | func FnCallLogger() Logger {
function Minidump (line 135) | func Minidump() bool {
function MinidumpLogger (line 139) | func MinidumpLogger() Logger {
function Stack (line 144) | func Stack() bool {
function StackLogger (line 148) | func StackLogger() Logger {
function WriteDAPListeningMessage (line 153) | func WriteDAPListeningMessage(addr net.Addr) {
function WriteAPIListeningMessage (line 158) | func WriteAPIListeningMessage(addr net.Addr) {
function writeListeningMessage (line 162) | func writeListeningMessage(server string, addr net.Addr) {
function WriteError (line 177) | func WriteError(msg string) {
function WriteCgoFlagsWarning (line 185) | func WriteCgoFlagsWarning() {
function Setup (line 194) | func Setup(logFlag bool, logstr, logDest string) error {
function Close (line 250) | func Close() {
type textHandler (line 256) | type textHandler struct
method Enabled (line 270) | func (h *textHandler) Enabled(_ context.Context, l slog.Level) bool {
method WithAttrs (line 274) | func (h *textHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
method WithGroup (line 305) | func (h *textHandler) WithGroup(group string) slog.Handler {
method Handle (line 310) | func (h *textHandler) Handle(_ context.Context, entry slog.Record) err...
function newTextHandler (line 263) | func newTextHandler(out io.WriteCloser, opts *slog.HandlerOptions) *text...
function appendAttr (line 293) | func appendAttr(b *bytes.Buffer, key string, val slog.Value) {
function needsQuoting (line 340) | func needsQuoting(text string) bool {
FILE: pkg/logflags/logflags_test.go
type dummyLogger (line 10) | type dummyLogger struct
function TestMakeLogger_usingLoggerFactory (line 14) | func TestMakeLogger_usingLoggerFactory(t *testing.T) {
function TestMakeLogger_usingDefaultBehavior (line 49) | func TestMakeLogger_usingDefaultBehavior(t *testing.T) {
function TestMakeLogger_usingDefaultBehaviorAndFlagged (line 82) | func TestMakeLogger_usingDefaultBehaviorAndFlagged(t *testing.T) {
type bufferWriter (line 115) | type bufferWriter struct
method Close (line 119) | func (bw bufferWriter) Close() error {
FILE: pkg/logflags/logger.go
type Logger (line 14) | type Logger interface
type LoggerFactory (line 30) | type LoggerFactory
function SetLoggerFactory (line 36) | func SetLoggerFactory(lf LoggerFactory) {
type Fields (line 41) | type Fields
type slogLogger (line 43) | type slogLogger struct
method Debugf (line 58) | func (s slogLogger) Debugf(format string, args ...interface{}) {
method Infof (line 64) | func (s slogLogger) Infof(format string, args ...interface{}) {
method Warnf (line 70) | func (s slogLogger) Warnf(format string, args ...interface{}) {
method Errorf (line 76) | func (s slogLogger) Errorf(format string, args ...interface{}) {
method Debug (line 82) | func (s slogLogger) Debug(args ...interface{}) {
method Info (line 88) | func (s slogLogger) Info(args ...interface{}) {
method Warn (line 94) | func (s slogLogger) Warn(args ...interface{}) {
method Error (line 100) | func (s slogLogger) Error(args ...interface{}) {
function sloglog (line 47) | func sloglog(logger *slog.Logger, level slog.Level, thunk func() string) {
FILE: pkg/proc/amd64_arch.go
function AMD64Arch (line 20) | func AMD64Arch(goos string) *Arch {
function amd64FixFrameUnwindContext (line 50) | func amd64FixFrameUnwindContext(fctxt *frame.FrameContext, pc uint64, bi...
constant amd64cgocallSPOffsetSaveSlot (line 134) | amd64cgocallSPOffsetSaveSlot = 0x28
function amd64SwitchStack (line 136) | func amd64SwitchStack(it *stackIterator, _ *op.DwarfRegisters) bool {
function amd64RegSize (line 267) | func amd64RegSize(rn uint64) int {
function amd64RegistersToDwarfRegisters (line 279) | func amd64RegistersToDwarfRegisters(staticBase uint64, regs Registers) *...
function initDwarfRegistersFromSlice (line 286) | func initDwarfRegistersFromSlice(maxRegs int, regs Registers, nameToDwar...
function loadMoreDwarfRegistersFromSliceFunc (line 297) | func loadMoreDwarfRegistersFromSliceFunc(dr *op.DwarfRegisters, regs Reg...
function amd64AddrAndStackRegsToDwarfRegisters (line 323) | func amd64AddrAndStackRegsToDwarfRegisters(staticBase, pc, sp, bp, lr ui...
function amd64DwarfRegisterToString (line 332) | func amd64DwarfRegisterToString(i int, reg *op.DwarfRegister) (name stri...
function formatSSEReg (line 365) | func formatSSEReg(name string, reg []byte) string {
function formatSSERegInternal (line 387) | func formatSSERegInternal(xmm []byte, out *bytes.Buffer) {
function formatX87Reg (line 420) | func formatX87Reg(b []byte) string {
FILE: pkg/proc/amd64_disasm.go
function amd64AsmDecode (line 14) | func amd64AsmDecode(asmInst *AsmInstruction, mem []byte, regs *op.DwarfR...
function init (line 25) | func init() {
FILE: pkg/proc/amd64util/debugregs.go
type DebugRegisters (line 11) | type DebugRegisters struct
method breakpoint (line 34) | func (drs *DebugRegisters) breakpoint(idx uint8) (addr uint64, read, w...
method SetBreakpoint (line 61) | func (drs *DebugRegisters) SetBreakpoint(idx uint8, addr uint64, read,...
method ClearBreakpoint (line 107) | func (drs *DebugRegisters) ClearBreakpoint(idx uint8) {
method GetActiveBreakpoint (line 117) | func (drs *DebugRegisters) GetActiveBreakpoint() (ok bool, idx uint8) {
function NewDebugRegisters (line 17) | func NewDebugRegisters(pDR0, pDR1, pDR2, pDR3, pDR6, pDR7 *uint64) *Debu...
function lenrwBitsOffset (line 26) | func lenrwBitsOffset(idx uint8) uint8 {
function enableBitOffset (line 30) | func enableBitOffset(idx uint8) uint8 {
FILE: pkg/proc/amd64util/xsave.go
type AMD64Xstate (line 14) | type AMD64Xstate struct
method Decode (line 41) | func (xstate *AMD64Xstate) Decode() []proc.Register {
method SetXmmRegister (line 158) | func (xstate *AMD64Xstate) SetXmmRegister(n int, value []byte) error {
type AMD64PtraceFpRegs (line 26) | type AMD64PtraceFpRegs struct
constant _XSAVE_XMM_REGION_START (line 77) | _XSAVE_XMM_REGION_START = 160
constant _XSAVE_HEADER_START (line 78) | _XSAVE_HEADER_START = 512
constant _XSAVE_HEADER_LEN (line 79) | _XSAVE_HEADER_LEN = 64
constant _XSAVE_EXTENDED_REGION_START (line 80) | _XSAVE_EXTENDED_REGION_START = 576
constant _XSAVE_SSE_REGION_LEN (line 81) | _XSAVE_SSE_REGION_LEN = 416
constant _I386_LINUX_XSAVE_XCR0_OFFSET (line 82) | _I386_LINUX_XSAVE_XCR0_OFFSET = 464
type xstate_bv (line 88) | type xstate_bv
method hasAVX (line 90) | func (s xstate_bv) hasAVX() bool { return s&(1<<2) != 0 }
method hasZMM_Hi256 (line 91) | func (s xstate_bv) hasZMM_Hi256() bool { return s&(1<<6) != 0 }
method hasHi16_ZMM (line 92) | func (s xstate_bv) hasHi16_ZMM() bool { return s&(1<<7) != 0 }
method hasPKRU (line 93) | func (s xstate_bv) hasPKRU() bool { return s&(1<<9) != 0 }
function AMD64XstateRead (line 101) | func AMD64XstateRead(xstateargs []byte, readLegacy bool, regset *AMD64Xs...
FILE: pkg/proc/arch.go
type Arch (line 12) | type Arch struct
method PtrSize (line 91) | func (a *Arch) PtrSize() int {
method MaxInstructionLength (line 96) | func (a *Arch) MaxInstructionLength() int {
method BreakpointInstruction (line 102) | func (a *Arch) BreakpointInstruction() []byte {
method AltBreakpointInstruction (line 107) | func (a *Arch) AltBreakpointInstruction() []byte {
method BreakInstrMovesPC (line 113) | func (a *Arch) BreakInstrMovesPC() bool {
method BreakpointSize (line 118) | func (a *Arch) BreakpointSize() int {
method DerefTLS (line 124) | func (a *Arch) DerefTLS() bool {
method getAsmRegister (line 131) | func (a *Arch) getAsmRegister(regs *op.DwarfRegisters, asmreg int) (ui...
type asmRegister (line 76) | type asmRegister struct
constant mask8 (line 83) | mask8 = 0x000000ff
constant mask16 (line 84) | mask16 = 0x0000ffff
constant mask32 (line 85) | mask32 = 0xffffffff
type DwarfRegisterToStringFunc (line 88) | type DwarfRegisterToStringFunc
function nameToDwarfFunc (line 147) | func nameToDwarfFunc(n2d map[string]int) func(string) (int, bool) {
constant crosscall2SPOffsetBad (line 156) | crosscall2SPOffsetBad = 0x8
constant crosscall2SPOffsetWindowsAMD64 (line 157) | crosscall2SPOffsetWindowsAMD64 = 0x118
constant crosscall2SPOffsetLinuxPPC64LE (line 158) | crosscall2SPOffsetLinuxPPC64LE = 0x158
constant crosscall2SPOffset (line 159) | crosscall2SPOffset = 0x58
FILE: pkg/proc/arm64_arch.go
function ARM64Arch (line 23) | func ARM64Arch(goos string) *Arch {
function arm64FixFrameUnwindContext (line 60) | func arm64FixFrameUnwindContext(fctxt *frame.FrameContext, pc uint64, bi...
constant arm64cgocallSPOffsetSaveSlot (line 143) | arm64cgocallSPOffsetSaveSlot = 0x8
constant prevG0schedSPOffsetSaveSlot (line 144) | prevG0schedSPOffsetSaveSlot = 0x10
function arm64SwitchStack (line 146) | func arm64SwitchStack(it *stackIterator, callFrameRegs *op.DwarfRegister...
function arm64RegSize (line 358) | func arm64RegSize(regnum uint64) int {
function arm64RegistersToDwarfRegisters (line 381) | func arm64RegistersToDwarfRegisters(staticBase uint64, regs Registers) *...
function arm64AddrAndStackRegsToDwarfRegisters (line 388) | func arm64AddrAndStackRegsToDwarfRegisters(staticBase, pc, sp, bp, lr ui...
function arm64DwarfRegisterToString (line 398) | func arm64DwarfRegisterToString(i int, reg *op.DwarfRegister) (name stri...
FILE: pkg/proc/arm64_disasm.go
function arm64AsmDecode (line 10) | func arm64AsmDecode(asmInst *AsmInstruction, mem []byte, regs *op.DwarfR...
function resolveCallArgARM64 (line 39) | func resolveCallArgARM64(inst *arm64asm.Inst, instAddr uint64, currentGo...
function init (line 78) | func init() {
type arm64ArchInst (line 95) | type arm64ArchInst
method Text (line 97) | func (inst *arm64ArchInst) Text(flavour AssemblyFlavour, pc uint64, sy...
method OpcodeEquals (line 114) | func (inst *arm64ArchInst) OpcodeEquals(op uint64) bool {
FILE: pkg/proc/bininfo.go
constant dwarfGoLanguage (line 46) | dwarfGoLanguage = 22
constant dwarfAttrAddrBase (line 47) | dwarfAttrAddrBase = 0x73
constant dwarfTreeCacheSize (line 48) | dwarfTreeCacheSize = 512
type BinaryInfo (line 53) | type BinaryInfo struct
method FindFunction (line 333) | func (bi *BinaryInfo) FindFunction(funcName string) ([]*Function, erro...
method LoadBinaryInfo (line 860) | func (bi *BinaryInfo) LoadBinaryInfo(path string, entryPoint uint64, d...
method GStructOffset (line 888) | func (bi *BinaryInfo) GStructOffset(mem MemoryReadWriter) (uint64, err...
method LastModified (line 903) | func (bi *BinaryInfo) LastModified() time.Time {
method Types (line 916) | func (bi *BinaryInfo) Types() ([]string, error) {
method EntryLineForFunc (line 924) | func (bi *BinaryInfo) EntryLineForFunc(fn *Function) (string, int) {
method pcToLine (line 928) | func (bi *BinaryInfo) pcToLine(fn *Function, pc uint64) (string, int) {
method PCToLine (line 938) | func (bi *BinaryInfo) PCToLine(pc uint64) (string, int, *Function) {
method AllPCsForFileLines (line 967) | func (bi *BinaryInfo) AllPCsForFileLines(filename string, linenos []in...
method PCToFunc (line 984) | func (bi *BinaryInfo) PCToFunc(pc uint64) *Function {
method PCToImage (line 999) | func (bi *BinaryInfo) PCToImage(pc uint64) *Image {
method HasGoImage (line 1061) | func (bi *BinaryInfo) HasGoImage() bool {
method AddImage (line 1074) | func (bi *BinaryInfo) AddImage(path string, addr uint64) error {
method LoadImageBinaryInfoAgain (line 1121) | func (bi *BinaryInfo) LoadImageBinaryInfoAgain(n int) error {
method moduleDataToImage (line 1136) | func (bi *BinaryInfo) moduleDataToImage(md *ModuleData) *Image {
method imageToModuleData (line 1155) | func (bi *BinaryInfo) imageToModuleData(image *Image, mds []ModuleData...
method typeToImage (line 1166) | func (bi *BinaryInfo) typeToImage(typ godwarf.Type) *Image {
method runtimeTypeTypename (line 1170) | func (bi *BinaryInfo) runtimeTypeTypename() string {
method Close (line 1180) | func (bi *BinaryInfo) Close() error {
method LoadImageFromData (line 1255) | func (bi *BinaryInfo) LoadImageFromData(dwdata *dwarf.Data, debugFrame...
method locationExpr (line 1274) | func (bi *BinaryInfo) locationExpr(entry godwarf.Entry, attr dwarf.Att...
method LocationCovers (line 1326) | func (bi *BinaryInfo) LocationCovers(entry *dwarf.Entry, attr dwarf.At...
method Location (line 1370) | func (bi *BinaryInfo) Location(entry godwarf.Entry, attr dwarf.Attr, p...
method loclistEntry (line 1385) | func (bi *BinaryInfo) loclistEntry(off int64, pc uint64) []byte {
method findCompileUnit (line 1423) | func (bi *BinaryInfo) findCompileUnit(pc uint64) *compileUnit {
method Producer (line 1450) | func (bi *BinaryInfo) Producer() string {
method DwarfVersion (line 1460) | func (bi *BinaryInfo) DwarfVersion() uint8 {
method funcToImage (line 1479) | func (bi *BinaryInfo) funcToImage(fn *Function) *Image {
method parseDebugFrameGeneral (line 1489) | func (bi *BinaryInfo) parseDebugFrameGeneral(image *Image, debugFrameB...
method getModuleData (line 1518) | func (bi *BinaryInfo) getModuleData(mem MemoryReadWriter) ([]ModuleDat...
method openSeparateDebugInfo (line 1539) | func (bi *BinaryInfo) openSeparateDebugInfo(image *Image, exe *elf.Fil...
method loadSymbolName (line 1813) | func (bi *BinaryInfo) loadSymbolName(image *Image, file *elf.File, wg ...
method loadBuildID (line 1827) | func (bi *BinaryInfo) loadBuildID(image *Image, file *elf.File) {
method getDebugLink (line 1859) | func (bi *BinaryInfo) getDebugLink(exe *elf.File) (debugLink string, c...
method parseDebugFrameElf (line 1881) | func (bi *BinaryInfo) parseDebugFrameElf(image *Image, dwarfFile, exeF...
method setGStructOffsetElf (line 1901) | func (bi *BinaryInfo) setGStructOffsetElf(image *Image, exe *elf.File,...
method setGStructOffsetPE (line 2035) | func (bi *BinaryInfo) setGStructOffsetPE(entryPoint uint64, peFile *pe...
method parseDebugFramePE (line 2086) | func (bi *BinaryInfo) parseDebugFramePE(image *Image, exe *pe.File, de...
method setGStructOffsetMacho (line 2159) | func (bi *BinaryInfo) setGStructOffsetMacho() {
method parseDebugFrameMacho (line 2171) | func (bi *BinaryInfo) parseDebugFrameMacho(image *Image, exe *macho.Fi...
method macOSDebugFrameBugWorkaround (line 2195) | func (bi *BinaryInfo) macOSDebugFrameBugWorkaround() {
method findType (line 2471) | func (bi *BinaryInfo) findType(name string) (godwarf.Type, error) {
method findTypeExpr (line 2482) | func (bi *BinaryInfo) findTypeExpr(expr ast.Expr) (godwarf.Type, error) {
method findArrayType (line 2532) | func (bi *BinaryInfo) findArrayType(n int, etyp string) (godwarf.Type,...
method registerTypeToPackageMap (line 2556) | func (bi *BinaryInfo) registerTypeToPackageMap(entry *dwarf.Entry) {
method loadDebugInfoMaps (line 2579) | func (bi *BinaryInfo) loadDebugInfoMaps(image *Image, debugInfoBytes, ...
method LookupGenericFunc (line 2718) | func (bi *BinaryInfo) LookupGenericFunc() map[string][]*Function {
method LookupFunc (line 2731) | func (bi *BinaryInfo) LookupFunc() map[string][]*Function {
method lookupOneFunc (line 2742) | func (bi *BinaryInfo) lookupOneFunc(name string) *Function {
method hasDebugPinner (line 2756) | func (bi *BinaryInfo) hasDebugPinner() bool {
method loadDebugInfoMapsCompileUnit (line 2761) | func (bi *BinaryInfo) loadDebugInfoMapsCompileUnit(ctxt *loadDebugInfo...
method loadDebugInfoMapsImportedUnit (line 2862) | func (bi *BinaryInfo) loadDebugInfoMapsImportedUnit(entry *dwarf.Entry...
method addAbstractSubprogram (line 2880) | func (bi *BinaryInfo) addAbstractSubprogram(entry *dwarf.Entry, ctxt *...
method addConcreteInlinedSubprogram (line 2900) | func (bi *BinaryInfo) addConcreteInlinedSubprogram(entry *dwarf.Entry,...
method addConcreteSubprogram (line 2924) | func (bi *BinaryInfo) addConcreteSubprogram(entry *dwarf.Entry, ctxt *...
method loadDebugInfoMapsInlinedCalls (line 2977) | func (bi *BinaryInfo) loadDebugInfoMapsInlinedCalls(ctxt *loadDebugInf...
method expandPackagesInType (line 3040) | func (bi *BinaryInfo) expandPackagesInType(expr ast.Expr) {
method symLookup (line 3091) | func (bi *BinaryInfo) symLookup(addr uint64) (string, uint64) {
method ListPackagesBuildInfo (line 3129) | func (bi *BinaryInfo) ListPackagesBuildInfo(includeFiles bool) []*Pack...
type ErrFunctionNotFound (line 160) | type ErrFunctionNotFound struct
method Error (line 164) | func (err *ErrFunctionNotFound) Error() string {
function FindFileLocation (line 170) | func FindFileLocation(p Process, filename string, lineno int) ([]uint64,...
type inlRange (line 302) | type inlRange struct
function allInlineCallRanges (line 312) | func allInlineCallRanges(tree *godwarf.Tree) []inlRange {
function FindFunctionLocation (line 346) | func FindFunctionLocation(p Process, funcName string, lineOffset int) ([...
function FirstPCAfterPrologue (line 386) | func FirstPCAfterPrologue(p Process, fn *Function, sameline bool) (uint6...
function findRetPC (line 417) | func findRetPC(t *Target, name string) ([]uint64, error) {
type cpuArch (line 439) | type cpuArch interface
type ErrUnsupportedArch (line 444) | type ErrUnsupportedArch struct
method Error (line 449) | func (e *ErrUnsupportedArch) Error() string {
type compileUnit (line 481) | type compileUnit struct
method filePath (line 3176) | func (cu *compileUnit) filePath(fileidx int, entry *dwarf.Entry) (stri...
type optimizedFlags (line 498) | type optimizedFlags
constant optimizedInlined (line 501) | optimizedInlined optimizedFlags = 1 << iota
constant optimizedOptimized (line 502) | optimizedOptimized
type fileLine (line 505) | type fileLine struct
type dwarfRef (line 511) | type dwarfRef struct
type InlinedCall (line 517) | type InlinedCall struct
type Function (line 523) | type Function struct
method instRange (line 554) | func (fn *Function) instRange() [2]int {
method PackageName (line 577) | func (fn *Function) PackageName() string {
method ReceiverName (line 594) | func (fn *Function) ReceiverName() string {
method BaseName (line 611) | func (fn *Function) BaseName() string {
method NameWithoutTypeParams (line 622) | func (fn *Function) NameWithoutTypeParams() string {
method Optimized (line 631) | func (fn *Function) Optimized() bool {
method PrologueEndPC (line 636) | func (fn *Function) PrologueEndPC() uint64 {
method AllPCs (line 644) | func (fn *Function) AllPCs(excludeFile string, excludeLine int) ([]uin...
method exportedRuntime (line 666) | func (fn *Function) exportedRuntime() bool {
method privateRuntime (line 673) | func (fn *Function) privateRuntime() bool {
method CompilationUnitName (line 679) | func (fn *Function) CompilationUnitName() string {
method rangeParentName (line 707) | func (fn *Function) rangeParentName() string {
method extra (line 720) | func (fn *Function) extra(bi *BinaryInfo) *functionExtra {
method rangeBodies (line 781) | func (fn *Function) rangeBodies(bi *BinaryInfo) []*Function {
type functionExtra (line 543) | type functionExtra struct
function packageName (line 582) | func packageName(name string) string {
function rangeParentName (line 686) | func rangeParentName(fnname string) int {
type constantsMap (line 801) | type constantsMap
type constantType (line 803) | type constantType struct
type constantValue (line 808) | type constantValue struct
type packageVar (line 818) | type packageVar struct
type buildIDHeader (line 825) | type buildIDHeader struct
type ElfDynamicSection (line 832) | type ElfDynamicSection struct
function NewBinaryInfo (line 838) | func NewBinaryInfo(goos, goarch string) *BinaryInfo {
function loadBinaryInfo (line 871) | func loadBinaryInfo(bi *BinaryInfo, image *Image, path string, entryPoin...
type ErrCouldNotFindLine (line 947) | type ErrCouldNotFindLine struct
method Error (line 953) | func (err *ErrCouldNotFindLine) Error() string {
type Image (line 1005) | type Image struct
method DwarfReader (line 908) | func (so *Image) DwarfReader() *reader.Reader {
method registerRuntimeTypeToDIE (line 1047) | func (image *Image) registerRuntimeTypeToDIE(entry *dwarf.Entry, ardr ...
method Stripped (line 1055) | func (image *Image) Stripped() bool {
method Close (line 1197) | func (image *Image) Close() error {
method setLoadError (line 1220) | func (image *Image) setLoadError(logger logflags.Logger, fmtstr string...
method LoadError (line 1230) | func (image *Image) LoadError() error {
method getDwarfTree (line 1234) | func (image *Image) getDwarfTree(off dwarf.Offset) (*godwarf.Tree, err...
method findCompileUnitForOffset (line 1436) | func (bi *Image) findCompileUnitForOffset(off dwarf.Offset) *compileUn...
method Type (line 1473) | func (image *Image) Type(offset dwarf.Offset) (godwarf.Type, error) {
type nilCloser (line 1249) | type nilCloser struct
method Close (line 1251) | func (c *nilCloser) Close() error { return nil }
type locationExpr (line 1294) | type locationExpr struct
method String (line 1304) | func (le *locationExpr) String() string {
function loadBinaryInfoElf (line 1670) | func loadBinaryInfoElf(bi *BinaryInfo, image *Image, path string, addr u...
function findGoFuncVal (line 1763) | func findGoFuncVal(moduleData []byte, roDataAddr uint64, ptrsize int) (u...
function parseModuleData (line 1797) | func parseModuleData(dataSection []byte, tableAddr uint64) ([]byte, erro...
constant _STT_FUNC (line 1811) | _STT_FUNC = 2
function getSymbol (line 1959) | func getSymbol(image *Image, logger logflags.Logger, exe *elf.File, name...
constant _IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE (line 1977) | _IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE = 0x0040
function loadBinaryInfoPE (line 1980) | func loadBinaryInfoPE(bi *BinaryInfo, image *Image, path string, entryPo...
function openExecutablePathPE (line 2073) | func openExecutablePathPE(path string) (*pe.File, io.Closer, error) {
function loadBinaryInfoMacho (line 2096) | func loadBinaryInfoMacho(bi *BinaryInfo, image *Image, path string, entr...
function macOSShortSectionNamesWorkaround (line 2293) | func macOSShortSectionNamesWorkaround(exe *macho.File) {
function loadBinaryInfoGoRuntimeElf (line 2320) | func loadBinaryInfoGoRuntimeElf(bi *BinaryInfo, image *Image, path strin...
function loadBinaryInfoGoRuntimeMacho (line 2376) | func loadBinaryInfoGoRuntimeMacho(bi *BinaryInfo, image *Image, path str...
function loadBinaryInfoGoRuntimeCommon (line 2430) | func loadBinaryInfoGoRuntimeCommon(bi *BinaryInfo, image *Image, cu *com...
function complexType (line 2546) | func complexType(typename string) bool {
function subprogramEntryName (line 2956) | func subprogramEntryName(entry *dwarf.Entry, cu *compileUnit) (string, b...
function subprogramEntryRange (line 2967) | func subprogramEntryRange(entry *dwarf.Entry, image *Image) (lowpc, high...
function escapePackagePath (line 3084) | func escapePackagePath(pkg string) string {
type PackageBuildInfo (line 3120) | type PackageBuildInfo struct
FILE: pkg/proc/breakpoints.go
constant UnrecoveredPanic (line 27) | UnrecoveredPanic = "unrecovered-panic"
constant FatalThrow (line 31) | FatalThrow = "runtime-fatal-throw"
constant HardcodedBreakpoint (line 35) | HardcodedBreakpoint = "hardcoded-breakpoint"
constant unrecoveredPanicID (line 37) | unrecoveredPanicID = -1
constant fatalThrowID (line 38) | fatalThrowID = -2
constant hardcodedBreakpointID (line 39) | hardcodedBreakpointID = -3
constant NoLogicalID (line 41) | NoLogicalID = -1000
type Breakpoint (line 47) | type Breakpoint struct
method String (line 199) | func (bp *Breakpoint) String() string {
method LogicalID (line 203) | func (bp *Breakpoint) LogicalID() int {
method VerboseDescr (line 214) | func (bp *Breakpoint) VerboseDescr() []string {
method checkCondition (line 286) | func (bp *Breakpoint) checkCondition(tgt *Target, thread Thread, bpsta...
method IsStepping (line 448) | func (bp *Breakpoint) IsStepping() bool {
method IsUser (line 460) | func (bp *Breakpoint) IsUser() bool {
method IsSharedLibBreakpoint (line 470) | func (bp *Breakpoint) IsSharedLibBreakpoint() bool {
method UserBreaklet (line 481) | func (bp *Breakpoint) UserBreaklet() *Breaklet {
method canOverlap (line 841) | func (bp *Breakpoint) canOverlap(kind BreakpointKind) bool {
type Breaklet (line 80) | type Breaklet struct
method SetCallback (line 117) | func (b *Breaklet) SetCallback(callback func(th Thread, p *Target) (bo...
type BreakpointKind (line 123) | type BreakpointKind
constant UserBreakpoint (line 127) | UserBreakpoint BreakpointKind = (1 << iota)
constant NextBreakpoint (line 130) | NextBreakpoint
constant NextDeferBreakpoint (line 135) | NextDeferBreakpoint
constant StepBreakpoint (line 139) | StepBreakpoint
constant WatchOutOfScopeBreakpoint (line 143) | WatchOutOfScopeBreakpoint
constant StackResizeBreakpoint (line 147) | StackResizeBreakpoint
constant PluginOpenBreakpoint (line 151) | PluginOpenBreakpoint
constant StepIntoNewProcBreakpoint (line 155) | StepIntoNewProcBreakpoint
constant NextInactivatedBreakpoint (line 158) | NextInactivatedBreakpoint
constant StepIntoRangeOverFuncBodyBreakpoint (line 160) | StepIntoRangeOverFuncBodyBreakpoint
constant SharedLibBreakpoint (line 164) | SharedLibBreakpoint
constant steppingMask (line 166) | steppingMask = NextBreakpoint | NextDeferBreakpoint | StepBreakpoint | S...
type WatchType (line 170) | type WatchType
method Read (line 178) | func (wtype WatchType) Read() bool {
method Write (line 183) | func (wtype WatchType) Write() bool {
method Size (line 188) | func (wtype WatchType) Size() int {
method withSize (line 193) | func (wtype WatchType) withSize(sz uint8) WatchType {
constant WatchRead (line 173) | WatchRead WatchType = 1 << iota
constant WatchWrite (line 174) | WatchWrite
type BreakpointExistsError (line 258) | type BreakpointExistsError struct
method Error (line 264) | func (bpe BreakpointExistsError) Error() string {
type InvalidAddressError (line 270) | type InvalidAddressError struct
method Error (line 274) | func (iae InvalidAddressError) Error() string {
type returnBreakpointInfo (line 278) | type returnBreakpointInfo struct
method Collect (line 1048) | func (rbpi *returnBreakpointInfo) Collect(t *Target, thread Thread) []...
function checkHitCond (line 378) | func checkHitCond(lbp *LogicalBreakpoint, goroutineID int64) bool {
function isPanicCall (line 406) | func isPanicCall(frames []Stackframe) (bool, int) {
function isDeferReturnCall (line 427) | func isDeferReturnCall(frames []Stackframe, deferReturns []uint64) (bool...
function evalBreakpointCondition (line 490) | func evalBreakpointCondition(tgt *Target, thread Thread, cond ast.Expr) ...
type NoBreakpointError (line 534) | type NoBreakpointError struct
method Error (line 538) | func (nbp NoBreakpointError) Error() string {
type BreakpointMap (line 543) | type BreakpointMap struct
method HasSteppingBreakpoints (line 962) | func (bpmap *BreakpointMap) HasSteppingBreakpoints() bool {
method HasHWBreakpoints (line 972) | func (bpmap *BreakpointMap) HasHWBreakpoints() bool {
function NewBreakpointMap (line 555) | func NewBreakpointMap() BreakpointMap {
method SetBreakpoint (line 563) | func (t *Target) SetBreakpoint(logicalID int, addr uint64, kind Breakpoi...
method SetEBPFTracepoint (line 569) | func (t *Target) SetEBPFTracepoint(fnName string) error {
method setEBPFTracepointOnFunc (line 610) | func (t *Target) setEBPFTracepointOnFunc(fn *Function, goidOffset int64)...
method SetWatchpoint (line 665) | func (t *Target) SetWatchpoint(logicalID int, scope *EvalScope, expr str...
method setBreakpointInternal (line 738) | func (t *Target) setBreakpointInternal(logicalID int, addr uint64, kind ...
method ClearBreakpoint (line 849) | func (t *Target) ClearBreakpoint(addr uint64) error {
method ClearSteppingBreakpoints (line 888) | func (t *Target) ClearSteppingBreakpoints() error {
method clearInactivatedSteppingBreakpoint (line 912) | func (t *Target) clearInactivatedSteppingBreakpoint() error {
method finishClearBreakpoint (line 938) | func (t *Target) finishClearBreakpoint(bp *Breakpoint) (bool, error) {
function totalHitCountByName (line 981) | func totalHitCountByName(lbpmap map[int]*LogicalBreakpoint, s string) (u...
function totalHitCountByID (line 990) | func totalHitCountByID(lbpmap map[int]*LogicalBreakpoint, id int) (uint6...
type BreakpointState (line 1000) | type BreakpointState struct
method checkCond (line 293) | func (bpstate *BreakpointState) checkCond(tgt *Target, breaklet *Break...
method Clear (line 1017) | func (bpstate *BreakpointState) Clear() {
method String (line 1025) | func (bpstate *BreakpointState) String() string {
function configureReturnBreakpoint (line 1036) | func configureReturnBreakpoint(bi *BinaryInfo, bp *Breakpoint, topframe ...
function returnInfoError (line 1091) | func returnInfoError(descr string, err error, bi *BinaryInfo, mem Memory...
type LogicalBreakpoint (line 1108) | type LogicalBreakpoint struct
method Enabled (line 1170) | func (lbp *LogicalBreakpoint) Enabled() bool {
method HitCond (line 1175) | func (lbp *LogicalBreakpoint) HitCond() string {
method Cond (line 1182) | func (lbp *LogicalBreakpoint) Cond() string {
type SetBreakpoint (line 1155) | type SetBreakpoint struct
type PidAddr (line 1164) | type PidAddr struct
function breakpointConditionSatisfiable (line 1188) | func breakpointConditionSatisfiable(lbpmap map[int]*LogicalBreakpoint, l...
function breakpointConditionUsesHitCounts (line 1297) | func breakpointConditionUsesHitCounts(lbp *LogicalBreakpoint) bool {
FILE: pkg/proc/core/core.go
type SplicedMemory (line 32) | type SplicedMemory struct
method Add (line 43) | func (r *SplicedMemory) Add(reader proc.MemoryReader, off, length uint...
method ReadMemory (line 103) | func (r *SplicedMemory) ReadMemory(buf []byte, addr uint64) (n int, er...
type readerEntry (line 36) | type readerEntry struct
type offsetReaderAt (line 147) | type offsetReaderAt struct
method ReadMemory (line 153) | func (r *offsetReaderAt) ReadMemory(buf []byte, addr uint64) (n int, e...
type process (line 158) | type process struct
method BinInfo (line 235) | func (p *process) BinInfo() *proc.BinaryInfo {
method EntryPoint (line 240) | func (p *process) EntryPoint() (uint64, error) {
method WriteBreakpoint (line 246) | func (p *process) WriteBreakpoint(*proc.Breakpoint) error {
method Recorded (line 251) | func (p *process) Recorded() (bool, string) { return true, "" }
method Restart (line 254) | func (p *process) Restart(*proc.ContinueOnceContext, string) (proc.Thr...
method ChangeDirection (line 259) | func (p *process) ChangeDirection(proc.Direction) error { return ErrCo...
method GetDirection (line 262) | func (p *process) GetDirection() proc.Direction { return proc.Forward }
method When (line 265) | func (p *process) When() (string, error) { return "", nil }
method Checkpoint (line 268) | func (p *process) Checkpoint(string) (int, error) { return -1, ErrCont...
method Checkpoints (line 271) | func (p *process) Checkpoints() ([]proc.Checkpoint, error) { return ni...
method ClearCheckpoint (line 274) | func (p *process) ClearCheckpoint(int) error { return errors.New("chec...
method SupportsBPF (line 276) | func (p *process) SupportsBPF() bool {
method SetUProbe (line 280) | func (p *process) SetUProbe(fnName string, goidOffset int64, args []eb...
method StartCallInjection (line 285) | func (p *process) StartCallInjection() (func(), error) { return func()...
method EnableURetProbes (line 287) | func (p *process) EnableURetProbes() error {
method DisableURetProbes (line 291) | func (p *process) DisableURetProbes() error {
method ReadMemory (line 298) | func (p *process) ReadMemory(data []byte, addr uint64) (n int, err err...
method WriteMemory (line 308) | func (p *process) WriteMemory(addr uint64, data []byte) (int, error) {
method FollowExec (line 313) | func (p *process) FollowExec(bool) error {
method Breakpoints (line 382) | func (p *process) Breakpoints() *proc.BreakpointMap {
method EraseBreakpoint (line 388) | func (p *process) EraseBreakpoint(bp *proc.Breakpoint) error {
method ClearInternalBreakpoints (line 394) | func (p *process) ClearInternalBreakpoints() error {
method ContinueOnce (line 398) | func (*process) ContinueOnce(cctx *proc.ContinueOnceContext) (proc.Thr...
method StepInstruction (line 404) | func (p *process) StepInstruction(int) error {
method RequestManualStop (line 410) | func (p *process) RequestManualStop(cctx *proc.ContinueOnceContext) er...
method CheckAndClearManualStopRequest (line 417) | func (p *process) CheckAndClearManualStopRequest() bool {
method Memory (line 422) | func (p *process) Memory() proc.MemoryReadWriter {
method Detach (line 429) | func (p *process) Detach(int, bool) error {
method Close (line 433) | func (p *process) Close() error {
method Valid (line 439) | func (p *process) Valid() (bool, error) {
method ResumeNotify (line 445) | func (p *process) ResumeNotify(chan<- struct{}) {
method ThreadList (line 449) | func (p *process) ThreadList() []proc.Thread {
method FindThread (line 458) | func (p *process) FindThread(threadID int) (proc.Thread, bool) {
method MemoryMap (line 463) | func (p *process) MemoryMap() ([]proc.MemoryMapEntry, error) {
method DumpProcessNotes (line 467) | func (p *process) DumpProcessNotes(notes []elfwriter.Note, threadDone ...
method GetBufferedTracepoints (line 471) | func (p *process) GetBufferedTracepoints() []ebpf.RawUProbeParams {
type thread (line 170) | type thread struct
method ProcessMemory (line 318) | func (t *thread) ProcessMemory() proc.MemoryReadWriter {
method Breakpoint (line 325) | func (t *thread) Breakpoint() *proc.BreakpointState {
method RestoreRegisters (line 331) | func (t *thread) RestoreRegisters(proc.Registers) error {
method BinInfo (line 336) | func (t *thread) BinInfo() *proc.BinaryInfo {
method SetCurrentBreakpoint (line 342) | func (t *thread) SetCurrentBreakpoint(adjustPC bool) error {
method SoftExc (line 347) | func (t *thread) SoftExc() bool {
method Common (line 353) | func (t *thread) Common() *proc.CommonThread {
method SetPC (line 359) | func (t *thread) SetPC(uint64) error {
method SetSP (line 365) | func (t *thread) SetSP(uint64) error {
method SetDX (line 371) | func (t *thread) SetDX(uint64) error {
method SetReg (line 377) | func (t *thread) SetReg(regNum uint64, reg *op.DwarfRegister) error {
type osThread (line 176) | type osThread interface
type openFn (line 196) | type openFn
function OpenCore (line 207) | func OpenCore(corePath, exePath string, debugInfoDirs []string) (*proc.T...
FILE: pkg/proc/core/core_test.go
function TestMain (line 24) | func TestMain(m *testing.M) {
function assertNoError (line 34) | func assertNoError(err error, t testing.TB, s string) {
function TestSplicedReader (line 42) | func TestSplicedReader(t *testing.T) {
function withCoreFile (line 201) | func withCoreFile(t *testing.T, name, args string) *proc.TargetGroup {
function logRegisters (line 239) | func logRegisters(t *testing.T, regs proc.Registers, arch *proc.Arch) {
function TestCore (line 252) | func TestCore(t *testing.T) {
function TestCoreFpRegisters (line 320) | func TestCoreFpRegisters(t *testing.T) {
function TestCoreWithEmptyString (line 411) | func TestCoreWithEmptyString(t *testing.T) {
function TestMinidump (line 450) | func TestMinidump(t *testing.T) {
function procdump (line 504) | func procdump(t *testing.T, exePath string) string {
function mustSupportCore (line 532) | func mustSupportCore(t *testing.T) {
FILE: pkg/proc/core/delve_core.go
function platformFromNotes (line 15) | func platformFromNotes(notes []*note) (goos, goarch string, err error) {
function threadsFromDelveNotes (line 30) | func threadsFromDelveNotes(p *process, notes []*note) (proc.Thread, erro...
type delveThread (line 128) | type delveThread struct
method ThreadID (line 133) | func (th *delveThread) ThreadID() int {
method Registers (line 137) | func (th *delveThread) Registers() (proc.Registers, error) {
type delveRegisters (line 141) | type delveRegisters struct
method PC (line 148) | func (regs *delveRegisters) PC() uint64 { return regs.pc }
method BP (line 149) | func (regs *delveRegisters) BP() uint64 { return regs.bp }
method SP (line 150) | func (regs *delveRegisters) SP() uint64 { return regs.sp }
method TLS (line 151) | func (regs *delveRegisters) TLS() uint64 { return regs.tls }
method GAddr (line 152) | func (regs *delveRegisters) GAddr() (uint64, bool) { return regs.gaddr...
method LR (line 153) | func (regs *delveRegisters) LR() uint64 { return 0 }
method Copy (line 155) | func (regs *delveRegisters) Copy() (proc.Registers, error) {
method Slice (line 159) | func (regs *delveRegisters) Slice(bool) ([]proc.Register, error) {
FILE: pkg/proc/core/linux_core.go
type linuxCoreTimeval (line 21) | type linuxCoreTimeval struct
constant _NT_FILE (line 27) | _NT_FILE elf.NType = 0x46494c45
constant _NT_X86_XSTATE (line 30) | _NT_X86_XSTATE elf.NType = 0x202
constant _NT_AUXV (line 33) | _NT_AUXV elf.NType = 0x6
constant _NT_FPREGSET (line 36) | _NT_FPREGSET elf.NType = 0x2
constant _EM_AARCH64 (line 41) | _EM_AARCH64 = 183
constant _EM_X86_64 (line 42) | _EM_X86_64 = 62
constant _EM_RISCV (line 43) | _EM_RISCV = 243
constant _EM_LOONGARCH (line 44) | _EM_LOONGARCH = 258
constant _ARM_FP_HEADER_START (line 45) | _ARM_FP_HEADER_START = 512
constant elfErrorBadMagicNumber (line 48) | elfErrorBadMagicNumber = "bad magic number"
function linuxThreadsFromNotes (line 50) | func linuxThreadsFromNotes(p *process, notes []*note, machineType elf.Ma...
function readLinuxOrPlatformIndependentCore (line 111) | func readLinuxOrPlatformIndependentCore(corePath, exePath string) (*proc...
type linuxAMD64Thread (line 184) | type linuxAMD64Thread struct
method Registers (line 204) | func (t *linuxAMD64Thread) Registers() (proc.Registers, error) {
method ThreadID (line 232) | func (t *linuxAMD64Thread) ThreadID() int {
type linuxARM64Thread (line 189) | type linuxARM64Thread struct
method Registers (line 211) | func (t *linuxARM64Thread) Registers() (proc.Registers, error) {
method ThreadID (line 236) | func (t *linuxARM64Thread) ThreadID() int {
type linuxRISCV64Thread (line 194) | type linuxRISCV64Thread struct
method Registers (line 218) | func (t *linuxRISCV64Thread) Registers() (proc.Registers, error) {
method ThreadID (line 240) | func (t *linuxRISCV64Thread) ThreadID() int {
type linuxLOONG64Thread (line 199) | type linuxLOONG64Thread struct
method Registers (line 225) | func (t *linuxLOONG64Thread) Registers() (proc.Registers, error) {
method ThreadID (line 244) | func (t *linuxLOONG64Thread) ThreadID() int {
type note (line 255) | type note struct
function readNotes (line 262) | func readNotes(core *elf.File, machineType elf.Machine) ([]*note, bool, ...
function readNote (line 299) | func readNote(r io.ReadSeeker, machineType elf.Machine) (*note, error) {
function readFpregsetNote (line 391) | func readFpregsetNote(note *note, fpregs interface{ Byte() []byte }, des...
function skipPadding (line 401) | func skipPadding(r io.ReadSeeker, pad int64) error {
function buildMemory (line 415) | func buildMemory(core, exeELF *elf.File, exe io.ReaderAt, notes []*note)...
function findEntryPoint (line 454) | func findEntryPoint(notes []*note, ptrSize int) uint64 {
type linuxPrPsInfo (line 467) | type linuxPrPsInfo struct
type linuxPrStatusAMD64 (line 481) | type linuxPrStatusAMD64 struct
type linuxPrStatusARM64 (line 494) | type linuxPrStatusARM64 struct
type linuxPrStatusRISCV64 (line 507) | type linuxPrStatusRISCV64 struct
type linuxPrStatusLOONG64 (line 520) | type linuxPrStatusLOONG64 struct
type linuxSiginfo (line 534) | type linuxSiginfo struct
type linuxNTFile (line 541) | type linuxNTFile struct
type linuxNTFileHdr (line 547) | type linuxNTFileHdr struct
type linuxNTFileEntry (line 553) | type linuxNTFileEntry struct
type elfNotesHdr (line 561) | type elfNotesHdr struct
FILE: pkg/proc/core/minidump/fileflags_string.go
constant _FileFlags_name (line 7) | _FileFlags_name = "FileNormalFileWithDataSegsFileWithFullMemoryFileWithH...
method String (line 32) | func (i FileFlags) String() string {
constant _StreamType_name (line 39) | _StreamType_name = "UnusedStreamReservedStream0ReservedStream1ThreadList...
method String (line 43) | func (i StreamType) String() string {
constant _Arch_name_0 (line 51) | _Arch_name_0 = "CpuArchitectureX86CpuArchitectureMipsCpuArchitectureAlph...
constant _Arch_name_1 (line 52) | _Arch_name_1 = "CpuArchitectureARM64"
constant _Arch_name_2 (line 53) | _Arch_name_2 = "CpuArchitectureUnknown"
method String (line 60) | func (i Arch) String() string {
constant _MemoryState_name_0 (line 74) | _MemoryState_name_0 = "MemoryStateCommit"
constant _MemoryState_name_1 (line 75) | _MemoryState_name_1 = "MemoryStateReserve"
constant _MemoryState_name_2 (line 76) | _MemoryState_name_2 = "MemoryStateFree"
method String (line 79) | func (i MemoryState) String() string {
constant _MemoryType_name_0 (line 93) | _MemoryType_name_0 = "MemoryTypePrivate"
constant _MemoryType_name_1 (line 94) | _MemoryType_name_1 = "MemoryTypeMapped"
constant _MemoryType_name_2 (line 95) | _MemoryType_name_2 = "MemoryTypeImage"
method String (line 98) | func (i MemoryType) String() string {
constant _MemoryProtection_name_0 (line 112) | _MemoryProtection_name_0 = "MemoryProtectNoAccessMemoryProtectReadOnly"
constant _MemoryProtection_name_1 (line 113) | _MemoryProtection_name_1 = "MemoryProtectReadWrite"
constant _MemoryProtection_name_2 (line 114) | _MemoryProtection_name_2 = "MemoryProtectWriteCopy"
constant _MemoryProtection_name_3 (line 115) | _MemoryProtection_name_3 = "MemoryProtectExecute"
constant _MemoryProtection_name_4 (line 116) | _MemoryProtection_name_4 = "MemoryProtectExecuteRead"
constant _MemoryProtection_name_5 (line 117) | _MemoryProtection_name_5 = "MemoryProtectExecuteReadWrite"
constant _MemoryProtection_name_6 (line 118) | _MemoryProtection_name_6 = "MemoryProtectExecuteWriteCopy"
constant _MemoryProtection_name_7 (line 119) | _MemoryProtection_name_7 = "MemoryProtectPageGuard"
constant _MemoryProtection_name_8 (line 120) | _MemoryProtection_name_8 = "MemoryProtectNoCache"
constant _MemoryProtection_name_9 (line 121) | _MemoryProtection_name_9 = "MemoryProtectWriteCombine"
method String (line 128) | func (i MemoryProtection) String() string {
FILE: pkg/proc/core/minidump/minidump.go
type minidumpBuf (line 30) | type minidumpBuf struct
method u16 (line 38) | func (buf *minidumpBuf) u16() uint16 {
method u32 (line 51) | func (buf *minidumpBuf) u32() uint32 {
method u64 (line 64) | func (buf *minidumpBuf) u64() uint64 {
function streamBuf (line 77) | func streamBuf(stream *Stream, buf *minidumpBuf, name string) *minidumpB...
type ErrNotAMinidump (line 89) | type ErrNotAMinidump struct
method Error (line 94) | func (err ErrNotAMinidump) Error() string {
constant minidumpSignature (line 99) | minidumpSignature = 0x504d444d
constant minidumpVersion (line 100) | minidumpVersion = 0xa793
type Minidump (line 104) | type Minidump struct
method addMemory (line 684) | func (mdmp *Minidump) addMemory(addr uint64, data []byte) {
type Stream (line 124) | type Stream struct
type Thread (line 132) | type Thread struct
type Module (line 143) | type Module struct
type VSFixedFileInfo (line 160) | type VSFixedFileInfo struct
type MemoryRange (line 179) | type MemoryRange struct
method ReadMemory (line 185) | func (m *MemoryRange) ReadMemory(buf []byte, addr uint64) (int, error) {
type MemoryInfo (line 198) | type MemoryInfo struct
type MemoryState (line 209) | type MemoryState
constant MemoryStateCommit (line 212) | MemoryStateCommit MemoryState = 0x1000
constant MemoryStateReserve (line 213) | MemoryStateReserve MemoryState = 0x2000
constant MemoryStateFree (line 214) | MemoryStateFree MemoryState = 0x10000
type MemoryType (line 218) | type MemoryType
constant MemoryTypePrivate (line 221) | MemoryTypePrivate MemoryType = 0x20000
constant MemoryTypeMapped (line 222) | MemoryTypeMapped MemoryType = 0x40000
constant MemoryTypeImage (line 223) | MemoryTypeImage MemoryType = 0x1000000
type MemoryProtection (line 227) | type MemoryProtection
constant MemoryProtectNoAccess (line 230) | MemoryProtectNoAccess MemoryProtection = 0x01
constant MemoryProtectReadOnly (line 231) | MemoryProtectReadOnly MemoryProtection = 0x02
constant MemoryProtectReadWrite (line 232) | MemoryProtectReadWrite MemoryProtection = 0x04
constant MemoryProtectWriteCopy (line 233) | MemoryProtectWriteCopy MemoryProtection = 0x08
constant MemoryProtectExecute (line 234) | MemoryProtectExecute MemoryProtection = 0x10
constant MemoryProtectExecuteRead (line 235) | MemoryProtectExecuteRead MemoryProtection = 0x20
constant MemoryProtectExecuteReadWrite (line 236) | MemoryProtectExecuteReadWrite MemoryProtection = 0x40
constant MemoryProtectExecuteWriteCopy (line 237) | MemoryProtectExecuteWriteCopy MemoryProtection = 0x80
constant MemoryProtectPageGuard (line 239) | MemoryProtectPageGuard MemoryProtection = 0x100
constant MemoryProtectNoCache (line 240) | MemoryProtectNoCache MemoryProtection = 0x200
constant MemoryProtectWriteCombine (line 241) | MemoryProtectWriteCombine MemoryProtection = 0x400
type FileFlags (line 246) | type FileFlags
constant FileNormal (line 249) | FileNormal FileFlags = 0x00000000
constant FileWithDataSegs (line 250) | FileWithDataSegs FileFlags = 0x00000001
constant FileWithFullMemory (line 251) | FileWithFullMemory FileFlags = 0x00000002
constant FileWithHandleData (line 252) | FileWithHandleData FileFlags = 0x00000004
constant FileFilterMemory (line 253) | FileFilterMemory FileFlags = 0x00000008
constant FileScanMemory (line 254) | FileScanMemory FileFlags = 0x00000010
constant FileWithUnloadedModules (line 255) | FileWithUnloadedModules FileFlags = 0x00000020
constant FileWithIncorrectlyReferencedMemory (line 256) | FileWithIncorrectlyReferencedMemory FileFlags = 0x00000040
constant FileFilterModulePaths (line 257) | FileFilterModulePaths FileFlags = 0x00000080
constant FileWithProcessThreadData (line 258) | FileWithProcessThreadData FileFlags = 0x00000100
constant FileWithPrivateReadWriteMemory (line 259) | FileWithPrivateReadWriteMemory FileFlags = 0x00000200
constant FileWithoutOptionalData (line 260) | FileWithoutOptionalData FileFlags = 0x00000400
constant FileWithFullMemoryInfo (line 261) | FileWithFullMemoryInfo FileFlags = 0x00000800
constant FileWithThreadInfo (line 262) | FileWithThreadInfo FileFlags = 0x00001000
constant FileWithCodeSegs (line 263) | FileWithCodeSegs FileFlags = 0x00002000
constant FileWithoutAuxilliarySegs (line 264) | FileWithoutAuxilliarySegs FileFlags = 0x00004000
constant FileWithFullAuxilliaryState (line 265) | FileWithFullAuxilliaryState FileFlags = 0x00008000
constant FileWithPrivateCopyMemory (line 266) | FileWithPrivateCopyMemory FileFlags = 0x00010000
constant FileIgnoreInaccessibleMemory (line 267) | FileIgnoreInaccessibleMemory FileFlags = 0x00020000
constant FileWithTokenInformation (line 268) | FileWithTokenInformation FileFlags = 0x00040000
type StreamType (line 272) | type StreamType
constant UnusedStream (line 275) | UnusedStream StreamType = 0
constant ReservedStream0 (line 276) | ReservedStream0 StreamType = 1
constant ReservedStream1 (line 277) | ReservedStream1 StreamType = 2
constant ThreadListStream (line 278) | ThreadListStream StreamType = 3
constant ModuleListStream (line 279) | ModuleListStream StreamType = 4
constant MemoryListStream (line 280) | MemoryListStream StreamType = 5
constant ExceptionStream (line 281) | ExceptionStream StreamType = 6
constant SystemInfoStream (line 282) | SystemInfoStream StreamType = 7
constant ThreadExListStream (line 283) | ThreadExListStream StreamType = 8
constant Memory64ListStream (line 284) | Memory64ListStream StreamType = 9
constant CommentStreamA (line 285) | CommentStreamA StreamType = 10
constant CommentStreamW (line 286) | CommentStreamW StreamType = 11
constant HandleDataStream (line 287) | HandleDataStream StreamType = 12
constant FunctionTableStream (line 288) | FunctionTableStream StreamType = 13
constant UnloadedModuleStream (line 289) | UnloadedModuleStream StreamType = 14
constant MiscInfoStream (line 290) | MiscInfoStream StreamType = 15
constant MemoryInfoListStream (line 291) | MemoryInfoListStream StreamType = 16
constant ThreadInfoListStream (line 292) | ThreadInfoListStream StreamType = 17
constant HandleOperationListStream (line 293) | HandleOperationListStream StreamType = 18
constant TokenStream (line 294) | TokenStream StreamType = 19
constant JavascriptDataStream (line 295) | JavascriptDataStream StreamType = 20
constant SystemMemoryInfoStream (line 296) | SystemMemoryInfoStream StreamType = 21
constant ProcessVMCounterStream (line 297) | ProcessVMCounterStream StreamType = 22
type Arch (line 301) | type Arch
constant CpuArchitectureX86 (line 304) | CpuArchitectureX86 Arch = 0
constant CpuArchitectureMips (line 305) | CpuArchitectureMips Arch = 1
constant CpuArchitectureAlpha (line 306) | CpuArchitectureAlpha Arch = 2
constant CpuArchitecturePPC (line 307) | CpuArchitecturePPC Arch = 3
constant CpuArchitectureSHX (line 308) | CpuArchitectureSHX Arch = 4
constant CpuArchitectureARM (line 309) | CpuArchitectureARM Arch = 5
constant CpuArchitectureIA64 (line 310) | CpuArchitectureIA64 Arch = 6
constant CpuArchitectureAlpha64 (line 311) | CpuArchitectureAlpha64 Arch = 7
constant CpuArchitectureMSIL (line 312) | CpuArchitectureMSIL Arch = 8
constant CpuArchitectureAMD64 (line 313) | CpuArchitectureAMD64 Arch = 9
constant CpuArchitectureWoW64 (line 314) | CpuArchitectureWoW64 Arch = 10
constant CpuArchitectureARM64 (line 315) | CpuArchitectureARM64 Arch = 12
constant CpuArchitectureUnknown (line 316) | CpuArchitectureUnknown Arch = 0xffff
function Open (line 320) | func Open(path string, logfn func(fmt string, args ...any)) (*Minidump, ...
function decodeUTF16 (line 421) | func decodeUTF16(in []byte) string {
function fileFlagsToString (line 435) | func fileFlagsToString(flags FileFlags) string {
function readMinidumpHeader (line 455) | func readMinidumpHeader(mdmp *Minidump, buf *minidumpBuf) {
function readDirectory (line 477) | func readDirectory(mdmp *Minidump, buf *minidumpBuf) {
function readLocationDescriptor (line 495) | func readLocationDescriptor(buf *minidumpBuf) (off int, rawData []byte) {
function readString (line 510) | func readString(buf *minidumpBuf) string {
function readThreadList (line 525) | func readThreadList(mdmp *Minidump, buf *minidumpBuf) {
function readModuleList (line 556) | func readModuleList(mdmp *Minidump, buf *minidumpBuf) {
function readMemory64List (line 601) | func readMemory64List(mdmp *Minidump, buf *minidumpBuf, logfn func(fmt s...
function readMemoryInfoList (line 628) | func readMemoryInfoList(mdmp *Minidump, buf *minidumpBuf, logfn func(fmt...
function readMiscInfo (line 663) | func readMiscInfo(mdmp *Minidump, buf *minidumpBuf) {
function readMemoryDescriptor (line 672) | func readMemoryDescriptor(mdmp *Minidump, buf *minidumpBuf) {
FILE: pkg/proc/core/windows_amd64_minidump.go
function readAMD64Minidump (line 10) | func readAMD64Minidump(minidumpPath, exePath string) (*process, proc.Thr...
type windowsAMD64Thread (line 56) | type windowsAMD64Thread struct
method ThreadID (line 60) | func (th *windowsAMD64Thread) ThreadID() int {
method Registers (line 64) | func (th *windowsAMD64Thread) Registers() (proc.Registers, error) {
FILE: pkg/proc/debuginfod/debuginfod.go
constant debuginfodFind (line 13) | debuginfodFind = "debuginfod-find"
constant notificationThrottle (line 14) | notificationThrottle time.Duration = 1 * time.Second
function execFind (line 16) | func execFind(ctx context.Context, notify func(string), args ...string) ...
function dropCR (line 60) | func dropCR(data []byte) []byte {
function GetSource (line 65) | func GetSource(buildid, filename string) (string, error) {
function GetDebuginfo (line 69) | func GetDebuginfo(ctx context.Context, notify func(string), buildid stri...
FILE: pkg/proc/disasm.go
type AsmInstruction (line 10) | type AsmInstruction struct
method IsCall (line 34) | func (instr *AsmInstruction) IsCall() bool {
method IsRet (line 39) | func (instr *AsmInstruction) IsRet() bool {
method IsJmp (line 44) | func (instr *AsmInstruction) IsJmp() bool {
method IsHardBreak (line 49) | func (instr *AsmInstruction) IsHardBreak() bool {
method Text (line 179) | func (instr *AsmInstruction) Text(flavour AssemblyFlavour, bi *BinaryI...
type AsmInstructionKind (line 23) | type AsmInstructionKind
constant OtherInstruction (line 26) | OtherInstruction AsmInstructionKind = iota
constant CallInstruction (line 27) | CallInstruction
constant RetInstruction (line 28) | RetInstruction
constant JmpInstruction (line 29) | JmpInstruction
constant HardBreakInstruction (line 30) | HardBreakInstruction
type archInst (line 53) | type archInst interface
type AssemblyFlavour (line 59) | type AssemblyFlavour
constant GNUFlavour (line 63) | GNUFlavour AssemblyFlavour = iota
constant IntelFlavour (line 65) | IntelFlavour
constant GoFlavour (line 67) | GoFlavour
type opcodeSeq (line 70) | type opcodeSeq
function firstPCAfterPrologueDisassembly (line 77) | func firstPCAfterPrologueDisassembly(p Process, fn *Function, sameline b...
function checkPrologue (line 108) | func checkPrologue(s []AsmInstruction, prologuePattern opcodeSeq) bool {
function Disassemble (line 123) | func Disassemble(mem MemoryReadWriter, regs Registers, breakpoints *Brea...
function disassemble (line 130) | func disassemble(memrw MemoryReadWriter, regs Registers, breakpoints *Br...
FILE: pkg/proc/dump.go
type DumpState (line 21) | type DumpState struct
method setErr (line 53) | func (state *DumpState) setErr(err error) {
method setThreadsTotal (line 64) | func (state *DumpState) setThreadsTotal(n int) {
method threadDone (line 71) | func (state *DumpState) threadDone() {
method setMemTotal (line 77) | func (state *DumpState) setMemTotal(n uint64) {
method memDone (line 83) | func (state *DumpState) memDone(delta uint64) {
method isCanceled (line 89) | func (state *DumpState) isCanceled() bool {
type DumpFlags (line 36) | type DumpFlags
constant DumpPlatformIndependent (line 39) | DumpPlatformIndependent DumpFlags = 1 << iota
type MemoryMapEntry (line 43) | type MemoryMapEntry struct
method Dump (line 96) | func (t *Target) Dump(out elfwriter.WriteCloserSeeker, flags DumpFlags, ...
method dumpThreadNotes (line 237) | func (t *Target) dumpThreadNotes(notes []elfwriter.Note, state *DumpStat...
method dumpMemory (line 297) | func (t *Target) dumpMemory(state *DumpState, w *elfwriter.Writer, mme *...
method shouldDumpMemory (line 354) | func (t *Target) shou
Copy disabled (too large)
Download .json
Condensed preview — 1451 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (17,044K chars).
[
{
"path": ".cirrus.yml",
"chars": 157,
"preview": "env:\n GOFLAGS: -mod=vendor\n\nfreebsd_instance:\n image_family: freebsd-14-3\n\ntest_task:\n install_script: pkg install -y"
},
{
"path": ".gitattributes",
"chars": 29,
"preview": "pkg/version/version.go ident\n"
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 27,
"preview": "blank_issues_enabled: true\n"
},
{
"path": ".github/ISSUE_TEMPLATE/issue_template.yml",
"chars": 1078,
"preview": "name: Bug Report\ndescription: File a bug report.\nbody:\n - type: input\n id: delve_version\n attributes:\n label"
},
{
"path": ".github/workflows/release.yml",
"chars": 2274,
"preview": "name: Release\n\non:\n push:\n tags:\n - 'v*'\n workflow_dispatch:\n inputs:\n tag:\n description: 'Git "
},
{
"path": ".github/workflows/test-windows-arm64.yml",
"chars": 713,
"preview": "name: Test Windows ARM64\n\non:\n push:\n pull_request:\n branches: [master]\n\n# Cancel existing runs if user makes anoth"
},
{
"path": ".gitignore",
"chars": 135,
"preview": "**/*.test\n.tags*\ntags\n.dbg_history\n**/**/dlv\n!cmd/dlv/\n.vagrant\n**/*.swp\nlocaltests\n.idea\n*.iml\n.teamcity/target\n.vscode"
},
{
"path": ".goreleaser.yaml",
"chars": 1984,
"preview": "version: 2\n\nproject_name: dlv\n\nbefore:\n hooks:\n - go mod download\n\nbuilds:\n - main: ./cmd/dlv\n binary: dlv\n #"
},
{
"path": ".teamcity/pom.xml",
"chars": 2987,
"preview": "<?xml version=\"1.0\"?>\n<project>\n <modelVersion>4.0.0</modelVersion>\n <name>Delve Config DSL Script</name>\n <groupId>D"
},
{
"path": ".teamcity/settings.kts",
"chars": 9532,
"preview": "import jetbrains.buildServer.configs.kotlin.AbsoluteId\nimport jetbrains.buildServer.configs.kotlin.BuildType\nimport jetb"
},
{
"path": "CHANGELOG.md",
"chars": 65485,
"preview": "# Changelog\n\nAll notable changes to this project will be documented in this file.\nThis project adheres to Semantic Versi"
},
{
"path": "CLAUDE.md",
"chars": 11075,
"preview": "# CLAUDE.md\n\nThis file provides guidance to Claude Code (claude.ai/code) when working\nwith code in this repository.\n\n## "
},
{
"path": "CONTRIBUTING.md",
"chars": 2750,
"preview": "# Contributing to Delve\n\nWant to help contribute to Delve? Great! Any and all help is certainly appreciated, whether it'"
},
{
"path": "Documentation/AI/AI_POLICY.md",
"chars": 3036,
"preview": "# AI Usage Policy\n\n> **Attribution:** This policy is adapted from the\n> [Ghostty project's AI_POLICY.md](https://github."
},
{
"path": "Documentation/EditorIntegration.md",
"chars": 1183,
"preview": "## Editor plugins\n\nThe following editor plugins for delve are available:\n\n**Atom**\n* [Go Debugger for Atom](https://gith"
},
{
"path": "Documentation/KnownBugs.md",
"chars": 691,
"preview": "# Known Bugs\n\n- When Delve is compiled with versions of go prior to 1.7.0 it is not possible to set a breakpoint on a fu"
},
{
"path": "Documentation/README.md",
"chars": 294,
"preview": "# Delve Documentation\n\nDocumentation for the project will reside in this directory.\n\n- [Installation](installation)\n- [U"
},
{
"path": "Documentation/api/ClientHowto.md",
"chars": 13633,
"preview": "# How to write a Delve client, an informal guide\n\n## Spawning the backend\n\nThe `dlv` binary built by our `Makefile` cont"
},
{
"path": "Documentation/api/README.md",
"chars": 1691,
"preview": "# Server/Client API Documentation\n\nDelve exposes two API interfaces, JSON-RPC and DAP, so that frontends other than the "
},
{
"path": "Documentation/api/dap/README.md",
"chars": 11414,
"preview": "# DAP Interface\n\nDelve exposes a [DAP](https://microsoft.github.io/debug-adapter-protocol/overview) API interface.\n\nThis"
},
{
"path": "Documentation/api/json-rpc/README.md",
"chars": 2017,
"preview": "# JSON-RPC interface\n\nDelve exposes a [JSON-RPC](https://www.jsonrpc.org/specification_v1) API interface. \n\nNote that th"
},
{
"path": "Documentation/backend_test_health.md",
"chars": 1583,
"preview": "Tests skipped by each supported backend:\n\n* 386 skipped = 11\n\t* 1 broken\n\t* 3 broken - cgo stacktraces\n\t* 6 not implemen"
},
{
"path": "Documentation/cli/README.md",
"chars": 24920,
"preview": "# Configuration and Command History\n\nIf `$XDG_CONFIG_HOME` is set, then configuration and command history files are loca"
},
{
"path": "Documentation/cli/cond.md",
"chars": 907,
"preview": "# Breakpoint conditions\n\nBreakpoints have two conditions:\n\n* The normal condition, which is specified using the command "
},
{
"path": "Documentation/cli/config.md",
"chars": 2319,
"preview": "# Configuration\n\nThe configuration file `config.yml` is found in `$XDG_CONFIG_HOME/dlv` if `$XDG_CONFIG_HOME` is set, if"
},
{
"path": "Documentation/cli/expr.md",
"chars": 5670,
"preview": "# Expressions\n\nDelve can evaluate a subset of go expression language, specifically the following features are supported:"
},
{
"path": "Documentation/cli/getting_started.md",
"chars": 3123,
"preview": "# Getting Started\n\nDelve aims to be a very simple and powerful tool, but can be confusing if you're\nnot used to using a "
},
{
"path": "Documentation/cli/locspec.md",
"chars": 1175,
"preview": "# Location Specifiers\n\nSeveral delve commands take a program location as an argument, the syntax accepted by this comman"
},
{
"path": "Documentation/cli/starlark.md",
"chars": 18585,
"preview": "# Introduction\n\nPassing a file with the .star extension to the `source` command will cause delve to interpret it as a st"
},
{
"path": "Documentation/cli/substitutepath.md",
"chars": 3578,
"preview": "## Path substitution configuration\n\nNormally Delve finds the path to the source code that was used to produce an executa"
},
{
"path": "Documentation/faq.md",
"chars": 6358,
"preview": "## Frequently Asked Questions\n\n<!-- BEGIN TOC -->\n* [I'm getting an error while compiling Delve / unsupported architectu"
},
{
"path": "Documentation/installation/README.md",
"chars": 3305,
"preview": "# Installation\nThe following instructions are known to work on Linux, macOS, Windows and FreeBSD.\n\nWith Go version 1.16 "
},
{
"path": "Documentation/installation/freebsd/install.md",
"chars": 49,
"preview": "See [general install instructions](../README.md)."
},
{
"path": "Documentation/installation/linux/install.md",
"chars": 50,
"preview": "See [general install instructions](../README.md).\n"
},
{
"path": "Documentation/installation/osx/install.md",
"chars": 193,
"preview": "## Homebrew\n\nYou can install Delve via HomeBrew with the following command:\n\n```shell\n$ brew install delve\n```\n\n## Other"
},
{
"path": "Documentation/installation/windows/install.md",
"chars": 49,
"preview": "See [general install instructions](../README.md)."
},
{
"path": "Documentation/internal/README.md",
"chars": 303,
"preview": "# Internal Documentation\n\n* [Architecture of Delve slides](https://speakerdeck.com/aarzilli/internal-architecture-of-del"
},
{
"path": "Documentation/internal/portnotes.md",
"chars": 9716,
"preview": "# Notes on porting Delve to other architectures\n\n## Continuous Integration requirements\n\nCode that isn't tested doesn't "
},
{
"path": "Documentation/usage/README.md",
"chars": 3063,
"preview": "# Using Delve\n\nYou can invoke Delve in [multiple ways](dlv.md), depending on your usage needs. Delve makes every attempt"
},
{
"path": "Documentation/usage/dlv.md",
"chars": 1515,
"preview": "## dlv\n\nDelve is a debugger for the Go programming language.\n\n### Synopsis\n\nDelve is a source level debugger for Go prog"
},
{
"path": "Documentation/usage/dlv_attach.md",
"chars": 2510,
"preview": "## dlv attach\n\nAttach to running process and begin debugging.\n\n### Synopsis\n\nAttach to an already running process and be"
},
{
"path": "Documentation/usage/dlv_backend.md",
"chars": 2831,
"preview": "## dlv backend\n\nHelp about the --backend flag.\n\n### Synopsis\n\nThe --backend flag specifies which backend should be used,"
},
{
"path": "Documentation/usage/dlv_connect.md",
"chars": 880,
"preview": "## dlv connect\n\nConnect to a headless debug server with a terminal client.\n\n### Synopsis\n\nConnect to a running headless "
},
{
"path": "Documentation/usage/dlv_core.md",
"chars": 2114,
"preview": "## dlv core\n\nExamine a core dump.\n\n### Synopsis\n\nExamine a core dump (only supports linux and windows core dumps).\n\nThe "
},
{
"path": "Documentation/usage/dlv_dap.md",
"chars": 2526,
"preview": "## dlv dap\n\nStarts a headless TCP server communicating via Debug Adaptor Protocol (DAP).\n\n### Synopsis\n\nStarts a headles"
},
{
"path": "Documentation/usage/dlv_debug.md",
"chars": 2942,
"preview": "## dlv debug\n\nCompile and begin debugging main package in current directory, or the package specified.\n\n### Synopsis\n\nCo"
},
{
"path": "Documentation/usage/dlv_exec.md",
"chars": 2799,
"preview": "## dlv exec\n\nExecute a precompiled binary, and begin a debug session.\n\n### Synopsis\n\nExecute a precompiled binary and be"
},
{
"path": "Documentation/usage/dlv_log.md",
"chars": 3109,
"preview": "## dlv log\n\nHelp about logging flags.\n\n### Synopsis\n\nLogging can be enabled by specifying the --log flag and using the\n-"
},
{
"path": "Documentation/usage/dlv_redirect.md",
"chars": 2749,
"preview": "## dlv redirect\n\nHelp about file redirection.\n\n### Synopsis\n\nThe standard file descriptors of the target process can be "
},
{
"path": "Documentation/usage/dlv_replay.md",
"chars": 1964,
"preview": "## dlv replay\n\nReplays a rr trace.\n\n### Synopsis\n\nReplays a rr trace.\n\nThe replay command will open a trace generated by"
},
{
"path": "Documentation/usage/dlv_run.md",
"chars": 2268,
"preview": "## dlv run\n\nDeprecated command. Use 'debug' instead.\n\n```\ndlv run [flags]\n```\n\n### Options\n\n```\n -h, --help help for "
},
{
"path": "Documentation/usage/dlv_test.md",
"chars": 2879,
"preview": "## dlv test\n\nCompile test binary and begin debugging program.\n\n### Synopsis\n\nCompiles a test binary with optimizations d"
},
{
"path": "Documentation/usage/dlv_trace.md",
"chars": 2297,
"preview": "## dlv trace\n\nCompile and begin tracing program.\n\n### Synopsis\n\nTrace program execution.\n\nThe trace sub command will set"
},
{
"path": "Documentation/usage/dlv_version.md",
"chars": 2255,
"preview": "## dlv version\n\nPrints version.\n\n```\ndlv version [flags]\n```\n\n### Options\n\n```\n -h, --help help for version\n```\n\n### "
},
{
"path": "LICENSE",
"chars": 1079,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2014 Derek Parker\n\nPermission is hereby granted, free of charge, to any person obta"
},
{
"path": "Makefile",
"chars": 874,
"preview": ".DEFAULT_GOAL=test\n\nSHELL := /bin/bash\nGO_SRC := $(shell find . -type f -not -path './_fixtures/*' -not -path './vendor/"
},
{
"path": "README.md",
"chars": 1684,
"preview": "\n\n[![license](https://img.s"
},
{
"path": "_fixtures/amend_breakpoint.star",
"chars": 166,
"preview": "bp = get_breakpoint(0, \"afuncbreak\").Breakpoint\nbp.Stacktrace = 2\nbp.HitCond = \"== 2\"\namend_breakpoint(bp)\nbp2 = get_bre"
},
{
"path": "_fixtures/asmnilptr/main.go",
"chars": 102,
"preview": "package main\n\nimport \"fmt\"\n\nfunc asmFunc(*int) int\n\nfunc main() {\n\tfmt.Printf(\"%d\\n\", asmFunc(nil))\n}\n"
},
{
"path": "_fixtures/asmnilptr/main_386.s",
"chars": 109,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOVL arg+0(FP), AX\n\tMOVL (AX), AX\n\tMOVL AX, ret+4(FP)\n\tRET\n"
},
{
"path": "_fixtures/asmnilptr/main_amd64.s",
"chars": 109,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOVQ arg+0(FP), AX\n\tMOVQ (AX), AX\n\tMOVQ AX, ret+8(FP)\n\tRET\n"
},
{
"path": "_fixtures/asmnilptr/main_arm64.s",
"chars": 109,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOVD arg+0(FP), R5\n\tMOVD (R5), R5\n\tMOVD R5, ret+8(FP)\n\tRET\n"
},
{
"path": "_fixtures/asmnilptr/main_loong64.s",
"chars": 109,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOVV arg+0(FP), R5\n\tMOVV (R5), R5\n\tMOVV R5, ret+8(FP)\n\tRET\n"
},
{
"path": "_fixtures/asmnilptr/main_ppc64le.s",
"chars": 109,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOVD arg+0(FP), R5\n\tMOVD (R5), R5\n\tMOVD R5, ret+8(FP)\n\tRET\n"
},
{
"path": "_fixtures/asmnilptr/main_riscv64.s",
"chars": 105,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmFunc(SB),0,$0-16\n\tMOV arg+0(FP), R5\n\tMOV (R5), R5\n\tMOV R5, ret+8(FP)\n\tRET"
},
{
"path": "_fixtures/backwardsiter.go",
"chars": 354,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"iter\"\n)\n\nfunc backwards(s []int) func(func(int) bool) {\n\treturn func(yield func(int) boo"
},
{
"path": "_fixtures/badflags.go",
"chars": 192,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc g() {\n}\n\nfunc main() {\n\tg()\n\ta := os.Args[1] == \"1\"\n\tif a {\n\t\tfmt.Printf(\"tr"
},
{
"path": "_fixtures/binarytrees.go",
"chars": 1976,
"preview": "/* The Computer Language Benchmarks Game\n * http://benchmarksgame.alioth.debian.org/\n *\n * based on Go program by The Go"
},
{
"path": "_fixtures/bpcountstest.go",
"chars": 416,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"sync\"\n\t\"time\"\n)\n\nfunc demo(id int, wait *sync.WaitGroup) {\n\tfor i := 0; i <"
},
{
"path": "_fixtures/bpfile",
"chars": 69,
"preview": "# comment line\ntrace main.main\n\nbreak main.sayhi\n\n#\n# comment line\n#\n"
},
{
"path": "_fixtures/bphitcountchain.go",
"chars": 358,
"preview": "package main\n\nimport \"fmt\"\n\nfunc breakfunc1() {\n\tfmt.Println(\"breakfunc1\")\n}\n\nfunc breakfunc2() {\n\tfmt.Println(\"breakfun"
},
{
"path": "_fixtures/break/break_amd64.s",
"chars": 64,
"preview": "#include \"textflag.h\"\n\nTEXT ·asmBrk(SB),0,$0-0\n\tBYTE\t$0xcc\n\tRET\n"
},
{
"path": "_fixtures/break/main.go",
"chars": 62,
"preview": "package main\r\n\r\nfunc asmBrk()\r\n\r\nfunc main() {\r\n\tasmBrk()\r\n}\r\n"
},
{
"path": "_fixtures/break.go",
"chars": 81,
"preview": "package main\n\nfunc main() {\n\ti := 0\n\tfor {\n\t\ti++\n\t\tif i > 10 {\n\t\t\tbreak\n\t\t}\n\t}\n}\n"
},
{
"path": "_fixtures/buildflagtest.go",
"chars": 235,
"preview": "package main\n\nimport \"fmt\"\n\n// To be set via\n// go build -ldflags '-X main.Hello=World'\nvar Hello string\n\nfunc main() "
},
{
"path": "_fixtures/buildtest/__debug_bin2807893743",
"chars": 0,
"preview": ""
},
{
"path": "_fixtures/buildtest/main.go",
"chars": 73,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"hello world!\")\n}\n"
},
{
"path": "_fixtures/buildtest/main_test.go",
"chars": 196,
"preview": "package main\n\nimport (\n\t\"os\"\n\t\"testing\"\n)\n\nfunc TestMain(m *testing.M) {\n\tos.Exit(m.Run())\n}\n\nfunc TestCurrentDirectory("
},
{
"path": "_fixtures/callme.go",
"chars": 316,
"preview": "package main\n\nimport \"fmt\"\n\nfunc callme(i int) {\n\tfmt.Println(\"got:\", i)\n}\n\nconst nBytes = 10\nvar zeroarr [nBytes]byte\n\n"
},
{
"path": "_fixtures/cat.go",
"chars": 171,
"preview": "package main\n\nimport (\n\t\"bufio\"\n\t\"fmt\"\n\t\"os\"\n)\n\nfunc main() {\n\ts := bufio.NewScanner(os.Stdin)\n\tfor s.Scan() {\n\t\tfmt.Pri"
},
{
"path": "_fixtures/cgodisass.go",
"chars": 132,
"preview": "package main\n\n/*\nint a(int v) {\n\treturn 0xff + v;\n}\n*/\nimport \"C\"\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"aaa\")\n\tprint"
},
{
"path": "_fixtures/cgosigsegvstack.go",
"chars": 183,
"preview": "package main\n\n// #cgo CFLAGS: -g -Wall -O0\n/*\nvoid sigsegv(int x) {\n\tint *p = NULL;\n\t*p = x;\n}\nvoid testfn(int x) {\n\tsig"
},
{
"path": "_fixtures/cgostacktest/hello.c",
"chars": 651,
"preview": "#include <stdio.h>\n\n#include \"_cgo_export.h\"\n\n#ifdef __amd64__\n#define BREAKPOINT asm(\"int3;\")\n#elif __i386__\n#define BR"
},
{
"path": "_fixtures/cgostacktest/hello.h",
"chars": 97,
"preview": "#ifndef __HELLO_H__\n#define __HELLO_H__\n\nvoid helloworld(int);\nvoid helloworld_pt3(int);\n\n#endif\n"
},
{
"path": "_fixtures/cgostacktest/main.go",
"chars": 386,
"preview": "package main\n\n// #include \"hello.h\"\nimport \"C\"\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc main() {\n\truntime.Breakpoint()\n\tC.hel"
},
{
"path": "_fixtures/cgotest.go",
"chars": 214,
"preview": "package main\n\n/*\n#include <stdio.h>\nchar* foo(void) { return \"hello, world!\"; }\n*/\nimport \"C\"\n\nimport \"fmt\"\nimport \"runt"
},
{
"path": "_fixtures/chain_breakpoints.star",
"chars": 333,
"preview": "def command_chain(args):\n\tv = args.split(\" \")\n\t\n\tbp = get_breakpoint(int(v[0]), \"\").Breakpoint\n\tbp.HitCond = \"== 1\"\n\tame"
},
{
"path": "_fixtures/changoroutines.go",
"chars": 384,
"preview": "package main\n\nimport (\n\t\"runtime\"\n\t\"time\"\n)\n\nfunc main() {\n\tblockingchan1 := make(chan int)\n\tblockingchan2 := make(chan "
},
{
"path": "_fixtures/clientdo.go",
"chars": 120,
"preview": "package main\n\nimport (\n\t\"net/http\"\n\t\"net/url\"\n)\n\nfunc main() {\n\thttp.DefaultClient.Do(&http.Request{URL: &url.URL{}})\n}\n"
},
{
"path": "_fixtures/closurecontents.go",
"chars": 340,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc makeAcc(scale int) func(x int) int {\n\ta := 0\n\treturn func(x int) int {\n"
},
{
"path": "_fixtures/condframe.go",
"chars": 166,
"preview": "package main\n\nimport \"fmt\"\n\nfunc callme() {\n\tfor i := 0; i < 10; i++ {\n\t\tcallme2()\n\t}\n}\n\nfunc callme2() {\n\tfmt.Println(\""
},
{
"path": "_fixtures/condperghitcount.go",
"chars": 256,
"preview": "package main\n\nimport (\n\t\"sync\"\n\t\"time\"\n)\n\nfunc main() {\n\tvar wg sync.WaitGroup\n\twg.Add(2)\n\tfor i := 0; i < 2; i++ {\n\t\tgo"
},
{
"path": "_fixtures/consts.go",
"chars": 533,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"github.com/go-delve/delve/_fixtures/internal/dir0/pkg\"\n\t\"runtime\"\n)\n\ntype ConstType uint"
},
{
"path": "_fixtures/continuetestprog.go",
"chars": 181,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc sleepytime() {\n\ttime.Sleep(time.Millisecond)\n}\n\nfunc sayhi() {\n\tfmt.Printl"
},
{
"path": "_fixtures/coreemptystring.go",
"chars": 86,
"preview": "package main\n\nfunc main() {\n\ts := \"\"\n\tt := \"test\"\n\tpanic(\"panic!!!\")\n\tprintln(s, t)\n}\n"
},
{
"path": "_fixtures/create_breakpoint_main.star",
"chars": 269,
"preview": "def main():\n\tfor f in functions().Funcs:\n\t\tv = f.split('.')\n\t\tif len(v) != 2:\n\t\t\tcontinue\n\t\tif v[0] != \"main\":\n\t\t\tcontin"
},
{
"path": "_fixtures/databpcountstest.go",
"chars": 399,
"preview": "package main\n\nimport (\n\t\"math/rand\"\n\t\"sync\"\n\t\"time\"\n)\n\nvar globalvar1 int\n\nfunc demo(id int, wait *sync.WaitGroup) {\n\tfo"
},
{
"path": "_fixtures/databpeasy.go",
"chars": 948,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n\t\"sync\"\n\t\"time\"\n)\n\nvar globalvar1 = 0\nvar globalvar2 = 0\n\nfunc main() { // Posi"
},
{
"path": "_fixtures/databpstack.go",
"chars": 237,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t//\n)\n\nfunc f() {\n\tw := 0\n\n\tg(1000, &w) // Position 0\n}\n\nfunc g(cnt int, p *int) {\n\tif cnt"
},
{
"path": "_fixtures/debugdetect.go",
"chars": 314,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\n\t\"github.com/go-delve/delve/pkg/debugdetect\"\n)\n\nfunc main() {\n\tattached, err := deb"
},
{
"path": "_fixtures/decllinetest.go",
"chars": 141,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc main() {\n\ta := 0\n\ta++\n\tb := 0\n\tf1(a, b)\n}\n\nfunc f1(\n\ta int,\n\tb int,\n) {\n\tfmt.Print"
},
{
"path": "_fixtures/defercall.go",
"chars": 336,
"preview": "package main\n\nvar n = 0\n\nfunc sampleFunction() {\n\tn++\n}\n\nfunc callAndDeferReturn() {\n\tdefer sampleFunction()\n\tsampleFunc"
},
{
"path": "_fixtures/deferstack.go",
"chars": 270,
"preview": "package main\n\nimport \"runtime\"\n\nfunc f1() {\n}\n\nfunc f2(a int8, b int32) {\n}\n\nfunc f3() {\n}\n\nfunc call1() {\n\tdefer f2(1, "
},
{
"path": "_fixtures/delvecatch.go",
"chars": 136,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfor i, iface := range []any{12, \"test\", nil, 2.2, \"hello\", 7} {\n\t\tfmt.Println"
},
{
"path": "_fixtures/dotpackagesiface.go",
"chars": 317,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"github.com/go-delve/delve/_fixtures/internal/dir.io\"\n\t\"github.com/go-delve/delve/_fixtur"
},
{
"path": "_fixtures/doubleinline.go",
"chars": 362,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n\t\"strconv\"\n)\n\ntype Rectangle struct{}\n\nfunc (r *Rectangle) Height() int {\n\th, _"
},
{
"path": "_fixtures/dwzcompression.go",
"chars": 176,
"preview": "package main\n\n// #include <stdio.h>\n// void fortytwo()\n// {\n// fprintf(stdin, \"42\");\n// }\nimport \"C\"\nimport \"runtim"
},
{
"path": "_fixtures/ebpf_trace.go",
"chars": 148,
"preview": "package main\n\nimport \"fmt\"\n\nfunc callme(i int) int {\n\tif i == 0 {\n\t\treturn 100\n\t}\n\treturn callme(i - 1)\n}\n\nfunc main() {"
},
{
"path": "_fixtures/ebpf_trace2.go",
"chars": 259,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc main() {\n\ti := int64(0)\n\tfor i = 0; i < 5; i++ {\n\t\ttracedFunction(i)\n\t}\n\tf"
},
{
"path": "_fixtures/ebpf_trace3.go",
"chars": 359,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc main() {\n\tstr := \"abcdefghijklmnopqrstuvqxyz\"\n\ti := int64(0)\n\tfor i = 0; i"
},
{
"path": "_fixtures/echo_expr.star",
"chars": 63,
"preview": "def command_echo_expr(a, b, c):\n\tprint(\"a\", a, \"b\", b, \"c\", c)\n"
},
{
"path": "_fixtures/examinememory.go",
"chars": 308,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"unsafe\"\n)\n\nfunc main() {\n\tl := int(51)\n\tbs := make([]byte, l)\n\tfor i := 0; i < l; i++ {\n"
},
{
"path": "_fixtures/exit.init",
"chars": 5,
"preview": "exit\n"
},
{
"path": "_fixtures/fake-debuginfod-find/debuginfod-find",
"chars": 192,
"preview": "#!/bin/bash\n\nif [ \"$1\" == \"--help\" ]; then\n\texit 0\nfi\n\nfor i in $(seq 1 100000 1000000); do\n\techo \"Downloading $i...\" >&"
},
{
"path": "_fixtures/fatalerror.go",
"chars": 52,
"preview": "package main\n\nfunc main() {\n\tvar f func()\n\tgo f()\n}\n"
},
{
"path": "_fixtures/find_array.star",
"chars": 394,
"preview": "def command_find_array(arr, pred):\n\t\"\"\"Calls pred for each element of the array or slice 'arr' returns the index of the "
},
{
"path": "_fixtures/fncall.go",
"chars": 5470,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"runtime\"\n\t\"strings\"\n)\n\nvar call = \"this is a variable named `call`\"\n\nfunc callstac"
},
{
"path": "_fixtures/fputest/fputest.go",
"chars": 697,
"preview": "package main\n\nimport (\n\t\"os\"\n\t\"runtime\"\n)\n\nfunc fputestsetup(f64a, f64b, f64c, f64d float64, f32a, f32b, f32c, f32d floa"
},
{
"path": "_fixtures/fputest/fputest_amd64.s",
"chars": 1679,
"preview": "TEXT ·fputestsetup(SB),$0-50\n\t// setup x87 stack\n\tFMOVD f64a+0(FP), F0\n\tFMOVD f64b+8(FP), F0\n\tFMOVD f64c+16(FP), F0\n\tFMO"
},
{
"path": "_fixtures/genericbp.go",
"chars": 134,
"preview": "package main\n\nimport \"fmt\"\n\nfunc testfn[T any](arg T) {\n\tfmt.Println(arg)\n}\n\nfunc main() {\n\ttestfn[uint16](1)\n\ttestfn[fl"
},
{
"path": "_fixtures/genericintoiface.go",
"chars": 235,
"preview": "package main\n\nimport \"fmt\"\n\ntype Blah[T any] struct {\n\tx T\n}\n\nfunc (b *Blah[T]) F(y T) {\n\tb.x = y\n}\n\ntype BlahInt interf"
},
{
"path": "_fixtures/godlopen/golib/golib.go",
"chars": 101,
"preview": "package main\n\nimport \"C\"\n\n//export GoFunction\nfunc GoFunction() int32 {\n\treturn 42\n}\n\nfunc main() {}\n"
},
{
"path": "_fixtures/godlopen/main.c",
"chars": 650,
"preview": "#include <dlfcn.h>\n#include <stdio.h>\n#include <stdlib.h>\n\nint main(int argc, char **argv) {\n if (argc < 2) {\n "
},
{
"path": "_fixtures/goroutineLabels.go",
"chars": 307,
"preview": "package main\n\nimport (\n\t\"context\"\n\t\"runtime\"\n\t\"runtime/pprof\"\n)\n\nfunc main() {\n\tctx := context.Background()\n\tlabels := p"
},
{
"path": "_fixtures/goroutine_start_line.star",
"chars": 444,
"preview": "def command_goroutine_start_line(args):\n\t\"prints the line of source code that started each currently running goroutine\"\n"
},
{
"path": "_fixtures/goroutinebreak.go",
"chars": 425,
"preview": "package main\n\nimport \"runtime\"\n\nconst N = 10\n\nfunc agoroutine(started chan<- struct{}, done chan<- struct{}, i int) {\n\ts"
},
{
"path": "_fixtures/goroutinegroup.go",
"chars": 1632,
"preview": "package main\n\nimport (\n\t\"context\"\n\t\"runtime\"\n\t\"runtime/pprof\"\n\t\"sync\"\n\t\"time\"\n)\n\nfunc sleepyfunc(wg *sync.WaitGroup, lbl"
},
{
"path": "_fixtures/goroutines-trace.go",
"chars": 450,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"sync\"\n)\n\nfunc callme(i int, s string) int {\n\tfmt.Println(s)\n\treturn i * i\n}\n\nfunc dostuf"
},
{
"path": "_fixtures/goroutinestackprog.go",
"chars": 610,
"preview": "package main\n\nimport \"runtime\"\n\nconst N = 10\n\nfunc agoroutine(started chan<- struct{}, done chan<- struct{}, i int) {\n\ts"
},
{
"path": "_fixtures/hcbpcountstest.go",
"chars": 450,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"runtime\"\n\t\"sync\"\n\t\"time\"\n)\n\nfunc demo(id int, wait *sync.WaitGroup) {\n\tfor "
},
{
"path": "_fixtures/http_server.go",
"chars": 198,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"net/http\"\n)\n\nfunc main() {\n\thttp.HandleFunc(\"/\", func(w http.ResponseWriter, r *http.Req"
},
{
"path": "_fixtures/ifaceembcall.go",
"chars": 376,
"preview": "package main\n\nimport \"fmt\"\n\ntype A struct {\n\ta int\n}\n\ntype B struct {\n\t*A\n}\n\ntype Iface interface {\n\tPtrReceiver() strin"
},
{
"path": "_fixtures/increment.go",
"chars": 230,
"preview": "package main\n\nimport \"fmt\"\n\n// Increment Natural number y\nfunc Increment(y uint) uint {\n\tif y == 0 {\n\t\treturn 1\n\t}\n\tif y"
},
{
"path": "_fixtures/inlinestripped.go",
"chars": 166,
"preview": "package main\n\nimport \"fmt\"\n\nfunc callme(i int) int {\n\treturn i * i\n}\n\nfunc main() {\n\tj := 0\n\tj += callme(2)\n\tfmt.Println"
},
{
"path": "_fixtures/integrationprog.go",
"chars": 192,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc sayhi() {\n\tfmt.Println(\"hi\")\n}\n\nfunc main() {\n\ttime.Sleep(1 * time.Second)"
},
{
"path": "_fixtures/internal/dir.io/dir.go",
"chars": 124,
"preview": "package dirio\n\ntype SomeType struct {\n\tX int\n}\n\nvar A string = \"something\"\n\nfunc SomeFunction() {\n\tprintln(\"hello world\""
},
{
"path": "_fixtures/internal/dir.io/io.io/io.go",
"chars": 51,
"preview": "package ioio\n\ntype SomeOtherType struct {\n\tY int\n}\n"
},
{
"path": "_fixtures/internal/dir0/pkg/main.go",
"chars": 232,
"preview": "package pkg\n\nvar A = 0\n\ntype SomeType struct {\n\tX float64\n}\n\nfunc (s *SomeType) AMethod(x int) int {\n\treturn x + 3\n}\n\nfu"
},
{
"path": "_fixtures/internal/dir0/renamedpackage/main.go",
"chars": 51,
"preview": "package realname\n\ntype SomeType struct {\n\tA bool\n}\n"
},
{
"path": "_fixtures/internal/dir1/pkg/main.go",
"chars": 63,
"preview": "package pkg\n\nvar A = 1\n\ntype SomeType struct {\n\tX int\n\tY int\n}\n"
},
{
"path": "_fixtures/internal/pluginsupport/pluginsupport.go",
"chars": 134,
"preview": "package pluginsupport\n\ntype Something interface {\n\tCallback(int) int\n}\n\ntype SomethingElse interface {\n\tCallback2(int, i"
},
{
"path": "_fixtures/is sue239.go",
"chars": 359,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\nfunc fibonacci(n int, c chan int) {\n\tx, y := 0, 1\n\tfor i := 0; i < n; i++ {\n\t\tc <- x\n\t\t"
},
{
"path": "_fixtures/issue1101.go",
"chars": 182,
"preview": "package main\n\nimport (\n\t\"os\"\n\t\"sync\"\n)\n\nvar wg sync.WaitGroup\n\nfunc f(from string) {\n\tdefer wg.Done()\n\treturn\n}\n\nfunc ma"
},
{
"path": "_fixtures/issue1264.go",
"chars": 157,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfor i := 0; i < 4; i++ {\n\t\tequalsTwo := i == 2\n\t\tfmt.Printf(\"i: %d -> equalsT"
},
{
"path": "_fixtures/issue1374.go",
"chars": 108,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\ti := getNum()\n\tfmt.Println(i)\n}\n\nfunc getNum() int {\n\treturn 0\n}\n"
},
{
"path": "_fixtures/issue1432.go",
"chars": 151,
"preview": "package main\n\nimport \"runtime\"\n\ntype s struct {\n\ti int64\n}\n\nfunc main() {\n\ti := 1\n\tp := &i\n\ts := s{i: 1}\n\t_ = s\n\truntime"
},
{
"path": "_fixtures/issue1469.go",
"chars": 162,
"preview": "package main\n\nimport \"time\"\n\nfunc main() {\n\tfor i := 0; i < 5; i++ {\n\t\tgo func() {\n\t\t\ttime.Sleep(11 * time.Millisecond)\n"
},
{
"path": "_fixtures/issue1531.go",
"chars": 354,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\ntype W struct {\n\tx int\n\ty int\n}\n\nfunc main() {\n\ttestMaps()\n}\n\nfunc testMaps("
},
{
"path": "_fixtures/issue1549.go",
"chars": 240,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc main() {\n\tsum := int64(0)\n\tstart := time.Now()\n\tfor value := int64(0); val"
},
{
"path": "_fixtures/issue1598.go",
"chars": 546,
"preview": "package main\n\nfunc main() {\n\ta := x()\n\tprintln(a) //break here\n}\n\nfunc x() string {\n\treturn `Lorem ipsum dolor sit amet,"
},
{
"path": "_fixtures/issue1601.go",
"chars": 178,
"preview": "package main\n\nimport (\n\t\"runtime\"\n)\n\n/*\ntypedef struct Qst Q1;\ntypedef const Q1 Q;\nstruct Qst {\n\tQ *q;\n};\n\nconst Q1 glob"
},
{
"path": "_fixtures/issue1615.go",
"chars": 264,
"preview": "package main\n\nvar strings = []string{\n\t\"one\",\n\t\"two\",\n\t\"three\",\n\t\"four\",\n\t\"projects/my-gcp-project-id-string/locations/u"
},
{
"path": "_fixtures/issue1656/main.go",
"chars": 168,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\nvar g int = 0\n\nfunc compromised(n int64)\n\n//go:nosplit\nfunc skipped() {\n\tg++\n}\n\nfunc ma"
},
{
"path": "_fixtures/issue1656/main.s",
"chars": 158,
"preview": "#include \"textflag.h\"\n\nTEXT ·compromised(SB),NOSPLIT,$0-8\n\tCMPQ n+0(FP), $0\n\tJNZ notzero\n\tRET\nnotzero:\n\tMOVQ $0, AX\n\tMOV"
},
{
"path": "_fixtures/issue1795.go",
"chars": 178,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"regexp\"\n\t\"runtime\"\n)\n\nfunc main() {\n\tr := regexp.MustCompile(\"ab\")\n\truntime.Breakpoint()"
},
{
"path": "_fixtures/issue1817.go",
"chars": 255,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n\t\"unsafe\"\n)\n\nfunc main() {\n\tl := int(51)\n\tbs := make([]byte, l)\n\tfor i := 0; i "
},
{
"path": "_fixtures/issue2023.go",
"chars": 222,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"time\"\n)\n\nfunc A() {\n\tfmt.Printf(\"hello delve\\n\")\n}\n\nfunc main() {\n\tcount := 0\n\tfor {\n\t\tA"
},
{
"path": "_fixtures/issue2078.go",
"chars": 94,
"preview": "package main\n\nfunc main() {\n\tf(nil) //break\n\tprintln(\"ok\")\n}\n\nfunc f(x *int) {\n\tprintln(*x)\n}\n"
},
{
"path": "_fixtures/issue2086.go",
"chars": 160,
"preview": "package main\n\nimport (\n\t\"runtime\"\n)\n\nvar i int\n\ntype T struct{}\n\nfunc (t T) m() { stop() }\n\nfunc stop() {\n\truntime.Break"
},
{
"path": "_fixtures/issue2113.go",
"chars": 460,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n\t\"sync\"\n)\n\nfunc coroutine(i int, start, finish *sync.WaitGroup) {\n\tdefer finish"
},
{
"path": "_fixtures/issue2138.go",
"chars": 88,
"preview": "package main\n\nimport (\n\t\"time\"\n)\n\nfunc main() {\n\ttime.Sleep(time.Hour)\n\tprintln(\"ok\")\n}\n"
},
{
"path": "_fixtures/issue2162.go",
"chars": 69,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"test dlv\")\n}\n"
},
{
"path": "_fixtures/issue2319/README.txt",
"chars": 1201,
"preview": "\nNote:\n-----\n\ncfile-linux-amd64.syso was generated from the C source file that appears below.\n\nBuild with Clang version "
},
{
"path": "_fixtures/issue2319/asm-linux-amd64.s",
"chars": 65,
"preview": "\n#include \"textflag.h\"\n\nTEXT ·cfunc(SB),$0\n JMP Cfunc(SB)\n"
},
{
"path": "_fixtures/issue2319/main.go",
"chars": 53,
"preview": "package main\n\nfunc cfunc()\n\nfunc main() {\n\tcfunc()\n}\n"
},
{
"path": "_fixtures/issue262.go",
"chars": 197,
"preview": "package main\n\nimport \"fmt\"\n\nfunc typicalFunction() (res int) {\n\tdefer func() {\n\t\tres = 2\n\t\treturn\n\t}()\n\tres = 10\n\treturn"
},
{
"path": "_fixtures/issue2896.go",
"chars": 357,
"preview": "package main\n\n// Vehicle defines the vehicle behavior\ntype Vehicle interface {\n\t// Run vehicle can run in a speed\n\tRun()"
},
{
"path": "_fixtures/issue305.go",
"chars": 73,
"preview": "package main\n\nfunc main() {\n\tfor i := 0; i < 10; i++ {\n\t\tprintln(i)\n\t}\n}\n"
},
{
"path": "_fixtures/issue3194.go",
"chars": 226,
"preview": "package main\n\n/*\n#cgo LDFLAGS: -framework CoreFoundation\n#cgo LDFLAGS: -framework CFNetwork\n#include <CFNetwork/CFProxyS"
},
{
"path": "_fixtures/issue3310.go",
"chars": 219,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n)\n\nvar i = 2\nvar val = reflect.ValueOf(i)\n\nfunc reflectFunc(value reflect.Value"
},
{
"path": "_fixtures/issue332.go",
"chars": 206,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tm := make([]string, 1, 25)\n\tfmt.Println(m) // [ ]\n\tchangeMe(m)\n\tfmt.Println(m"
},
{
"path": "_fixtures/issue3548.go",
"chars": 378,
"preview": "package main\n\nimport (\n\t\"fmt\"\n)\n\ntype Thing struct {\n\tstr string\n}\n\nfunc (d *Thing) Test() bool {\n\treturn d != nil\n}\n\nfu"
},
{
"path": "_fixtures/issue384.go",
"chars": 244,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"reflect\"\n)\n\nfunc main() {\n\ttype S struct {\n\t\tF string `species:\"gopher\" color:\"blue\"`\n\t}"
},
{
"path": "_fixtures/issue387.go",
"chars": 273,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"sync\"\n)\n\nfunc dostuff(id int, wg *sync.WaitGroup) {\n\tfmt.Println(\"goroutine:\", id)\n\tfmt."
},
{
"path": "_fixtures/issue4000.go",
"chars": 185,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tvar test = \"a string\"\n\tvar f = func() {\n\t\ttest = \"another string\"\n\t\tfmt.Print"
},
{
"path": "_fixtures/issue4051.go",
"chars": 555,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nvar os = func() func() {\n\ta := 1\n\treturn func() {\n\t\tfmt.Println(a)\n\t\ta++\n\t}\n"
},
{
"path": "_fixtures/issue406.go",
"chars": 7312,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"log\"\n\t\"regexp\"\n\t\"strings\"\n\n\t//\t\"golang.org/x/crypto/ssh/terminal\"\n)\n\n// Blacklist type i"
},
{
"path": "_fixtures/issue4116.go",
"chars": 2220,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\ntype A struct {\n}\n\nfunc (a *A) Model() string {\n\treturn \"A\"\n}\n\ntype B struct"
},
{
"path": "_fixtures/issue419.go",
"chars": 280,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"os/signal\"\n)\n\nfunc main() {\n\n\tfmt.Println(\"Start\")\n\n\tsc := make(chan os.Signal, 1)"
},
{
"path": "_fixtures/issue528.go",
"chars": 140,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"github.com/go-delve/liner\"\n)\n\nfunc main() {\n\tline := liner.NewLiner()\n\tline.Close()\n\tfmt"
},
{
"path": "_fixtures/issue561.go",
"chars": 108,
"preview": "package main\n\nimport \"fmt\"\n\nfunc testfunction() {\n\tfmt.Printf(\"here!\\n\")\n}\n\nfunc main() {\n\ttestfunction()\n}\n"
},
{
"path": "_fixtures/issue573.go",
"chars": 602,
"preview": "package main\n\n// A debugger test.\n// dlv debug\n// b main.foo\n// c\n// s\n// s\n// Expect to be stopped in fmt.Pri"
},
{
"path": "_fixtures/issue594.go",
"chars": 235,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc dontsegfault() {\n\tvar p *int\n\tfunc() int {\n\t\tdefer func() {\n\t\t\trecover("
},
{
"path": "_fixtures/issue664.go",
"chars": 140,
"preview": "package main\n\nfunc asdfasdf() {\n\tfor i := 0; i < 5; i++ {\n\t\tfor i := 0; i < 5; i++ {\n\t\t\t//...\n\t\t}\n\t\t//...\n\t}\n}\n\nfunc mai"
},
{
"path": "_fixtures/issue683.go",
"chars": 91,
"preview": "package main\n\nimport \"fmt\"\n\nfunc main() {\n\tfmt.Println(\"adssd\") // put a breakpoint here\n}\n"
},
{
"path": "_fixtures/issue871.go",
"chars": 156,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc main() {\n\ta := [3]int{1, 2, 3}\n\tb := &a\n\truntime.Breakpoint()\n\tfmt.Prin"
},
{
"path": "_fixtures/issue877.go",
"chars": 153,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"runtime\"\n)\n\nfunc main() {\n\tdyldenv := os.Getenv(\"DYLD_LIBRARY_PATH\")\n\truntime.Brea"
},
{
"path": "_fixtures/issue951.go",
"chars": 268,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc main() {\n\tshadow(42)\n}\n\nfunc shadow(i int) {\n\tfor i := 0; i < 5; i++ {\n"
},
{
"path": "_fixtures/leaf4.go",
"chars": 252,
"preview": "package main\n\nimport \"fmt\"\n\nfunc D(i int) int {\n\treturn i * i * i\n}\nfunc C(i int) int {\n\n\treturn i + 20\n}\nfunc B(i int) "
},
{
"path": "_fixtures/leafcommon.go",
"chars": 257,
"preview": "package main\n\nimport \"fmt\"\n\nfunc D(i int) int {\n\treturn i * i * i\n}\nfunc C(i int) int {\n\n\treturn D(i+10) + 20\n}\nfunc B(i"
},
{
"path": "_fixtures/leafindrec.go",
"chars": 233,
"preview": "package main\n\nimport \"fmt\"\n\nfunc B(i int) int {\n\tif i > 0 {\n\t\treturn A(i - 1)\n\t} else {\n\t\treturn 0\n\t}\n}\nfunc A(n int) in"
},
{
"path": "_fixtures/leafrec.go",
"chars": 179,
"preview": "package main\n\nimport \"fmt\"\n\nfunc A(i int, n int) int {\n\tif n == 1 {\n\t\treturn i\n\t} else {\n\t\tn--\n\t\treturn (i * A(i-1, n))\n"
},
{
"path": "_fixtures/leafregex.go",
"chars": 298,
"preview": "package main\n\nimport \"fmt\"\n\nfunc callmed(i int) int {\n\treturn i * i * i\n}\nfunc callmee(i int) int {\n\n\treturn i + 20\n}\nfu"
},
{
"path": "_fixtures/linked_list.star",
"chars": 513,
"preview": "def command_linked_list(args):\n\t\"\"\"Prints the contents of a linked list.\n\t\n\tlinked_list <var_name> <next_field_name> <ma"
},
{
"path": "_fixtures/livetestprog.go",
"chars": 283,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"os\"\n\t\"runtime\"\n\t\"time\"\n)\n\nfunc printPid(pid int) {\n\tfmt.Println(pid)\n}\n\nfunc sayhi() {\n\t"
},
{
"path": "_fixtures/locationsUpperCase.go",
"chars": 72,
"preview": "package main\r\n\r\nimport \"fmt\"\r\n\r\nfunc main() {\r\n\tfmt.Println(\"test\")\r\n}\r\n"
},
{
"path": "_fixtures/locationsprog.go",
"chars": 689,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"io/ioutil\"\n)\n\ntype SomeType struct {\n}\n\ntype OtherType struct {\n}\n\nfunc (a *SomeType) St"
},
{
"path": "_fixtures/locationsprog2.go",
"chars": 411,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"runtime\"\n)\n\nfunc afunction(s string) {\n\tfmt.Println(s)\n}\n\ntype someStruct struct {\n\ts st"
},
{
"path": "_fixtures/locationsprog3.go",
"chars": 123,
"preview": "package main\n\nimport (\n\t\"fmt\"\n\t\"math/rand\"\n\t\"runtime\"\n)\n\nfunc main() {\n\truntime.Breakpoint()\n\tfmt.Println(rand.Intn(10))"
},
{
"path": "_fixtures/locationsprog_generic.go",
"chars": 345,
"preview": "package main\n\nimport \"fmt\"\n\ntype ParamReceiver[T any] struct {\n\tfield T\n}\n\nfunc (r *ParamReceiver[T]) Amethod() {\n\tfmt.P"
}
]
// ... and 1251 more files (download for full content)
About this extraction
This page contains the full source code of the go-delve/delve GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1451 files (18.0 MB), approximately 4.0M tokens, and a symbol index with 92373 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.