按 32 位 x86 教学模型依次掌握寄存器、常用汇编指令和汇编格式,再说明选择、循环与过程调用如何由机器级控制流和栈帧实现。

本节与教材一样,先建立 “汇编指令怎样读” 的基础,再分别讨论高级语言中的选择、循环和过程调用。以下均以 32 位 x86、Intel 汇编格式和传统 cdecl 调用约定为教学模型;它适合分析 408 常见的反汇编片段,不能不加区别地套用到 x86-64 的 System V、Windows x64 或 ARM ABI。

# 一、常用汇编指令介绍

# 1.1. 相关寄存器

x86 的 32 位通用寄存器包括 EAX 、 EBX 、 ECX 、 EDX 、 ESI 、 EDI 、 EBP 和 ESP 。 E 是 Extended 的缩写:为兼容早期 16 位体系, EAX 、 EBX 、 ECX 、 EDX 的低 16 位可分别以 AX 、 BX 、 CX 、 DX 单独访问;其中低 16 位又可分成两个 8 位部分。

下图用 Mermaid 的 packet 图展示 EAX 的别名关系。横向字段按寄存器的高位到低位阅读;图内 0 至 31 是 Mermaid 给三个栏位的顺序编号,方框中的 [31:16] 、 [15:8] 、 [7:0] 才是实际 x86 位段。 AH 和 AL 不是新寄存器,而是同一组存储位的不同命名。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
packet
0-7: "AL = EAX[0:7]"
8-15: "AH = EAX[8:15]"
16-31: "EAX[16:31]"
32-39: "BL = EBX[0:7]"
40-47: "BH = EBX[8:15]"
48-63: "EBX[16:31]"
64-71: "CL = ECX[0:7]"
72-79: "CH = ECX[8:15]"
80-95: "ECX[16:31]"
96-127: "ESI"
128-159: "EDI"
160-191: "EBP"
192-223: "ESP"

32 位名可访问的旧名传统职责读汇编时的要点
EAXAX 、 AH 、 AL累加器整数返回值通常放在 EAX ;并非每次算术都必须使用它
EBXBX 、 BH 、 BL基址寄存器在本节 cdecl 模型中通常属于被调用者保存寄存器
ECXCX 、 CH 、 CL计数寄存器常作循环计数; CL 可指定移位位数
EDXDX 、 DH 、 DL数据寄存器乘除法中常与 EAX 组成 EDX:EAX ;也常保存临时值
ESI无 8 位旧名源变址寄存器常保存数组或字符串的源地址,仍可作一般用途
EDI无 8 位旧名目的变址寄存器常保存数组或字符串的目的地址,仍可作一般用途
EBP无 8 位旧名栈帧基址指针以固定偏移定位当前过程的参数、局部变量
ESP无 8 位旧名栈顶指针指向当前栈顶; push 、 pop 、 call 、 ret 会隐含修改它

除 EBP 、 ESP 的栈帧角色外,其他 “传统职责” 并非硬性限制。优化后的代码可能用 ESI 保存普通变量,或省略 EBP 而改用 ESP 相对寻址;因此应按指令序列判断用途,而不能只按寄存器名猜测。

# 1.2. 常用指令

以下所有指令均按 Intel 的 “目的操作数在前,源操作数在后” 书写。 <reg> 、 <mem> 、 <con> 的精确定义及两种汇编格式的差异,集中在 1.3 汇编指令格式 说明。

# 1.2.1. 数据传送指令

# mov

mov dst, src 将源值复制到目的地,不改变源操作数。源可为寄存器、内存内容或立即数,目的通常为寄存器或内存。双操作数 mov 的两个操作数不能同时是内存;内存到内存的复制要经寄存器中转。

1
2
3
4
5
6
7
mov eax, ebx              ; R[eax] ← R[ebx]
mov byte ptr [var], 5 ; M[var] 的 1 B ← 5

; 错误:两个操作数不能同时为内存
; mov [dst], [src]
mov eax, [src]
mov [dst], eax

# push

在本节的 32 位、栈向低地址增长模型中, push 先让 ESP 减 4,再把一个双字写入新栈顶:

pushx:ESP←ESP−4,M[ESP]←x.\texttt{push }x:\qquad ESP\leftarrow ESP-4,\quad M[ESP]\leftarrow x.

常见形式为 push <reg32> 、 push <mem> 、 push <con32> 。例如 push eax 压入 eax 的值, push [var] 压入 var 处的 4 B 内容;它们都不是 “把地址压栈”。

# pop

pop 与 push 相反:先读当前栈顶,再让 ESP 加 4。

popd:d←M[ESP],ESP←ESP+4.\texttt{pop }d:\qquad d\leftarrow M[ESP],\quad ESP\leftarrow ESP+4.

pop eax 将栈顶双字写入寄存器; pop [ebx] 则将栈顶双字写到 R[ebx] 指向的内存。栈增长方向和单次调整的字节数属于本模型的约定,不能无条件推广到所有平台。

例题 4.6:用 `mov`、`push`、`pop` 追踪状态

设初始 eax=1 、 ebx=2 、 esp=0x1000 ,栈向低地址增长。执行:

1
2
3
push eax
mov eax, ebx
pop ebx

【解】 push eax 后 esp=0x0ffc ,且 M[0x0ffc]=1M[\texttt{0x0ffc}]=1; mov eax, ebx 后 eax=2 ; pop ebx 取回栈顶的 1 并令 esp=0x1000 。最终 eax=2 、 ebx=1 ,栈指针恢复原值。真正保存旧 eax 的是 push , mov 只做复制。

# 1.2.2. 算术和逻辑运算指令

# add / sub

对二操作数算术指令,第一个操作数既是输入又是结果位置:

addd,s:d←d+s,subd,s:d←d−s.\texttt{add }d,s:\ d\leftarrow d+s, \qquad \texttt{sub }d,s:\ d\leftarrow d-s.

例如 sub eax, 10 表示 R[eax]←R[eax]−10R[eax]\leftarrow R[eax]-10; add byte ptr [var], 10 只修改 var 处的一个字节。与 mov 相同,普通双操作数形式不能把两个内存操作数直接相加或相减。

# inc / dec

inc <reg>/<mem> 和 dec <reg>/<mem> 分别将一个寄存器或内存操作数加 1、减 1,常用于循环变量更新:

1
2
dec eax
inc dword ptr [var]

它们的数值语义分别等同于加 1、减 1;题目若考察标志位,仍须按 x86 对 inc 、 dec 的具体标志规则判断,不能简单替换为 add 、 sub 。

# imul

imul 是有符号整数乘法,常用两操作数和三操作数形式:

1
2
imul eax, dword ptr [var]    ; eax ← eax × M[var]
imul esi, edi, 25 ; esi ← edi × 25

两操作数形式把第一个寄存器作为目的;三操作数形式把第二、第三个操作数相乘,结果写入第一个寄存器,因而不会覆盖第二个操作数。

应与无符号单操作数 mul r/m32 区分: mul 隐含以 EAX 为一个乘数,完整的 64 位乘积放入 EDX:EAX 。若 mul 乘积高 32 位 EDX 非零,结果不能只用 EAX 容纳,x86 会置 CF 、 OF 。

# idiv

idiv r/m32 是有符号除法,隐含使用 EDX:EAX 作为 64 位被除数;执行后商在 EAX ,余数在 EDX 。无符号 div 的寄存器位置相同,只是操作数按无符号数解释。

执行 idiv ebx 前, EDX:EAX 必须已经是正确的 64 位有符号被除数;实际代码常以 cdq 把 EAX 的符号扩展到 EDX 。除数为零,或商无法装入 EAX 时会产生异常。

# and / or / xor

三者按位执行与、或、异或,结果写回第一个操作数:

1
2
3
and eax, 0fh       ; 保留低 4 位,其他位清零
or eax, 80h ; 将第 7 位置 1
xor edx, edx ; edx 清零

xor edx, edx 是常见清零习惯用法,但它也会更新条件标志;只有 “寄存器最终为 0” 时才能把它与 mov edx, 0 等同。

# not

not <reg>/<mem> 对操作数的每一位取反:

1
not byte ptr [var]

它只修改该操作数,适合将位掩码整体反转。

# neg

neg <reg>/<mem> 计算操作数的补码负数,即 x←−xx\leftarrow-x:

1
neg eax

neg 不同于 not :前者是带进位的补码求负,后者仅逐位取反。

# shl / shr

shl 逻辑左移、 shr 逻辑右移;被移位数可以是寄存器或内存,移位次数可由立即数或 cl 指定:

1
2
shl eax, 1         ; eax 逻辑左移 1 位
shr ebx, cl ; ebx 逻辑右移 CL 所给的位数

逻辑右移的高位补 0。不要把它与算术右移或循环移位混为一谈;若题目问移出位、溢出或标志位,应按照指定位宽和指令形式逐位分析。

# 1.2.3. 控制流指令

EIP 相当于程序计数器:顺序执行时它指向下一条指令,控制流指令会改变下一条要执行的位置。 EIP 不是可像 EAX 那样作为普通 <reg> 直接读写的通用寄存器;标签(如 .L1 、 done )是目标机器指令地址的符号名,而不是运行时变量。

# jmp

jmp <label> 无条件转到标签所指的指令地址:

1
jmp begin

执行该指令后,程序不会顺序执行紧随其后的指令,而从 begin 继续。

# jcondition (条件转移)

jcondition <label> 根据状态标志决定是否转移。 je 与 jz 、 jne 与 jnz 分别表示相等 / 为零和不等 / 非零;有符号比较与无符号比较必须使用不同条件:

关系常见跳转标志位解释
相等 / 为零je / jzZF=1
不等 / 非零jne / jnzZF=0
有符号大于、大于等于jg 、 jge依据 ZF 、 SF 、 OF 判断
有符号小于、小于等于jl 、 jle依据 ZF 、 SF 、 OF 判断
无符号小于或等于jbe依据 CF 、 ZF 判断

CPU 不知道一个 C 变量应按 signed 还是 unsigned 解释;编译器通过选择 jg / jle 或 ja / jbe 把该语义编码到分支中。

# cmp / test

cmp a, b 按 a−ba-b 更新标志位但不保存差,也不改写操作数; test a, b 按 a&ba\mathbin{\&}b 更新标志位但不保存与运算结果。常用标志位包括 ZF (结果为 0)、 SF (结果符号)、 CF (无符号进 / 借位相关状态)和 OF (有符号溢出)。

1
2
3
4
5
cmp dword ptr [var], 10
jne loop

test eax, eax
jz zero

第二组指令不会改变 eax ,却可在 eax=0 时令 ZF=1 并跳到 zero ;它是测试某个值是否为零的常用组合。

# call / ret

call <label> 将下一条指令的地址(返回地址)压入栈,再转到被调用过程; ret 从栈顶弹出返回地址并转回调用点之后。二者只解决 “转过去、再回来” 的控制流,参数位置、寄存器保护、局部变量和返回值位置由调用约定确定,详见 第四节。

# 1.3. 汇编指令格式

使用不同编程工具时,汇编文本可能采用 Intel 或 AT&T 格式。两者可以表示同一条机器指令,却不能混读。

对比点AT&T 格式Intel 格式
操作数顺序源, 目的目的, 源
寄存器、立即数前缀%eax 、 $100eax 、 100
内存寻址-8(%ebp)[ebp-8]
复杂寻址8(%edx,%eax,2)[edx+eax*2+8]
宽度说明指令后缀 b 、 w 、 lbyte ptr 、 word ptr 、 dword ptr

例如下列两行具有同一语义,均为 M[R[ebx]]←R[eax]M[R[ebx]]\leftarrow R[eax]:

1
2
3
4
5
# AT&T
mov %eax, (%ebx)

# Intel
mov [ebx], eax

在本节 Intel 格式中, <reg> 表示寄存器, <mem> 表示内存操作数, <con> 表示立即数:

记号含义例子
<reg32>32 位通用寄存器eax 、 ebx 、 ecx 、 edx 、 esi 、 edi 、 ebp 、 esp
<reg16>可访问的 16 位旧名ax 、 bx 、 cx 、 dx
<reg8>可访问的 8 位旧名ah 、 al 、 bh 、 bl 、 ch 、 cl 、 dh 、 dl
<mem>方括号给出的有效地址处的内容[eax] 、 [var+4] 、 dword ptr [eax+ebx]
<con>指令中编码的常量5 、 0fh 、 -8

[eax] 表示地址 R[eax] 所指内存的内容,而不是 eax 本身。若汇编器无法由另一操作数推断内存宽度,需显式写出 byte ptr 、 word ptr 或 dword ptr ;x86 中 word 始终是 16 bit, dword 是 32 bit。

复杂地址的有效地址可写为

EA=R[base]+R[index]×scale+disp.\mathrm{EA}=R[\text{base}]+R[\text{index}]\times\text{scale}+\text{disp}.

例如 [edx+eax*2+8] 的有效地址是 R[edx]+2R[eax]+8R[edx]+2R[eax]+8。方括号说明表达式作为内存地址使用; lea eax, [edx+eax] 是例外,它只计算 R[edx]+R[eax]R[edx]+R[eax],不读取该地址处的内存。

x86 还使用变长编码。机器指令会同时编码操作码、操作数宽度、寄存器 / 寻址方式、位移和立即数;同一助记符的不同形式不是一串固定字节。

汇编形式一种对应编码形式形式为何不同
mov ax, imm16B8 iw目标是 AX ,源是 16 位立即数
mov al, imm8B0 ib目标是 AL ,源是 8 位立即数
mov r/m16, r1689 /r目的可以是寄存器或内存,须有附加字段说明
mov r8, r/m88A /r数据宽度和传送方向不同
mov r16, r/m168B /r与上一行的目的 / 源方向不同

iw 、 ib 是随指令出现的立即数, /r 表示还要有编码寄存器与寻址方式的字段。读十六进制机器码时,应先识别完整指令长度,不能把每个字节都独立当作一条指令。

# 二、选择语句的机器级表示

常见选择结构包括 if-then 和 if-then-else 。编译器先用 cmp 、 test 或算术 / 逻辑指令设置条件码,再以 jcondition 选择分支。对 if-then-else ,最常见的结构是 “条件为假时跳到 else ,真分支结束后无条件跳过假分支”。

1
2
3
4
5
if (test_expr) {
then_statement;
} else {
else_statement;
}

flowchart TD
    A[计算 test_expr 并设置标志位] --> B{条件是否为真?}
    B -->|是| C[then_statement]
    B -->|否| D[else_statement]
    C --> E[done:后续代码]
    D --> E

相应的控制流骨架为:

1
2
3
4
5
6
7
; cmp 或 test 已设置条件标志
jfalse else_part
; then_statement
jmp done
else_part:
; else_statement
done:

补充例题:指针比较为何使用 `jbe`

考虑以下函数。参数 p1 、 p2 已位于当前栈帧的 [ebp+8] 、 [ebp+12] ,返回值放在 eax :

1
2
3
4
int get_cont(int *p1, int *p2) {
if (p1 > p2) return *p2;
return *p1;
}

1
2
3
4
5
6
7
8
9
mov eax, dword ptr [ebp+8]    ; eax ← p1
mov edx, dword ptr [ebp+12] ; edx ← p2
cmp eax, edx
jbe .L1 ; 若 p1 ≤ p2(无符号),转到 return *p1
mov eax, dword ptr [edx] ; return *p2
jmp .L2
.L1:
mov eax, dword ptr [eax] ; return *p1
.L2:

【解】 前两条 mov 取得的是两个指针值; cmp 只留下比较标志。 jbe 采用无符号 “小于等于”,符合本模型将地址按无符号量比较的约定。两个分支最后都把所指向的 int 值装入 eax ,故 .L2 是统一出口。

# 三、循环语句的机器级表示

x86 没有一条与 C 的 while 、 for 、 do-while 完全一一对应的通用指令。编译器以 cmp / test 设置标志位,以 jcondition 建立循环入口、退出点和回边。

# 1. do-while 循环

do-while 是后测循环:先执行循环体,再检查条件,故循环体至少执行一次。

1
2
3
do {
body_statement;
} while (test_expr);

1
2
3
4
loop:
; body_statement
; 计算 test_expr 并设置标志位
jtrue loop

若条件为真, jtrue 跳回 loop 开始下一轮;若为假,顺序执行后续代码。首次进入时不需要先检查 test_expr 。

# 2. while 循环

while 是前测循环:第一次检查即为假时,循环体执行 0 次。可将它理解为带一次初始判断的 do-while 结构:

1
2
3
4
5
6
7
; 计算初始 test_expr 并设置标志位
jfalse done
loop:
; body_statement
; 重新计算 test_expr 并设置标志位
jtrue loop
done:

初始的 jfalse done 正是 while 与 do-while 的根本区别。

# 3. for 循环

for (init_expr; test_expr; update_expr) body_statement 的执行顺序是:先执行一次初始化;每轮先测试条件;条件为真时执行循环体、更新变量,再回到条件测试。因此它可先改写为 while ,再按前测循环翻译。

1
2
3
4
5
init_expr;
while (test_expr) {
body_statement;
update_expr;
}

补充例题:`for` 循环的寄存器分工与回边

将下面函数在 “参数 n 位于 [ebp+8] ” 的模型下读作一段汇编控制流:

1
2
3
4
5
6
int nsum_for(int n) {
int i;
int result = 0;
for (i = 1; i <= n; i++) result += i;
return result;
}

1
2
3
4
5
6
7
8
9
10
11
mov ecx, dword ptr [ebp+8]    ; ecx ← n
mov eax, 0 ; eax ← result = 0
mov edx, 1 ; edx ← i = 1
cmp edx, ecx
jg .L2 ; 若 i > n,第一次即退出
.L1:
add eax, edx ; result += i
add edx, 1 ; i++
cmp edx, ecx
jle .L1 ; 若 i ≤ n,回到循环体
.L2:

【解】 ecx 保存不变的上界, edx 是循环变量, eax 同时保存累加结果和函数返回值。 jg .L2 是前测检查,故 n<1 时循环体不执行; jle .L1 是回边。这里 i 、 n 均为 int ,所以用 signed 的 jg 、 jle ,不能换成无符号跳转。

# 四、过程调用的机器级表示

当过程 P 调用过程 Q 时,机器要完成参数传递、控制转移、现场保护和返回:

  1. P 将实参放在 Q 可访问的位置;
  2. call Q 将返回地址压栈,再转到 Q;
  3. Q 建立自己的栈帧,并在需要时保存寄存器、分配局部变量;
  4. Q 执行过程体,把返回值放到约定位置;
  5. Q 释放局部变量空间并恢复应保留的寄存器;
  6. ret 弹出返回地址,回到 P 中 call 的下一条指令。

在本节的 32 位 cdecl 模型中, EAX 、 ECX 、 EDX 是调用者保存寄存器:调用者若要在 call 后继续使用其旧值,须自行保存。 EBX 、 ESI 、 EDI 是被调用者保存寄存器:被调用过程若使用它们,必须先保存并在返回前恢复。整数返回值通常放在 EAX 。

每次过程执行都拥有一个栈帧。栈从高地址向低地址增长, ESP 随压栈、弹栈动态变化; EBP 在过程执行期间保持为当前帧基址,因此可用固定偏移访问参数和局部变量。一个 caller 调用 add 的典型时刻如下:

flowchart TB
    H[高地址] --> O[调用者 P 的旧帧内容]
    O --> L1[caller:EBP - 4,sum]
    L1 --> L2[caller:EBP - 8,temp2 = 80]
    L2 --> L3[caller:EBP - 12,temp1 = 125]
    L3 --> PAD[为对齐预留的空间]
    PAD --> A2[传给 add 的第二个参数 80]
    A2 --> A1[传给 add 的第一个参数 125]
    A1 --> RA[call 压入的返回地址]
    RA --> OLD[add 帧底部:保存的 caller EBP]
    OLD --> EBP[EBP 指向 add 当前帧基址]
    EBP --> ESP[ESP:会随压栈、弹栈移动]
    ESP --> LO[低地址]

block
  block
    columns 1
    O["调用者 P 的旧帧内容"]
    L1["caller:EBP - 4,sum"]
    L2["caller:EBP - 8,temp2 = 80"]
    L3["caller:EBP - 12,temp1 = 125"]
    PAD["为对齐预留的空间"]
    A2["传给 add 的第二个参数 80"]
    A1["传给 add 的第一个参数 125"]
    RA["call 压入的返回地址"]
    OLD["add 帧底部:保存的 caller EBP"]
    EBP["EBP 指向 add 当前帧基址"]
    ESP["ESP:会随压栈、弹栈移动"]
  end

push ebp; mov ebp, esp 是常见的过程准备阶段:先保存调用者的 EBP ,再让 EBP 指向该保存位置。若调用者执行 sub esp, 24 ,这 24 B 可包含 12 B 的局部变量、8 B 的实参槽及对齐填充。实际使用数据为 4 B(旧 EBP )+ 12 B + 8 B + 4 B(返回地址)= 28 B;为满足 16 B 对齐,栈帧可以扩展为 32 B。

以下 caller 调用 add(temp1, temp2) ,并将结果保存到局部变量 sum :

1
2
3
4
5
6
int caller(void) {
int temp1 = 125;
int temp2 = 80;
int sum = add(temp1, temp2);
return sum;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
caller:
push ebp
mov ebp, esp
sub esp, 24
mov dword ptr [ebp-12], 125
mov dword ptr [ebp-8], 80
mov eax, dword ptr [ebp-8]
mov dword ptr [esp+4], eax ; 第二个实参 temp2
mov eax, dword ptr [ebp-12]
mov dword ptr [esp], eax ; 第一个实参 temp1
call add ; 返回值在 eax
mov dword ptr [ebp-4], eax
mov eax, dword ptr [ebp-4]
leave
ret

call 后紧接着的 mov [ebp-4], eax 正是返回地址指向的下一条工作。 leave 等价于:

1
2
mov esp, ebp
pop ebp

它先回收当前帧的局部空间,再恢复调用者帧指针;随后 ret 从当前栈顶取得返回地址。编译器也可以不用 leave ,而用显式调整 esp 和 pop 完成同一回收动作。

被调用的 add 可以很短:

1
2
3
4
5
6
7
8
add:
push ebp
mov ebp, esp
mov eax, dword ptr [ebp+12] ; y
mov edx, dword ptr [ebp+8] ; x
lea eax, [edx+eax] ; eax ← x + y,不读内存
pop ebp
ret

lea eax, [edx+eax] 的方括号表达式只用于计算地址形式,结果为 R[edx]+R[eax]R[edx]+R[eax];它没有从该数值作为地址的内存单元读取数据。这个 add 没有局部变量、没有调用其他过程,也没有改写需要被调用者保存的 EBX 、 ESI 、 EDI ,故结束阶段只需恢复 EBP 并执行 ret 。