[译]使用 LLDB 调试 Go 程序

2018阿里云全部产品优惠券(好东东,强烈推荐)
领取地址https://promotion.aliyun.com/ntms/act/ambassador/sharetouser.html?userCode=gh9qh5ki&utm_source=gh9qh5ki

推荐:【编程语言】正则表达式的高级使用

[(1)后向引用 在匹配模式中使用小括号指定一个子表达式后,匹配这个子表达式的文本(也就是此分组捕获的内容)可以在表达式或其它程序中作进一步的处理。默认情况下,每个分

我一般调试Go程序都是通过log日志,性能调试的话通过 pprof 、trace、flamegraph等,主要是Go没有一个很好的集成的debugger,前两年虽然关注了delve,但是在IDE中集成比较粗糙,调试也很慢,所以基本不使用debugger进行调试, 最近看到滴滴的工程师分享的使用debugger在调试Go程序,我觉得有必要在尝试一下这方面的技术了。

本文翻译自 Debugging Go Code with LLDB , 更好的调试Go程序的工具是 delve , 因为它是专门为Go开发, 使用起来也很简单,并且还可以远程调试。delve的命名还可参考: dlv cli ,但是流行的通用的基础的debugger也是常用的手段之一。我在译文后面也列出了几篇其它关于go debug的相关文章,有兴趣的话也可以扩展阅读一下。

本文主要介绍应用于glang compiler 工具链的技术, 除了本文的介绍外,你还可以参考 LLDB 手册

介绍

在 Linux、Mac OS X, FreeBSD 或者 NetBSD环境中,当你使用 gc工具链编译和链接Go程序的时候, 编译出的二进制文件会携带 DWARFv3 调试信息。 LLDB调试器( > 3.7)可以使用这个信息调试进程或者core dump文件。

使用 -w 可以告诉链接器忽略这个调试信息, 比如 go build -ldflags "-w" prog.go

gc编译器产生的代码可能会包含内联的优化,这不方便调试器调试,为了禁止内联, 你可以使用 -gcflags "-N -l" 参数。

安装lldb

MacOS下如果你安装了XCode,应该已经安装了LLDB, LLDB是XCode默认的调试器。

Linux/MacOS/Windows下的安装方法可以参考: Installing-LLDB

通用操作

  • 显示文件和行号,设置断点以及反编译:
(lldb) l
(lldb) l line
(lldb) l file.go:line
(lldb) b line
(lldb) b file.go:line
(lldb) disas
  • 显示 backtrace 和 unwind stack frame:
(lldb) bt
(lldb) frame n
  • Show the name, type and location on the stack frame of local variables, arguments and return values:
(lldb) frame variable
(lldb) p varname
(lldb) expr -T -- varname

Go扩展

表达式解析

LLDB支持Go表达式:

(lldb) p x
(lldb) expr *(*int32)(t)
(lldb) help expr

Interface

默认LLDB显示接口的动态类型。通常它是一个指针, 比如 func foo(a interface{}) { ... } , 如果你调用 callfoo(1.0) , lldb会把 a 看作 *float64inside ,你也可以禁止为一个表达式禁止这种处理,或者在全局禁用:

(lldb) expr -d no-dynamic-values -- a
(lldb) settings set target.prefer-dynamic-values no-dynamic-values

Data Formatter

LLDB包含 go string 和 slice的格式化输出器,查看 LLDB docs 文档学习定制格式化输出。如果你想扩展内建的格式化方式,可以参考 GoLanguageRuntime.cpp

Channel和map被看作引用类型,lldb把它们作为指针类型, 就像C++的类型 hash<int,string>* 。Dereferencing会显示类型内部的表示。

Goroutine

LLDB 把 Goroutine 看作 thread。

(lldb) thread list
(lldb) bt all
(lldb) thread select 2

已知问题

  • 如果编译时开启优化,调试信息可能是错误的。请确保开启参数 -gcflags "-N -l"
  • 不能改变变量的值,或者调用goh函数
  • 需要更好的支持 chan 和 map 类型
  • 调试信息不包含输入的package, 所以你在表达式中需要package的全路径。当package中包含 non-identifier 字符的时候你需要用引号包含它: x.(*foo/bar.BarType) 或者 (*“v.io/x/foo”.FooType)(x)
  • 调试信息不包含作用域,所以变量在它们初始化之前是可见的。 如果有同名的本地变量,比如shadowed 变量, 你不知道哪个是哪个
  • 调试信息仅仅描述了变量在内存中的位置,所以你可能看到寄存器中的变量的stale数据
  • 不能打印函数类型

教程

在这个例子中我们可以检查标准库正则表达式。为了构建二进制文件, 进入 $GOROOT/src/regexp 然后运行 run go test -gcflags "-N -l" -c ,这会产生可执行文件 regexp.test

启动

启动 lldb, 调试 regexp.test:

$ lldb regexp.test
(lldb) target create "regexp.test"
Current executable set to 'regexp.test' (x86_64).
(lldb)

设置断点

在TestFind 函数上设置断点:

推荐:调试工具系列--java 正则表达式(regular expression)调试工具

[我心爱的原创调试工具之一,可以放便的测试正则java表达式的正确性。开放它方便大家。有人说,经常使用调试工具不是好习惯。应该是将整个模块代码都写完,再开始调试。有

(lldb) b regexp.TestFind

有时候 go编译器会使用全路径为函数名添加前缀,如果你不能使用上面简单的名称,你可以使用正则表达式设置断点:

(lldb) break set -r regexp.TestFind$
Breakpoint 5: where = regexp.test`_/code/go/src/regexp.TestFind + 37 at find_test.go:149, address = 0x00000000000863a5

运行程序:

(lldb) run --test.run=TestFind
Process 8496 launched: '/code/go/src/regexp/regexp.test' (x86_64)
Process 8496 stopped
* thread #9: tid = 0x0017, 0x00000000000863a5 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 37 at find_test.go:149, stop reason = breakpoint 2.1 3.1 5.1
    frame #0: 0x00000000000863a5 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 37 at find_test.go:149
   146         // First the simple cases.
   147
   148         func TestFind(t *testing.T) {
->149                 for _, test := range findTests {
   150                         re := MustCompile(test.pat)
   151                         if re.String() != test.pat {
   152                                 t.Errorf("String() = `%s`; should be `%s`", re.String(), test.pat)

程序会运行到设置的断点上,查看运行的goroutine以及它们在做什么:

(lldb) thread list
Process 8496 stopped
  thread #1: tid = 0x12201, 0x000000000003c0ab regexp.test`runtime.mach_semaphore_wait + 11 at sys_darwin_amd64.s:412
  thread #2: tid = 0x122fa, 0x000000000003bf7c regexp.test`runtime.usleep + 44 at sys_darwin_amd64.s:290
  thread #4: tid = 0x0001, 0x0000000000015865 regexp.test`runtime.gopark(unlockf=0x00000000000315a0, lock=0x00000002083220b8, reason="chan receive") +261at proc.go:131
  thread #5: tid = 0x0002, 0x0000000000015865 regexp.test`runtime.gopark(unlockf=0x00000000000315a0, lock=0x00000000002990d0, reason="force gc (idle)") + 261 at proc.go:131
  thread #6: tid = 0x0003, 0x0000000000015754 regexp.test`runtime.Gosched + 20 at proc.go:114
  thread #7: tid = 0x0004, 0x0000000000015865 regexp.test`runtime.gopark(unlockf=0x00000000000315a0, lock=0x00000000002a07d8, reason="finalizer wait") + 261 at proc.go:131
* thread #9: tid = 0x0017, 0x00000000000863a5 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 37 at find_test.go:149, stop reason = breakpoint 2.1 3.1 5.1

* 标出的那个goroutine是当前的goroutine。

查看代码

使用 l 或者 list 查看代码, # 重复最后的命令:

(lldb) l
(lldb) # Hit enter to repeat last command. Here, list the next few lines

命名

变量和函数名必须使用它们所隶属的package的全名, 比如 Compile 函数的名称是 regexp.Compile

方法必须使用receiver类型的全程, 比如 *Regexp 类型的 String 方法是 regexp.(*Regexp).String

被closure引用的变量会有 & 前缀。

查看堆栈

查看程序暂停的位置处的堆栈:

(lldb) bt
* thread #9: tid = 0x0017, 0x00000000000863a5 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 37 at find_test.go:149, stop reason = breakpoint 2.13.15.1
  * frame #0: 0x00000000000863a5 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 37 at find_test.go:149
    frame #1: 0x0000000000056e3f regexp.test`testing.tRunner(t=0x000000000003b671, test=0x000000020834a000) + 191 at testing.go:447
    frame #2: 0x00000000002995a0 regexp.test`/code/go/src/regexp.statictmp_3759 + 96
    frame #3: 0x000000000003b671 regexp.test`runtime.goexit + 1 at asm_amd64.s:2232
The stack frame shows we’re currently executing the regexp.TestFind function, as expected.

命令 frame variable 会列出这个函数所有的本地变量以及它们的值。但是使用它有点危险,因为它会尝试打印出未初始化的变量。未初始化的slice可能会导致lldb打印出巨大的数组。

函数参数:

(lldb)framevar-l
(*testing.T) t = 0x000000020834a000

打印这个参数的时候,你会注意到它是一个指向 Regexp 的指针。

(lldb) p re
(*_/code/go/src/regexp.Regexp) $3 =0x000000020834a090
(lldb) p t
(*testing.T) $4 =0x000000020834a000
(lldb) p *t
(testing.T) $5 = {
  testing.common = {
    mu = {
      w = (state =0, sema =0)
      writerSem =0
      readerSem =0
      readerCount =0
      readerWait =0
    }
    output = (len0, cap0) {}
    failed = false
    skipped = false
    finished = false
    start = {
      sec =63579066045
      nsec =777400918
      loc =0x00000000002995a0
    }
    duration =0
    self =0x000000020834a000
    signal =0x0000000208322060
  }
  name = "TestFind"
  startParallel =0x0000000208322240
}
(lldb) p *t.startParallel
(hchan<bool>) $3 = {
  qcount =0
  dataqsiz =0
  buf =0x0000000208322240
  elemsize =1
  closed =0
  elemtype =0x000000000014eda0
  sendx =0
  recvx =0
  recvq = {
    first =0x0000000000000000
    last =0x0000000000000000
  }
  sendq = {
    first =0x0000000000000000
    last =0x0000000000000000
  }
  lock = (key =0x0000000000000000)
}

hchan<bool> 是这个channel的在运行时的内部数据结构。

步进:

(lldb) n # execute next line
(lldb) # enter is repeat
(lldb) # enter is repeat
Process 17917 stopped
* thread #8: tid = 0x0017, 0x000000000008648f regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 271 at find_test.go:151, stop reason = step over
    frame #0: 0x000000000008648f regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 271 at find_test.go:151
   148         func TestFind(t *testing.T) {
   149                 for _, test := range findTests {
   150                         re := MustCompile(test.pat)
-> 151                         if re.String() != test.pat {
   152                                 t.Errorf("String() = `%s`; should be `%s`", re.String(), test.pat)
   153                         }
   154                         result := re.Find([]byte(test.text))
(lldb) p test.pat
(string) $4 = ""
(lldb) p re
(*_/code/go/src/regexp.Regexp) $5 = 0x0000000208354320
(lldb) p *re
(_/code/go/src/regexp.Regexp) $6 = {
  expr = ""
  prog = 0x0000000208ac6090
  onepass = 0x0000000000000000
  prefix = ""
  prefixBytes = (len 0, cap 0) {}
  prefixComplete = true
  prefixRune = 0
  prefixEnd = 0
  cond = 0
  numSubexp = 0
  subexpNames = (len 1, cap 1) {
    [0] = ""
  }
  longest = false
  mu = (state = 0, sema = 0)
  machine = (len 0, cap 0) {}
}
(lldb) p *re.prog
(regexp/syntax.Prog) $7 = {
  Inst = (len 3, cap 4) {
    [0] = {
      Op = 5
      Out = 0
      Arg = 0
      Rune = (len 0, cap 0) {}
    }
    [1] = {
      Op = 6
      Out = 2
      Arg = 0
      Rune = (len 0, cap 0) {}
    }
    [2] = {
      Op = 4
      Out = 0
      Arg = 0
      Rune = (len 0, cap 0) {}
    }
  }
  Start = 1
  NumCap = 2
}

我们还可以通过 s 命令 Step Into :

(lldb) s
Process 17917 stopped
* thread #8: tid = 0x0017, 0x0000000000067332 regexp.test`_/code/go/src/regexp.(re=0x0000000208354320, ~r0="").String + 18 at regexp.go:104, stop reason = step in
    frame #0: 0x0000000000067332 regexp.test`_/code/go/src/regexp.(re=0x0000000208354320, ~r0="").String + 18 at regexp.go:104
   101
   102         // String returns the source text used to compile the regular expression.
   103         func (re *Regexp) String() string {
->104                 return re.expr
   105         }
   106
   107         // Compile parses a regular expression and returns, if successful,

查看堆栈信息,看看目前我们停在哪儿:

(lldb) bt
* thread #8: tid = 0x0017, 0x0000000000067332 regexp.test`_/code/go/src/regexp.(re=0x0000000208354320, ~r0="").String + 18 at regexp.go:104, stop reason = step in
  * frame #0: 0x0000000000067332 regexp.test`_/code/go/src/regexp.(re=0x0000000208354320, ~r0="").String + 18 at regexp.go:104
    frame #1: 0x00000000000864a0 regexp.test`_/code/go/src/regexp.TestFind(t=0x000000020834a000) + 288 at find_test.go:151
    frame #2: 0x0000000000056e3f regexp.test`testing.tRunner(t=0x000000000003b671, test=0x000000020834a000) + 191 at testing.go:447
    frame #3: 0x00000000002995a0 regexp.test`/code/go/src/regexp.statictmp_3759 + 96
    frame #4: 0x000000000003b671 regexp.test`runtime.goexit + 1 at asm_amd64.s:2232

其它调试参考文章

  1. Debugging Go code using VS Code
  2. Debugging Go Code with GDB
  3. Debugging Go Code
  4. Debugging Go programs with Delve
  5. debug by Goland
  6. Using the gdb debugger with Go
  7. 用 debugger 学习 golang

推荐:C语言使用正则表达式

[一、简介 一个好的程序员是会使用DB和Regular Expression的程序员,可见两者是多么重要。正则表达式是能极大地提高工作效率的工具,使用过Linux下各种具备RE特性的工具的

在线网页数据采集器

相关推荐