汇编语言编程完全指南

← 返回指南列表

汇编语言编程完全指南

一、汇编语言概述

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                 # 管道查看

祝你在汇编的世界里,彻底理解计算机的底层运行机制,成为一名掌控硬件的底层开发者!