在 gdb 里给一个函数下断点,程序停下,你兴冲冲地敲 print a,得到一个「No symbol a in current context」。换个思路看栈,发现栈上确实有值,但和你传进去的参数对不上。再换到 Windows 上分析另一个程序,同样的函数,参数又跑到了完全不同的寄存器里。这不是工具坏了,而是你还没掌握「调用约定」这套规则。

汇编难读,很大一部分难在「值在哪」。同一个整数,可能躺在寄存器里,可能在栈上,也可能是某条指令临时算出来的中间结果。这篇先把 x86-64 的寄存器、栈和调用约定讲清楚,再给一个最小函数做对照。读完至少能做到:看到一个 call,知道参数从哪来、返回值去哪找。

寄存器:CPU 手边的那几个抽屉

寄存器是 CPU 内部极快的存储位置,数量很少,名字固定。x86-64 有 16 个通用寄存器,每个 64 位。它们没有类型,既可以存地址,也可以存整数,怎么用完全由指令决定。

数据寄存器rax、rbx、rcx、rdx。历史上各有分工,现在更多是约定俗成。函数返回值通常放在 rax。
指针与索引rsi、rdi 常做源/目的指针,rsp 是栈顶指针,rbp 常做栈帧基址。它们也能参与普通运算。
扩展寄存器r8 到 r15,64 位时代新增。前六个整数参数会用到其中的几个,具体看调用约定。

同一个寄存器可以按宽度取不同名字。以 rax 为例:rax 是 64 位,eax 是低 32 位,ax 是低 16 位,al 是最低 8 位,ah 是次低 8 位。反汇编里频繁出现 eax,不是另一个寄存器,就是 rax 的低半截。写 32 位寄存器时,高 32 位会被清零,这一点和写 16 位、8 位不同,调试时容易看错。

不要背「rax 是累加器、rcx 是计数器」这类老说法。在现代编译器生成的代码里,寄存器的传统用途基本失效,真正决定用途的是调用约定和优化器分配。看到 rcx 不一定在计数,它可能只是第三个参数。

栈:函数临时住的地方

栈是一块从高地址往低地址增长的内存区域。rsp 永远指向当前栈顶,push 会先减 rsp 再写值,pop 先读值再增 rsp。函数调用时,返回地址由 call 指令自动压栈;进入函数后,典型开场是 push rbp 加 mov rbp,rsp,把上一个栈帧的基址保存起来,再把当前栈顶固定成新的基址。

固定基址之后,局部变量就能用 [rbp-4]、[rbp-8] 这样的偏移访问。偏移是负的,因为栈往低地址长。参数如果超过寄存器能传的数量,也会放在 [rbp+16] 这种正偏移处。返回地址在 [rbp+8]。这张「栈帧地图」是读反汇编时最实用的东西之一。

一个典型栈帧从高到低的样子
调用者的栈帧
第 7 个及以后的参数
返回地址 [rbp+8]
保存的旧 rbp [rbp]
局部变量 [rbp-4] 起
当前 rsp

注意这个顺序是示意图,不是内存地址的增长方向。实际地址从下往上增大,栈顶在最低处。用 gdb 的 x/8gx $rsp 看一块栈内存时,左边是低地址,右边是高地址,和这张图的视觉顺序相反,别被绕晕。

递归函数最能体现栈帧的作用。每递归一层,就多压一份返回地址、旧 rbp 和局部变量;递归太深,栈空间耗尽,程序直接崩溃,这类崩溃通常表现为段错误而不是正常的错误返回。反过来,尾递归在优化后可能复用同一个栈帧,递归深度就不再是问题。分析崩溃时看到 rsp 已经跑到栈区边界之外,基本可以往「递归或超大局部数组」方向查;越界之后覆盖到的往往是返回地址,崩溃点反而出现在别处。

常见指令:先认骨架,不背全集

x86-64 指令很多,但逆向里八成的时间只在看十几类。下面这张表按「它想干什么」分组,比按字母顺序背有用。

类别典型指令读法
搬数据mov、movzx、movsx把源搬到目的;zx 是零扩展,sx 是符号扩展
算地址lea只算地址不访问内存,常被编译器拿来做加法
算术add、sub、imul、idiv加减乘除;注意有符号与无符号的差别
位运算and、or、xor、shl、shr掩码、置位、异或、移位;xor eax,eax 常用来清零
比较cmp、test只改标志位不写结果;test eax,eax 等价于和 0 比较
跳转jmp、je、jne、jg、jl无条件或按标志位跳;je 就是相等/为零时跳
调用call、retcall 压返回地址再跳,ret 弹出返回地址

两个语法风格要先分清。AT&T 语法是「源在前、目的在后」,寄存器带 %,立即数带 $;Intel 语法反过来,寄存器和立即数不带前缀。同一句 mov %rax,%rbx 在 Intel 语法里写成 mov rbx,rax。objdump 默认是 AT&T,加 -M intel 切换;gdb 里用 set disassembly-flavor intel。两种都能读,但对照资料时一定要先确认对方用的是哪种。

还要记住 cmp 和 test 不写结果,它们只改标志位。后面的 je、jne、jg 看的是标志位,不是寄存器本身。最常用的是零标志 ZF:结果为 0 时置位,所以 test eax,eax 后面接 je,意思就是「eax 等于 0 就跳」。有符号比较还会看符号标志和溢出标志,这也是为什么 jg 与 ja 不能混用:前者按有符号数比较,后者按无符号数比较,同一组值可能得出相反的结论。

调用约定:参数和返回值走哪条路

函数不是凭空调用的,调用者和被调用者必须事先约好:前几个参数放哪、多余参数放哪、返回值放哪、哪些寄存器必须保持不变。这套规则叫调用约定。Linux、macOS 等类 Unix 系统在 x86-64 上用 System V AMD64 ABI;Windows 用另一套 Microsoft x64 约定。

System V AMD64(Linux 常见)

整数或指针参数依次放 rdi、rsi、rdx、rcx、r8、r9,第 7 个起放栈上。返回值在 rax。被调用者要保证 rbx、rbp、r12 到 r15 恢复原值。

Microsoft x64(Windows 常见)

前四个参数放 rcx、rdx、r8、r9,第 5 个起放栈上。调用者还要预留 32 字节的 shadow space。返回值同样在 rax。

差异最直接的影响是:同一份 C 代码,在 Linux 和 Windows 上编译出来的反汇编,参数寄存器不一样。看网上的分析文章时,先确认样本的平台,否则会把 rcx 当成计数器而不是第一个参数。浮点参数又是另一套规则,走 xmm 寄存器,这里先不展开。

调用约定不是建议,是硬规则。手写汇编调用 C 函数时,参数放错寄存器、栈没对齐、该保存的寄存器没保存,表现可能是立刻崩溃,也可能是运行很久之后才在完全无关的地方出错。排查这类问题时,先核对 ABI,不要先怀疑业务逻辑。

走查:一个三参数函数在两种编译选项下的样子

用一个最小例子把上面的规则落地。函数接收三个整数,返回它们的和:

int add3(int a, int b, int c) {
    return a + b + c;
}

int main(void) {
    return add3(1, 2, 3);
}

在 Linux 上用 gcc -O0 -g 编译,然后反汇编 add3:

gcc -O0 -g -o add3 add3.c
objdump -d -M intel add3 | sed -n '/<add3>:/,+12p'

去掉地址后,核心指令大致是这样:

push   rbp
mov    rbp,rsp
mov    DWORD PTR [rbp-0x4],edi
mov    DWORD PTR [rbp-0x8],esi
mov    DWORD PTR [rbp-0xc],edx
mov    edx,DWORD PTR [rbp-0x4]
mov    eax,DWORD PTR [rbp-0x8]
add    eax,edx
add    eax,DWORD PTR [rbp-0xc]
pop    rbp
ret

这段几乎是把源码逐句翻译了一遍:三个参数 edi、esi、edx 先落到栈上的三个槽位,再依次取出来相加,结果留在 eax。看到这里,-O0 的「笨」反而成了优点:变量、参数、返回值的来龙去脉都在明面上。

换成 -O2 再反汇编,同样的函数可能只剩三条指令:

lea    eax,[rdi+rsi*1]
add    eax,edx
ret

没有栈帧,没有局部变量,参数直接从寄存器用,lea 被拿来算 rdi + rsi。*1 是比例因子的默认写法,表示不加倍。这不是编译器「优化掉了逻辑」,而是它发现中间变量根本不需要存在。读优化后的代码,重点看数据从哪进、从哪出,不要执着于找回源码里的每一行。换句话说,函数还在,但源码里的「形状」没了;只靠指令数量判断逻辑复杂度,会被优化误导。

动态确认可以这样做(本机没有 gdb,以下命令按 Linux 靶场写法给出,未在本机实测):

gdb -q ./add3
(gdb) set disassembly-flavor intel
(gdb) break add3
(gdb) run
(gdb) info registers rdi rsi rdx
(gdb) finish
(gdb) print $eax

预期 info registers 显示 rdi=1、rsi=2、rdx=3,finish 后 eax=6。如果你在 Windows 上编译同样的代码,断点停下时参数会在 rcx、rdx、r8,数值仍然是 1、2、3,只是位置换了。这个对比能一次性把调用约定记住。

优化带来的三种「变形」

除了去掉栈帧,优化还会做几件影响阅读的事。第一种是内联:小函数被直接展开进调用者,反汇编里再也找不到 call add3,只剩几行算术。第二种是尾调用:函数最后一句是调用另一个函数,编译器可能把 call 加 ret 改成 jmp,栈帧直接复用。第三种是无分支化:简单的 if 被改成 cmov 或 setcc,控制流图上没有跳转,只有条件传送。

这三种变形都会让「按源码结构找函数」的方法失效。应对办法不是背优化规则,而是改变观察单位:不要问「这个函数对应源码哪一段」,改问「这个值从哪里来、经过什么变换、最后去了哪里」。数据流比控制流更稳定,尤其在优化之后。

现象、原因与第一步

现象真实原因第一步查什么
断点处看不到函数参数名符号被剥离,调试信息不存在按 ABI 看 rdi/rsi/rdx 或 rcx/rdx/r8
栈上值比预期多出 32 字节空白Windows x64 的 shadow space确认样本是 PE 还是 ELF,再对照调用约定
finish 后返回值是 0看错寄存器,或函数走的是错误分支看 rax/eax,再检查跳转条件
函数里找不到 push rbp叶子函数或优化后省略帧指针直接看 rsp 偏移和参数寄存器
反汇编和网上文章对不上AT&T 与 Intel 语法,或平台不同先看操作数顺序和寄存器前缀
手写汇编调用 C 函数就崩栈未按 16 字节对齐,或破坏了被调用者保存寄存器检查 rsp 对齐和 rbx/r12-r15

边界与代价

调用约定能解释「常规函数」的传参,但解释不了所有情况。C++ 的成员函数隐含 this 指针,虚函数走虚表间接调用,异常展开、协程、手写汇编函数都可能偏离标准 ABI。Go、Rust 在某些版本和平台上也有自己的寄存器约定。遇到对不上的情况,先确认语言和编译器,再查该语言自己的 ABI 文档,不要硬套 System V。

另一个代价是可移植性。依赖具体寄存器写出来的分析结论,换平台就失效。写报告时把「平台 + 架构 + 编译器」写清楚,比只写「参数在 rdi」有价值得多。做实验时也尽量固定编译器和优化级别,否则两次反汇编的差异会让你误以为是程序行为变了。

当天能自己验证的练习

  1. 把 add3 改成四个、六个、八个参数,分别用 -O0 反汇编,找出第 7 个参数在栈上的位置,验证 [rbp+16] 这个偏移。
  2. 把返回类型改成 long,观察返回值用的是 rax 还是 eax,想想为什么。
  3. 用 -O0 和 -O2 各编译一次,把两份 add3 的指令数列出来,标出哪些行消失了、哪些被合并了。
  4. 写一个带 if 的小函数,在 -O2 下找找有没有 cmov 或 setne,体会「无分支」长什么样。
  5. 如果你有 Windows 环境,把同样的源码用 MinGW 或 MSVC 编译,对照参数寄存器,确认 rcx/rdx/r8/r9 的顺序。

小结

三句话:寄存器是值的第一站,栈帧是局部变量和多余参数的家;调用约定决定参数和返回值走哪条路,Linux 与 Windows 不一样;优化会去掉栈帧、内联函数、改写分支,读优化代码要看数据流而不是源码结构。

下一篇进入静态分析:拿到一个没有源码、可能连符号都没有的文件,怎么用 file、strings、readelf、objdump 把函数边界、字符串引用和导入函数一点点拼出来。今天学的栈帧和参数位置,会在那里变成定位函数的坐标。