How to debug golang linux

Go language is a high-level programming language published for more convenient and faster development. It can not only run on multiple operating systems such as Windows, MacOS and Linux, but also provides powerful debugging tools. Help developers solve problems. This article will introduce how to debug Go language programs on Linux systems.

Debugging Tools

The Go language provides a built-in debugger - go debug, but the efficient features of Go also bring many debugging challenges. Dlv (https://github.com/go-delve/delve) is a modern debugger for the Go language that supports Go-specific debugging features. Dlv provides common debugging functions such as single-step tracing, viewing variables, modifying variables, and breakpoints. In addition, GDB also supports Go language debugging, but it cannot understand the Go language scheduler, so it is more suitable for kernel development or program debugging that only needs to use a few Go-specific functions.

Installing Dlv

Dlv is written in Go language, so installing it requires installing the Go language itself first. You can download the latest version of the Go language installation package from the official website (https://golang.org/dl/) and configure it into the environment variables.

After installing the Go language, we need to first install the library that Dlv depends on - dynamically linked Linux utilities:

sudo apt-get update
sudo apt-get install linux-tools-common linux-tools-generic linux-tools-`uname -r`

Then execute the following command to install Dlv:

go get -u github.com/go-delve/delve/cmd/dlv

The above command Install Dlv into the $GOPATH/bin directory, you can add it to the PATH variable manually, or you can add it to the PATH with the following command:

echo "export PATH=$PATH:$(go env GOPATH)/bin" >> ~/.bashrc
source ~/.bashrc

Compile Debugger

We need Enter the directory where the program is located, use go build to compile the program and generate a binary file. Assuming that our program is named debug-demo, we can compile it with the following command:

go build -gcflags "-N -l" -o debug-demo

• -gcflags "-N -l": Add the compilation flag to ensure that the compiler will not optimize the code, thus Convenient for debugging.
• -o debug-demo: Name the generated executable file debug-demo.

In order to solve the problem of source code being assembled, we can also use the go env command to get the value of CGO_ENABLED, set it to 0, and then compile again:

go env
go build -gcflags "-N -l" -o debug-demo -tags netgo -ldflags '-w -extldflags "-static"' -v main.go

Set break Click

Setting breakpoints in the program is the most commonly used operation during debugging. We can set a breakpoint anywhere in the code to wait until the program execution reaches that location.

Using Dlv, you can set breakpoints in the following two ways:

1. Graphic interface (recommended)

Using Dlv's graphical interface can be more intuitive Manipulate and modify programs. Execute the following command, and then the graphical interface will automatically open:

dlv debug ./debug-demo

2. Command line

Execute the following command to enter the Dlv command line mode:

dlv debug ./debug-demo --headless --listen=:2345 --api-version=2

Enter Dlv After that, we can use the break (or abbreviated as b) command to set a breakpoint:

(b)reak {<location>|<function>|<filename>:<line>|<remote package path>}: 设置断点
(b)reakpoints: 显示当前所有的断点
(d)elete {<breakpoint#>|<breakpoint.id>}: 删除断点#或通过Breakpoint.id删除指定断点
(c)ontinue: 从当前位置继续执行程序，直到下一个断点或程序完结

For example, we can set a breakpoint on line 10 of the program:

(b)reak main.go:10

Control the program running

During the running of the program, you can use the step (or abbreviated as s) and next (or abbreviated as n) commands to control the program running:

(s)tep: 单步调试，如果当前位置是函数，则进入该函数内部
(n)ext: 单步调试，如果当前位置是函数，则不进入该函数内部

View variables

Dlv is also provided In order to display the variable command, use the print (or abbreviated as p) command to view the variables in the current scope:

(p)rint <variable>: 显示变量

For example, we can use the following command to view variable a and variable b:

(p)rint a
(p)rint b

Modify variables

In addition to viewing variables, Dlv also supports modifying the value of variables. Use the set command to modify the value of variables:

(s)et <variable> = <value>: 修改变量的值

For example, we can use the following command to set the value of variable a Modified to 100:

(s)et a = 100

Summary

This article introduces how to use Dlv to debug Go programs on Linux systems. First, we installed the Go language and Dlv debugger, then used go build to compile the program and set breakpoints in the program, used Dlv's graphical interface or command line to control the program to run, and view and modify the values ​​of variables to solve Go Problems encountered during program debugging. I hope that through this article, readers can master the basic skills of using Dlv to debug Go programs under Linux systems.

The above is the detailed content of How to debug golang linux. For more information, please follow other related articles on the PHP Chinese website!