开发一个Linux调试器（八）：堆栈展开

有时你需要知道的最重要的信息是什么，你当前的程序状态是如何到达那里的。有一个 backtrace 命令，它给你提供了程序当前的函数调用链。这篇文章将向你展示如何在 x86_64 上实现堆栈展开以生成这样的回溯。

系列索引

这些链接将会随着其他帖子的发布而上线。

1. 准备环境
2. 断点
3. 寄存器和内存
4. ELF 和 DWARF
5. 源码和信号
6. 源码级逐步执行
7. 源码级断点
8. 堆栈展开
9. 读取变量
10. 之后步骤

用下面的程序作为例子：

1. void a() { 
2.     //stopped here 
3. } 
4. void b() { 
5.      a(); 
6. } 
7. void c() { 
8.      a(); 
9. } 
10. int main() { 
11.     b(); 
12.     c(); 
13. } 

如果调试器停在 //stopped here' 这行，那么有两种方法可以达到：main->b->a或main->c->a`。如果我们用 LLDB 设置一个断点，继续执行并请求一个回溯，那么我们将得到以下内容：

1. * frame #0: 0x00000000004004da a.out`a() + 4 at bt.cpp:3 
2.   frame #1: 0x00000000004004e6 a.out`b() + 9 at bt.cpp:6 
3.   frame #2: 0x00000000004004fe a.out`main + 9 at bt.cpp:14 
4.   frame #3: 0x00007ffff7a2e830 libc.so.6`__libc_start_main + 240 at libc-start.c:291 
5.   frame #4: 0x0000000000400409 a.out`_start + 41 

这说明我们目前在函数 a 中，a 从函数 b 中跳转，b 从 main 中跳转等等。最后两个帧是编译器如何引导 main 函数的。

现在的问题是我们如何在 x86_64 上实现。最稳健的方法是解析 ELF 文件的 .eh_frame 部分，并解决如何从那里展开堆栈，但这会很痛苦。你可以使用 libunwind 或类似的来做，但这很无聊。相反，我们假设编译器以某种方式设置了堆栈，我们将手动遍历它。为了做到这一点，我们首先需要了解堆栈的布局。

1.     High 
2. |   ...   | 
3. +---------+ 
4. |  Arg 1  | 
5. +---------+ 
6. |  Arg 2  | 
7. +---------+ 
8. | Return  | 
9. +---------+ 
10. |Saved EBP| 
11. +---------+ 
12. |  Var 1  | 
13. +---------+ 
14. |  Var 2  | 
15. +---------+ 
16. |   ...   | 
17.     Low 

如你所见，最后一个堆栈帧的帧指针存储在当前堆栈帧的开始处，创建一个链接的指针列表。堆栈依据这个链表解开。我们可以通过查找 DWARF 信息中的返回地址来找出列表中下一帧的函数。一些编译器将忽略跟踪 EBP 的帧基址，因为这可以表示为 ESP 的偏移量，并可以释放一个额外的寄存器。即使启用了优化，传递 -fno-omit-frame-pointer 到 GCC 或 Clang 会强制它遵循我们依赖的约定。

我们将在 print_backtrace 函数中完成所有的工作：

1. void debugger::print_backtrace() { 

首先要决定的是使用什么格式打印出帧信息。我用了一个 lambda 来推出这个方法：

1. auto output_frame = [frame_number = 0] (auto&& func) mutable { 
2.     std::cout << "frame #" << frame_number++ << ": 0x" << dwarf::at_low_pc(func) 
3.               << ' ' << dwarf::at_name(func) << std::endl; 
4. }; 

打印输出的第一帧是当前正在执行的帧。我们可以通过查找 DWARF 中的当前程序计数器来获取此帧的信息：

1. auto current_func = get_function_from_pc(get_pc()); 
2.     output_frame(current_func); 

接下来我们需要获取当前函数的帧指针和返回地址。帧指针存储在 rbp 寄存器中，返回地址是从帧指针堆栈起的 8 字节。

1. auto frame_pointer = get_register_value(m_pid, reg::rbp); 
2. auto return_address = read_memory(frame_pointer+8); 

现在我们拥有了展开堆栈所需的所有信息。我只需要继续展开，直到调试器命中 main，但是当帧指针为 0x0 时，你也可以选择停止，这些是你在调用 main 函数之前调用的函数。我们将从每帧抓取帧指针和返回地址，并打印出信息。

1. while (dwarf::at_name(current_func) != "main") { 
2.         current_func = get_function_from_pc(return_address); 
3.         output_frame(current_func); 
4.         frame_pointer = read_memory(frame_pointer); 
5.         return_address = read_memory(frame_pointer+8); 
6.     } 
7. } 

就是这样!以下是整个函数：

1. void debugger::print_backtrace() { 
2.     auto output_frame = [frame_number = 0] (auto&& func) mutable { 
3.         std::cout << "frame #" << frame_number++ << ": 0x" << dwarf::at_low_pc(func) 
4.                   << ' ' << dwarf::at_name(func) << std::endl; 
5.     }; 
6.     auto current_func = get_function_from_pc(get_pc()); 
7.     output_frame(current_func); 
8.     auto frame_pointer = get_register_value(m_pid, reg::rbp); 
9.     auto return_address = read_memory(frame_pointer+8); 
10.     while (dwarf::at_name(current_func) != "main") { 
11.         current_func = get_function_from_pc(return_address); 
12.         output_frame(current_func); 
13.         frame_pointer = read_memory(frame_pointer); 
14.         return_address = read_memory(frame_pointer+8); 
15.     } 
16. } 

添加命令

当然，我们必须向用户公开这个命令。

1. else if(is_prefix(command, "backtrace")) { 
2.     print_backtrace(); 
3. } 

测试

测试此功能的一个方法是通过编写一个测试程序与一堆互相调用的小函数。设置几个断点，跳到代码附近，并确保你的回溯是准确的。

我们已经从一个只能产生并附加到其他程序的程序走了很长的路。本系列的倒数第二篇文章将通过支持读写变量来完成调试器的实现。在此之前，你可以在这里找到这个帖子的代码。

原文发布时间为：2017-10-09

本文作者:Simon Brand

本文来自云栖社区合作伙伴“51CTO”，了解相关信息可以关注。