计算机是怎么长出来的
总目录/ 第 1 部/ 1.6 把程序做出来的一套工具/ 1.6.2

1.6.2 调试器:断点、单步与看变量,程序怎么被“冻住”

约 0.65 万字 · 6 张图 · 读完你能说清断点在机器层面到底是什么、 为什么点在一行的断点会跳到另一行、为什么优化过的程序没法好好调试, 以及为什么「停下来看一眼」这件事本身会改变程序的行为

上一节最后说,编辑器只知道语法,不知道你传的参数是不是反了。 要回答这类问题,得让程序真的跑起来,然后在中途停下来看。 这个「停下来看」的动作,就是调试器。

它看起来像魔法:点一下行号,程序乖乖停在那儿;鼠标悬在一个变量上,值就显示出来; 按一下「单步」,它就往前挪一行。可 CPU 里没有「停在这一行」这条指令, 也没有「把这个变量的值告诉我」这种功能。 所有这些都是调试器用很土的办法拼出来的: 改一个字节、置一个标志位、然后求内核帮忙。

这一节就拆这些土办法。拆完之后你会明白三件事: 为什么断点有时下不上,为什么优化过的程序调试起来像噩梦, 以及为什么有些 bug 一开调试器就消失——那不是玄学,是被观察这件事本身改变了程序。

本节的小部分

  1. 1 一个点了几十年的动作
  2. 2 调试器凭什么能控制别人的程序
  3. 3 软件断点:把一个字节改掉
  4. 4 硬件断点:只有四个的稀缺资源
  5. 5 单步为什么慢得离谱
  6. 6 断点怎么绑到源代码行上
  7. 7 看变量:值到底在哪儿
  8. 8 调用栈是怎么摊开的
  9. 9 改值、跳行、强制返回
  10. 10 远程、多线程、崩溃现场
  11. 11 为什么它有时候不灵
  12. 12 撑不起什么:它只能看见这一次

1.6.2-1一个点了几十年的动作

在行号左边点一下,出现一个红点,程序跑到那儿就停。 这个交互从 1980 年代的符号调试器开始就没怎么变过,因为它确实好用: 你不用改一行代码,就能让程序在任意位置暂停,把当时的全部状态翻出来看。

但机器层面根本没有「暂停在这一行」这回事。CPU 只会做一件事:取出下一条指令、执行、取下一条。 它不认识行,不认识函数,更不认识你的变量名。

所以「停住」必须借助某种副作用: 想办法让 CPU 在跑到那个位置的时候出点事,出的事要能被操作系统捕获, 捕获之后要能通知到调试器。三种手段就是这么来的:

手段怎么让它「出事」典型用途
软件断点把那条指令的首字节改成「陷阱指令」点行号下的普通断点
硬件断点让 CPU 自己比较地址只读代码、精确监视
单步让 CPU 每执行完一条就报一次逐行看逻辑

三者没有高下之分,各自卡在不同的限制上。 下面一个一个拆。

1.6.2-2调试器凭什么能控制别人的程序

先说一个前提问题:一个进程凭什么能读写另一个进程的内存? 正常情况下当然不行——那是最基本的内存保护,否则任何程序都能偷别人的密码。

左右两个盒子:左边是调试器,右边是被调试的进程,中间用双向箭头相连,向下的箭头标着 PTRACE_ATTACH、PEEKDATA、POKEDATA,向上的箭头标着 SIGTRAP
图 1.6.2-1 调试器和被调试进程的关系。所有读写都走系统调用,调试器自己也没有特权。它做的是「请求内核代劳」:内核检查权限、检查关系,符合条件才替它去读那块内存。所以调试器不是「绕过」了内存保护,而是走了保护机制留下的那扇门。

这扇门在 Linux 上叫 ptrace(process trace),在 Windows 上是 DebugActiveProcess 那一套。它们的模型一样: 调试器当父进程,被调试的程序当子进程, 子进程每次「出事」(触发断点、收到信号、退出)都要先停下来告诉父进程。

典型的调用顺序是这样的:

ptrace(PTRACE_ATTACH, pid)      // 挂上去,让对方停下来
ptrace(PTRACE_PEEKDATA, pid, addr)   // 读对方某个地址的 8 个字节
ptrace(PTRACE_POKEDATA, pid, addr, val)  // 写
ptrace(PTRACE_GETREGS, pid, 0, &regs)   // 把全部寄存器捞出来
ptrace(PTRACE_CONT, pid)        // 放它继续跑,直到下次出事
ptrace(PTRACE_SINGLESTEP, pid)  // 只放它跑一条指令

注意这里没有一条是「读变量 x」。调试器拿到的是地址和字节, 至于「哪个地址是变量 x」,那是下一节要讲的调试信息干的活。

这套机制有三条硬限制,都是权限问题,绕不过去: 要么同用户要么 root; 一个进程同时只能被一个调试器挂住(第二个会被拒绝,这就是「另一个调试器正在运行」的报错来源); 只能父盯子,或者显式允许被 attach。

为什么调试器不能是「特权程序」: 如果 gdb 有权利读写任何进程的内存,那它自己就成了最大的安全漏洞—— 任何能运行 gdb 的人都能读别人的密码。所以设计上是反过来的: 调试器没有任何特权,它只是有权「请求」内核,而内核按规则判断给不给。 这条原则在操作系统里反复出现:把能力收在内核,外面只留受控的入口。

1.6.2-3软件断点:把一个字节改掉

最常见的手段,也是最土的一个:把目标指令的第一个字节换成 0xCC。

三行字节对比:原来五个字节是 B8 01 00 00 00,下断点后首字节变成 CC,命中后恢复成 B8,并有一个黄色箭头表示程序计数器往回退一格
图 1.6.2-2 下断点就是把首字节换成 0xCC。x86 上 0xCC 是 int3 指令,正好一个字节,所以替换之后后面的字节位置完全不变,指令边界不会乱。这一个字节的选择很讲究:如果用两字节的指令,就得考虑「原来的指令正好一字节怎么办」,整个方案会复杂十倍。

完整的流程有五个步骤,缺一步都会出问题:

1. 下断点    把 addr 处的首字节存起来,写入 0xCC
2. 执行到     CPU 执行 0xCC,触发断点异常,内核通知调试器
3. 恢复     调试器把原字节写回去(否则你看到的内存是坏的)
4. 回退     PC 减 1,指回这条指令的开头(否则一继续就又撞上)
5. 继续     如果还要保留断点,把 0xCC 再写回去,然后放行

第 4 步是最容易被忽略的。执行 0xCC 之后,PC 已经指向下一个字节了, 因为 CPU 认为这条一字节的指令已经执行完。可它其实只是一个「占位符」, 真正的指令还没执行。所以必须把 PC 往回挪一格,让它重新指向这条指令的开头。

这也解释了一个很常见的困惑:为什么断点打在有优化的代码上,有时会「跳过」一次。 如果你在同一个位置反复继续,恢复原字节、单步执行一条、再写回 0xCC, 这三步之间有一个时间窗。如果这条指令本身会跳转,或者别的线程改了这个位置,就可能错过。

软件断点最大的限制是:它要写内存。 如果代码在只读段(比如单片机烧在 Flash 里的固件、游戏卡带、某些嵌入式设备的 ROM), 写不进去,断点就下不上。这时候只能换硬件断点。

1.6.2-4硬件断点:只有四个的稀缺资源

CPU 里有几个专门的寄存器,叫调试寄存器。x86 上有四个,叫 DR0 到 DR3。 你往里面写一个地址,再在控制寄存器里设好「要监视读还是写」, CPU 就会在执行时不停比较:当前访问的地址是不是这几个之一,是就停下来。

它和软件断点的区别很关键: 软件断点比较的是「执行到哪个地址」,硬件断点可以比较「读写了哪个地址」。 后者带来一个非常好用的功能——监视点(watchpoint)。

变量 total 明明没赋值,怎么自己变了?

watch total          // 设一个写监视点
继续跑
→ 程序停在某一行:total = 0;
   就是这儿改的。原来是一段十年前的老代码在偷偷重置它。

这类 bug 靠读代码几乎找不到,靠打日志又太笨,靠断点得在所有可能的位置都下一遍。 监视点是唯一能直接回答「谁改了这个变量」的工具。

代价是那两个数字:只有四个,而且监视点和硬件断点共用这四个。 用完就没了,第五个下不上。这不是软件舍不得给,是 CPU 的硬件限制, 换台机器、换个操作系统,还是四个。

到这里四种手段都出场了,摆在一起看,各自的位置就清楚了:

四张卡片横排对比:软件断点用 0xCC,数量不限但改不了只读代码;硬件断点用 DR0-3 寄存器,只有四个但不改内存;监视点盯地址读写,四个名额和硬件断点共用;单步用 TF 标志位,无限制但极慢
图 1.6.2-3 四种手段摆在一起。选哪个不取决于哪个更「高级」,取决于你此刻要回答什么问题。想看「这段逻辑对不对」用软件断点(随便下);想查「谁改了这个变量」用监视点(只有四个,省着用);想进某个函数慢慢看用单步(只走关键的几步)。用错工具,时间全花在等上面。

1.6.2-5单步为什么慢得离谱

单步用的是另一个机制:CPU 的状态寄存器里有一个「陷阱标志位」(trap flag)。 把它置 1 之后,每执行完一条指令,CPU 就主动触发一次异常。 调试器收到通知,看看现在到哪儿了,再把标志位设回去,放它跑下一条。

四个盒子组成的循环:执行一条指令、触发 trap、内核接管、调试器醒来,然后用一个回环箭头回到起点,标注你按一下单步就再来一遍
图 1.6.2-4 单步一次要走完整条内核路径。一条指令本身零点几纳秒,一次往返要几微秒到几十微秒,差了几千倍。所以「单步一千行」在调试器里感觉是过了几秒,而真实程序跑完这一段连一毫秒都不到。这个差距是理解「调试器不能用来测性能」的关键。

所以单步慢,不是因为指令慢,是因为每条指令都伴随一次用户态到内核态的往返, 外加调试器刷新一次界面。这个开销和指令本身的工作量完全无关—— 你单步一行 a + b 和单步一行 sort(arr), 在调试器里的「一步」耗时居然差不多,因为时间全花在报告上了。

顺手解释三个常被搞混的按钮:

操作实际做了什么什么时候用
步过(Step Over)在下一行设临时断点,然后全速跑这行调用了一个你不想进去的函数
步入(Step Into)真的单步,指令级想看看这个函数内部怎么跑的
步出(Step Out)在返回地址设临时断点,全速跑这个函数看够了,想回到调用者

注意「步过」和「步出」都不是单步,它们是「临时断点 + 全速运行」。 所以它们很快——这也解释了为什么「步过一行调用 sort()」是瞬间完成的, 而「步入 sort() 再单步走」会慢到令人放弃。

1.6.2-6断点怎么绑到源代码行上

你点的是一行源码,机器里只有地址。中间靠调试信息翻译—— Linux 上是 DWARF,Windows 上是 PDB。

左边是四行源码,第 42 行被高亮;中间是行号表,第 42 行对应两个地址 0x40113a 和 0x401145;右边说明为什么会有两个地址,以及优化之后更乱
图 1.6.2-5 行号到地址的映射表。它不是一一对应的:一行可能对应好几个地址(循环的头和尾),也可能一个地址都不对应(这行被优化掉了)。你点断点时,调试器要在这张表里查「离这一行最近的、真实存在的地址」,查出来的结果和你的直觉经常不一样。

这张表就是-g 编译选项生成的东西。没有它,调试器只能给你看汇编和十六进制, 不知道哪条指令对应哪一行、哪个变量叫什么名字。

一旦开了优化,这张表就开始失真。编译器会做几件事,每一件都在破坏映射:

合并。几个相邻的语句被合成一条指令,原来五行现在只有一个地址, 你在中间三行下的断点全都落到同一个地方。

重排。为了减少跳转,编译器会把代码块的顺序打乱。 第 43 行的指令可能被排到第 41 行前面,于是断点的命中顺序和源码顺序不一致。

内联。小函数被直接展开到调用处。你在那个函数里下的断点, 可能命中在十个不同的地方——因为它被内联了十次。

这就是「Release 模式下断点乱跳」的全部原因。不是调试器笨, 是它守着一张已经被编译器重写过的表,而你的直觉还停在源码的顺序上。

还有两个由此产生的日常现象,知道原理就不奇怪了:

断点下在注释行、空白行、或者 } 上,会自动跳到下一行有指令的地方。 因为那些位置根本没有对应的机器码,调试器只能往最近的有效地址挪。 同理,如果一个函数只有一行(比如 int f() { return 1; }), 在它身上下的断点,命中的位置常常让你意外。

条件断点也是一个普通断点。 你写 i == 999,调试器不会让 CPU 帮你判断—— 它还是在那一行下 0xCC,每次命中都停下来,读一下 i, 不满足条件就悄悄继续。所以条件越晚成立,代价越高: 在一个跑一百万次的循环里,它会真的停一百万次、判断一百万次, 每次都是一轮完整的内核往返。慢到你以为程序卡死了。

但别以为 -O0 就万事大吉: 关掉优化让调试变容易,但程序的行为会变。 有些 bug 只在优化后出现(比如依赖内存顺序的竞态、依赖未定义行为的代码), 你在 -O0 下怎么调都调不出来。调试版本和发布版本是两个程序, 这句话不是夸张。

1.6.2-7看变量:值到底在哪儿

把鼠标悬在变量上,值就出来了。这个过程比看起来复杂: 调试器得先知道这个变量此刻存在哪儿。

左边是三个栈帧,当前帧用黄色标出;右边是调试信息里的描述:变量 x 在 rbp-8,变量 y 在寄存器 rbx,变量 tmp 已被优化掉
图 1.6.2-6 变量的三种位置。「看变量」不是去内存里找一个叫 x 的盒子:调试信息里写的是一条规则,比如「x 在栈帧指针往下 8 个字节」「y 现在在 rbx 寄存器里」。调试器按这条规则去取,取到的是那一刻的值。变量一旦被优化掉,规则就没了,界面上只能显示 optimized out。

三种情况各自有各自的坑:

在栈上最常见。位置写成「相对帧指针的偏移」, 取的时候按当前帧指针加偏移算地址。这类变量最可靠,除非栈被写坏了。

在寄存器里是优化后的常态。编译器发现某个变量只在几行内用到, 就干脆让它住寄存器,不占内存。这时候调试信息会写「y 在 rbx」, 可问题是寄存器会被复用——你单步到下一行,rbx 可能已经装了别的东西, 界面上 y 的值就变成了一个莫名其妙的数。

不存在就是彻底没了。变量被常量折叠(const int a = 5 之后所有 a 都换成 5)、 被死代码消除(算了但没人用)、或者被证明和另一个变量等价(直接复用)。 这时候调试器只能说 optimized out。

一个实用技巧: 想看一个被优化掉的变量的真实值,可以在它后面加一句 volatile 读,或者把它打印出来,或者干脆把这个文件单独用 -O0 编。 不要试图和优化器较劲——它是对的,你只是想看中间结果。

1.6.2-8调用栈是怎么摊开的

调试器界面上那一列「main → foo → bar」,叫调用栈。 它看起来理所当然,其实要解决一个很麻烦的问题: 栈上只有当前帧的信息,上一帧在哪,得算出来。

最老的办法是「帧指针链」。每个函数开头把上一个函数的帧指针压栈, 于是栈上就形成一条链:当前 rbp 指向的格子里存着上一个 rbp, 顺着往上走就能把每一帧串起来。

bar  的帧:  [ 上一个 rbp ] ← rbp 现在指这儿
            [ 返回地址    ]
            [ 局部变量    ]
foo  的帧:  [ 上一个 rbp ]
            ...

这个办法简单有效,但有一个致命弱点:它要占一个寄存器。 x86-64 只有 16 个通用寄存器,优化器很想把 rbp 也拿去用。 于是有了 -fomit-frame-pointer 这个选项(现在很多编译器默认就开), 帧指针链就断了。

现代调试器用的是另一套东西:DWARF 的调用帧信息(CFI)。 编译器在调试信息里写一张表,描述「从这个地址的这条指令,怎么算出上一帧的返回地址和栈指针」。 展开栈的时候,调试器逐帧查表、逐帧恢复寄存器,一层层往上走。

这解释了为什么有些栈回溯会缺帧或者错位: CFI 表是按地址区间写的,如果 PC 落在一个表里没描述的位置 (比如手写的汇编、JIT 生成的代码、被内联搅乱的地方), 调试器就不知道该怎么往上走,只能停下,栈就断在那儿。

1.6.2-9改值、跳行、强制返回

调试器能读内存,自然也能写。所以它还能做几件「改程序行为」的事:

改变量的值。把 count 从 0 改成 100,继续跑, 看看后面的逻辑对不对。这是最快的「如果输入是这样会怎样」实验。

改 PC。直接把程序计数器指到另一行,跳过一段代码。 用来验证「这段是不是罪魁祸首」特别快。

强制返回。让当前函数立刻返回一个指定值, 不执行剩下的部分。排查「是不是这个函数返回值不对」时很好用。

这些操作在底层都只是 ptrace 的写操作,没有任何魔法。 但它们有一个共同的风险:你破坏了程序的不变式。

你手动跳过了 malloc 的失败分支:
  ptr = malloc(n);
  if (!ptr) return -1;     // 你把 PC 直接跳过了这行
  memset(ptr, 0, n);       // 于是这里对 NULL 写入 → 崩了

崩溃的原因不是你原来想查的 bug,
而是你刚刚制造的新 bug。

所以改值、跳行这些手段,适合用来做实验、缩小范围, 不适合用来「修好再继续跑」——那样你测的已经不是原来的程序了。

1.6.2-10远程、多线程、崩溃现场

这三个场景听起来很不一样,底下是同一套抽象。

远程调试。调试器在你这台机器上,程序跑在另一台(开发板、容器、手机)。 中间只需要一个「代理」:代理在那头执行 ptrace,这头用协议(gdbstub、DAP)发指令。 所以远程调试不是「通过网络调试」,是把 ptrace 搬到对面去执行。

多线程。默认行为是「一个断点触发,所有线程一起停」—— 这样你看到的是一个一致的快照,不会出现「我看的时候它还在变」。 但这也带来一个副作用:停下来这件事本身改变了线程的时序, 有些竞态 bug 就此消失(下一节细说)。

崩溃现场。程序已经死了,来不及调。 操作系统可以在它死的那一刻把整个内存镜像写成文件(core dump), 事后拿调试器打开这个文件,栈、变量、寄存器全都在。 这相当于给程序的尸体做尸检,是线上问题排查的主力手段。

场景调试器在哪被调试的东西
本地调试同一台机器一个活着的进程
远程调试另一台机器,通过代理一个活着的进程
事后调试任意机器一个 core 文件

1.6.2-11为什么它有时候不灵

下面这几种情况,几乎每个用调试器的人都遇到过。它们不是 bug,是原理决定的。

一是优化过的代码。前面讲过:断点跳行、变量看不到、单步乱走。 根子是同一件事——源码和机器码之间不再是一一对应的。

二是内联。一个函数被展开到十个调用点, 你在函数体里下的断点会命中十次,而且每次的「调用栈」看起来都怪怪的 (因为它根本不在栈上)。

三是竞态。这是最气人的一类。程序平时一跑就崩,一开调试器就好了。 原因很实在:断点让所有线程停下来,等你按继续,这段时间足够让另一个线程把活干完。 那个「两个线程同时改一个变量」的窗口,被你亲手关上了。

这类 bug 怎么查: 别用断点,用日志(它不打断时序),或者用「记录后再回放」的工具 (rr、WinDbg 的 TTD),它们能把一次运行完整录下来,事后随意前后拖动。 核心思路是同一个:不要用「暂停」去观察一个怕暂停的东西。

四是实时系统和内核。前者要求「必须在几毫秒内响应」, 你让它停下来看变量,它就已经不是原来那个系统了; 后者没有普通进程的地址空间,得用双机调试(一台机器跑内核,另一台用串口或网线连上来看)。

1.6.2-12撑不起什么:它只能看见这一次

调试器很强,但它的能力有一个明确的边界,值得说清楚。

它只能看「这一次运行」。 你停在一个断点上,看到 x = 42,这只说明这一次、这个输入、这个时刻它是 42。 换一个输入、换一个线程调度、换一台机器,它可能是别的值。 调试器不给你任何「所有情况下都成立」的结论。

停下来这件事本身会改变程序。 前面说的竞态是极端例子,但影响更广: 停下来会让缓存冷掉、让超时计时器继续走、让另一个进程抢走锁。 你观察到的状态,不是它自然运行时的状态。

它不能证明程序是对的。 你跑通了一百次,第一百零一次可能还是错的。 调试器只能证明「这一次是错的」——它给你的是反例,不是证明。

要回答「这个程序在所有情况下都对吗」,得换一套方法: 不是手动跑一次看,而是写一批检查,让机器每次都跑一遍。 那就是下一节的事:测试。

自测:能答上 6 题,这一节就算过了

  1. 为什么「让程序停在这一行」在 CPU 层面没有对应的指令?
  2. 软件断点的完整五步是什么?为什么第 4 步「PC 回退」不能省?
  3. 为什么软件断点下在只读代码上会失败?
  4. 硬件断点为什么只有四个?监视点和它是什么关系?
  5. 单步为什么比直接跑慢几千倍?
  6. 「步过」和「单步」的底层实现有什么区别?为什么步过快那么多?
  7. 为什么一行源码会对应两个地址?
  8. 「断点在 Release 模式下乱跳」的三个原因是什么?
  9. 变量显示 optimized out 是什么意思?三种可能的位置分别是什么?
  10. 为什么帧指针链会被优化掉?现代调试器用什么替代它?
  11. 为什么有些 bug 一开调试器就消失?怎么查这类 bug?
  12. 调试器能证明程序正确吗?为什么?
点开看答案(先自己想,别急着点)
  1. 因为 CPU 只会一条一条取指令执行,它不认识「行」这个概念。行是源码层面的东西,机器里只有地址。所以「停住」必须借助副作用:让 CPU 在那个位置出点事,被操作系统捕获。
  2. 写下 0xCC → 执行到触发异常 → 恢复原字节 → PC 减 1 指回指令开头 → 继续时再写回 0xCC。第 4 步不能省,因为执行完 0xCC 之后 PC 已经指向下一个字节,不回退的话一继续就又会撞上同一个断点,程序永远走不动。
  3. 因为软件断点的做法是往那个地址写一个字节。只读段(Flash、ROM)写不进去,所以只能改用硬件断点——它比较地址,不改内存。
  4. 因为它们是 CPU 里的物理调试寄存器,x86 架构只定义了 DR0 到 DR3 四个。监视点(watchpoint)用的就是这四个寄存器,所以两者共享配额,用完就没了。
  5. 因为每走一条指令都要走一遍「用户态 → 内核 → 调试器 → 内核 → 用户态」的完整往返,还要刷新界面。一条指令本身零点几纳秒,一次往返几微秒,差了几千倍。
  6. 「步过」不是单步,它的实现是「在下一行设一个临时断点,然后全速运行」,所以几乎瞬间完成。「单步」是真的让 CPU 每执行一条指令就报一次,慢得多。
  7. 因为一行源码可能被编译成多段指令,最典型的是循环头:第一次进入循环和每轮跳回来,是两个不同的地址。断点只下在其中一个,所以只在第一次命中。
  8. 合并(几行合成一条指令)、重排(代码块顺序被打乱)、内联(函数被展开到多个调用点)。三者都让「源码行」和「指令地址」的对应关系变得不唯一。
  9. 意思是这个变量在当前这一点上根本不存在——被常量折叠、被死代码消除,或者被证明和别的变量等价。三种可能的位置是:栈上(按 rbp 偏移)、寄存器里(会被复用)、不存在。
  10. 因为帧指针要占一个通用寄存器,x86-64 只有 16 个,优化器很想拿它去用,于是有了 -fomit-frame-pointer。现代调试器改用 DWARF 的调用帧信息(CFI),按地址区间描述「怎么算出上一帧」,不依赖帧指针。
  11. 因为断点会让所有线程停下来,等你按继续。这段暂停时间里,另一个线程可能把活干完了,那个「同时改一个变量」的窗口就被关上了。查这类 bug 要用日志,或者用记录回放工具(rr、TTD),不要用会暂停的手段。
  12. 不能。它只能证明「这一次是错的」,给的是反例。你跑通一百次,第一百零一次仍可能错。要回答「所有情况下都对吗」,得写测试让机器反复验证。
← 1.6.1 编辑器与 IDE:补全、跳转和语法高亮是怎么做到的