汇编语言编程完全指南
一、汇编语言概述
1.1 语言简介
汇编语言(Assembly Language)是一种低级编程语言,与计算机的机器指令一一对应。它是人类可读的机器码表示形式,通过助记符(Mnemonics)来代表二进制的机器指令。
核心特征:
| 特性 | 说明 |
|---|---|
| 机器直接 | 每条汇编指令对应一条机器指令,与CPU架构强绑定 |
| 助记符表示 | 使用人类可读的单词(如MOV、ADD、JMP)代替二进制码 |
| 完全控制 | 直接操控寄存器、内存地址、CPU标志位 |
| 极致性能 | 无运行时开销,精确控制每一条指令的执行 |
| 架构相关 | x86、ARM、RISC-V 各自主流不同的汇编语法 |
| 无抽象 | 没有类型检查、内存安全、垃圾回收等高层抽象 |
汇编语言在计算机体系中的位置:
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
1.2 汇编语言的用途
| 领域 | 应用场景 | 说明 |
|---|---|---|
| 操作系统内核 | 引导加载器、中断处理、上下文切换 | 需要直接操作特定寄存器和硬件 |
| 驱动程序开发 | 设备初始化、DMA控制、I/O端口操作 | 必须使用特权指令和内存映射 |
| 嵌入式系统 | 微控制器编程、实时控制系统 | 资源受限,需要用汇编优化 |
| 性能优化 | 热点代码重写、SIMD向量化、加密算法 | 编译器无法做到的最优指令调度 |
| 逆向工程 | 二进制分析、漏洞挖掘、软件破解 | 反编译的目标就是汇编代码 |
| 编译器开发 | 代码生成后端、JIT编译 | 将高级语言翻译为汇编/机器码 |
| 安全研究 | Shellcode编写、ROP链构建、漏洞利用 | 需要精确控制二进制输出 |
1.3 主要汇编语法对比
| 特性 | AT&T 语法(GAS) | Intel 语法(NASM/MASM) |
|---|---|---|
| 操作数顺序 | 源在前,目的在后:movl $5, %eax |
目的在前,源在后:mov eax, 5 |
| 寄存器前缀 | %eax、%rbx |
eax、rbx |
| 立即数前缀 | $5、$0x10 |
5、0x10 |
| 内存操作数 | (%ebx)、4(%ebx) |
[ebx]、[ebx+4] |
| 指令大小后缀 | movb、movw、movl、movq |
mov byte、mov word、mov dword |
| 主要使用者 | GCC、Linux内核、GDB | Windows、IDA Pro、MSVC |
本指南默认使用 Intel 语法(NASM),因为它是逆向工程、Windows开发和大多数现代工具的首选语法。
1.4 环境搭建
Linux(推荐 Ubuntu/Debian):
BASH
# ========== 安装汇编工具链 ==========
# NASM 汇编器
sudo apt update
sudo apt install nasm
# GNU 汇编器(GAS,可选)
sudo apt install binutils
# 链接器
sudo apt install binutils-gold # 推荐 gold linker
# 调试器
sudo apt install gdb
sudo apt install gdb-multiarch # 多架构支持
# 反汇编工具
sudo apt install objdump
sudo apt install radare2 # 高级逆向工具
# 编译辅助
sudo apt install build-essential
sudo apt install gcc g++
# 验证安装
nasm --version
# NASM version 2.16.x
gdb --version
ld --version
macOS:
BASH
# 使用 Homebrew 安装
brew install nasm
brew install gdb
# macOS 自带 LLVM 汇编器
# /usr/bin/as —— LLVM 集成汇编器
# /usr/bin/otool —— 反汇编工具
Windows:
BASH
# MSYS2/MinGW-w64 环境(推荐)
pacman -S mingw-w64-x86_64-nasm
pacman -S mingw-w64-x86_64-gdb
pacman -S mingw-w64-x86_64-gcc
1.5 第一个汇编程序
ASM
; ============================================================
; hello.asm —— 在 Linux x86-64 上输出 "Hello, World!"
; 编译: nasm -f elf64 hello.asm -o hello.o
; 链接: ld hello.o -o hello
; 运行: ./hello
; ============================================================
section .data
msg db 'Hello, World!', 0x0A ; 字符串 + 换行符
msg_len equ $ - msg ; 计算字符串长度
section .text
global _start ; 程序入口,链接器需要
_start:
; sys_write(1, msg, msg_len)
mov rax, 1 ; 系统调用号: sys_write
mov rdi, 1 ; fd = 1 (stdout)
mov rsi, msg ; 缓冲区地址
mov rdx, msg_len ; 字节数
syscall ; 触发系统调用
; sys_exit(0)
mov rax, 60 ; 系统调用号: sys_exit
xor rdi, rdi ; exit_code = 0
syscall ; 触发系统调用
BASH
# 一行命令编译并运行
nasm -f elf64 hello.asm -o hello.o && ld hello.o -o hello && ./hello
# 输出: Hello, World!
1.6 x86 处理器发展简史
| 年代 | 架构 | 字长 | 主要特征 |
|---|---|---|---|
| 1978 | 8086/8088 | 16位 | x86 架构起点,段式内存模型 |
| 1985 | 80386 | 32位 | 引入保护模式、分页、32位通用寄存器 |
| 1993 | Pentium | 32位 | 超标量、分支预测、MMX指令集 |
| 1999 | Pentium III | 32位 | SSE 指令集(SIMD 浮点) |
| 2003 | Athlon 64 | 64位 | AMD64 (x86-64) 扩展,16个通用寄存器 |
| 2011 | Sandy Bridge | 64位 | AVX 指令集,256位 SIMD |
| 2017 | Zen / Skylake-X | 64位 | AVX2/AVX-512 扩展 |
| 2020+ | Zen 4 / Raptor Lake | 64位 | 更多核心、更高频率、AVX-512 普及 |
1.7 各部分如何分工协作
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
二、基础语法详解
2.1 x86-64 通用寄存器
x86-64 架构提供 16个64位通用寄存器,每个寄存器有不同的历史命名和隐含用途。理解寄存器的命名习惯是编写有效汇编代码的基础。
CODE
64位: RAX, RBX, RCX, RDX, RSI, RDI, RBP, RSP, R8-R15
32位: EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP, R8D-R15D
16位: AX, BX, CX, DX, SI, DI, BP, SP, R8W-R15W
8位: AL, BL, CL, DL, SIL, DIL, BPL, SPL, R8B-R15B
8位H: AH, BH, CH, DH (仅低8位的高字节)
寄存器功能与隐含用途:
| 寄存器 | 64位 | 32位 | 16位 | 8位 | 常用隐含角色 |
|---|---|---|---|---|---|
| 累加器 | RAX | EAX | AX | AL | 函数返回值、算术运算结果 |
| 基址 | RBX | EBX | BX | BL | 被调用者保存,数据指针 |
| 计数 | RCX | ECX | CX | CL | 循环计数器、REP前缀、变参计数 |
| 数据 | RDX | EDX | DX | DL | 除法余数、函数第3参数、I/O端口 |
| 源索引 | RSI | ESI | SI | SIL | 字符串/数据源指针(函数第2参数) |
| 目标索引 | RDI | EDI | DI | DIL | 字符串/数据目标指针(函数第1参数) |
| 基指针 | RBP | EBP | BP | BPL | 栈帧基址指针 |
| 栈指针 | RSP | ESP | SP | SPL | 栈顶指针 |
| 扩展 | R8-R15 | R8D-R15D | R8W-R15W | R8B-R15B | 通用,第4-第6函数参数 |
调用约定中的寄存器分类:
| 类型 | 寄存器 | 说明 |
|---|---|---|
| 被调用者保存(Callee-saved) | RBX, RBP, R12-R15 | 函数必须恢复原值 |
| 调用者保存(Caller-saved) | RAX, RCX, RDX, RSI, RDI, R8-R11 | 调用者需自行保存 |
| 返回值 | RAX(64位)、RAX+RDX(128位) | 函数返回值 |
| 参数传递 | RDI, RSI, RDX, RCX, R8, R9 | 前6个整数/指针参数 |
| 浮点返回值 | XMM0 | 浮点/向量返回值 |
2.2 寄存器操作示例
ASM
section .text
global _start
_start:
; ========== 赋值与移动 ==========
; 寄存器 → 寄存器
mov rax, 42 ; rax = 42
mov rbx, rax ; rbx = rax
mov r8, 0xDEADBEEF ; r8 = 0xDEADBEEF
; ========== 32/16/8 位子寄存器 ==========
mov eax, 0x12345678 ; 注意:写32位寄存器自动清零高32位!
; rax = 0x0000000012345678
mov ax, 0xFFFF ; 写16位寄存器不影响高48位
mov al, 0x42 ; 写8位寄存器不影响其他位
; ========== 加法和减法 ==========
add rax, rbx ; rax += rbx
sub rax, 10 ; rax -= 10
inc rax ; rax++ (不影响CF标志)
dec rax ; rax-- (不影响CF标志)
; ========== 乘法和除法 ==========
; 乘法:mul r/m → RDX:RAX = RAX * r/m
mov rax, 1000
mov rcx, 2000
mul rcx ; RDX:RAX = RAX * RCX
; 有符号乘法
mov rax, -100
mov rcx, 200
imul rax, rcx ; rax = rax * rcx (截断到64位)
; 除法:div r/m → RAX = RDX:RAX / r/m, RDX = 余数
xor rdx, rdx ; 清零 rdx
mov rax, 1000
mov rcx, 7
div rcx ; rax = 142 (商), rdx = 6 (余数)
; 有符号除法
mov rax, -1000
cqo ; 符号扩展 RAX → RDX:RAX
mov rcx, 7
idiv rcx ; rax = -142, rdx = -6
; ========== 逻辑运算 ==========
and rax, 0x0F ; 按位与
or rax, 0xF0 ; 按位或
xor rax, rax ; 异或(清零惯用法,比 mov rax,0 更高效)
not rax ; 按位取反
neg rax ; 取负
; ========== 移位操作 ==========
shl rax, 1 ; 逻辑左移1位(相当于 *2)
shr rax, 1 ; 逻辑右移1位(无符号 /2)
sar rax, 1 ; 算术右移1位(有符号 /2,保留符号位)
rol rax, 1 ; 循环左移
ror rax, 1 ; 循环右移
shl rax, cl ; 左移 cl 位(移位位数必须放在 CL 中)
; ========== 条件移动(CMOVcc)==========
cmp rax, rbx
cmovg rax, rcx ; 如果 rax > rbx,则 rax = rcx
cmove rax, rdx ; 如果 rax == rbx,则 rax = rdx
; ========== 地址加载 ==========
lea rax, [rbx + rcx*4 + 8] ; rax = rbx + rcx*4 + 8 (不访问内存)
lea rax, [rel msg] ; 加载 msg 的地址(位置无关代码)
; 退出
mov rax, 60
xor rdi, rdi
syscall
2.3 数据类型与大小
汇编语言本身没有类型系统,数据类型通过指令的后缀(AT&T)或操作数大小限定符(Intel NASM)来表达。
| 数据类型 | 缩写 | 大小 | 示例定义 |
|---|---|---|---|
| Byte(字节) | db | 1字节 | db 0x42 |
| Word(字) | dw | 2字节 | dw 0x1234 |
| Double Word(双字) | dd | 4字节 | dd 0xDEADBEEF |
| Quad Word(四字) | dq | 8字节 | dq 0x1234567890ABCDEF |
| Ten Bytes(十字节) | dt | 10字节 | dt 3.14159(x87浮点) |
| Double-Octo Word | do | 16字节 | do 0x...(XMM寄存器大小) |
| YMM Word | dy | 32字节 | dy 0x...(YMM寄存器大小) |
| ZMM Word | dz | 64字节 | dz 0x...(ZMM寄存器大小) |
NASM 操作数大小限定:
ASM
section .text
global _start
_start:
; ========== 使用大小限定操作 ==========
; 当操作数大小不能从寄存器推断时,需要显式指定大小
mov byte [buffer], 0x41 ; 写入1字节
mov word [buffer], 0x4241 ; 写入2字节
mov dword [buffer], 0x1234 ; 写入4字节
mov qword [buffer], rax ; 写入8字节(可从寄存器推断)
; ========== 符号扩展 ==========
; 有符号扩展:cbw/cwde/cdqe
mov al, -1 ; al = 0xFF
cbw ; ax = 0xFFFF (AL → AX)
cwde ; eax = 0xFFFFFFFF (AX → EAX)
cdqe ; rax = 0xFFFFFFFFFFFFFFFF (EAX → RAX)
cqo ; rdx:rax = rax 的符号扩展
; ========== 零扩展 ==========
; movzx: 零扩展
mov al, 0x7F
movzx eax, al ; eax = 0x0000007F
movzx rax, word [buffer] ; 从内存读2字节,零扩展到8字节
; ========== 有符号扩展 ==========
; movsx: 符号扩展
mov al, 0x80
movsx eax, al ; eax = 0xFFFFFF80
movsx rax, dword [buffer] ; 从内存读4字节,符号扩展到8字节
section .bss
buffer resb 16 ; 预留16字节的缓冲区
2.4 数据段定义
ASM
section .data
; ========== 已初始化数据 ==========
; 整型常量
a_byte db 0x42 ; 1字节: 66
a_word dw 0x1234 ; 2字节
a_dword dd 0xDEADBEEF ; 4字节
a_qword dq 0x1234567890ABCDEF ; 8字节
; 字符串
greeting db 'Hello, World!', 0x0A ; 以逗号分隔多个值
hello_len equ $ - greeting ; 当前地址 - 起始地址 = 长度
; 有符号数值
negative dd -12345
pi_single dd 3.14159 ; 单精度浮点
; 数组
array dd 1, 2, 3, 4, 5 ; 5个双字
squares dq 0, 1, 4, 9, 16, 25 ; 6个四字
byte_arr db 0, 1, 2, 3, 4, 5, 6, 7 ; 8个字节
; 重复定义
zeros times 100 db 0 ; 100个0
pattern times 8 dw 0xABCD ; 8个0xABCD
; 指针 / 地址引用
ptr_array dq array ; 存储 array 的地址
section .bss
; ========== 未初始化数据 ==========
buffer resb 256 ; 256个字节
int_array resd 100 ; 100个双字
qword_buf resq 10 ; 10个四字
section .text
global _start
_start:
; 访问数据段中的数据
mov al, byte [a_byte] ; 读1字节
mov eax, dword [a_dword] ; 读4字节
mov rax, qword [squares + 8*3] ; 读 squares[3] = 9
2.5 x86-64 寻址模式
寻址模式决定了 CPU 如何计算内存操作数的有效地址。x86-64 提供极其灵活的寻址方式。
通用格式:
CODE
[base + index * scale + displacement]
| 组件 | 说明 | 合法值 |
|---|---|---|
| base | 基址寄存器 | 任何通用寄存器 |
| index | 索引寄存器 | 任何通用寄存器(不能是RSP) |
| scale | 缩放因子 | 1, 2, 4, 8 |
| displacement | 位移/偏移量 | -2^31 ~ 2^31-1 |
寻址模式示例:
ASM
section .data
arr dd 10, 20, 30, 40, 50, 60, 70, 80
table dq func0, func1, func2, func3 ; 函数指针表
section .text
; ========== 1. 立即寻址 ==========
; 操作数就是立即数本身
mov eax, 42 ; eax = 42
; ========== 2. 寄存器寻址 ==========
; 操作数在寄存器中
mov eax, ebx ; eax = ebx
; ========== 3. 直接寻址 ==========
; [地址] —— 从指定内存地址读写
mov eax, dword [arr] ; eax = [arr] = 10
; ========== 4. 寄存器间接寻址 ==========
; [寄存器] —— 寄存器存放着地址
lea rsi, [arr] ; rsi = arr 的地址
mov eax, dword [rsi] ; eax = *rsi = 10
; ========== 5. 基址+位移寻址 ==========
; [base + displacement]
mov eax, dword [rsi + 4] ; eax = arr[1] = 20
mov eax, dword [rsi - 4] ; 负偏移也可以
; ========== 6. 基址+索引+缩放寻址 ==========
; [base + index * scale]
mov ecx, 3
mov eax, dword [rsi + rcx*4] ; eax = arr[3] = 40
; ========== 7. 基址+索引+缩放+位移寻址 ==========
; [base + index * scale + displacement]
mov eax, dword [rsi + rcx*4 + 8] ; arr[rcx + 2] = arr[5] = 60
; ========== 8. RIP相对寻址 ==========
; x86-64 新增,用于位置无关代码(PIC)
mov eax, dword [rel arr] ; 相对于当前指令地址
lea rsi, [rel arr] ; 加载相对地址
; ========== 9. 跳转表寻址(jump table)==========
; 常用于 switch 语句的实现
lea rbx, [rel table]
jmp qword [rbx + rcx*8] ; 跳转到 func[rcx]
; 退出
mov rax, 60
xor rdi, rdi
syscall
2.6 操作数大小与NASM限定符
ASM
section .bss
buf resb 8 ; 8字节缓冲区
section .text
; 从内存加载时,当不能从目标寄存器推断大小时需显式指定
; 以下四个指令的区别:
; 错误: mov [buf], 0x1234
; NASM 报错: operation size not specified
mov byte [buf], 0x42 ; [buf] = 0x42 (1字节)
mov word [buf], 0x1234 ; [buf] = 0x34, [buf+1] = 0x12
mov dword [buf], 0xDEADBEEF ; 4字节
mov qword [buf], 0x1234567890ABCDEF ; 8字节
; STRICT 限定(强制使用最小编码)
; 默认 NASM 会优化 mov rax, 1 为 mov eax, 1 (节省字节)
mov rax, 1 ; 编码为 B8 01000000 (7字节)
mov rax, strict dword 1 ; 编码为 48 C7C0 01000000 (7字节)
mov rax, strict qword 1 ; 编码为 48 B8 01000000... (10字节)
2.7 常用指令格式参考
ASM
; ========== 数据传输指令 ==========
; MOV —— 移动数据
mov r/m, r/m/i ; 注意:不能两个都是内存操作数
; LEA —— 加载有效地址(不访问内存)
lea r, [base + idx*scale + disp]
; PUSH / POP —— 入栈/出栈
push r/m/i ; RSP -= 8; [RSP] = value
pop r/m ; value = [RSP]; RSP += 8
; PUSHA / POPA —— 全部通用寄存器入栈/出栈(仅32位模式)
pushfq ; RFLAGS 入栈
popfq ; RFLAGS 出栈
; XCHG —— 交换
xchg r/m, r ; 交换两个操作数
; CMPXCHG —— 比较并交换(CAS 原语)
cmpxchg r/m, r ; 如果 [r/m]==AL/AX/EAX/RAX,则 [r/m]=r,否则 r=[r/m]
; 常用于实现原子操作和无锁数据结构(lock cmpxchg)
; ========== 算术指令 ==========
ADD dst, src ; dst += src
SUB dst, src ; dst -= src
ADC dst, src ; dst += src + CF (带进位加)
SBB dst, src ; dst -= src + CF (带借位减)
INC dst ; dst++
DEC dst ; dst--
MUL src ; 无符号乘: RDX:RAX = RAX * src
IMUL dst, src ; 有符号乘: dst *= src
DIV src ; 无符号除: RAX = RDX:RAX / src
IDIV src ; 有符号除
NEG dst ; dst = -dst
; ========== 逻辑指令 ==========
AND dst, src
OR dst, src
XOR dst, src
NOT dst
; ========== 移位指令 ==========
SHL dst, count ; 逻辑左移
SHR dst, count ; 逻辑右移
SAR dst, count ; 算术右移(保留符号)
ROL dst, count ; 循环左移
ROR dst, count ; 循环右移
SHLD dst, src, count ; 双精度左移
SHRD dst, src, count ; 双精度右移
; ========== 比较指令 ==========
CMP left, right ; 计算 left - right,只影响标志位,不修改目的操作数
TEST left, right ; 计算 left & right,只影响标志位
; ========== 跳转指令 ==========
JMP target ; 无条件跳转
Jcc target ; 条件跳转 (见 4.1 节)
; ========== 字符串指令 ==========
MOVSB ; [RDI] = [RSI]; RSI++; RDI++ (1字节)
MOVSW ; 同上,2字节
MOVSD ; 同上,4字节
MOVSQ ; 同上,8字节
LODSB ; AL = [RSI]; RSI++/--
STOSB ; [RDI] = AL; RDI++/--
CMPSB ; 比较 [RSI] 和 [RDI]
SCASB ; 比较 AL 和 [RDI]
; 配合 REP/REPE/REPNE 前缀使用
; ========== 系统指令 ==========
SYSCALL ; 64位系统调用
SYSENTER ; Intel 快速系统调用
INT n ; 中断调用
HLT ; 暂停CPU(等待中断)
CPUID ; 获取CPU信息
RDTSC ; 读取时间戳计数器
2.8 标志寄存器
| 位 | 标志 | 名称 | 说明 |
|---|---|---|---|
| 0 | CF | 进位标志 | 无符号运算进位/借位 |
| 2 | PF | 奇偶标志 | 运算结果低8位中1的个数为偶数 |
| 4 | AF | 辅助进位标志 | BCD运算的进位(用于AAA等指令) |
| 6 | ZF | 零标志 | 运算结果为零 |
| 7 | SF | 符号标志 | 运算结果为负(最高位为1) |
| 10 | DF | 方向标志 | 字符串操作方向(0=递增,1=递减) |
| 11 | OF | 溢出标志 | 有符号运算溢出 |
ASM
section .text
; ========== 标志位操作 ==========
; CF (进位标志) 操作
stc ; CF = 1
clc ; CF = 0
cmc ; CF = ~CF
; DF (方向标志) 操作
std ; DF = 1 (字符串操作递减)
cld ; DF = 0 (字符串操作递增)
; 保存和恢复标志
pushfq ; 保存 RFLAGS 到栈
popfq ; 从栈恢复 RFLAGS
; LAHF / SAHF (兼容旧版)
lahf ; AH = FLAGS 的低8位
sahf ; FLAGS 的低8位 = AH
三、常用指令集详解
3.1 MOV —— 数据传输
ASM
section .data
src dq 0x1122334455667788
dst dq 0
section .text
_start:
; ========== MOV 基础用法 ==========
; 寄存器 ← 立即数
mov rax, 0x1234567890ABCDEF
mov ebx, 42
mov cl, 0xFF
; 寄存器 ← 寄存器
mov rcx, rax
; 寄存器 ← 内存
mov rdx, qword [src]
; 内存 ← 寄存器
mov qword [dst], rdx
; 内存 ← 立即数
mov dword [dst], 0xDEADBEEF
mov word [dst], 0xBEEF
; ========== MOVZX 零扩展移动 ==========
; 从较小的源移动到较大的目标,高位填零
mov al, 0x7F
movzx eax, al ; eax = 0x0000007F
movzx rax, word [src] ; 从内存读2字节零扩展到8字节
; ========== MOVSX 符号扩展移动 ==========
; 从较小的源移动到较大的目标,高位填符号位
mov al, 0x80
movsx eax, al ; eax = 0xFFFFFF80
movsx rax, dword [src] ; 从内存读4字节符号扩展到8字节
; ========== MOVSXD 双字到四字符号扩展 ==========
; x86-64 特有
movsxd rax, dword [src] ; 32位有符号 → 64位有符号
; ========== 条件移动 CMOVcc ==========
; 避免分支,提升性能
cmp rax, rbx
cmovl rax, rbx ; 如果 rax < rbx, rax = rbx (有符号)
; 可用条件码: CMOVE/CMOVNE, CMOVG/CMOVGE, CMOVL/CMOVLE
; CMOVA/CMOVAE, CMOVB/CMOVBE, CMOVO/CMOVNO, CMOVS/CMOVNS
mov rax, 60
xor rdi, rdi
syscall
3.2 LEA —— 地址计算
ASM
section .data
arr dq 10, 20, 30, 40, 50
matrix dd 1, 2, 3, 4, 5, 6, 7, 8, 9 ; 3x3 矩阵
section .text
_start:
; ========== LEA 与 MOV 的本质区别 ==========
; MOV 访问内存,LEA 只计算地址
lea rax, [arr] ; rax = arr 的地址(等价于 mov rax, arr)
mov rax, qword [arr] ; rax = [arr] = 10(实际访问内存)
; ========== LEA 用于乘法优化 ==========
; lea 可以在一个周期内完成 加法+移位
mov rcx, 5
lea rax, [rcx * 2] ; rax = rcx * 2
lea rax, [rcx * 4] ; rax = rcx * 4
lea rax, [rcx * 8] ; rax = rcx * 8
lea rax, [rcx + rcx*2] ; rax = rcx * 3
lea rax, [rcx + rcx*4] ; rax = rcx * 5
lea rax, [rcx*4 + rcx] ; 同上
lea rax, [rcx*8 + rcx*2] ; rax = rcx * 10
; 比 imul 快得多!
; ========== LEA 用于简单加法(同时用3个操作数)==========
; 目的 = 源1 + 源2*scale + 位移
mov rbx, 100
lea rax, [rbx + rcx*4 + 8] ; rax = rbx + rcx*4 + 8
; ========== 计算数组地址 ==========
mov rsi, 2
lea rax, [arr + rsi*8] ; rax = arr[2] 的地址
mov rdx, qword [rax] ; rdx = arr[2] = 30
; ========== 计算二维数组地址 ==========
; matrix[1][2],假设每行3个元素,每个4字节
mov rcx, 1 ; 行
mov rdx, 2 ; 列
lea rax, [rcx + rcx*2] ; rax = 行 * 3
add rax, rdx ; rax = 行*3 + 列
mov eax, dword [matrix + rax*4] ; eax = matrix[1][2] = 6
mov rax, 60
xor rdi, rdi
syscall
3.3 PUSH / POP —— 栈操作
ASM
section .text
global _start
_start:
mov rax, 0xAAAAAAAAAAAAAAAA
mov rbx, 0xBBBBBBBBBBBBBBBB
mov rcx, 0xCCCCCCCCCCCCCCCC
; ========== PUSH ==========
; push 的完整步骤: RSP -= 8; [RSP] = operand
push rax ; 将 rax 压栈
push rbx ; 将 rbx 压栈
push rcx ; 将 rcx 压栈
; 此时栈: [top] rcx, rbx, rax [bottom]
; 压入立即数
push 42 ; 压入立即数 42
push qword [some_data] ; 压入内存中的8字节值
; 压入全部寄存器
; pusha 仅32位模式可用
; x86-64 手动保存:
push rax
push rbx
push rcx
push rdx
push rsi
push rdi
push rbp
push r8
push r9
push r10
push r11
; ========== POP ==========
; pop 的完整步骤: dst = [RSP]; RSP += 8
; 按相反顺序恢复
pop r11
pop r10
pop r9
pop r8
pop rbp
pop rdi
pop rsi
pop rdx
pop rcx
pop rbx
pop rax
; 弹出到内存
pop qword [saved_rax]
mov rax, 60
xor rdi, rdi
syscall
section .data
some_data dq 0x1234567890ABCDEF
section .bss
saved_rax resq 1
3.4 CMP / TEST —— 比较与测试
ASM
section .text
; ========== CMP ==========
; 执行 目的 - 源,根据结果设置标志位,不修改任何操作数
mov rax, 10
mov rbx, 5
cmp rax, rbx ; 计算 10 - 5 = 5,设置标志位
; ZF = 0 (不为零)
; SF = 0 (结果为正)
; CF = 0 (无借位,因为 10 >= 5)
; OF = 0 (无溢出)
cmp rax, 10 ; 计算 10 - 10 = 0
; ZF = 1 (为零!)
cmp rax, 20 ; 计算 10 - 20 = -10
; ZF = 0, SF = 1, CF = 1 (借位)
; ========== TEST ==========
; 执行 目的 & 源,根据结果设置标志位
mov rax, 0x0F
test rax, 0x08 ; 0x0F & 0x08 = 0x08
; ZF = 0 (不为零,说明第3位是1)
test rax, 0xF0 ; 0x0F & 0xF0 = 0x00
; ZF = 1 (为零,说明高4位全是0)
; TEST 常用于:
; 1. 检查某位是否为0
; 2. 检查寄存器是否为零 (test reg, reg)
test rax, rax ; 比 cmp rax, 0 更高效
jz .zero_branch ; 如果 rax == 0 则跳转
; ========== 结合条件跳转 ==========
cmp rax, 100
jg .greater_than ; rax > 100
jl .less_than ; rax < 100
je .equal ; rax == 100
.greater_than:
.less_than:
.equal:
.zero_branch:
3.5 CALL / RET —— 过程调用
ASM
section .text
global _start
_start:
; ========== 基本调用 ==========
call my_function ; 将返回地址压栈,然后跳转到 my_function
; ... 返回后继续执行
jmp exit
my_function:
; 被调用者保存寄存器
push rbp ; 保存旧的帧指针
mov rbp, rsp ; 建立新的栈帧
push rbx ; 保存需要保留的寄存器
; 子程序完成工作
mov eax, 42
; 被调用者恢复寄存器
pop rbx
pop rbp
ret ; 弹出返回地址并跳转回去
exit:
mov rax, 60
xor rdi, rdi
syscall
3.6 x86-64 System V ABI 调用约定
Linux/macOS/BSD 下的标准调用约定:
ASM
section .text
global _start
_start:
; ========== 调用 C 风格的函数 ==========
; 参数顺序: RDI, RSI, RDX, RCX, R8, R9 (前6个整数/指针)
; 更多参数: 通过栈传递(从右到左压栈)
; 返回值: RAX (整数/指针), XMM0 (浮点)
; 调用 printf(format, arg1, arg2)
lea rdi, [rel fmt_str] ; 第1参数: format 字符串
mov rsi, 42 ; 第2参数: 整数
mov rdx, 100 ; 第3参数: 整数
xor eax, eax ; 可变参数: AL = 使用的 XMM 寄存器数量
call printf ; 调用 C 函数
; ========== 栈对齐 ==========
; 调用前 RSP 必须 16字节对齐
; CALL 指令会压入8字节的返回地址,所以入口时 RSP % 16 == 8
; 标准做法: 如果需要,push rbp 或 sub rsp, 8
; ========== 函数序言(Prologue)==========
push rbp ; 保存帧指针
mov rbp, rsp ; 设置新帧
sub rsp, 32 ; 分配局部变量空间
; ... 函数体 ...
; ========== 函数尾声(Epilogue)==========
mov rsp, rbp ; 恢复栈指针
pop rbp ; 恢复帧指针
ret
; 退出
mov rax, 60
xor rdi, rdi
syscall
section .data
fmt_str db 'answer = %d, value = %d', 0x0A, 0
四、控制流结构
4.1 条件跳转(Jcc 指令族)
| 指令 | 条件 | 标志位 | 说明 |
|---|---|---|---|
| JE / JZ | 相等 / 为零 | ZF = 1 | == |
| JNE / JNZ | 不等 / 非零 | ZF = 0 | != |
| JA / JNBE | 高于(无符号) | CF=0 AND ZF=0 | > (unsigned) |
| JAE / JNB | 高于等于(无符号) | CF = 0 | >= (unsigned) |
| JB / JNAE | 低于(无符号) | CF = 1 | < (unsigned) |
| JBE / JNA | 低于等于(无符号) | CF=1 OR ZF=1 | <= (unsigned) |
| JG / JNLE | 大于(有符号) | ZF=0 AND SF=OF | > (signed) |
| JGE / JNL | 大于等于(有符号) | SF = OF | >= (signed) |
| JL / JNGE | 小于(有符号) | SF != OF | < (signed) |
| JLE / JNG | 小于等于(有符号) | ZF=1 OR SF!=OF | <= (signed) |
| JO | 溢出 | OF = 1 | |
| JNO | 未溢出 | OF = 0 | |
| JS | 符号位为1 | SF = 1 | 结果为负 |
| JNS | 符号位为0 | SF = 0 | 结果非负 |
| JCXZ / JECXZ | CX/ECX 为零 | 很少使用 |
4.2 if-else 结构
ASM
section .data
score dq 85
grade_a db 'A', 0
grade_b db 'B', 0
grade_c db 'C', 0
grade_f db 'F', 0
section .text
; ========== 简单 if ==========
mov rax, qword [score]
cmp rax, 60
jl .fail ; 如果 < 60,跳转到 .fail
; >= 60 的逻辑
mov rdi, 1 ; stdout
lea rsi, [rel grade_b]
call print_string
jmp .end
.fail:
lea rsi, [rel grade_f]
call print_string
.end:
; ========== if-elseif-else 链 ==========
mov rax, qword [score]
cmp rax, 90
jge .grade_a ; score >= 90 → A
cmp rax, 80
jge .grade_b ; score >= 80 → B
cmp rax, 70
jge .grade_c ; score >= 70 → C
cmp rax, 60
jge .grade_d ; score >= 60 → D
jmp .grade_f ; 否则 → F
.grade_a:
mov eax, 'A'
jmp .print_grade
.grade_b:
mov eax, 'B'
jmp .print_grade
.grade_c:
mov eax, 'C'
jmp .print_grade
.grade_d:
mov eax, 'D'
jmp .print_grade
.grade_f:
mov eax, 'F'
.print_grade:
; eax 含等级字母
; ========== 复合条件 ==========
; if (x > 0 && x < 100)
mov rax, 50
cmp rax, 0
jle .out_of_range ; x <= 0 → 跳转
cmp rax, 100
jge .out_of_range ; x >= 100 → 跳转
; 在范围内
.out_of_range:
; if (x == 0 || x == 100)
cmp rax, 0
je .boundary ; x == 0
cmp rax, 100
je .boundary ; x == 100
; 不在边界
.boundary:
; 退出
mov rax, 60
xor rdi, rdi
syscall
print_string: ; rsi = 字符串地址
push rax
push rdi
push rdx
push rcx
; 计算字符串长度
mov rcx, rsi
.len_loop:
cmp byte [rsi], 0
je .len_done
inc rsi
jmp .len_loop
.len_done:
mov rdx, rsi ; rdx = 结束位置
sub rdx, rcx ; rdx = 长度
mov rsi, rcx ; rsi = 起始位置
mov rax, 1
mov rdi, 1
syscall
pop rcx
pop rdx
pop rdi
pop rax
ret
4.3 循环结构
ASM
section .data
array dq 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
arr_len equ ($ - array) / 8
section .text
global _start
_start:
; ========== for 循环 ==========
; for (int i = 0; i < 10; i++) { sum += i; }
xor rax, rax ; sum = 0
xor rcx, rcx ; i = 0
.for_loop:
cmp rcx, 10
jge .for_done ; if i >= 10 → done
add rax, rcx ; sum += i
inc rcx ; i++
jmp .for_loop
.for_done:
; rax = 45 (= 0+1+2+...+9)
; ========== while 循环 ==========
; while (n > 0) { n >>= 1; count++; }
mov rax, 1024
xor rcx, rcx ; count = 0
.while_loop:
test rax, rax
jz .while_done ; if n == 0 → done
shr rax, 1 ; n >>= 1
inc rcx ; count++
jmp .while_loop
.while_done:
; rcx = 11 (log2(1024) + 1)
; ========== do-while 循环 ==========
; do { n /= 3; count++; } while (n > 1);
mov rax, 729
xor rcx, rcx ; count = 0
.do_loop:
; 循环体(至少执行一次)
xor rdx, rdx
mov rbx, 3
div rbx ; rax /= 3
inc rcx ; count++
cmp rax, 1
jg .do_loop ; if n > 1 → 继续
; ========== 遍历数组 ==========
xor rax, rax ; sum = 0
lea rsi, [rel array] ; rsi = &array[0]
xor rcx, rcx ; i = 0
.array_loop:
cmp rcx, arr_len
jge .array_done
add rax, qword [rsi + rcx*8] ; sum += array[i]
inc rcx
jmp .array_loop
.array_done:
; rax = 55 (= 1+2+...+10)
; ========== REP 前缀(字符串循环)==========
; 清理缓冲区 (memset)
cld ; 确保 DF = 0 (递增)
lea rdi, [rel buffer]
mov ecx, 256 ; 重复次数
xor eax, eax ; 填充值 = 0
rep stosb ; while (ecx--) *rdi++ = al
; 复制缓冲区 (memcpy)
cld
lea rsi, [rel source]
lea rdi, [rel dest]
mov ecx, 64
rep movsb ; while (ecx--) *rdi++ = *rsi++
; ========== LOOP 指令 ==========
; 递减 ecx,如果不为零则跳转
mov ecx, 5
xor rax, rax
.loop_example:
add rax, rcx ; rax += rcx (5+4+3+2+1 = 15)
loop .loop_example
; 注意: LOOP 在 CPUs 上较慢(微码复杂),通常用 dec/jnz 替代
; 退出
mov rax, 60
xor rdi, rdi
syscall
section .bss
buffer resb 256
source resb 64
dest resb 64
4.4 switch / 跳转表
ASM
section .data
; 跳转表:存储每个 case 的代码地址
.jmp_tbl:
dq .case0
dq .case1
dq .case2
dq .case3
dq .default
section .text
; ========== 跳转表实现 switch ==========
; switch (index) { case 0: ... case 1: ... case 2: ... case 3: ... default: ... }
mov rcx, 2 ; index = 2
; 边界检查
cmp rcx, 3
ja .default ; if index > 3 → default
; 跳转表
lea rbx, [rel .jmp_tbl]
jmp qword [rbx + rcx*8]
.case0:
mov rax, 100
jmp .switch_end
.case1:
mov rax, 200
jmp .switch_end
.case2:
mov rax, 300
jmp .switch_end
.case3:
mov rax, 400
jmp .switch_end
.default:
mov rax, -1
.switch_end:
; rax = 300
五、内存管理
5.1 x86-64 进程内存布局
CODE
高地址 (0x7FFFFFFFFFFF)
┌─────────────────────────────────┐
│ 内核空间 (不可访问) │
├─────────────────────────────────┤
│ 栈 (Stack) │ ← RSP (向低地址增长)
│ • 函数局部变量 │
│ • 返回地址 │
│ • 保存的寄存器 │
├─────────────────────────────────┤
│ ↓ (栈向下增长) │
│ ↑ (堆向上增长) │
├─────────────────────────────────┤
│ 内存映射区 │
│ • 动态库 (.so) │
│ • mmap 映射 │
├─────────────────────────────────┤
│ 堆 (Heap) │ ← brk (向高地址增长)
│ • malloc/free │
├─────────────────────────────────┤
│ BSS 段 (未初始化全局变量) │
├─────────────────────────────────┤
│ Data 段 (已初始化全局变量) │
├─────────────────────────────────┤
│ Text 段 (代码) │ ← _start / main
└─────────────────────────────────┘
低地址 (0x400000)
ELF 文件映射:
| 段(Segment) | 权限 | 内容 |
|---|---|---|
| .text | r-x | 可执行代码(只读+执行) |
| .rodata | r– | 只读数据(字符串常量、虚表等) |
| .data | rw- | 已初始化全局/静态变量 |
| .bss | rw- | 未初始化全局/静态变量(文件不占空间) |
| .plt / .plt.got | r-x | 过程链接表(动态链接) |
5.2 栈操作详解
ASM
section .text
my_program:
; ========== 函数序言 ==========
push rbp ; 保存旧的基指针
mov rbp, rsp ; rbp = rsp(当前栈顶)
sub rsp, 64 ; 分配64字节局部变量空间
; 此时栈帧布局:
; [rbp+16] = 可能的第7+个参数
; [rbp+8] = 返回地址
; [rbp] = 旧的 rbp
; [rbp-8] = 第一个局部变量
; [rbp-16] = 第二个局部变量
; ...
; [rsp] = 栈顶
; ========== 访问局部变量 ==========
mov qword [rbp - 8], 42 ; local_var1 = 42
mov qword [rbp - 16], rbx ; local_var2 = rbx
; ========== 对齐栈到16字节 ==========
; x86-64 ABI 要求: CALL 前 RSP % 16 == 0
; CALL 压入8字节返回地址 → 进入函数时 RSP % 16 == 8
; 如果要在函数中调用其他函数,确保:
; sub rsp, 8 + N*16 (N >= 0)
; 调用前:
and rsp, ~0xF ; 对齐 RSP 到16字节边界
; 或:
sub rsp, 8 ; 使 RSP % 16 == 0
; ========== 函数尾声 ==========
mov rsp, rbp ; 恢复栈指针
pop rbp ; 恢复基指针
ret ; 返回
5.3 堆内存分配
ASM
section .text
global _start
_start:
; ========== 通过 brk 系统调用分配内存 ==========
; 获取当前 brk
mov rax, 12 ; sys_brk(0) 获取当前堆顶
xor rdi, rdi
syscall
; rax = 当前堆顶地址
mov qword [heap_start], rax ; 保存初始堆顶
; 扩展堆 4096 字节
mov rax, 12 ; sys_brk
mov rdi, qword [heap_start]
add rdi, 4096 ; 请求新堆顶
syscall
; rax = 新堆顶(如果返回原值则失败)
mov qword [heap_end], rax ; 保存新堆顶
; ========== 通过 mmap 分配内存 ==========
mov rax, 9 ; sys_mmap
xor rdi, rdi ; addr = NULL(让内核选择)
mov rsi, 65536 ; length = 64KB
mov rdx, 3 ; prot = PROT_READ | PROT_WRITE
mov r10, 34 ; flags = MAP_PRIVATE | MAP_ANONYMOUS
mov r8, -1 ; fd = -1(匿名映射)
xor r9, r9 ; offset = 0
syscall
; rax = 映射的内存地址(失败返回 -errno)
mov qword [mmap_buf], rax
; 使用分配的内存
mov rdi, qword [mmap_buf]
mov qword [rdi], 0xCAFEBABE ; 写入数据
mov qword [rdi + 8], 0xDEADBEEF
; ========== 释放内存 ==========
; 释放 mmap 分配的内存
mov rax, 11 ; sys_munmap
mov rdi, qword [mmap_buf] ; addr
mov rsi, 65536 ; length
syscall
; 释放 brk 分配的内存(缩小堆)
mov rax, 12 ; sys_brk
mov rdi, qword [heap_start] ; 恢复到初始堆顶
syscall
; 退出
mov rax, 60
xor rdi, rdi
syscall
section .bss
heap_start resq 1
heap_end resq 1
mmap_buf resq 1
5.4 内存操作指令
ASM
section .text
; ========== MOVS 系列:数据块传输 ==========
cld ; 确保递增方向
lea rsi, [src_data]
lea rdi, [dst_data]
mov ecx, 64 ; 传输 64 字节
rep movsb ; REP 前缀 + MOVSB
mov ecx, 16 ; 传输 16 个四字(128字节)
rep movsq ; REP 前缀 + MOVSQ(每次8字节)
; ========== STOS 系列:填充内存 ==========
cld
lea rdi, [buffer]
mov ecx, 256
xor eax, eax
rep stosb ; 用0填充256字节
mov ecx, 10
mov eax, 0xDEADBEEF
rep stosd ; 用0xDEADBEEF填充10个双字
; ========== LODS 系列:从内存加载 ==========
; 配合REP使用较少,因为每次都会覆盖AL/AX/EAX/RAX
; 通常配合 STOS 读取并转存
; ========== SCAS 系列:扫描内存 ==========
cld
lea rdi, [buffer]
mov ecx, 256
mov al, 0xFF ; 搜索 0xFF
repne scasb ; while (ecx--) { if (*rdi++ == al) break; }
; 如果找到,rdi 指向匹配字节的下一个位置
; 没找到则 ecx == 0
; ========== CMPS 系列:比较内存 ==========
cld
lea rsi, [buffer1]
lea rdi, [buffer2]
mov ecx, 64
repe cmpsb ; while (ecx--) { if (*rsi++ != *rdi++) break; }
; 如果 ecx != 0,说明发现了不同的字节
section .data
src_data times 256 db 0x42
buffer1 times 64 db 0x41
buffer2 times 64 db 0x41
section .bss
dst_data resb 256
buffer resb 256
六、系统调用
6.1 Linux x86-64 系统调用
系统调用是用户程序与内核交互的唯一方式。x86-64 Linux 使用 syscall 指令触发系统调用。
调用约定:
| 项目 | 说明 |
|---|---|
| 调用号 | RAX |
| 第1参数 | RDI |
| 第2参数 | RSI |
| 第3参数 | RDX |
| 第4参数 | R10(不是RCX,因为SYSCALL会破坏RCX) |
| 第5参数 | R8 |
| 第6参数 | R9 |
| 返回值 | RAX(错误时返回 -errno) |
| 被破坏 | RCX, R11 |
| 指令 | syscall |
6.2 常用系统调用
ASM
section .data
filename db 'test.txt', 0
msg db 'Hello, System Calls!', 0x0A
msg_len equ $ - msg
st_buf resb 144 ; 足够存放 stat 结构体
dir_name db '.', 0 ; 当前目录
section .bss
read_buf resb 4096
fd resq 1
dir_fd resq 1
section .text
global _start
_start:
; ============================================================
; 文件 I/O 系统调用
; ============================================================
; ---------- sys_open ----------
; RAX=2, RDI=pathname, RSI=flags, RDX=mode
mov rax, 2 ; sys_open
lea rdi, [rel filename] ; 文件名
mov rsi, 0x241 ; O_WRONLY | O_CREAT | O_TRUNC
mov rdx, 0o644 ; 权限 rw-r--r--
syscall
mov qword [fd], rax ; 保存文件描述符
; ---------- sys_write ----------
; RAX=1, RDI=fd, RSI=buf, RDX=count
mov rax, 1 ; sys_write
mov rdi, qword [fd] ; 文件描述符
lea rsi, [rel msg] ; 数据缓冲区
mov rdx, msg_len ; 字节数
syscall
; ---------- sys_close ----------
; RAX=3, RDI=fd
mov rax, 3 ; sys_close
mov rdi, qword [fd]
syscall
; ---------- sys_read ----------
; RAX=0, RDI=fd, RSI=buf, RDX=count
mov rax, 2 ; sys_open (读模式)
lea rdi, [rel filename]
xor rsi, rsi ; O_RDONLY = 0
xor rdx, rdx
syscall
mov qword [fd], rax
mov rax, 0 ; sys_read
mov rdi, qword [fd]
lea rsi, [rel read_buf]
mov rdx, 4096
syscall
; rax = 实际读取的字节数(0=EOF, 负数=错误)
mov rax, 3 ; sys_close
mov rdi, qword [fd]
syscall
; ============================================================
; 文件和目录操作
; ============================================================
; ---------- sys_stat ----------
; RAX=4, RDI=pathname, RSI=statbuf
mov rax, 4 ; sys_stat
lea rdi, [rel filename]
lea rsi, [rel st_buf]
syscall
; st_buf 中:
; [rsi+0] = 设备ID (8字节)
; [rsi+24] = 文件大小 (8字节)
; [rsi+32] = 块数
mov rbx, qword [rsi + 24] ; rbx = 文件大小
; ---------- sys_getdents ----------
; RAX=78, RDI=fd, RSI=dirent, RDX=count(读取目录项)
mov rax, 2 ; sys_open
lea rdi, [rel dir_name]
xor rsi, rsi ; O_RDONLY
syscall
mov qword [dir_fd], rax
mov rax, 78 ; sys_getdents
mov rdi, qword [dir_fd]
lea rsi, [rel read_buf]
mov rdx, 4096
syscall
; rax = 读取的字节数, read_buf 包含多个 linux_dirent 结构体
mov rax, 3
mov rdi, qword [dir_fd]
syscall
; ============================================================
; 进程管理
; ============================================================
; ---------- sys_exit ----------
; RAX=60, RDI=exit_code
mov rax, 60
xor rdi, rdi
syscall ; 正常退出,不要在此之后执行
; ---------- sys_fork ----------
; RAX=57,无参数
; 父进程返回子进程PID,子进程返回0
; ---------- sys_execve ----------
; RAX=59, RDI=filename, RSI=argv, RDX=envp
; ---------- sys_wait4 ----------
; RAX=61, RDI=pid, RSI=status, RDX=options, R10=rusage
; ---------- sys_nanosleep ----------
; RAX=35, RDI=req, RSI=rem
; 使进程休眠指定时间
; ============================================================
; 内存管理
; ============================================================
; ---------- sys_brk ----------
; RAX=12, RDI=new_brk
; 设置/获取程序断点(堆顶)
; ---------- sys_mmap ----------
; RAX=9, RDI=addr, RSI=length, RDX=prot, R10=flags, R8=fd, R9=offset
; ---------- sys_munmap ----------
; RAX=11, RDI=addr, RSI=length
6.3 常用系统调用号速查表
| 调用号 | 名称 | 功能 | 参数 |
|---|---|---|---|
| 0 | read | 读取文件 | fd, buf, count |
| 1 | write | 写入文件 | fd, buf, count |
| 2 | open | 打开文件 | pathname, flags, mode |
| 3 | close | 关闭文件 | fd |
| 4 | stat | 获取文件信息 | pathname, statbuf |
| 5 | fstat | 获取文件信息(通过fd) | fd, statbuf |
| 8 | lseek | 移动文件指针 | fd, offset, whence |
| 9 | mmap | 内存映射 | addr, len, prot, flags, fd, off |
| 11 | munmap | 解除内存映射 | addr, len |
| 12 | brk | 更改堆大小 | brk |
| 21 | access | 检查文件权限 | pathname, mode |
| 35 | nanosleep | 精确定时休眠 | req, rem |
| 39 | getpid | 获取进程ID | — |
| 57 | fork | 创建子进程 | — |
| 59 | execve | 执行程序 | filename, argv, envp |
| 60 | exit | 退出进程 | status |
| 61 | wait4 | 等待子进程 | pid, status, options, rusage |
| 78 | getdents | 读取目录项 | fd, dirent, count |
| 83 | mkdir | 创建目录 | pathname, mode |
| 84 | rmdir | 删除目录 | pathname |
| 85 | creat | 创建文件 | pathname, mode |
| 87 | unlink | 删除文件 | pathname |
| 89 | readlink | 读取符号链接 | path, buf, bufsize |
| 90 | chmod | 更改权限 | pathname, mode |
CODE
### 6.4 系统调用与C库对比
```asm
section .text
; ========== 直接系统调用方式 ==========
; 优点: 无依赖,精确控制
; 缺点: 不可移植,手动处理错误
syscall_write:
mov rax, 1
mov rdi, 1 ; stdout
mov rsi, rcx ; buffer
mov rdx, r8 ; length
syscall
; 返回: rax = 写入字节数,负数 = 错误
ret
; ========== C 库方式 (libc) ==========
; 优点: 可移植,缓冲I/O,自动错误处理
; 缺点: 需要链接 libc,有运行时开销
; 等价于:
; extern int printf(const char *format, ...);
七、与C语言互操作
7.1 从C调用汇编函数
ASM
; ============================================================
; asm_math.asm —— 汇编实现的数学函数
; 编译: nasm -f elf64 asm_math.asm -o asm_math.o
; ============================================================
section .text
global asm_add ; 导出给 C 使用
global asm_factorial
global asm_strlen
global asm_memcpy
; int64_t asm_add(int64_t a, int64_t b)
; 参数: RDI = a, RSI = b
; 返回: RAX = a + b
asm_add:
mov rax, rdi ; rax = a
add rax, rsi ; rax += b
ret
; uint64_t asm_factorial(uint64_t n)
; 参数: RDI = n
; 返回: RAX = n!
asm_factorial:
mov rax, 1 ; result = 1
cmp rdi, 1
jbe .done ; if n <= 1: 返回 1
.fact_loop:
mul rdi ; rax *= rdi
dec rdi ; n--
cmp rdi, 1
ja .fact_loop ; while n > 1
.done:
ret
; size_t asm_strlen(const char *s)
; 参数: RDI = s(字符串指针)
; 返回: RAX = 字符串长度(不含 '\0')
asm_strlen:
push rdi ; 保存起始位置
xor eax, eax ; al = 0 (搜索 '\0')
mov rcx, -1 ; ecx = -1(无限制扫描)
cld
repne scasb ; 扫描,直到找到 '\0'
; rdi 现在指向 '\0' 之后的地址
mov rax, rdi ; rax = 结束地址
pop rdi ; rdi = 起始地址
sub rax, rdi ; rax = 结束 - 起始
dec rax ; 减去 '\0' 自身
ret
; void *asm_memcpy(void *dest, const void *src, size_t n)
; 参数: RDI = dest, RSI = src, RDX = n
; 返回: RAX = dest(原样)
asm_memcpy:
mov rax, rdi ; 保存返回值
mov rcx, rdx ; 计数器 = n
cld
rep movsb ; 按字节复制
ret
C
// ============================================================
// main.c —— 调用汇编函数的主程序
// 编译: gcc -o program main.c asm_math.o
// ============================================================
#include <stdio.h>
#include <stdint.h>
// 声明外部汇编函数
extern int64_t asm_add(int64_t a, int64_t b);
extern uint64_t asm_factorial(uint64_t n);
extern size_t asm_strlen(const char *s);
extern void *asm_memcpy(void *dest, const void *src, size_t n);
int main() {
// 测试 asm_add
int64_t sum = asm_add(123, 456);
printf("asm_add(123, 456) = %ld\n", sum);
// 测试 asm_factorial
uint64_t fact = asm_factorial(10);
printf("asm_factorial(10) = %lu\n", fact);
// 测试 asm_strlen
const char *str = "Hello, Assembly!";
size_t len = asm_strlen(str);
printf("asm_strlen(\"%s\") = %zu\n", str, len);
// 测试 asm_memcpy
char src[] = "Copy this!";
char dest[32];
asm_memcpy(dest, src, sizeof(src));
printf("asm_memcpy: '%s'\n", dest);
return 0;
}
7.2 内联汇编(GCC / Clang)
C
// ============================================================
// inline_asm.c —— C 中直接嵌入汇编
// 编译: gcc -o inline_asm inline_asm.c
// ============================================================
#include <stdio.h>
#include <stdint.h>
// ========== 基本内联汇编 ==========
void basic_inline() {
int a = 10, b = 20, result;
// __asm__ 和 asm 等价
asm volatile (
"movl %1, %%eax\n\t" // eax = a
"addl %2, %%eax\n\t" // eax += b
"movl %%eax, %0" // result = eax
: "=r" (result) // 输出操作数
: "r" (a), "r" (b) // 输入操作数
: "%eax" // 被破坏的寄存器列表
);
printf("Inline asm: %d + %d = %d\n", a, b, result);
}
// ========== 扩展约束 ==========
// =r : 任意通用寄存器
// =m : 内存操作数
// =g : 任意通用寄存器、内存或立即数
// =a : RAX/EAX
// =b : RBX/EBX
// =c : RCX/ECX
// =d : RDX/EDX
// =S : RSI/ESI
// =D : RDI/EDI
// ========== cpuid 指令示例 ==========
void get_cpu_vendor(char vendor[13]) {
uint32_t eax, ebx, ecx, edx;
asm volatile (
"cpuid"
: "=a"(eax), "=b"(ebx), "=c"(ecx), "=d"(edx)
: "a"(0) // eax = 0: 获取厂商ID
);
// 将 ebx, edx, ecx 中的12字符复制到vendor
((uint32_t *)vendor)[0] = ebx;
((uint32_t *)vendor)[1] = edx;
((uint32_t *)vendor)[2] = ecx;
vendor[12] = '\0';
}
// ========== RDTSC(读取时间戳计数器)==========
uint64_t read_tsc() {
uint32_t low, high;
asm volatile (
"rdtsc"
: "=a"(low), "=d"(high)
);
return ((uint64_t)high << 32) | low;
}
// ========== 原子比较交换 ==========
int atomic_cas(int *ptr, int old_val, int new_val) {
int result;
asm volatile (
"lock cmpxchgl %2, %1" // lock 前缀确保原子性
: "=a"(result), "+m"(*ptr)
: "r"(new_val), "0"(old_val)
: "cc", "memory"
);
return result; // 返回旧值
}
// ========== 内存屏障 ==========
#define barrier() asm volatile("" ::: "memory")
// ========== 无分支 abs ==========
int fast_abs(int x) {
int mask = x >> 31; // 符号位扩散到所有位
return (x + mask) ^ mask;
// 等价汇编(一条指令):
// mov eax, edi
// mov edx, edi
// sar edx, 31
// add eax, edx
// xor eax, edx
}
int main() {
basic_inline();
char vendor[13];
get_cpu_vendor(vendor);
printf("CPU Vendor: %s\n", vendor);
uint64_t tsc = read_tsc();
printf("TSC: %lu\n", tsc);
return 0;
}
八、SIMD 与向量指令
8.1 XMM/YMM/ZMM 寄存器
x86-64 SIMD 指令集演进:
| 指令集 | 寄存器 | 宽度 | 引入年份 |
|---|---|---|---|
| MMX | MM0-MM7 | 64位 | 1997 |
| SSE | XMM0-XMM7 | 128位 | 1999 |
| SSE2/SSE3/SSSE3 | XMM0-XMM7 | 128位 | 2000-2006 |
| SSE4.1/4.2 | XMM0-XMM15 | 128位 | 2008 |
| AVX | YMM0-YMM15 | 256位 | 2011 |
| AVX2 | YMM0-YMM15 | 256位 | 2013 |
| AVX-512 | ZMM0-ZMM31 | 512位 | 2017 |
8.2 SSE/AVX 数据处理示例
ASM
section .data
align 16 ; 16字节对齐(SSE需要)
vec_a dd 1.0, 2.0, 3.0, 4.0 ; 4个单精度浮点
vec_b dd 5.0, 6.0, 7.0, 8.0 ; 4个单精度浮点
align 16
int_a dd 10, 20, 30, 40 ; 4个32位整数
int_b dd 1, 2, 3, 4 ; 4个32位整数
align 16
scale dd 10.0, 10.0, 10.0, 10.0 ; 标量广播
section .bss
align 16
result resd 4 ; 4个单精度浮点结果
section .text
sse_examples:
; ========== 加载/存储 XMM 寄存器 ==========
; MOVAPS —— 16字节对齐移动(更快,要求16字节对齐)
; MOVUPS —— 非对齐移动(不要求对齐)
; MOVSS —— 移动单精度标量(最低32位)
; MOVSD —— 移动双精度标量(最低64位)
movaps xmm0, [vec_a] ; xmm0 = {1.0, 2.0, 3.0, 4.0}(4个float)
movaps xmm1, [vec_b] ; xmm1 = {5.0, 6.0, 7.0, 8.0}
; ========== 向量加法 ==========
; ADDPS —— 打包单精度加法
addps xmm0, xmm1 ; xmm0 = {6.0, 8.0, 10.0, 12.0}
; ========== 向量乘法 ==========
movaps xmm0, [vec_a]
mulps xmm0, xmm1 ; xmm0 = {5.0, 12.0, 21.0, 32.0}
; ========== 向量减法 ==========
subps xmm0, xmm1
; ========== 向量除法 ==========
divps xmm0, xmm1
; ========== 平方根倒数(RSQRTPS)==========
; 常用于图形学中的归一化
rsqrtps xmm0, xmm1 ; xmm0 ≈ 1/sqrt(xmm1)
; ========== 水平操作 ==========
; HADDPS —— 水平加法(相邻元素两两相加)
movaps xmm0, [vec_a] ; {1.0, 2.0, 3.0, 4.0}
haddps xmm0, xmm0 ; {3.0, 7.0, 3.0, 7.0}
; ========== 混洗 ==========
; SHUFPS —— 任意顺序重组向量元素
movaps xmm0, [vec_a] ; {1.0, 2.0, 3.0, 4.0}
shufps xmm0, xmm0, 0x1B ; {4.0, 3.0, 2.0, 1.0}(反转)
; ========== 整数 SIMD 指令 ==========
movdqa xmm0, [int_a] ; 对齐的整数加载
movdqa xmm1, [int_b]
paddd xmm0, xmm1 ; 打包32位整数加法
; xmm0 = {11, 22, 33, 44}
pmulld xmm0, xmm1 ; 打包32位整数乘法(SSE4.1)
; xmm0 = {10, 40, 90, 160}
pcmpeqd xmm0, xmm1 ; 打包比较相等(32位)
; 相等位置全1,不等位置全0
; ========== 掩码操作(AVX-512)==========
; AVX-512 引入 opmask 寄存器(k1-k7),每条指令可带掩码
; vaddps zmm0 {k1}, zmm1, zmm2 ; 仅对k1掩码选中的元素执行加法
ret
8.3 实际应用:SIMD 加速 memcpy
ASM
; ============================================================
; sse_memcpy —— 使用 SSE 128位指令加速的 memcpy
; 参数: RDI = dest, RSI = src, RDX = size
; 返回: RAX = dest
; ============================================================
section .text
global sse_memcpy
sse_memcpy:
mov rax, rdi ; 保存返回值
cmp rdx, 128
jb .byte_copy ; 小于128字节走字节复制
; ========== 128位对齐复制 ==========
; 先处理未对齐的头(直到 dest 16字节对齐)
mov rcx, rdi
and rcx, 0xF ; dest 的对齐偏移
jz .aligned ; 已经对齐
neg rcx
add rcx, 16 ; 需要的填充字节数
sub rdx, rcx
rep movsb ; 复制填充字节
.aligned:
; 128位批量复制
mov rcx, rdx
shr rcx, 7 ; rcx = size / 128(128字节块数)
jz .simd_tail ; 不足一个128字节块
.copy_128_loop:
; 预取下一块(减少缓存未命中)
prefetchnta [rsi + 256] ; 预取 32 字节后的数据
; 加载 128 字节(8个 XMM 寄存器)
movdqa xmm0, [rsi]
movdqa xmm1, [rsi + 16]
movdqa xmm2, [rsi + 32]
movdqa xmm3, [rsi + 48]
movdqa xmm4, [rsi + 64]
movdqa xmm5, [rsi + 80]
movdqa xmm6, [rsi + 96]
movdqa xmm7, [rsi + 112]
; 存储(使用非临时存储——绕过缓存,直接写内存)
movntdq [rdi], xmm0
movntdq [rdi + 16], xmm1
movntdq [rdi + 32], xmm2
movntdq [rdi + 48], xmm3
movntdq [rdi + 64], xmm4
movntdq [rdi + 80], xmm5
movntdq [rdi + 96], xmm6
movntdq [rdi + 112], xmm7
add rsi, 128
add rdi, 128
dec rcx
jnz .copy_128_loop
.simd_tail:
mov rcx, rdx
and rcx, 0x7F ; 剩余字节 (< 128)
rep movsb ; 尾部字节复制
sfence ; 确保非临时存储完成
ret
.byte_copy:
mov rcx, rdx
rep movsb
ret
九、调试与逆向
9.1 GDB 汇编调试
BASH
# ========== 编译带调试信息的汇编 ==========
nasm -f elf64 -g -F dwarf program.asm -o program.o
ld program.o -o program
# ========== 启动 GDB ==========
gdb ./program
# ========== GDB 常用命令 ==========
# (gdb) break _start # 设置断点
# (gdb) run # 运行程序
# (gdb) stepi # 单步执行一条机器指令
# (gdb) nexti # 单步执行(跳过函数调用)
# (gdb) continue # 继续执行
# (gdb) finish # 执行到当前函数返回
# ========== 查看寄存器 ==========
# (gdb) info registers # 显示所有寄存器
# (gdb) p/x $rax # 以十六进制显示 RAX
# (gdb) p/d $rax # 以十进制显示 RAX
# (gdb) p/t $rax # 以二进制显示 RAX
# ========== 查看内存 ==========
# (gdb) x/8gx $rsp # 查看栈顶8个四字(十六进制)
# (gdb) x/s $rdi # 以字符串形式显示 RDI 指向的内容
# (gdb) x/16bx $rsi # 以字节形式显示 16 个字节
# ========== 查看反汇编 ==========
# (gdb) disassemble _start # 反汇编当前函数
# (gdb) disassemble /r _start # 同时显示机器码
# ========== 修改寄存器和内存 ==========
# (gdb) set $rax = 42 # 修改寄存器值
# (gdb) set {int}$rsp = 100 # 修改内存值
# ========== 查看标志位 ==========
# (gdb) info registers eflags
# ========== 布局模式 ==========
# (gdb) layout asm # 汇编视图
# (gdb) layout regs # 寄存器视图
# (gdb) layout src # 源代码视图
# (gdb) tui enable # 启用 TUI 模式
# (gdb) tui reg general # 显示通用寄存器
9.2 NASM 调试指令
ASM
section .data
debug_msg db 'Program reached checkpoint', 0x0A
.len equ $ - debug_msg
section .text
; ========== 汇编级断言(assert)==========
%macro assert_eq 3 ; assert(%1 == %2), message = %3
cmp %1, %2
je %%ok
; 失败时输出错误信息并退出
mov rax, 1
mov rdi, 2 ; stderr
lea rsi, [rel assert_fail_msg]
mov rdx, assert_fail_len
syscall
mov rax, 60
mov rdi, 1
syscall
%%ok:
%endmacro
; ========== 条件断点宏 ==========
%macro debug_break 0
int3 ; 触发调试中断(如果不在GDB下会崩溃)
%endmacro
; ========== 打印寄存器宏(调试用)==========
%macro debug_print_reg 1
push rax
push rdi
push rsi
push rdx
mov rdi, 1 ; stdout
lea rsi, [rel reg_label_%1]
mov rdx, 4 ; "RAX=" 等
mov rax, 1
syscall
; 这里会调用一个十六进制输出例程...
pop rdx
pop rsi
pop rdi
pop rax
%endmacro
section .data
assert_fail_msg db 'ASSERTION FAILED!', 0x0A
assert_fail_len equ $ - assert_fail_msg
reg_label_rax db 'RAX='
reg_label_rbx db 'RBX='
9.3 使用 objdump 反汇编
BASH
# ========== 反汇编目标文件 ==========
objdump -d program.o # 反汇编所有节
objdump -d -M intel program.o # 使用 Intel 语法
# ========== 查看节头信息 ==========
objdump -h program.o # 查看 .text/.data/.bss 等节
# ========== 查看符号表 ==========
objdump -t program.o # 查看所有符号
objdump -T /lib/libc.so.6 # 查看动态符号
# ========== 显示重定位信息 ==========
objdump -r program.o
# ========== 查看完整内容 ==========
objdump -s -d program.o # 完整反汇编 + 十六进制
# ========== 查看 ELF 头 ==========
readelf -h program # ELF 文件头
readelf -l program # 段(Program Headers)
readelf -S program # 节(Section Headers)
readelf -s program # 符号表
readelf -r program # 重定位表
十、实战案例
10.1 字符串转换为整数(atoi)
ASM
; ============================================================
; asm_atoi —— 字符串转为有符号整数
; 参数: RDI = 字符串指针
; 返回: RAX = 整数值
; 破坏: RAX, RDX, RCX, RSI, RDI
; ============================================================
section .text
global asm_atoi
asm_atoi:
xor eax, eax ; result = 0
xor ecx, ecx ; sign = 0(正数)
; ========== 跳过空白字符 ==========
.skip_whitespace:
movzx edx, byte [rdi]
cmp dl, ' '
je .next_char
cmp dl, 0x09 ; '\t'
jne .check_sign
.next_char:
inc rdi
jmp .skip_whitespace
; ========== 检查符号 ==========
.check_sign:
cmp dl, '-'
jne .not_negative
mov ecx, 1 ; sign = 负面
inc rdi
jmp .parse_digits
.not_negative:
cmp dl, '+'
jne .parse_digits
inc rdi
; ========== 解析数字 ==========
.parse_digits:
movzx edx, byte [rdi]
cmp dl, '0'
jb .apply_sign ; 不是数字,结束
cmp dl, '9'
ja .apply_sign
sub dl, '0' ; 转成数值
imul rax, rax, 10 ; result *= 10
add rax, rdx ; result += digit
inc rdi
jmp .parse_digits
; ========== 应用符号 ==========
.apply_sign:
test ecx, ecx
jz .done
neg rax ; result = -result
.done:
ret
10.2 冒泡排序
ASM
; ============================================================
; asm_bubble_sort —— 对有符号整数数组冒泡排序
; 参数: RDI = 数组指针, RSI = 元素数量
; 返回: 数组原地排序
; ============================================================
section .text
global asm_bubble_sort
asm_bubble_sort:
push rbx
push r12
push r13
dec rsi ; n = count - 1
jz .done ; 如果只剩0或1个元素
mov r12, rsi ; r12 = n (外层循环边界)
.outer_loop:
xor r13, r13 ; swapped = false
lea rbx, [rdi + r12*4] ; rbx = 循环结束位置
xor eax, eax ; i = 0 (索引)
xor ecx, ecx ; j = 0 (地址偏移)
.inner_loop:
lea rcx, [rax + 1] ; j = i + 1
cmp rcx, r12
ja .check_swap ; 越界检查
; 比较 arr[i] 和 arr[i+1]
mov edx, dword [rdi + rax*4 + 4] ; arr[i+1]
cmp dword [rdi + rax*4], edx ; arr[i] vs arr[i+1]
jle .no_swap ; 如果 arr[i] <= arr[i+1],不交换
; 交换 arr[i] 和 arr[i+1]
mov ecx, dword [rdi + rax*4] ; ecx = arr[i]
mov dword [rdi + rax*4], edx ; arr[i] = arr[i+1]
mov dword [rdi + rax*4 + 4], ecx ; arr[i+1] = ecx
mov r13, 1 ; swapped = true
.no_swap:
inc rax
cmp rax, r12
jb .inner_loop
.check_swap:
test r13, r13
jz .done ; 如果没有交换,则已完成
dec r12
jnz .outer_loop
.done:
pop r13
pop r12
pop rbx
ret
10.3 快速计算斐波那契(带记忆化)
ASM
; ============================================================
; asm_fibonacci —— 计算第 n 个斐波那契数(迭代法,O(n))
; 参数: RDI = n(0 <= n <= 93,超过则溢出64位)
; 返回: RAX = Fib(n)
; ============================================================
section .text
global asm_fibonacci
asm_fibonacci:
cmp rdi, 0
jne .not_zero
xor eax, eax ; Fib(0) = 0
ret
.not_zero:
cmp rdi, 1
jne .compute
mov eax, 1 ; Fib(1) = 1
ret
.compute:
; F(0)=0, F(1)=1
; i=2; while (i <= n) { c=a+b; a=b; b=c; i++; }
xor eax, eax ; a = 0 (F(k-2))
mov edx, 1 ; b = 1 (F(k-1))
mov ecx, 2 ; i = 2
.fib_loop:
cmp rcx, rdi
ja .fib_done
mov rsi, rdx ; temp = b
add rdx, rax ; b = a + b
mov rax, rsi ; a = temp
inc rcx
jmp .fib_loop
.fib_done:
mov rax, rdx ; 返回 b(即 Fib(n))
ret
10.4 简单的 ROT13 加密
ASM
; ============================================================
; asm_rot13 —— 原地 ROT13 加密/解密(ROT13 是对合,自逆)
; 参数: RDI = 字符串指针
; 返回: 原地修改
; ============================================================
section .text
global asm_rot13
asm_rot13:
push rdi
.rot13_loop:
movzx eax, byte [rdi] ; 加载字符
test al, al ; '\0'?
jz .rot13_done
; 检查是否大写字母
cmp al, 'A'
jb .next
cmp al, 'Z'
ja .check_lower
; 大写 ROT13
sub al, 'A' ; 转为 0-25
add al, 13 ; +13
xor edx, edx
mov ecx, 26
div ecx ; mod 26(edx = 余数)
add dl, 'A' ; 转回 ASCII
mov byte [rdi], dl
jmp .next
.check_lower:
cmp al, 'a'
jb .next
cmp al, 'z'
ja .next
; 小写 ROT13
sub al, 'a'
add al, 13
xor edx, edx
mov ecx, 26
div ecx
add dl, 'a'
mov byte [rdi], dl
.next:
inc rdi
jmp .rot13_loop
.rot13_done:
pop rdi
ret
十一、最佳实践与优化
11.1 性能优化技巧
| 技巧 | 说明 | 示例 |
|---|---|---|
| LEA 代替 MUL | LEA 在1个周期内完成乘加 | lea rax, [rcx+rcx*4] 比 imul rax, 5 快 |
| XOR 清零 | 比 MOV 小1字节,且打破依赖链 | xor eax, eax 而非 mov eax, 0 |
| TEST 自比较 | 比 CMP 小1字节,相同速度 | test rax, rax 而非 cmp rax, 0 |
| 32位操作清零高位 | 32位写入自动清高32位 | xor eax, eax 清除整个 RAX |
| 避免 LOOP 指令 | LOOP 在现代CPU上慢 | 用 dec ecx + jnz 替代 |
| CMOV 避免分支 | 条件移动比分支预测失败更快 | cmovg rax, rbx |
| 对齐热循环 | 16字节对齐减少取指次数 | align 16 |
| 使用 INC/DEC 慎用 | 它们不更新 CF,必要时用 ADD/SUB | |
| 预取数据 | PREFETCH 减少缓存未命中 | prefetcht0 [rsi + 64] |
| 非临时存储 | MOVNTDQ 绕过缓存直接写内存 | 用于一次性大数据写入 |
11.2 NASM 宏与预处理
ASM
; ============================================================
; 实用宏定义
; ============================================================
; ========== 系统调用封装宏 ==========
%macro sys_write 3 ; fd, buf, len
mov rax, 1
mov rdi, %1
mov rsi, %2
mov rdx, %3
syscall
%endmacro
%macro sys_exit 1 ; exit_code
mov rax, 60
mov rdi, %1
syscall
%endmacro
; ========== 函数序言/尾声 ==========
%macro func_prologue 0
push rbp
mov rbp, rsp
%endmacro
%macro func_epilogue 0
mov rsp, rbp
pop rbp
ret
%endmacro
; ========== 保存/恢复所有通用寄存器 ==========
%macro save_regs 0
push rax
push rbx
push rcx
push rdx
push rsi
push rdi
push rbp
push r8
push r9
push r10
push r11
%endmacro
%macro restore_regs 0
pop r11
pop r10
pop r9
pop r8
pop rbp
pop rdi
pop rsi
pop rdx
pop rcx
pop rbx
pop rax
%endmacro
; ========== 使用示例 ==========
my_func:
func_prologue
save_regs
; 函数体
sys_write 1, msg, msg_len
restore_regs
func_epilogue
section .data
msg db 'Hello from macro!', 0x0A
msg_len equ $ - msg
11.3 安全编码实践
ASM
section .text
; ========== 1. 栈金丝雀(Stack Canary)==========
; 手动实现栈保护(GCC 使用 -fstack-protector 自动插入)
safe_function:
push rbp
mov rbp, rsp
sub rsp, 32
; 放置金丝雀值
mov qword [rbp - 8], 0xDEADBEEFCAFEBABE ; 金丝雀值
; 函数体(可能有栈缓冲区操作)
; ...
; 函数返回前检查金丝雀
cmp qword [rbp - 8], 0xDEADBEEFCAFEBABE
jne .stack_smash ; 金丝雀不匹配 → 栈被破坏
jmp .safe_return
.stack_smash:
mov rax, 1
mov rdi, 2
lea rsi, [rel smash_msg]
mov rdx, smash_len
syscall
mov rax, 60
mov rdi, 134
syscall
.safe_return:
leave
ret
section .data
smash_msg db 'Stack smashing detected!', 0x0A
smash_len equ $ - smash_msg
; ========== 2. 安全的字符串复制 ==========
; strncpy: 限制复制长度,防止缓冲区溢出
; 参数: RDI = dest, RSI = src, RDX = max_len
safe_strncpy:
test rdx, rdx
jz .done
mov rax, rdi ; 保存 dest
.copy_loop:
dec rdx
jz .null_terminate
mov cl, byte [rsi]
mov byte [rdi], cl
test cl, cl
jz .done
inc rsi
inc rdi
jmp .copy_loop
.null_terminate:
mov byte [rdi], 0
.done:
ret
; ========== 3. 常量时间比较(防时序攻击)==========
; 密码/哈希比较不应在发现第一个不同字符时立即返回
; 参数: RDI = a, RSI = b, RDX = len
; 返回: RAX = 0(相同), 1(不同)
constant_time_compare:
xor eax, eax ; result = 0
xor ecx, ecx ; i = 0
.ct_loop:
cmp rcx, rdx
jae .ct_done
mov r8b, byte [rdi + rcx]
xor r8b, byte [rsi + rcx] ; XOR(不同则非零)
or al, r8b ; 累积差异(不用 if,不会短路)
inc rcx
jmp .ct_loop
.ct_done:
; rax == 0 表示完全相同
ret
11.4 编码规范
ASM
; ============================================================
; 推荐的汇编编码风格
; ============================================================
; 1. 标签命名
; - 全局标签: 小写+下划线,含义清晰: asm_memcpy、my_sort
; - 局部标签: 以 . 开头,描述控制流: .loop、.done、.error
; - 避免单字母标签(除了 .L* 生成的标签)
; 2. 注释规范
; - 文件头: 功能说明、调用约定、寄存器使用
; - 每个函数: 参数、返回值、破坏的寄存器
; - 关键指令: 右对齐注释,解释为什么这样做
; 3. 缩进和间距
; - 标签靠左: my_func:
; - 指令缩进4空格: mov rax, 1
; - 操作数对齐: mov rax, 1
; mov rdi, 2
; 4. 寄存器约定
; - 明确文档化哪些寄存器被破坏
; - 优先使用调用者保存寄存器(RAX, RCX, RDX, R8-R11)
; - 非必要不使用 RBP(可以用帧指针省略优化)
十二、总结
12.1 何时使用汇编语言
| 场景 | 建议 |
|---|---|
| 性能关键路径 | 用汇编重写最热的函数,获得10-50%的提升 |
| 硬件直接控制 | 写驱动、访问特殊寄存器时必不可少 |
| 加密/解密 | 可利用CPU专用指令(AES-NI、SHA等) |
| 启动代码 | Bootloader、内核入口必须使用汇编 |
| 上下文切换 | 必须精确保存/恢复寄存器 |
| 逆向/分析 | 阅读汇编是逆向工程的基本功 |
| 教学/学习 | 理解计算机底层运行原理的最佳途径 |
| 不适合场景 | 替代方案 |
|---|---|
| 业务逻辑 | 使用高级语言(C/Go/Python) |
| 跨平台代码 | 汇编架构绑定,用 C 或 Rust |
| 快速原型 | 汇编开发速度慢10-100倍 |
| 维护周期长的项目 | 汇编可读性差,容易出错 |
| 团队协作 | 会汇编的开发者相对较少 |
12.2 学习路径
CODE
CPU 基础架构
↓
寄存器与内存模型 → 基础指令 (MOV/ADD/JMP)
↓
寻址模式 → 条件跳转 → 循环结构
↓
函数调用 (CALL/RET/ABI) → 栈帧管理
↓
系统调用 → 与 C 语言交互
↓
SIMD 向量化 → 性能优化技巧 → 调试/逆向
↓
操作系统内核 → 编译器后端 → 安全研究
12.3 推荐资源
| 资源 | 类型 | 说明 |
|---|---|---|
| Intel® 64 and IA-32 Architectures SDM | 官方手册 | Intel 指令集权威文档 |
| AMD64 Architecture Programmer’s Manual | 官方手册 | AMD 指令集权威文档 |
| NASM 官方文档 | 工具文档 | NASM 汇编器完整参考 |
| x86 Assembly Guide (University of Virginia) | 教程 | 系统学习 x86 汇编 |
| Agner Fog’s Optimization Manuals | 优化指南 | 微架构深入分析,指令延迟表 |
| The Art of Assembly Language | 书籍 | 经典汇编语言教材 |
| godbolt.org (Compiler Explorer) | 在线工具 | 查看 C/C++ 编译后的汇编 |
| radare2 / Ghidra | 逆向工具 | 专业逆向工程分析 |
| /r/asm (Reddit) | 社区 | 汇编语言讨论社区 |
| Intel Intrinsics Guide | 参考 | SIMD 内建函数在线查询 |
12.4 常用命令速查
BASH
# ========== 汇编和链接 ==========
nasm -f elf64 source.asm -o obj.o # 汇编
nasm -f elf64 -g -F dwarf source.asm -o obj.o # 带调试信息
ld obj.o -o program # 链接
gcc -nostartfiles -no-pie obj.o -o program # 链接(无标准启动)
gcc -o program main.c asm_func.o # 混合编译
# ========== 反汇编和分析 ==========
objdump -d -M intel program # 反汇编(Intel 语法)
objdump -d -M intel program.o | less # 分页查看
objdump -t program.o # 符号表
readelf -a program # 所有 ELF 信息
nm program.o # 列出符号
strings program # 提取字符串
# ========== 调试 ==========
gdb ./program
strace ./program # 跟踪系统调用
ltrace ./program # 跟踪库函数调用
valgrind ./program # 内存错误检测
perf stat ./program # 性能计数统计
perf record ./program && perf report # CPU 性能采样
# ========== 十六进制查看 ==========
xxd program.o # 十六进制转储
hexdump -C program.o | head -50 # 管道查看
祝你在汇编的世界里,彻底理解计算机的底层运行机制,成为一名掌控硬件的底层开发者!