使用 gdb 工具调试 Go

排除应用程序故障是比较复杂的，特别是处理像 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
3. import (
4. "fmt"
5. )
7. func main() {
8. for i := 0 ; i < 5 ; i++ {
9. fmt.Println( "looping" )
10. }
11. fmt.Println( "Done" )
12. }

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

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

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

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

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

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

因为我们需要调试的是变量 y 。我们可以在 y 被设置的地方放置断点然后单步执行。可以使用 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
5. Breakpoint 1 , main.f (x= 0 , ~anon1= 833492132160 )
6. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
7. 33 return x*x + x
8. (gdb) info args
9. x = 0
10. (gdb) continue
11. Breakpoint 1 , main.f (x= 0 , ~anon1= 833492132160 )
12. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
13. 33 return x*x + x
14. (gdb) info args
15. x = 2
16. (gdb) bt
17. # 0 main.f (x= 2 , ~anon1= 1 )
18. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 33
19. # 1 0x0000000000400f0e in main.handleNumber (i= 2 , ~anon1= 0x1 )
20. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 24
21. # 2 0x0000000000400c47 in main.main ()
22. 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 }
6. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
7. 18 fmt.Println( "looping" )
8. (gdb) p pairs
9. $ 1 = []*main.pair = { 0xc82000a3a0 }
10. (gdb) p pairs[ 0 ]
11. Structure has no component named operator[].
12. (gdb) p pairs.array
13. $ 2 = (struct main.pair **) 0xc820030028
14. (gdb) p pairs.array[ 0 ]
15. $ 3 = (struct main.pair *) 0xc82000a3a0
16. (gdb) p *pairs.array[ 0 ]
17. $ 4 = {x = 0 , y = 0 }
18. (gdb) p (*pairs.array[ 0 ]).x
19. $ 5 = 0
20. (gdb) p (*pairs.array[ 0 ]).y
21. $ 6 = 0
22. (gdb) continue
23. Continuing.
24. looping
25. &{x: 1 y: 1 }
27. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
28. 18 fmt.Println( "looping" )
29. (gdb) p (pairs.array[ 1 ][ 5 ]).y
30. $ 7 = 1
31. (gdb) continue
32. Continuing.
33. looping
34. &{x: 2 y: 6 }
36. Breakpoint 1 , main.main () at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 18
37. 18 fmt.Println( "looping" )
38. (gdb) p (pairs.array[ 2 ][ 6 ]).y
39. $ 8 = 6
40. (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 不用的成员方法监听增加的 x 和 y 的值，要注意的是，这里的 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)
21. 如果我等待 WaitGroup 执行完毕再检查 pairs slice 的结果，我们可以预期到内容是完全相同的，虽然它的排序可能有些出入。gdb 真正的威力来自于它可以在 goroutines 正在运行时进行检查：
23. (gdb) b main.go: 43
24. Breakpoint 1 at 0x400f7f : file /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go, line 43 .
25. (gdb) run
26. Starting program: /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/gdb_sandbox
28. Breakpoint 1 , main.handleNumber (i= 0 , ~r1= 0x0 )
29. at /home/bfosberry/.go/src/github.com/bfosberry/gdb_sandbox/main.go: 43
30. 43 y: val,
31. (gdb) l
32. 38 if i% 2 == 0 {
33. 39 val = f(i)
34. 40 }
35. 41 return &pair{
36. 42 x: i,
37. 43 y: val,
38. 44 }
39. 45 }
40. 46
41. 47 func f(x int ) int {
42. (gdb) info args
43. i = 0
44. ~r1 = 0x0
45. (gdb) p val
46. $ 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 时，暂停然后审查程序状态会更好