7838 字
39 分钟
从 add(2, 3) 到 ret:零基础看懂 C 函数背后的 x86-64 汇编

从 add(2, 3) 到 ret:零基础看懂 C 函数背后的 x86-64 汇编#

很多人第一次看到汇编代码时都会有一种感觉:

C 语言明明只有三行,为什么编译出来突然变成十几行看不懂的东西?

例如下面这个再简单不过的函数:

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

调用它:

add(2, 3);

在 x86-64 平台上,如果暂时关闭编译器优化,可能得到类似这样的汇编代码:

add:
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
mov eax, DWORD PTR [rbp-4]
add eax, DWORD PTR [rbp-8]
mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]
leave
ret

如果没有学过计算机组成原理,这段东西里几乎每一个词都会形成一个新问题:

rbp 是什么?

rsp 又是什么?

为什么参数突然变成了 edi 和 esi?

[rbp-4] 为什么代表变量?

DWORD PTR 又是什么?

leave 和 ret 到底干了什么?

其实这段汇编没有做任何神秘的事情。它只是把 C 语言隐藏掉的细节全部摆到了桌面上。

本文就从这一个 add(2, 3) 出发,把寄存器、内存、栈、函数调用、返回值以及 call/ret 串起来。


1. 先暂时忘掉 C 语言里的“变量”#

在 C 语言里,我们习惯这样思考:

int a = 2;
int b = 3;
int c = a + b;

脑子里自然会出现三个变量:

a = 2
b = 3
c = 5

但 CPU 并不知道什么叫“变量 a”。

CPU 真正能够直接处理的东西大致只有两类:

寄存器中的数据
内存中的数据

以及一些最基础的指令:

复制
加法
减法
跳转
比较
……

所以从底层看:

c = a + b;

必须被拆成类似这样的过程:

找到 a
↓
把 a 取到 CPU 中
找到 b
↓
执行加法
保存结果

汇编做的事情,本质上就是把这些过程明确写出来。


2. CPU 手边的小盒子:寄存器#

CPU 内部有一批很小、很快的存储空间,叫做寄存器。

x86-64 中常见的名字有:

rax
rbx
rcx
rdx
rsi
rdi
rsp
rbp
rip
……

可以暂时把它们理解成 CPU 手边的一排小盒子:

┌─────────────┐
│ rax │
├─────────────┤
│ rbx │
├─────────────┤
│ rdi │
├─────────────┤
│ rsi │
├─────────────┤
│ rsp │
├─────────────┤
│ rbp │
└─────────────┘

例如某一刻可能是:

rdi = 2
rsi = 3
rax = 5

这里的:

rdi
rsi
rax

不是 C 变量。

它们是真正存在于 CPU 内部的硬件存储位置。


3. rax 和 eax 为什么长得这么像?#

代码中没有大量出现 rax,反而出现了:

eax
edi
esi

这是因为 x86 寄存器可以按照不同宽度访问。

例如 rax 是一个 64 位寄存器:

63 0
┌────────────────────────────────────────┐
│ rax │
└────────────────────────────────────────┘

而 eax 表示它的低 32 位:

63 32 31 0
┌────────────────────┬────────────────────┐
│ │ eax │
└────────────────────┴────────────────────┘
整个仍然是 rax

同理:

rdi:64 位
edi:rdi 的低 32 位
rsi:64 位
esi:rsi 的低 32 位

我们的函数参数是:

int a
int b

而现代 x86-64 系统上的普通 int 一般是:

32 bit = 4 byte

所以这里经常直接使用:

edi
esi
eax

来处理这些 32 位整数。


4. 内存其实可以理解成一排带编号的小格子#

内存没有 a、b、c 这种名字。

它更接近:

地址 内容
0x1000 ?
0x1001 ?
0x1002 ?
0x1003 ?
0x1004 ?
...

每一个内存位置都有一个编号,这个编号就是地址。

例如:

0x1000

可以理解为:

“编号为 0x1000 的内存位置”。

这里的 0x 表示十六进制。刚开始学习汇编时,不需要急着熟练进行十六进制计算,只需要知道:

0x1000
0x1001
0x1002
...

都是地址即可。


5. 一个 int 为什么需要 4 个字节?#

计算机中:

1 byte = 8 bit

一个普通的 int 通常是:

32 bit = 4 byte

因此:

int x;

需要连续占用 4 个字节的内存。

可以想象成:

地址
100 ┐
101 │
102 │ int x
103 ┘

这也解释了汇编中的:

DWORD PTR

在本文这段代码里,可以直接理解成:

接下来操作的是 4 个字节。

因为:

DWORD = 32 bit = 4 byte

所以:

mov DWORD PTR [rbp-4], edi

实际上是在说:

从 [rbp-4] 对应的地址开始,写入 4 字节数据。


6. 汇编里最重要的符号之一:[]#

初学汇编时,最容易混淆的是:

rbp - 4

和:

[rbp - 4]

这两者完全不是一回事。

假设:

rbp = 1000

那么:

rbp - 4 = 996

得到的是一个地址:

996

如果地址 996 中存的是:

2

那么:

[rbp - 4]

表示:

访问地址 996 中保存的数据。

因此:

rbp - 4

可以理解为:

地址 996

而:

[rbp - 4]

才相当于:

地址 996 中的内容

这和 C 语言中的指针很像。

如果:

int *p;

并且:

p = 996

那么:

p

代表地址。

而:

*p

代表这个地址里的数据。

因此初学阶段可以粗略地把:

[rbp-4]

理解为:

*(rbp - 4)

当然二者在类型系统等方面并不完全等价,但这种理解非常适合入门。


7. 什么是栈?#

接下来进入整段代码的核心。

函数运行的时候经常需要保存:

局部变量
返回地址
寄存器旧值
临时数据
……

这些东西通常会使用一块特殊用途的内存区域:

stack

也就是栈。

需要强调一点:

栈本质上仍然是普通内存。

并不存在一个神秘的“栈芯片”。

它只是操作系统为程序准备的一块虚拟内存区域,同时 CPU 和编译器按照特定规则来使用它。

假设栈附近的地址是:

高地址
1000
992
984
976
968
低地址

在 x86 上有一个比较反直觉的特点:

栈向低地址增长。

也就是说,栈里的东西越多,地址反而越小。

例如:

原来:
rsp = 1000

压入 8 字节之后:

rsp = 992

再压入 8 字节:

rsp = 984

因此可以画成:

高地址
↑
1000
992
984
976
↓
低地址
栈向低地址增长

8. rsp:当前栈顶在哪里?#

CPU 有一个专门的寄存器:

rsp

它叫:

Stack Pointer

也就是栈指针。

它保存的是:

当前栈顶的位置。

例如:

rsp = 984

表示当前栈顶在地址 984。

因此以后看到:

sub rsp, 16

不要把它理解成某种神秘汇编语法。

它真的就是:

rsp = rsp - 16

由于栈向低地址增长,所以这相当于向栈中“腾出”16字节的新空间。


9. rbp:给当前函数放一把固定的尺子#

另一个经常和 rsp 一起出现的寄存器是:

rbp

它通常叫:

Base Pointer

可以把它理解为当前函数栈帧的一个固定参考点。

原因是 rsp 可能经常变化:

push ...
sub rsp, ...

都会改变它。

如果所有变量都相对于 rsp 查找,就容易变得麻烦。

于是无优化代码中常见这样的做法:

rbp = 当前函数的固定基准点

以后变量就可以写成:

a 在 rbp - 4
b 在 rbp - 8
c 在 rbp - 12

无论 rsp 如何变化,只要 rbp 保持不动:

rbp - 4
rbp - 8
rbp - 12

的位置就不会变。

可以把二者记成:

rsp:会移动的栈顶
rbp:当前函数固定的尺子零点

10. add(2, 3) 的参数是怎么进入函数的?#

现在正式执行:

add(2, 3);

本文假设的是 Linux 等平台常见的 x86-64 System V ABI。

按照这个函数调用约定,前几个整数或指针参数通常依次放入:

第 1 个参数 → rdi
第 2 个参数 → rsi
第 3 个参数 → rdx
第 4 个参数 → rcx
第 5 个参数 → r8
第 6 个参数 → r9

由于这里是 32 位的 int,所以我们看到的是这些寄存器的低 32 位:

第 1 个 int 参数 → edi
第 2 个 int 参数 → esi

所以:

add(2, 3)

在进入函数之前,可以理解为:

edi = 2
esi = 3

对应:

int add(int a, int b)
↑ ↑
│ │
edi esi

这里需要注意:

“第一个参数放 edi”不是 CPU 天生规定的语言规则,而是调用约定规定的。

如果换成 Windows x64,参数寄存器规则就不同。

因此学习汇编时,一定要逐渐形成一个概念:

汇编语言本身是一层;操作系统、编译器和 ABI 又规定了一层约定。


11. 调用函数前,还有一个问题:怎么回来?#

假设调用者正在执行:

int x = add(2, 3);
printf("%d\n", x);

进入 add 很容易。

但 add 结束以后,CPU 怎么知道:

应该回来继续执行 printf 前面的下一条机器指令?

因此函数调用还需要保存一个东西:

返回地址

假设:

call add

后面的下一条机器指令地址是:

0x400500

那么执行:

call add

时,CPU 大致做两件事情:

1. 把返回地址 0x400500 压入栈
2. 跳转到 add

这就是为什么后面的 ret 能找到回去的地方。


12. 完整模拟一次 add(2, 3)#

下面真正开始逐条执行。

为了方便观察,假设调用前:

edi = 2
esi = 3
rsp = 1000
rbp = 2000

并假设返回地址:

0x400500

这里的数字只是为了方便演示,并不代表真实程序一定使用这些地址。


13. call add#

调用者执行:

call add

在 x86-64 上,返回地址占 8 字节。

因此原来:

rsp = 1000

保存返回地址之后:

rsp = 992

栈变成:

高地址
1000
992 返回地址 0x400500 ← rsp
低地址

然后 CPU 跳到:

add:

开始执行我们的函数。


14. 第一条:push rbp#

push rbp

push 可以先粗略理解成:

rsp -= 8
[rsp] = 要保存的东西

这里为什么要保存 rbp?

因为调用者自己也在使用 rbp。

现在 add 想把 rbp 改成自己的栈帧基准,但不能把调用者原本的值弄丢。

所以先保存:

旧 rbp = 2000

原来:

rsp = 992

执行:

push rbp

之后:

rsp = 984

并且:

[984] = 2000

于是:

高地址
1000
992 返回地址 0x400500
984 调用者原来的 rbp = 2000 ← rsp
低地址

此时寄存器:

edi = 2
esi = 3
rbp = 2000
rsp = 984

注意:

push rbp

只是把 rbp 中的旧值复制到栈里。

它并没有直接修改 rbp。


15. 第二条:mov rbp, rsp#

mov rbp, rsp

本文使用的是 Intel 汇编语法。

Intel 语法中的:

mov A, B

基本可以理解成:

A = B

因此:

mov rbp, rsp

就是:

rbp = rsp

当前:

rsp = 984

所以执行后:

rbp = 984
rsp = 984

栈:

高地址
992 返回地址
984 调用者原来的 rbp ← rbp
← rsp
低地址

从这一刻开始:

rbp = 984

就成为 add() 自己的固定参考点。


16. 第三条:sub rsp, 16#

sub rsp, 16

就是:

rsp = rsp - 16

所以:

984 - 16 = 968

于是:

rbp = 984
rsp = 968

注意 rbp 没动。

现在栈大致变成:

高地址
992 返回地址
984 旧 rbp ← rbp
980
976
972
968 ← rsp
低地址

这里的 16 字节:

968 ~ 983

就是当前函数腾出来的局部空间。

这就是:

sub rsp, 16

的真正意义。

它没有向操作系统重新申请 16 字节物理内存,也没有调用 malloc。

只是:

把栈顶往下移动 16 字节,宣布这 16 字节暂时归当前函数使用。


17. 编译器给 a、b、c 安排位置#

我们的 C 代码里有:

int a;
int b;
int c;

每一个 int 4 字节。

编译器可以给它们安排成:

a → [rbp-4]
b → [rbp-8]
c → [rbp-12]

因为:

rbp = 984

所以:

rbp - 4 = 980
rbp - 8 = 976
rbp - 12 = 972

栈帧就可以画成:

高地址
992 返回地址
984 调用者旧 rbp ← rbp
980~983 a
976~979 b
972~975 c
968~971 暂未使用 ← rsp
低地址

这张图几乎是理解整个函数最重要的一张图。


18. 为什么变量在 rbp-4,而不是 rbp+4?#

因为栈向低地址增长。

当前函数通过:

sub rsp, 16

获得的空间在:

rbp

下面。

也就是比 rbp 更小的地址。

因此局部变量自然是:

rbp - 4
rbp - 8
rbp - 12

反过来看:

rbp + 8

是什么?

因为:

rbp = 984

所以:

rbp + 8 = 992

而我们刚刚知道:

992

保存的正是:

返回地址

因此整个布局非常整齐:

高地址
rbp + 8 返回地址
rbp 调用者旧 rbp
rbp - 4 a
rbp - 8 b
rbp - 12 c
低地址

19. 保存参数 a#

接下来:

mov DWORD PTR [rbp-4], edi

拆开来看。

首先:

edi = 2

然后:

rbp - 4 = 980

所以:

[rbp-4]

表示:

地址 980 中的数据

而:

DWORD PTR

表示:

操作 4 字节

因此整句话:

mov DWORD PTR [rbp-4], edi

就是:

把 edi 中的 32 位整数 2 写入从地址 980 开始的 4 个字节。

结果:

a = 2

栈:

992 返回地址
984 旧 rbp ← rbp
980~983 a = 2
976~979 ?
972~975 ?
968~971 ← rsp

20. 保存参数 b#

下一条:

mov DWORD PTR [rbp-8], esi

当前:

esi = 3

并且:

rbp - 8 = 976

所以执行之后:

b = 3

栈:

992 返回地址
984 旧 rbp ← rbp
980~983 a = 2
976~979 b = 3
972~975 c = ?
968~971 ← rsp

至此:

int add(int a, int b)

中的两个参数已经从参数寄存器保存到了当前函数自己的栈帧中。


21. 为什么不直接用 edi 和 esi?#

这时很容易发现:

本来已经:

edi = 2
esi = 3

为什么还要先存进内存,稍后又取出来?

其实完全可以不这么做。

优化后的代码很可能接近:

mov eax, edi
add eax, esi
ret

甚至编译器还可能根据上下文进一步优化。

本文使用的是便于观察的无优化代码。

无优化情况下,编译器往往会机械地维护源代码中的变量:

参数 a
↓
给 a 一个栈位置
参数 b
↓
给 b 一个栈位置
局部变量 c
↓
也给 c 一个栈位置

因此代码更长,但反而非常适合入门理解 C 与汇编之间的映射。


22. 把 a 取进 CPU#

下一条:

mov eax, DWORD PTR [rbp-4]

注意这一次 mov 的方向发生了变化。

之前:

mov DWORD PTR [rbp-4], edi

是:

内存 ← edi

现在:

mov eax, DWORD PTR [rbp-4]

是:

eax ← 内存

我们知道:

[rbp-4] = a = 2

所以执行之后:

eax = 2

现在 CPU 的状态大致是:

eax = 2
edi = 2
esi = 3

而栈依然:

a = 2
b = 3
c = ?

23. 真正的加法只发生在这一条指令#

下面:

add eax, DWORD PTR [rbp-8]

Intel 语法里的:

add A, B

意思是:

A = A + B

因此:

add eax, DWORD PTR [rbp-8]

就是:

eax = eax + [rbp-8]

而:

eax = 2
[rbp-8] = b = 3

所以:

eax = 2 + 3
eax = 5

到这一刻:

a + b

真正计算完成。

注意一个很有意思的事实:

这一整个 C 表达式:

a + b

真正涉及数学意义上加法的机器指令,其实只有:

add eax, DWORD PTR [rbp-8]

其他大量代码都在处理:

参数
内存
栈帧
函数调用
返回

这也是为什么理解汇编之后,会发现高级语言隐藏了多少运行时细节。


24. 保存局部变量 c#

C 中写的是:

int c = a + b;

目前:

eax = 5

但变量 c 对应:

[rbp-12]

所以接下来:

mov DWORD PTR [rbp-12], eax

相当于:

c = eax

于是:

c = 5

完整栈帧:

高地址
992 返回地址
984 调用者旧 rbp ← rbp
980~983 a = 2
976~979 b = 3
972~975 c = 5
968~971 ← rsp
低地址

这时源代码里的:

int c = a + b;

已经彻底完成。


25. return c 在 CPU 眼中是什么?#

接下来:

mov eax, DWORD PTR [rbp-12]

也就是:

eax = c

因此:

eax = 5

为什么 return c 要把值放进 eax?

还是因为调用约定。

在当前 ABI 中,一个普通整数函数返回 int 时:

返回值通过 eax 交给调用者。

因此:

return c;

从底层看,并不存在一个带参数的:

return c

机器指令。

它实际上由两个概念组成:

第一步:
eax = c
第二步:
返回调用者

也就是大致:

mov eax, ...
ret

所以以后看到函数结束前:

eax

里面的值,往往值得特别关注。

它很可能就是:

函数返回值

26. 为什么又把 5 存进 c,又马上读回 eax?#

现在代码显得更“笨”了:

add eax, DWORD PTR [rbp-8]
mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]

明明:

eax

本来已经是 5。

理论上直接返回就行。

之所以出现:

eax → c
c → eax

仍然是因为这是无优化代码。

源代码明确写了:

int c = a + b;
return c;

所以编译器忠实地制造出了一个真实存在于栈中的 c。

打开优化以后,这种无意义的来回搬运通常会被直接删除。


27. 函数执行完了,但栈还没恢复#

现在状态大概是:

eax = 5
rbp = 984
rsp = 968

栈:

高地址
992 返回地址
984 调用者旧 rbp ← rbp
980~983 a = 2
976~979 b = 3
972~975 c = 5
968~971 ← rsp
低地址

问题来了:

当前函数马上要结束。

它不能就这样直接回去。

因为:

rsp
rbp

都已经被 add() 改过了。

必须恢复进入函数之前的状态。

于是出现:

leave

28. leave 并不神秘#

可以把:

leave

理解成基本等价于:

mov rsp, rbp
pop rbp

分两步理解即可。


29. leave 第一步:丢掉整个局部变量区域#

首先:

mov rsp, rbp

执行前:

rbp = 984
rsp = 968

执行后:

rsp = 984

于是:

992 返回地址
984 调用者旧 rbp ← rbp
← rsp
980 a = 2
976 b = 3
972 c = 5

这一步相当于:

一口气释放当前函数的局部变量栈空间。

注意这里的“释放”并不表示:

a
b
c

所在的字节立刻被全部清零。

内存里面原先的比特甚至可能暂时仍然存在。

只是:

rsp 已经移动过去,程序不再把那片区域看作当前有效栈空间。

以后新的函数调用、push 等操作完全可以把它覆盖掉。

这也是为什么 C 中:

返回局部变量地址

往往是危险行为。

因为函数返回以后,那片栈空间已经不再归这个函数所有。


30. leave 第二步:恢复调用者的 rbp#

第二步相当于:

pop rbp

当前:

rsp = 984

而:

[984] = 2000

这里保存的是函数开始时通过:

push rbp

保存下来的旧值。

pop rbp 可以粗略理解成:

rbp = [rsp]
rsp += 8

所以:

rbp = 2000
rsp = 992

现在:

992 返回地址 ← rsp

调用者原来的:

rbp = 2000

也已经恢复。

开头和结尾形成了一组非常漂亮的对称:

push rbp
mov rbp, rsp
...
leave

本质上就是:

进入函数:
保存调用者环境
建立自己的栈帧
离开函数:
销毁自己的栈帧
恢复调用者环境

31. 最后的 ret 到底返回到哪里?#

现在只剩:

ret

当前栈顶:

rsp = 992

而:

[992] = 0x400500

这正是之前:

call add

保存下来的返回地址。

ret 可以粗略理解为:

取出栈顶的返回地址
↓
跳转到这个地址
↓
rsp 再增加 8

也就是近似:

rip = [rsp]
rsp += 8

这里又出现了一个重要寄存器:

rip

32. rip:CPU 下一步应该执行哪里?#

CPU 执行机器代码时,总得知道:

下一条指令在哪里?

x86-64 使用:

rip

这个指令指针寄存器保存代码执行位置。

当:

ret

从栈里取到:

0x400500

以后,CPU 会回到:

0x400500

继续执行。

而这个地址恰好就是:

call add

后面的那条指令。

所以:

call

和:

ret

是天然的一对。

可以把整个过程理解成:

main
│
│
│ call add
│
│ 把“回来以后继续执行的位置”压入栈
│
▼
add
│
│ 执行函数
│
│ ret
│
│ 从栈里取出返回地址
│
▼
main 中 call 后面的下一条指令

因此 ret 并不知道:

我要返回 main

它也不认识什么 C 函数。

它只是知道:

栈顶有一个地址,把它取出来,然后跳过去。

这就是函数“返回”的底层含义。


33. 把整个函数执行过程放到一张图里#

现在重新执行一次:

add(2, 3);

进入之前:

edi = 2
esi = 3
rsp = 1000
rbp = 2000

执行:

call add

得到:

rsp = 992
992 返回地址

执行:

push rbp

得到:

992 返回地址
984 旧 rbp ← rsp

执行:

mov rbp, rsp

得到:

rbp = 984
rsp = 984

执行:

sub rsp, 16

得到:

rbp = 984
rsp = 968

执行:

mov DWORD PTR [rbp-4], edi

得到:

a = 2

执行:

mov DWORD PTR [rbp-8], esi

得到:

b = 3

执行:

mov eax, DWORD PTR [rbp-4]

得到:

eax = 2

执行:

add eax, DWORD PTR [rbp-8]

得到:

eax = 5

执行:

mov DWORD PTR [rbp-12], eax

得到:

c = 5

执行:

mov eax, DWORD PTR [rbp-12]

得到:

eax = 5

这个 5 已经准备作为函数返回值。


执行:

leave

得到:

rbp = 2000
rsp = 992

局部变量区域被放弃,只剩:

992 返回地址 ← rsp

执行:

ret

从栈顶获得返回地址,回到调用者。

同时:

eax = 5

于是调用者得到:

add(2, 3) = 5

34. 这段代码执行到中间时,机器到底是什么样?#

假设此时已经计算完:

int c = a + b;

那么 CPU 与内存可以画成:

CPU
┌────────────────────────┐
│ edi = 2 │
│ esi = 3 │
│ eax = 5 │
│ rbp = 984 │
│ rsp = 968 │
└────────────────────────┘
内存 / 栈
高地址
↑
992 返回地址 0x400500
984 调用者旧 rbp = 2000
↑
rbp
980~983 a = 2
976~979 b = 3
972~975 c = 5
968~971 临时空间
↑
rsp
↓
低地址

这张图真正体现了高级语言和机器运行之间的区别。

C 语言里只看到:

a
b
c

而机器真正处理的是:

寄存器里的值
+
内存地址
+
栈指针
+
函数调用约定

35. 再看原汇编,就已经不是乱码了#

重新看:

add:
push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
mov eax, DWORD PTR [rbp-4]
add eax, DWORD PTR [rbp-8]
mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]
leave
ret

现在完全可以逐句翻译成人话。


push rbp

保存调用者原来的 rbp。


mov rbp, rsp

建立当前函数自己的栈帧基准。


sub rsp, 16

给当前函数腾出 16 字节栈空间。


mov DWORD PTR [rbp-4], edi

把第一个整数参数保存成 a。


mov DWORD PTR [rbp-8], esi

把第二个整数参数保存成 b。


mov eax, DWORD PTR [rbp-4]

把 a 取进 eax。


add eax, DWORD PTR [rbp-8]

计算:

eax = a + b

mov DWORD PTR [rbp-12], eax

把结果保存到 c。


mov eax, DWORD PTR [rbp-12]

把 c 放入整数返回值寄存器 eax。


leave

销毁当前函数栈帧,恢复调用者的 rbp。


ret

取出返回地址,回到调用者。


36. rbp-4 中的 4 和 DWORD 中的“4字节”不是一回事#

这是初学时一个非常容易留下的错误理解。

例如:

DWORD PTR [rbp-4]

里面恰好同时出现了两个“4字节相关”的概念。

但两者完全不同。

首先:

rbp - 4

中的:

4

表示:

地址偏移量。

如果:

rbp = 984

那么:

rbp - 4 = 980

只是算出了地址 980。

而:

DWORD PTR

才是在说:

从这个地址开始操作 4 个字节的数据。

所以:

DWORD PTR [rbp-4]

应该理解成:

从地址 rbp-4 开始的 4 字节内存。

不能理解成:

因为减了 4,所以这里自然是 4 字节。

例如理论上完全可能看到:

QWORD PTR [rbp-16]

这里:

-16

仍然只是地址偏移。

而:

QWORD

才表示操作 8 字节。


37. 为什么真实编译器生成的代码可能和本文不一样?#

学习汇编时很快会遇到一个问题:

明明都是:

int add(int a, int b)

为什么不同网站、不同编译器甚至不同优化等级生成的代码不一样?

因为汇编并不存在“唯一正确翻译”。

例如本文的无优化版本:

push rbp
mov rbp, rsp
sub rsp, 16
mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi
mov eax, DWORD PTR [rbp-4]
add eax, DWORD PTR [rbp-8]
mov DWORD PTR [rbp-12], eax
mov eax, DWORD PTR [rbp-12]
leave
ret

实际上非常啰嗦。

编译器一看就知道:

a 没必要存到内存
b 没必要存到内存
c 也没必要真的存在

于是优化后完全可能变成:

mov eax, edi
add eax, esi
ret

直接三条。

甚至还能使用:

lea eax, [rdi+rsi]
ret

完成类似效果。

所以刚开始学习 C 到汇编的映射时:

无优化代码往往更适合学习。

而研究程序真实性能时:

优化后的汇编才更有意义。


38. 栈帧不是所有函数都必须存在#

看完本文,很容易产生另一个误解:

每一个函数都一定有 push rbp / mov rbp,rsp / leave。

并不是。

这是很经典的一种栈帧写法,尤其常见于:

关闭优化
保留 frame pointer
调试构建
教学示例

现代编译器优化以后,经常直接省略 rbp 栈帧。

例如:

add:
mov eax, edi
add eax, esi
ret

这里根本没有:

rbp
rsp
局部变量栈空间

因为这个函数太简单,所有事情只靠寄存器就能完成。

所以更准确的理解应该是:

rbp 栈帧是一种常见的函数管理方式
但不是“函数存在”的必要条件

39. 汇编中的“变量”其实只是人为解释#

这是理解底层非常关键的一步。

当看到:

mov DWORD PTR [rbp-4], edi

我们说:

[rbp-4] 是变量 a

其实 CPU 根本不知道它叫 a。

对 CPU 来说:

[rbp-4]

就只是一段内存。

所谓:

a
b
c

是:

C 编译器
调试信息
程序员

赋予这些存储位置的意义。

类似地:

eax 是返回值
edi 是第一个参数

也并不是这些寄存器刻在硬件上的永久身份。

它们只是:

在当前调用约定和当前时间点下承担这样的角色

同一个 rax 在别的代码中完全可能只是普通临时寄存器。

这也是理解汇编最重要的思想之一:

寄存器和内存本身没有“变量语义”,语义来自程序如何使用它们。


40. 从这一个函数,可以看见 C 语言背后很多东西#

一个只有三行的函数:

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

实际上已经涉及:

CPU 寄存器
内存地址
字节
栈
栈指针
栈帧
参数传递
调用约定
局部变量
返回地址
函数返回值
程序跳转

这些概念以后会不断出现。

例如学习:

int x;

就会涉及栈上的局部变量。

学习:

int *p;

就会真正开始操作地址。

学习:

int a[10];

就会发现数组其实是一片连续内存。

学习:

f(g(x));

就会看到多层函数调用如何不断产生栈帧。

学习递归时:

f(n - 1);

就会理解为什么每一次递归都能够拥有自己的局部变量。

学习栈溢出时,也会明白:

无限递归为什么最终把栈空间耗尽。

甚至以后学习缓冲区溢出时,会发现:

局部数组
保存的 rbp
返回地址

为什么在栈中彼此离得如此之近。


41. 初学阶段真正需要记住的寄存器并不多#

现在没有必要背几十个寄存器。

理解本文只需要先记住几个:

寄存器 当前阶段的理解
rax 64 位通用寄存器
eax rax 的低 32 位,常处理 int,也常装整数返回值
rdi/edi 当前调用约定下常用于第一个整数参数
rsi/esi 当前调用约定下常用于第二个整数参数
rsp 当前栈顶
rbp 常作为当前函数栈帧参考点
rip 指令执行位置

同样,指令也只需要先熟悉几条。

mov A, B

理解成:

A = B

add A, B

理解成:

A = A + B

sub A, B

理解成:

A = A - B

push X

大致理解成:

rsp -= 8
[rsp] = X

pop X

大致理解成:

X = [rsp]
rsp += 8

call X

大致理解成:

保存返回地址
跳到 X

ret

大致理解成:

取出返回地址
跳回去

42. 一套很实用的汇编阅读方法#

以后再遇到 C 对应汇编,不要试图直接“读懂整段代码”。

可以按照下面的顺序。

第一步,先找参数在哪里。

例如:

edi
esi
rdx
...

看函数一开始如何使用它们。

第二步,找到栈帧。

看到:

push rbp
mov rbp, rsp
sub rsp, ...

就先画:

返回地址
旧 rbp
rbp-4
rbp-8
rbp-12
...

第三步,给每个栈位置标名字。

例如发现:

mov [rbp-4], edi

就标:

[rbp-4] = a

发现:

mov [rbp-8], esi

就标:

[rbp-8] = b

这样后面的:

mov eax, [rbp-4]
add eax, [rbp-8]

立刻就可以重新翻译成:

eax = a
eax += b

第四步,始终跟踪几个关键寄存器:

eax
rsp
rbp

第五步,看到 ret 前重点观察:

rax/eax

因为那里往往是返回值。

这套方法比背几十条汇编指令有效得多。


43. 最后重新看一次 add#

现在把源代码和汇编并排来看。

C:

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

汇编:

add:
push rbp
mov rbp, rsp
sub rsp, 16

建立当前函数的栈帧。

mov DWORD PTR [rbp-4], edi
mov DWORD PTR [rbp-8], esi

保存:

a = 2
b = 3
mov eax, DWORD PTR [rbp-4]
add eax, DWORD PTR [rbp-8]

执行:

eax = a + b = 5
mov DWORD PTR [rbp-12], eax

得到:

c = 5
mov eax, DWORD PTR [rbp-12]

准备:

返回值 = 5
leave

恢复栈帧。

ret

根据栈中的返回地址回到调用者。

最终调用者看到:

eax = 5

于是:

add(2, 3)

的值就是:

5

结语#

刚开始学汇编时,很容易把注意力全部放在:

mov 是什么?
DWORD 是什么?
rbp 是什么?

于是汇编就变成了一堆需要死记硬背的缩写。

更好的方式,是先建立一幅机器运行的画面:

CPU 有几个寄存器。
内存是一大排带地址的字节。
rsp 指着栈顶。
rbp 给当前函数提供一个参考点。
call 把返回地址放进栈。
函数把参数和局部数据放在寄存器或栈里。
运算指令真正进行计算。
返回值放入约定的寄存器。
ret 从栈里找到返回地址并跳回去。

有了这幅图,再看:

mov eax, DWORD PTR [rbp-4]

就不会再把它当成一句陌生咒语。

它只是非常机械地说:

去当前函数栈帧中找到那个 4 字节整数,把它复制到 eax。

汇编难的地方从来不只是指令本身,而是它把高级语言替我们隐藏的所有细节重新暴露了出来。

而一旦这些细节能够在脑子里连成一张图,汇编反而会变得相当直白。

从 add(2, 3) 到 ret:零基础看懂 C 函数背后的 x86-64 汇编
https://sanzenin.top/posts/obsidian/汇编入门/
作者
Sanzenin 凪
发布于
2026-08-22
许可协议
CC BY-NC-SA 4.0

分享文章

生成精美分享图或复制链接,与更多人分享本文。

继续阅读

沿着主题读

基于共同的标签与分类

换条路线

从其他文章中稳定抽取