首页 > 其他分享 >使用 gdb 工具调试 Go

使用 gdb 工具调试 Go

时间:2023-02-22 14:36:32浏览次数:45  
标签:src sandbox go gdb bfosberry Go main 调试

排除应用程序故障是比较复杂的,特别是处理像 Go 这样的高并发语言。它更容易在具体位置使用 print 打印语句来确定程序状态,但是 这个方法 很难根据条件发展去动态响应 你的代码 。

调试器提供了一个强大得令人难以置信的故障排除机制。添加排除故障的代码可以巧妙地影响到应用程序该如何运行。调试器可以给正在迷茫的你更精确的看法。

已经有许多 Go 的调试器存在了,其中一些调试器的不好之处是通过在编译时注入代码来提供一个交互终端。gdb 调试器则允许你调试已经编译好的二进制文件,只要他们已经与 debug 信息连接,并不用修改源代码。这是个相当不错的特性,因此你可以从你的部署环境中取一个产品然后灵活地调试它。你可以从 Golang 官方文档 中阅读更多关于 gdb 的信息,那么这篇指南将简单讲解使用 gdb 调试器来调试 Go 应用程序的基本用法。

这儿会宣布一些 gdb 的最新更新 ,最特别的是替换 -> 操作为 . 符号来访问对象属性。记住这儿可能在gdb 和 Go 版本中有细微改变。本篇指南基于 gdb 7.7.1和go 1.5beta2。

开始 gdb 调试

为了实验 gdb 我使用了一个测试程序,完整的源代码可以在 gdb_sandbox_on_Github 上查看。让我们从一个非常简单的程序开始吧:


  1. package main
  2. import (
  3. "fmt"
  4. )
  5. func main() {
  6. for i := 0 ; i < 5 ; i++ {
  7. fmt.Println( "looping" )
  8. }
  9. fmt.Println( "Done" )
  10. }

我们可以运行这段代码并看到它输出内容的和我们想象的一样:


  1. $ go run main.go
  2. looping
  3. looping
  4. looping
  5. looping
  6. looping
  7. Done

我们来调试这个程序吧。首先,使用 go build 编译成二进制文件,接着使用这个二进制文件的路径做为参数运行 gdb 。根据你的设定,你也可以使用 source 命令来获取 Go 运行时(Go runtime)的支持。现在我们已经在 gdb 的命令行中了,我们可以在运行我们的二进制文件前为它设置断点。

go build -gcflags "-N -l" -ldflags=-compressdwarf=false main.go


  1. $ go build -gcflags "-N -l" -o gdb_sandbox main.go
  2. $ ls
  3. gdb_sandbox  main.go  README.md
  4. $ gdb gdb_sandbox
  5. ....
  6. (gdb) source /usr/local/src/go/src/runtime/runtime-gdb.py
  7. Loading Go Runtime support.

第一关,我们在 for 循环里面设置一个断点(b)来查看执行每次循环时我们的代码会各有什么状态。我们可以使用print(p)命令来检查当前内容的一个变量,还有 list(l)和 backtrace(bt)命令查看当前步骤周围的代码。程序运行时可以使用 next(n)执行下一步或者使用 breakpoint(c)执行到下一个断点。


  1. (gdb) b main.go: 9
  2. Breakpoint 1 at 0x400d35 : file /home/bfosberry/workspace/gdb_sandbox/main.go, line 9 .
  3. (gdb) run
  4. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox Breakpoint 1 , main.main () at
  5. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 9
  6. 9 fmt.Println( "looping" )
  7. (gdb) l
  8. 4 "fmt"
  9. 5 )
  10. 6
  11. 7 func main() {
  12. 8 for i := 0 ; i < 5 ; i++ {
  13. 9 fmt.Println( "looping" )
  14. 10 }`
  15. 11 fmt.Println( "Done" )
  16. 12 }
  17. (gdb) p i
  18. $ 1 = 0
  19. (gdb) n
  20. looping
  21. Breakpoint 1 , main.main () at
  22. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 9
  23. 9 fmt.Println( "looping" )
  24. (gdb) p i
  25. $ 2 = 1
  26. (gdb) bt
  27. # 0 main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 9

我们的断点可以设置在关联文件的行号中、 GOPATH 里的文件的行号或一个包里的函数。如下也是一个有效的断点:


  1. (gdb) b github.com/bfosberry/gdb_sandbox/main.go: 9
  2. (gdb) b 'main.main'

Structs

我们可以用稍微复杂一点的代码来实例演示如何调试。我们将使用 函数生成一个简单的pair,x和y,当x相等时y=f(x),否则=x。


  1. type pair struct {
  2. x int
  3. y int
  4. }
  5. func handleNumber(i int ) *pair {
  6. val := i
  7. if i% 2 == 0 {
  8. val = f(i)
  9. }
  10. return &pair{
  11. x: i,
  12. y: val,
  13. }
  14. }
  15. func f( int x) int {
  16. return x*x + x
  17. }

也可以在循环中改变代码来访问这些新函数。


  1. p := handleNumber(i)
  2. fmt.Printf( "%+v/n" , p)
  3. fmt.Println( "looping" )

因为我们需要调试的是变量 。我们可以在 被设置的地方放置断点然后单步执行。可以使用 info args 查看函数的参数,在 bt 之前可以返回当前回溯。


  1. (gdb) b 'main.f'
  2. (gdb) run
  3. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox
  4. Breakpoint 1 , main.f (x= 0 , ~anon1= 833492132160 )
  5. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
  6. 33 return x*x + x
  7. (gdb) info args
  8. x = 0
  9. (gdb) continue
  10. Breakpoint 1 , main.f (x= 0 , ~anon1= 833492132160 )
  11. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
  12. 33 return x*x + x
  13. (gdb) info args
  14. x = 2
  15. (gdb) bt
  16. # 0 main.f (x= 2 , ~anon1= 1 )
  17. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
  18. # 1 0x0000000000400f0e in main.handleNumber (i= 2 , ~anon1= 0x1 )
  19. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 24
  20. # 2 0x0000000000400c47 in main.main ()
  21. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 14

因为我们在变量 y 是在函数 f 中被设定的这样一个条件下,我们可以跳到这个函数的上下文并检查堆区的代码。应用运行时我们可以在一个更高的层次上设置断点并检查其状态。


  1. (gdb) b main.go: 26
  2. Breakpoint 2 at 0x400f22 : file
  3. /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 26 .
  4. (gdb) continue
  5. Continuing.
  6. Breakpoint 2 , main.handleNumber (i= 2 , ~anon1= 0x1 )
  7. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 28
  8. 28 y: val,
  9. (gdb) l
  10. 23 if i% 2 == 0 {
  11. 24 val = f(i)
  12. 25 }
  13. 26 return &pair{
  14. 27 x: i,
  15. 28 y: val,
  16. 29 }
  17. 30 }
  18. 31
  19. 32 func f(x int ) int {
  20. (gdb) p val
  21. $ 1 = 6
  22. (gdb) p i
  23. $ 2 = 2

如果我们在这个断点处继续住下走我们将越过在这个函数中的断点1,而且将立即触发在 HandleNumer 函数中的断点,因为函数 f 只是对变量 i 每隔一次才执行。我们可以通过暂时使断点 2不工作来避免这种情况的发生。


  1. (gdb) disable breakpoint 2
  2. (gdb) continue
  3. Continuing.
  4. &{x: 2 y: 6 }
  5. looping
  6. &{x: 3 y: 3 }
  7. looping
  8. [New LWP 15200 ]
  9. [Switching to LWP 15200 ]
  10. Breakpoint 1 , main.f (x= 4 , ~anon1= 1 )
  11. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
  12. 33 return x*x + x
  13. (gdb)

我们也可以分别使用 clear 和 delete breakpoint NUMBER 来清除和删除断点。动态产生和系住断点,我们可以有效地在应用流中来回移动。

Slices and Pointers

上例程序太简单了,只用到了整数型和字符串,所以我们将写一个稍微复杂一点的。首先添加一个slice(切片类型)的指针到 main 函数,并保存生成的 pair,我们后面将用到它。


  1. var pairs []*pair
  2. for i := 0 ; i < 10 ; i++ {
  3. p := handleNumber(i)
  4. fmt.Printf( "%+v/n" , p)
  5. pairs = append(pairs, p)
  6. fmt.Println( "looping" )
  7. }

现在我们来检查生成出来的 slice 或 pairs,首先我们用转换成数组来看一下这个 slice。因为 handleNumber 返回的是一个 *pair 类型,我们需要引用这个指针来访问 struct(结构)的属性。


  1. (gdb) b main.go: 18
  2. Breakpoint 1 at 0x400e14 : file /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 18 .
  3. (gdb) run
  4. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox &{x: 0 y: 0 }
  5. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
  6. 18 fmt.Println( "looping" )
  7. (gdb) p pairs
  8. $ 1 = []*main.pair = { 0xc82000a3a0 }
  9. (gdb) p pairs[ 0 ]
  10. Structure has no component named operator[].
  11. (gdb) p pairs.array
  12. $ 2 = (struct main.pair **) 0xc820030028
  13. (gdb) p pairs.array[ 0 ]
  14. $ 3 = (struct main.pair *) 0xc82000a3a0
  15. (gdb) p *pairs.array[ 0 ]
  16. $ 4 = {x = 0 , y = 0 }
  17. (gdb) p (*pairs.array[ 0 ]).x
  18. $ 5 = 0
  19. (gdb) p (*pairs.array[ 0 ]).y
  20. $ 6 = 0
  21. (gdb) continue
  22. Continuing.
  23. looping
  24. &{x: 1 y: 1 }
  25. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
  26. 18 fmt.Println( "looping" )
  27. (gdb) p (pairs.array[ 1 ][ 5 ]).y
  28. $ 7 = 1
  29. (gdb) continue
  30. Continuing.
  31. looping
  32. &{x: 2 y: 6 }
  33. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
  34. 18 fmt.Println( "looping" )
  35. (gdb) p (pairs.array[ 2 ][ 6 ]).y
  36. $ 8 = 6
  37. (gdb)

你会发现这里 gdb 并不确定 pairs 是一个 slice 类型,我们不能直接访问它的属性,为了访问它的成员我们需要使用 pairs.array 来转换成数组,然后我们就可以检查 slice 的 length(长度)和 capacity(容量):


  1. (gdb) p $len(pairs)
  2. $ 12 = 3
  3. (gdb) p $cap(pairs)
  4. $ 13 = 4

这时我们可以让它循环几次,并透过这个 slice 不用的成员方法监听增加的 和 的值,要注意的是,这里的 struct 属性可以通过指针访问,所以 p pairs.array[2].y 一样可行。

Goroutines

现在我们已经可以访问 struct 和 slice 了,下面再来更加复杂一点的程序吧。让我们添加一些goroutines 到 mian 函数,并行处理每一个数字,返回的结果存入信道(chan)中:


  1. pairs := []*pair{}
  2. pairChan := make(chan *pair)
  3. wg := sync.WaitGroup{}
  4. for i := 0 ; i < 10 ; i++ {
  5. wg.Add( 1 )
  6. go func(val int ) {
  7. p := handleNumber(val)
  8. fmt.Printf( "%+v/n" , p)
  9. pairChan <- p
  10. wg.Done()
  11. }(i)
  12. }
  13. go func() {
  14. for p := range pairChan {
  15. pairs = append(pairs, p)
  16. }
  17. }()
  18. wg.Wait()
  19. close(pairChan)
  20. 如果我等待 WaitGroup 执行完毕再检查 pairs slice 的结果,我们可以预期到内容是完全相同的,虽然它的排序可能有些出入。gdb 真正的威力来自于它可以在 goroutines 正在运行时进行检查:
  21. (gdb) b main.go: 43
  22. Breakpoint 1 at 0x400f7f : file /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 43 .
  23. (gdb) run
  24. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox
  25. Breakpoint 1 , main.handleNumber (i= 0 , ~r1= 0x0 )
  26. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 43
  27. 43 y: val,
  28. (gdb) l
  29. 38 if i% 2 == 0 {
  30. 39 val = f(i)
  31. 40 }
  32. 41 return &pair{
  33. 42 x: i,
  34. 43 y: val,
  35. 44 }
  36. 45 }
  37. 46
  38. 47 func f(x int ) int {
  39. (gdb) info args
  40. i = 0
  41. ~r1 = 0x0
  42. (gdb) p val
  43. $ 1 = 0

你会发现我们在 goroutine 要执行的代码段中放置了一个断点,从这里我们可以检查到局部变量,和进程中的其它 goroutines:


  1. (gdb) info goroutines
  2. 1 waiting runtime.gopark
  3. 2 waiting runtime.gopark
  4. 3 waiting runtime.gopark
  5. 4 waiting runtime.gopark
  6. * 5 running main.main.func1
  7. 6 runnable main.main.func1
  8. 7 runnable main.main.func1
  9. 8 runnable main.main.func1
  10. 9 runnable main.main.func1
  11. * 10 running main.main.func1
  12. 11 runnable main.main.func1
  13. 12 runnable main.main.func1
  14. 13 runnable main.main.func1
  15. 14 runnable main.main.func1
  16. 15 waiting runtime.gopark
  17. (gdb) goroutine 11 bt
  18. # 0 main.main.func1 (val= 6 , pairChan= 0xc82001a180 , &wg= 0xc82000a3a0 )
  19. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 19
  20. # 1 0x0000000000454991 in runtime.goexit () at /usr/local/go/src/runtime/asm_amd64.s: 1696
  21. # 2 0x0000000000000006 in ?? ()
  22. # 3 0x000000c82001a180 in ?? ()
  23. # 4 0x000000c82000a3a0 in ?? ()
  24. # 5 0x0000000000000000 in ?? ()
  25. (gdb) goroutine 11 l
  26. 48 return x*x + x
  27. 49 }
  28. (gdb) goroutine 11 info args
  29. val = 6
  30. pairChan = 0xc82001a180
  31. &wg = 0xc82000a3a0
  32. (gdb) goroutine 11 p val
  33. $ 2 = 6

在这里我们做的第一件事就是列出所有正在运行的 goroutine,并确定我们正在处理的那一个。然后我们可以看到一些回溯,并发送任何调试命令到 goroutine。这个回溯和列表清单并不太准确,如何让回溯更准确,goroutine 上的 info args 显示了我们的局部变量,以及主函数中的可用变量,goroutine 函数之外的使用前缀 

结论

当调试应用时, gdb 的强大令人难以置信。但它仍然是一个相当新的事物,并不是所有的地方工作地都很完美。使用最新的稳定版 gdb ,go 1.5 beta2,有不少地方有突破:

Interfaces

根据 go 博客上的文章 , go 的 interfaces 应该已经支持了,这允许在 gdb 中动态的投影其基类型。这应该算一个突破。

Interface{} 类型

目前没有办法转换 interface{} 为它的类型。

列出 goroutine 的不同点

在其他 goroutine 中列出周边代码会导致一些行数的漂移,最终导致 gdb 认为当前的行数超出文件范围并抛出一个错误:


  1. (gdb) info goroutines
  2. 1 waiting runtime.gopark
  3. 2 waiting runtime.gopark
  4. 3 waiting runtime.gopark
  5. 4 waiting runtime.gopark
  6. * 5 running main.main.func1
  7. 6 runnable main.main.func1
  8. 7 runnable main.main.func1
  9. 8 runnable main.main.func1
  10. 9 runnable main.main.func1
  11. * 10 running main.main.func1
  12. 11 runnable main.main.func1
  13. 12 runnable main.main.func1
  14. 13 runnable main.main.func1
  15. 14 runnable main.main.func1
  16. 15 waiting runtime.gopark
  17. (gdb) goroutine 11 bt
  18. # 0 main.main.func1 (val= 6 , pairChan= 0xc82001a180 , &wg= 0xc82000a3a0 )
  19. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 19
  20. # 1 0x0000000000454991 in runtime.goexit () at /usr/local/go/src/runtime/asm_amd64.s: 1696
  21. # 2 0x0000000000000006 in ?? ()
  22. # 3 0x000000c82001a180 in ?? ()
  23. # 4 0x000000c82000a3a0 in ?? ()
  24. # 5 0x0000000000000000 in ?? ()
  25. (gdb) goroutine 11 l
  26. 48 return x*x + x
  27. 49 }
  28. (gdb) goroutine 11 l
  29. Python Exception < class 'gdb.error' > Line number 50 out of range; /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go has 49 lines.:
  30. Error occurred in Python command: Line number 50 out of range; /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go has 49 lines.

Goroutine 调试还不稳定

处理 goroutines 往往不稳定;我遇到过执行简单命令产生错误的情况。现阶段你应该做好处理类似问题的准备。

gdb 支持 Go 的配置非常麻烦

运行 gdb 支持 Go 调试的配置非常麻烦,获取正确的路径结合与构建 flags,还有 gdb 自动加载功能好像都不能正常的工作。首先,通过一个 gdb 初始化文件加载 Go 运行时支持就会产生初始化错误。这就需要手动通过一个源命令去加载,调试 shell 需要像指南里面描述的那样去进行初始化。

我什么时候该使用一个调试器?

所以什么情况下使用 gdb 更有用?使用 print 语言和调试代码是更有针对性的方法。

  • 当不适合修改代码的时候

  • 当调试一个问题,但是不知道源头,动态断点或许更有效

  • 当包含许多 goroutines 时,暂停然后审查程序状态会更好

标签:src,sandbox,go,gdb,bfosberry,Go,main,调试
From: https://www.cnblogs.com/gongxianjin/p/17144216.html

相关文章

  • Django中获取用户IP方法
    Django中通过request.META可以来获取用户的IP。request.META是一个Python字典,包含了所有本次HTTP请求的Header信息,比如用户IP地址和用户Agent(通常是浏览器的名称和版本号......
  • 【Go】使用Go语言打造定时提醒小工具,从基础到优化全方位探索
    一、引言1.目的和背景本文和大家分享编程语言对于时间和日期的处理方式,以及代码的优化思路。2.选择GO语言的原因简单易学:GO语言的语法简单易学,这使得初学者能够快速上......
  • php调试配置
    错误信息输出错误日志nginx把对php的请求发给php-fpmfastcgi进程来处理,默认的php-fpm只会输出php-fpm的错误信息,在php-fpm的errorslog里也看不到php的errorlog。原因是......
  • GO 管理微信公众号后台(wechat)
    2023-02-2209:57:10星期三目的微信公众号后台管理,实现简单的文本接收与信息回复。前提配置好微信服务器,并正常启动安装了golang安装了wechat包示例代码演示......
  • Django - 创建工程 和 APP 与 开发工具
    1.安装在这里使用的是Anaconda,直接使用Anaconda命令进行安装;(E:\Anaconda3)C:\Users\yuan>condainstalldjango//安装指定版本django(E:\Anaconda3)C:\Users\yuan>con......
  • python+playwright 学习-8.如何在控制台调试定位(Inspect selectors)
    前言在运行selenium脚本的时候,我们通常习惯用sleep去让页面暂停,打开console输入$(selector)去调试定位页面的元素。有时候明明页面能找到元素,代码运行却找不到,很是郁......
  • go 关闭chan 广播信号
    packagemainimport( "fmt" "sync")funchello(num...int){ num[0]=18}funcmain(){ closeChan:=make(chanstruct{}) wg:=&sync.WaitGroup{} fo......
  • openapi generator(go学习)
    一.安装通过npm安装,其他安装方式请见:https://openapi-generator.tech/docs/installation/#安装脚手架npminstall@openapitools/openapi-generator-cli-g#设置使......
  • django解决网站CORS前后端跨域问题
    1.安装cors-headers⼯具  pipinstalldjango-cors-headers 2.安装cors-headers应⽤#注册应用INSTALLED_APPS=['django.contrib.admin','django.con......
  • ansible playbook role及调试
    目录ansibleplaybookrole及调试role简介创建role步骤role中变量设置使用default定义变量使用命令行的变量在palybbok.yml文件直接定义变量在var中定义自己的变量pre_tas......