从 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 = 2b = 3c = 5但 CPU 并不知道什么叫“变量 a”。
CPU 真正能够直接处理的东西大致只有两类:
寄存器中的数据内存中的数据以及一些最基础的指令:
复制加法减法跳转比较……所以从底层看:
c = a + b;必须被拆成类似这样的过程:
找到 a↓把 a 取到 CPU 中
找到 b↓执行加法
保存结果汇编做的事情,本质上就是把这些过程明确写出来。
2. CPU 手边的小盒子:寄存器
CPU 内部有一批很小、很快的存储空间,叫做寄存器。
x86-64 中常见的名字有:
raxrbxrcxrdxrsirdirsprbprip……可以暂时把它们理解成 CPU 手边的一排小盒子:
┌─────────────┐│ rax │├─────────────┤│ rbx │├─────────────┤│ rdi │├─────────────┤│ rsi │├─────────────┤│ rsp │├─────────────┤│ rbp │└─────────────┘例如某一刻可能是:
rdi = 2rsi = 3rax = 5这里的:
rdirsirax不是 C 变量。
它们是真正存在于 CPU 内部的硬件存储位置。
3. rax 和 eax 为什么长得这么像?
代码中没有大量出现 rax,反而出现了:
eaxediesi这是因为 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 aint b而现代 x86-64 系统上的普通 int 一般是:
32 bit = 4 byte所以这里经常直接使用:
ediesieax来处理这些 32 位整数。
4. 内存其实可以理解成一排带编号的小格子
内存没有 a、b、c 这种名字。
它更接近:
地址 内容
0x1000 ?0x1001 ?0x1002 ?0x1003 ?0x1004 ?...每一个内存位置都有一个编号,这个编号就是地址。
例如:
0x1000可以理解为:
“编号为 0x1000 的内存位置”。
这里的 0x 表示十六进制。刚开始学习汇编时,不需要急着熟练进行十六进制计算,只需要知道:
0x10000x10010x1002...都是地址即可。
5. 一个 int 为什么需要 4 个字节?
计算机中:
1 byte = 8 bit一个普通的 int 通常是:
32 bit = 4 byte因此:
int x;需要连续占用 4 个字节的内存。
可以想象成:
地址
100 ┐101 │102 │ int x103 ┘这也解释了汇编中的:
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 和编译器按照特定规则来使用它。
假设栈附近的地址是:
高地址
1000992984976968
低地址在 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 - 4b 在 rbp - 8c 在 rbp - 12无论 rsp 如何变化,只要 rbp 保持不动:
rbp - 4rbp - 8rbp - 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 = 2esi = 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 = 2esi = 3
rsp = 1000rbp = 2000并假设返回地址:
0x400500这里的数字只是为了方便演示,并不代表真实程序一定使用这些地址。
13. call add
调用者执行:
call add在 x86-64 上,返回地址占 8 字节。
因此原来:
rsp = 1000保存返回地址之后:
rsp = 992栈变成:
高地址
1000
992 返回地址 0x400500 ← rsp
低地址然后 CPU 跳到:
add:开始执行我们的函数。
14. 第一条:push rbp
push rbppush 可以先粗略理解成:
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 = 2esi = 3
rbp = 2000rsp = 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 = 984rsp = 984栈:
高地址
992 返回地址
984 调用者原来的 rbp ← rbp ← rsp
低地址从这一刻开始:
rbp = 984就成为 add() 自己的固定参考点。
16. 第三条:sub rsp, 16
sub rsp, 16就是:
rsp = rsp - 16所以:
984 - 16 = 968于是:
rbp = 984rsp = 968注意 rbp 没动。
现在栈大致变成:
高地址
992 返回地址
984 旧 rbp ← rbp
980976972968 ← 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 = 980rbp - 8 = 976rbp - 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 - 4rbp - 8rbp - 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 ← rsp20. 保存参数 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 = 2esi = 3为什么还要先存进内存,稍后又取出来?
其实完全可以不这么做。
优化后的代码很可能接近:
mov eax, ediadd eax, esiret甚至编译器还可能根据上下文进一步优化。
本文使用的是便于观察的无优化代码。
无优化情况下,编译器往往会机械地维护源代码中的变量:
参数 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 = 2edi = 2esi = 3而栈依然:
a = 2b = 3c = ?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 + 3eax = 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], eaxmov eax, DWORD PTR [rbp-12]明明:
eax本来已经是 5。
理论上直接返回就行。
之所以出现:
eax → cc → eax仍然是因为这是无优化代码。
源代码明确写了:
int c = a + b;return c;所以编译器忠实地制造出了一个真实存在于栈中的 c。
打开优化以后,这种无意义的来回搬运通常会被直接删除。
27. 函数执行完了,但栈还没恢复
现在状态大概是:
eax = 5
rbp = 984rsp = 968栈:
高地址
992 返回地址
984 调用者旧 rbp ← rbp
980~983 a = 2
976~979 b = 3
972~975 c = 5
968~971 ← rsp
低地址问题来了:
当前函数马上要结束。
它不能就这样直接回去。
因为:
rsprbp都已经被 add() 改过了。
必须恢复进入函数之前的状态。
于是出现:
leave28. leave 并不神秘
可以把:
leave理解成基本等价于:
mov rsp, rbppop rbp分两步理解即可。
29. leave 第一步:丢掉整个局部变量区域
首先:
mov rsp, rbp执行前:
rbp = 984rsp = 968执行后:
rsp = 984于是:
992 返回地址
984 调用者旧 rbp ← rbp ← rsp
980 a = 2
976 b = 3
972 c = 5这一步相当于:
一口气释放当前函数的局部变量栈空间。
注意这里的“释放”并不表示:
abc所在的字节立刻被全部清零。
内存里面原先的比特甚至可能暂时仍然存在。
只是:
rsp已经移动过去,程序不再把那片区域看作当前有效栈空间。
以后新的函数调用、push 等操作完全可以把它覆盖掉。
这也是为什么 C 中:
返回局部变量地址
往往是危险行为。
因为函数返回以后,那片栈空间已经不再归这个函数所有。
30. leave 第二步:恢复调用者的 rbp
第二步相当于:
pop rbp当前:
rsp = 984而:
[984] = 2000这里保存的是函数开始时通过:
push rbp保存下来的旧值。
pop rbp 可以粗略理解成:
rbp = [rsp]rsp += 8所以:
rbp = 2000rsp = 992现在:
992 返回地址 ← rsp调用者原来的:
rbp = 2000也已经恢复。
开头和结尾形成了一组非常漂亮的对称:
push rbpmov rbp, rsp
...
leave本质上就是:
进入函数:保存调用者环境建立自己的栈帧
离开函数:销毁自己的栈帧恢复调用者环境31. 最后的 ret 到底返回到哪里?
现在只剩:
ret当前栈顶:
rsp = 992而:
[992] = 0x400500这正是之前:
call add保存下来的返回地址。
ret 可以粗略理解为:
取出栈顶的返回地址
↓
跳转到这个地址
↓
rsp 再增加 8也就是近似:
rip = [rsp]rsp += 8这里又出现了一个重要寄存器:
rip32. 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 = 2esi = 3
rsp = 1000rbp = 2000执行:
call add得到:
rsp = 992
992 返回地址执行:
push rbp得到:
992 返回地址
984 旧 rbp ← rsp执行:
mov rbp, rsp得到:
rbp = 984rsp = 984执行:
sub rsp, 16得到:
rbp = 984rsp = 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 = 2000rsp = 992局部变量区域被放弃,只剩:
992 返回地址 ← rsp执行:
ret从栈顶获得返回地址,回到调用者。
同时:
eax = 5于是调用者得到:
add(2, 3) = 534. 这段代码执行到中间时,机器到底是什么样?
假设此时已经计算完:
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 语言里只看到:
abc而机器真正处理的是:
寄存器里的值
+
内存地址
+
栈指针
+
函数调用约定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 + bmov 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 rbpmov rbp, rspsub rsp, 16
mov DWORD PTR [rbp-4], edimov DWORD PTR [rbp-8], esi
mov eax, DWORD PTR [rbp-4]add eax, DWORD PTR [rbp-8]
mov DWORD PTR [rbp-12], eaxmov eax, DWORD PTR [rbp-12]
leaveret实际上非常啰嗦。
编译器一看就知道:
a 没必要存到内存
b 没必要存到内存
c 也没必要真的存在于是优化后完全可能变成:
mov eax, ediadd eax, esiret直接三条。
甚至还能使用:
lea eax, [rdi+rsi]ret完成类似效果。
所以刚开始学习 C 到汇编的映射时:
无优化代码往往更适合学习。
而研究程序真实性能时:
优化后的汇编才更有意义。
38. 栈帧不是所有函数都必须存在
看完本文,很容易产生另一个误解:
每一个函数都一定有
push rbp / mov rbp,rsp / leave。
并不是。
这是很经典的一种栈帧写法,尤其常见于:
关闭优化保留 frame pointer调试构建教学示例现代编译器优化以后,经常直接省略 rbp 栈帧。
例如:
add: mov eax, edi add eax, esi ret这里根本没有:
rbprsp局部变量栈空间因为这个函数太简单,所有事情只靠寄存器就能完成。
所以更准确的理解应该是:
rbp 栈帧是一种常见的函数管理方式
但不是“函数存在”的必要条件39. 汇编中的“变量”其实只是人为解释
这是理解底层非常关键的一步。
当看到:
mov DWORD PTR [rbp-4], edi我们说:
[rbp-4] 是变量 a其实 CPU 根本不知道它叫 a。
对 CPU 来说:
[rbp-4]就只是一段内存。
所谓:
abc是:
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 = Badd A, B理解成:
A = A + Bsub A, B理解成:
A = A - Bpush X大致理解成:
rsp -= 8[rsp] = Xpop X大致理解成:
X = [rsp]rsp += 8call X大致理解成:
保存返回地址跳到 Xret大致理解成:
取出返回地址跳回去42. 一套很实用的汇编阅读方法
以后再遇到 C 对应汇编,不要试图直接“读懂整段代码”。
可以按照下面的顺序。
第一步,先找参数在哪里。
例如:
ediesirdx...看函数一开始如何使用它们。
第二步,找到栈帧。
看到:
push rbpmov rbp, rspsub rsp, ...就先画:
返回地址旧 rbprbp-4rbp-8rbp-12...第三步,给每个栈位置标名字。
例如发现:
mov [rbp-4], edi就标:
[rbp-4] = a发现:
mov [rbp-8], esi就标:
[rbp-8] = b这样后面的:
mov eax, [rbp-4]add eax, [rbp-8]立刻就可以重新翻译成:
eax = aeax += b第四步,始终跟踪几个关键寄存器:
eaxrsprbp第五步,看到 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 = 2b = 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。
汇编难的地方从来不只是指令本身,而是它把高级语言替我们隐藏的所有细节重新暴露了出来。
而一旦这些细节能够在脑子里连成一张图,汇编反而会变得相当直白。
分享文章
生成精美分享图或复制链接,与更多人分享本文。
继续阅读
最后更新于 ,距今已过 86 天
部分内容可能已过时