汇编语言杂记

汇编语言杂记

  • NASM
  • GDB
  • ld
  • ar
  • gcc
  • xxd/GHex

寄存器名称与主要用途

寄存器 传统名称 主要用途
RAX 累加器 (Accumulator) 函数返回值、算术运算、系统调用号
RCX 计数器 (Counter) 第4个整数参数、循环计数、通用寄存器
RDX 数据寄存器 (Data) 第3个整数参数、与RAX配合用于乘除法、通用寄存器
RBX 基址寄存器 (Base) 被调用者保存、常用于存储基地址
RSP 栈指针 (Stack Pointer) 指向当前栈顶、永远指向内存中的栈顶
RBP 基址指针 (Base Pointer) 被调用者保存、通常用作栈帧基址(可选)
RSI 源索引 (Source Index) 第2个整数参数、字符串/数组操作源地址
RDI 目的索引 (Destination Index) 第1个整数参数、字符串/数组操作目的地址

通用寄存器

  • 64 bit
    rax rcx rdx rbx rsp rbp rsi rdi r8 r9 r10 r11 r12 r13 r14 r15
  • 32 bit
    eax ecx edx ebx esp ebp esi edi r8d r9d r10d r11d r12d r13d r14d r15d

    后缀d意为double word

  • 16 bit
    ax cx dx bx sp bp si di r8w r9w r10w r11w r12w r13w r14w r15w

    后缀w意为word

  • 8 bit (low)
    al cl dl bl spl bpl sil dil r8b r9b r10b r11b r12b r13b r14b r15b

    后缀b意为byte

  • 8 bit (high) 仅前4个寄存器,继承于8086,x86_64汇编中尽量不使用
    ah ch dh bh

向量寄存器(SIMD)

1
2
3
4
xmm0  xmm1  xmm2  xmm3  xmm4
xmm5 xmm6 xmm7 xmm8 xmm9
xmm10 xmm11 xmm12 xmm13 xmm14
xmm15

标志 RFlags寄存器

标志是独立于其他任何位的位(bit)信息,根据CPU的需要将相应位设置为0/1,以表示CPU内部某些条件的状态。
可以设置标志位作为向CPU发送信号的一种方式。

RFlags整体上是嵌在CPU内部的一个64位寄存器。是EFlags 32b位与Flags 16位的扩展。

RFlags目前仅使用了18位作为标志位,其余保留。

这18个标志位通常被分为三类:状态标志(Status Flags)、控制标志(Control Flags) 和 系统标志(System Flags)。

以下是这 18 个标志的位位置、全称及其简要功能的详细列表:

位 (Bit) 标志 (Flag) 全称 (Full Name) 功能简介
状态标志 (Status Flags)
0 CF Carry Flag 进位标志:当算术运算导致结果最高位产生进位或借位时置1,用于无符号整数运算的溢出检测。
2 PF Parity Flag 奇偶标志:当计算结果的最低有效字节中“1”的个数为偶数时置1,用于数据校验。
4 AF Auxiliary Carry Flag 辅助进位标志:当运算时低4位(半个字节)产生进位或借位时置1,用于BCD码算术运算。在x64中被视作为过时
6 ZF Zero Flag 零标志:当运算结果为时置1。
7 SF Sign Flag 符号标志:当运算结果为负时置1(即与结果的最高有效位相同)。
11 OF Overflow Flag 溢出标志:当有符号整数运算结果超出其类型所能表示的范围时置1。
控制标志 (Control Flag)
10 DF Direction Flag 方向标志:控制串操作指令(如 MOVS, CMPS)处理字符串时变址寄存器的方向。DF=0 时递增地址,DF=1 时递减地址。
系统标志 (System Flags) 和 IOPL 字段
8 TF Trap Flag 陷阱标志:当置1时,处理器进入单步调试模式,每条指令执行后都会产生一个调试异常。
9 IF Interrupt Enable Flag 中断允许标志:控制处理器是否响应可屏蔽中断请求。IF=1 时允许响应,IF=0 时禁止。
12-13 IOPL I/O Privilege Level I/O 特权级字段:指定当前任务或程序执行 I/O 指令所需的特权级别,共4个级别(0-3)。
14 NT Nested Task Flag 任务嵌套标志:指示当前任务是否与之前执行的任务嵌套。在 IA-32e 模式下(64位模式),此标志不被使用 。
16 RF Resume Flag 恢复标志:用于控制处理器对调试异常的响应,常与指令断点配合使用,防止重复触发调试异常。
17 VM Virtual-8086 Mode Flag 虚拟8086模式标志:置1时启用虚拟8086模式,允许在保护模式下运行实模式程序。在 IA-32e 模式下不被使用 。
18 AC Alignment Check Flag 对齐检查标志:当此位和 CR0 控制寄存器的 AM 位均置1时,若用户模式访问未对齐的内存,会触发对齐检查异常。
19 VIF Virtual Interrupt Flag 虚拟中断标志:IF 标志的虚拟映像,与 VIP 标志配合使用,用于支持虚拟模式下的中断机制。
20 VIP Virtual Interrupt Pending 虚拟中断挂起标志:由软件置位,用于指示一个虚拟中断正在等待处理,处理器只读取此标志。
21 ID Identification Flag 识别标志:程序若能成功置位或清除此标志,则表明该 CPU 支持 CPUID 指令。

标志位可以影响程序中机器指令的流程

命令

  • mov movsx
  • inc dec increase decrease
  • neg negtive
  • add diff
  • mul div imul idiv
  • and or xor
  • cmp test
  • jcc
  • movcc

System V ABI 函数调用约定

  1. 整数/指针传递规则
    函数调用时,参数从左到右依次放入以下寄存器:

    参数位置 寄存器
    第1个 RDI
    第2个 RSI
    第3个 RDX
    第4个 RCX
    第5个 R8
    第6个 R9
    第7个及以上 通过栈传递(从右向左压栈)
  2. 返回值规则

    整数/指针返回值:存放在 RAX 中(64位)
    128位返回值(如long double或某些结构体):使用 RAX 和 RDX 联合返回
    浮点返回值:使用 XMM0 寄存器(单/双精度浮点数)

  3. 保存责任规则(关键!)

    保存责任规则.png

    保存责任规则.png

    • 调用者保存寄存器:函数可以随意修改这些寄存器。如果调用者希望调用后这些寄存器的值保持不变,调用者需要在调用前保存它们。
    • 被调用者保存寄存器:如果被调用函数要使用这些寄存器,必须在函数开头保存它们的原始值,并在返回前恢复。
  4. 栈对齐要求

    在call指令执行前,栈指针RSP必须是16字节对齐的。因为call指令会将8字节的返回地址压栈,此时RSP会减去8,从而保证进入函数时RSP是16字节对齐的。

  5. 浮点/向量参数传递

    对于浮点数和向量参数,使用XMM0-XMM7寄存器(最多8个单/双精度浮点数参数):

    • 第1个浮点参数:XMM0
    • 第2个浮点参数:XMM1
    • 以此类推…

C语言函数模型

1
2
long example_func(long a, long b, long c, long d, long e, long f, long g, long h);
// a=1, b=2, c=3, d=4, e=5, f=6, g=7, h=8

汇编代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
section .text
global _start

_start:
; 设置前6个参数到寄存器
mov rdi, 1 ; 第1个参数 a = 1
mov rsi, 2 ; 第2个参数 b = 2
mov rdx, 3 ; 第3个参数 c = 3
mov rcx, 4 ; 第4个参数 d = 4
mov r8, 5 ; 第5个参数 e = 5
mov r9, 6 ; 第6个参数 f = 6

; 第7个及以后的参数通过栈传递(从右向左压栈)
push 8 ; 第8个参数 h = 8(先压栈)
push 7 ; 第7个参数 g = 7(后压栈)

; 此时RSP应该是16字节对齐的(如果不是,需要调整)
call example_func

; 清理栈空间:2个参数 * 8字节 = 16字节
; 将 g h 两个参数出栈
add rsp, 16

; 返回值现在在RAX中
; ... 使用返回值 ...

; 程序退出
mov rax, 60
xor rdi, rdi
syscall

; 被调用函数示例
example_func:
; 函数序言:保存被调用者保存的寄存器(如果需要)
push rbp
mov rbp, rsp

; 可以安全使用RAX, RCX, RDX等调用者保存寄存器
; 如果要使用RBX, R12-R15等,需要先保存
push rbx

; 函数体:访问参数
; 前6个参数在寄存器中:rdi, rsi, rdx, rcx, r8, r9
; 第7个参数g在 [rbp + 16](跳过保存的rbp和返回地址)
; 第8个参数h在 [rbp + 24]

; 示例:计算总和
mov rax, rdi ; rax = a
add rax, rsi ; rax += b
add rax, rdx ; rax += c
add rax, rcx ; rax += d
add rax, r8 ; rax += e
add rax, r9 ; rax += f

mov rbx, [rbp + 16] ; 获取g
add rax, rbx
mov rbx, [rbp + 24] ; 获取h
add rax, rbx

; 函数尾声:恢复寄存器
pop rbx
mov rsp, rbp
pop rbp
ret

栈帧的作用

  1. 保存调用上下文

    在 x86-64 System V ABI 调用约定中,寄存器被分为两类:

    1
    2
    3
    - 调用者保存寄存器:如 RAX, RCX, RDX, R8, R9, R10, R11。如果调用者(Caller)希望在这些寄存器中的值在子函数调用后保持不变,它自己必须在 call 指令前将它们保存到自己的栈帧或其它地方。

    - 被调用者保存寄存器:如 RBX, RBP, R12-R15。如果被调用函数(Callee,即当前函数)要使用它们,它必须在修改前将其原始值压入栈,并在返回前弹出恢复。这正是你观察到的核心操作。

    若没有栈帧,则程序无法安全的使用这些寄存器

  2. 为局部变量提供存储空间

    寄存器数量极其有限(仅16个通用寄存器)。任何复杂的函数(例如处理数组、大型结构体或递归函数)都需要在内存中存放局部变量。

    1
    2
    3
    4
    5
    6
    int example(int n)
    {
    int large_array[100]; // 400字节,必须放在栈上
    // ... 使用数组
    return large_array[n];
    }
  3. 传参数量超过6

    rdi rsi rdx rcx r8 r9

    第七个及其之后的参数需要从右到左压入栈中

    调用者会将它们压入自己的栈帧,而被调用函数则会通过自己栈帧指针 RBP 的一个固定偏移(如 [rbp+16])来访问它们。这同样需要栈帧作为可靠的中转存储。

  4. 保证栈对齐

    出于性能和安全考虑,System V ABI 要求在调用函数之前,栈指针 RSP 必须16字节对齐。call 指令本身会压入一个8字节的返回地址,这会破坏对齐。因此,函数开场经常通过调整 RSP(例如 sub rsp, 8)来重新对齐,以便安全地调用其他函数(如 printf)。这个调整也是栈帧管理的一部分。

关于栈帧,类似的,像进程、线程等有进行上下文状态保存需要的结构,其实现基础仍是类似与函数栈帧的结构,是在此基础之上的。
函数栈帧是原子操作,线程是管理这些原子操作的执行流,进程是为这些执行流提供隔离资源的容器。 从保存几个寄存器到保存整个CPU上下文,思想一脉相承。这正是计算机系统中“局部性”和“分层”思想的优美体现。

转移指令及其原理

在 x86_64 汇编中,转移指令是控制程序执行流程的核心。它们可以分为四大类:

  1. 无条件转移指令
  2. 过程调用与返回指令
  3. 条件转移指令
  4. 特殊转移指令

一、无条件转移指令

这是最直接、最常用的跳转。

  • JMP (Jump):无条件跳转到指定目标。
    • 作用:实现 goto、无限循环、跳出深层结构。
    • 示例:
      assembly jmp label ; 直接跳转到标签处 jmp [rax] ; 间接跳转,跳往地址存在 rax 指向的内存中 jmp rax ; 间接跳转,跳往地址存在 rax 寄存器中

二、过程(函数)调用与返回指令

这是实现函数模块化的基石。

  • CALL (Call Procedure):
    • 作用:1) 将 RIP(下一条指令地址)压栈; 2) 跳转到目标函数。
    • 示例:call my_function
  • RET (Return from Procedure):
    • 作用:从栈顶弹出地址到 RIP,从而返回到 call 之后的指令。
    • 示例:ret

三、条件转移指令(最常用、最复杂)

这是实现 if、else、while、for 等高级语言控制逻辑的关键。它们根据标志寄存器 (RFLAGS) 中的状态位来决定是否跳转。

最重要的四个状态位:

  • CF (Carry Flag):无符号运算溢出/借位。
  • ZF (Zero Flag):结果为零。
  • SF (Sign Flag):结果为负(有符号数)。
  • OF (Overflow Flag):有符号运算溢出。

下表列出了最常用的条件跳转指令及其判断逻辑:

指令 含义 检查的标志位(条件) 典型应用场景
JE / JZ 等于 / 为零时跳转 ZF = 1 if (a == b),循环结束判断
JNE / JNZ 不等于 / 不为零时跳转 ZF = 0 if (a != b),循环继续判断
JG / JNLE 大于跳转(有符号) ZF = 0 and SF = OF if (a > b) (有符号数比较)
JGE / JNL 大于等于跳转(有符号) SF = OF if (a >= b) (有符号数)
JL / JNGE 小于跳转(有符号) SF != OF if (a < b) (有符号数)
JLE / JNG 小于等于跳转(有符号) ZF = 1 or SF != OF if (a <= b) (有符号数)
JA / JNBE 高于跳转(无符号) CF = 0 and ZF = 0 if (a > b) (无符号数,如地址、数据大小)
JB / JNAE / JC 低于跳转(无符号) CF = 1 if (a < b) (无符号数),也用于检查进位
JS 符号位为1(负数)跳转 SF = 1 if (a < 0)
JNS 符号位为0(非负)跳转 SF = 0 if (a >= 0)

示例:实现 if (rax > rbx)

1
2
3
4
5
6
7
cmp rax, rbx  ; 计算 rax - rbx,设置标志位
jg greater ; 如果有符号数 rax > rbx,则跳转
; 否则继续执行
jmp end
greater:
; rax > rbx 时要执行的代码
end:

四、需要特别注意的“特殊”转移指令

  1. 与 CX 相关的跳转:
    • JCXZ / JECXZ / JRCXZ:当 RCX/ECX/CX 寄存器的值为 0 时跳转。这是 loop 指令族里唯一仍有实用价值的,常用于在循环开始前检查计数器是否为零,避免零次循环。
  2. 循环指令(建议避免使用):
    • LOOP, LOOPZ/LOOPE, LOOPNZ/LOOPNE:它们将“RCX减1”和“条件判断跳转”合并为一条指令。在现代CPU上性能不佳且不够灵活,你应始终使用 DEC RCX + JNZ 等组合来替代。

1
nasm -f elf64 -g -F dwarf eatsyscall.asm
  • nasm 汇编器
  • f elf64 生成elf64格式的***.o***文件
  • g 将调试信息保留在汇编文件.o中
  • F dwarf 以DWARF格式生成调试信息
  • eatsyscall.asm 需要汇编的文件名
1
ld -o eatsyscall eatsyscall.o
  • ld 链接器
  • o eatsyscall 指定生成的可执行程序名
  • eatesyscall.o 指定需要链接的目标代码文件

在类UNIX系统中,其中一个最有用的基本机制是:I/O 重定向,该功能可以通过C/C++以及汇编得到极大的利用

常用汇编程序框架

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

; 初始注释块
;

SECTION .data
hello: db 'Hello, World',10
fedora: db 'Hello',', Fedora',10

SECTION .bss

SECTION .text

global _start

_start:

; 汇编语句
;

mov rax, 0x3C
xor rdi, rdi
syscall
  • .data块 包含已初始化数据项的数据定义。值在程序开始之前确定,是可执行文件的一部分。
    • 可以使用db dw dd dq在.data块中定义一块内存空间 (byte word double-word quad-word)
    • 使用 ’ “ 界定字符串,可以使用 , 分隔子字符串,使用汇编时计算进行推导字符串长度
  • .bss块 Block Start Symbol 为缓冲区预留一定数量的字节并为其命名。
  • .text块 存放实际组成程序的机器指令
  • 标签 指示跳转指令的跳转位置,为可调用的汇编语言过程命名。注意,标签实际上是一个地址
    • 必须以 [:alpha:] _ . ? 开头,其后必须跟一个 : 区分大小写,并将字面量转换为对应ASCII字符

可以通过栈(Stack)后进先出

栈(Stack) 是一种内置在CPU硬件中的存储机制,存在于普通内存中

在x64架构中,堆栈顶使用栈指针 rsp进行管理,向低地址增长。由此,我们可以理解以下Linux内存模型
|内存模型|
|:—:|
|高地址|
|栈初始空栈,rsp指向栈空间最高地址+1处|
|堆(由操作系统管理内存堆栈的分配)|
|.bss未初始化数据项|
|.data初始化数据项|
|.text程序|
|低地址|

.text标签标识的程序,从低地址向高地址执行

rsp栈指针寄存器,值从高地址处由指令控制,向低地址增长

  • 使用push pop进行入栈、出栈,控制rsp的值
    • push 将一个 16bit 64bit 的寄存器或内存值压入栈,***注意:不能将8bit 32bit值压入栈
    • pushfq 将完整的 64bit RFlags 压入栈,Q为quad,该指令不接受操作数
    • pop 将一个 16bit 64bit 的栈顶值弹出栈到寄存器或内存,***注意:不能将8bit 32bit值压入栈
    • popfq 将完整的 64bit 弹出栈到标志寄存器RFlags,不处理操作数

注意: CPU和Linux系统内核都不会记录放置在栈上的数据项大小,需要自己控制。压栈时,先减少rsp值再存入数据项,出栈时,先提取数据项再增加rsp值
PUSHFQ POPFQ不显式处理操作数,仅专注于RFlags
PUSHA PUSHAD POPA POPAD 已经停用,用于一次性压入/弹出所有通用寄存器的内容

使用栈,允许有限的寄存器执行多重任务,临时保存值,通过站指针直接操作值


通过SYSCALL使用Linux内核操作

API:应用程序接口,是可调用的函数集合,可供高级语言使用
ABI:应用程序二进制接口,在机器代码层面详细描述一段二进制代码与另一段代码通信或与寄存器等CPU硬件通信时发生的情况。位于API之下一层。定义了一组基本的可调用函数,通常由操作系统提供。以及与程序链接等内容
。Linux包含了System V ABI。

System V ABI 系统调用约定

前两行

|RAX 系统调用|RDI|RSI|RDX|R10|R8|R9|
|:—:|:—:|:—:|:—:|:—:|:—:|:—:|
|0 sys_read|文件描述符|缓冲的地址|缓冲的长度|n/a|n/a|n/a|
|1 sys_write|文件描述符|文本的地址|文本的长度|n/a|n/a|n/a|

注意:在SYSCALL指令在内部使用RAX RCX R11。在SYSCALL返回后,不能假设以上寄存器与系统调用前相同。

  • cmp 减法,设置OF SF ZF AF PF CF
  • test 与运算
  • bt 位测试 bt <value containing bit>, <bit number>,将所选位复制到CF标志

x64长模式内存寻址:[基址 + (索引 * 比例) + 位移量]

  • 基址,任何通用寄存器
  • 索引,任何通用寄存器
  • 比例,1 2 4 8将比例应用于索引
  • 位移量(Displacement,而非偏移offset),任意32bit常量
1
mov qword rax, [rcx]

以上程序,将地址[rcx]处开始的8字节值放入rax寄存器

  • lea 指令,意为“加载有效地址”,利用源操作数计算地址加载到一个指定的寄存器中(仅可用寄存器承接)
1
lea rbx, [ScaleValues + rcx * 4]

注意在 mov quad r8, [rax + rcx4]* 是将该地址处的8字节值加载到r8;在 lea r8, [rax + rcx4]* 中,则是将该地址值加载到r8

可以使用表代替计算如平方根表以优化数学处理

在处理跳转语句时,需要注意操作与跳转所控制与检查的RFlags位

  • Linux系统调用细节
  • Linux系统调用表

    以上两种调用适用于系统调用,而非用户空间调用即调用C编程中使用的glibc代码库

  • System V ABI 手册
  • 全局标签:globalName
  • 本地标签:.labelName
    • 用于两个相邻全局标签之间
    • 本地标签隐含包含其所属的全局标签,可以使用:global.label进行强制跳转到一个本地标签代码段

过程定义 Procedure

过程是通过调用call和返回ret指令来实现的,是**指令集的一部分

  • call 调用过程
  • ret 过程返回

Procedure

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
section .data
hello_str: db 'Hello, World!',10
.len: equ $ - hello_str

section .bss

section .text

global _start

_start:

;

call Hello_fn ; 调用过程

mov rax, 0x3C
xor rdi, rdi
syscall

; Hello_fn 过程 Procedure
Hello_fn:
push rbp
mov rbp, rsp
push rbp
push rax
push rdi
push rsi
push rdx

mov rax, 0x01
mov rdi, 0x01
mov rsi, hello_str
mov rdx, hello_str.len
syscall

pop rdx
pop rsi
pop rdi
pop rax
pop rbp
mov rsp, rbp
pop rbp

ret ; 返回,退出过程

;

宏定义 Macro

是汇编器的一种技巧,并不依赖于任何特定的指令或指令组

macro

是一个代表某些文本行序列的标签。可以是指令序列。汇编器在代码文件中遇到宏时,将宏标签所代表的文本行替换宏标签,称为扩展宏。

宏的定义在***%MACRO和%ENDMACRO***之间

1
2
3
%MACRO macro_name [:number:] ; 宏名 参数数量(0~)

%ENDMACRO

宏的扩展仅发生在内存中

使用宏:

1
2
3
section .text

macro_name para1, para2, ... ; 直接使用 宏名 参数1, 参数2, ...

%ENDMACRO标签位于宏的最后一行之后的一行

macro宏用例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
%MACRO HELLO_MACRO 2 ; %1 字符串 %2 字符串长度
mov rax, 0x01
mov rdi, 0x01
mov rsi, %1
mov rdx, %2
syscall
%ENDMACRO

section .data
hello_str: db 'Hello, World!',10
.len: equ $ - hello_str

section .bss

section .text

global _start

_start:

;

HELLO_MACRO hello_str, hello_str.len

mov rax, 0x3C
xor rdi, rdi
syscall

;

其中的宏参数进行的是一种替换,而不会被压入栈中或设置到其他类似的地方
在调用宏时,寄存器名、[寄存器],忽略多余的实参

  • 宏中的标签使用**%%**开头,可以在宏扩展后避免重复标签错误
1
2
3
%macro macro_name
%%inner_macro_label:
%endmacro

也可以使用%define定义单行宏,类似于C语言中的#define

1
2
3
4
5
6
%define print_string(addr, len) \
mov rax, 0x01 ; \
mov rdi, 0x01 ; \
mov rsi, addr ; \
mov rdx, len ; \
syscall

还可以定义条件宏,进行条件汇编%if %ifdef %ifndef %else %elif %endif与在C语言中的宏使用类似

要注意不要过度包装宏

可以将多个宏包装为宏库 .mac / .inc

  • 在源文件中使用**%include ""** 进行扩展

宏库,不能被编译为目标文件再链接到文件中,因为它执行的相当于在预处理阶段翻译文件中的宏定义,插入宏定义,无法在汇编上先进行编译打包,但是,可以将该文件与过程库文件进行编译打包,将过程库文件中的宏扩展。


构建外部过程库

在某一个过程的代码量巨大且复杂,可以将其放入一个单独的源代码文件中。称为库文件,可以包含许多过程(最好是有相关联性的过程)

  • 一个库文件可以 单独汇编为一个 .o 文件,然后由Linux链接器链接到其他程序中。
  • 库文件也可通过一个名为 %INCLUDE 的指令被包含在主程序的源代码文件中。在SASM中使用
  • %INCLUDE “textlibgcc.asm”

库文件汇编

1
2
3
4
5
6
section .data
section .text

global lib_process ; 将函数导出

lib_process: ; 定义外部函数

引用的汇编文件

1
2
3
4
5
6
7
8
9
10
section .data
section .bss
section .text
global _start

extern lib_process ; 声明外部函数

_start:

call lib_process ; 调用外部函数

在 x86-64 Linux 环境下,编写和使用汇编库是组织代码、实现复用的关键一步。整个过程可以拆解为三个环节:编写可重用的汇编代码、将其打包为库、以及在其他汇编或 C 程序中使用。

以下是完整的操作指南,以 NASM 语法为例。

一、编写可重用的汇编代码

编写库函数时,关键在于遵守调用约定,确保函数能被其他代码正确调用。

  1. 函数声明:使用 global 将函数名导出,使其对链接器可见。
  2. 遵循调用约定:
  • 参数传递:在 x86-64 系统中,前6个整数或指针参数依次使用 rdi, rsi, rdx, rcx, r8, r9 寄存器传递。
  • 返回值:通常将返回值放在 rax 寄存器中。
  • 寄存器保存:被调用者必须保存 rbp, rbx, r12~`r15` 等寄存器,如果需要使用它们,需在栈中暂存。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
; math.asm - 一个简单的数学库
section .text

; 导出函数符号,使其对链接器可见
global add_two
global square

; int add_two(int a, int b)
; 参数 a 在 rdi, 参数 b 在 rsi
add_two:
mov rax, rdi ; 将第一个参数移到 rax
add rax, rsi ; 加上第二个参数
ret ; 返回 (结果在 rax)

; int square(int x)
; 参数 x 在 rdi
square:
mov rax, rdi
imul rax, rax ; 与自身相乘
ret

二、编译与打包为库

将汇编代码分别编译成目标文件(.o),然后打包成静态库(.a)或动态库(.so)。

1. 编译为目标文件

1
nasm -f elf64 math.asm -o math.o

2. 创建静态库(.a)
使用 ar 命令将目标文件打包:

1
ar rcs libmath.a math.o
  • r:将文件插入库中。
  • c:创建库(如果不存在)。
  • s:创建目标文件索引,加快链接速度(等同于执行 ranlib libmath.a)。

3. 创建动态库(.so)
使用 gcc 链接器创建共享库:

1
2
# 如果使用 NASM,通常无需 -fPIC,因为它的代码本身就是位置无关的
gcc -shared -o libmath.so math.o

三、在汇编源文件中引用与链接

在其他汇编代码中,使用 extern 声明外部函数,然后正常 call 即可。

1. 编写调用程序(main.asm)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
; main.asm
section .data
msg db "Result: ", 0 ; 注意:这里只是演示,实际输出需要系统调用
; 为了简化,我们不在这里实现完整的打印

section .text
global _start
extern add_two ; 声明外部函数
extern square

_start:
; 调用 add_two(5, 3)
mov rdi, 5
mov rsi, 3
call add_two
; 此时 rax 中应为 8

; 调用 square(6)
mov rdi, 6
call square
; 此时 rax 中应为 36

; 退出程序
mov rax, 60 ; syscall: exit
xor rdi, rdi ; status: 0
syscall

2. 编译与链接

  • 静态链接:直接将库文件链接到最终可执行文件中。
    bash nasm -f elf64 main.asm -o main.o ld main.o libmath.a -o program
    也可以使用 gcc 进行链接:
    bash gcc -static -nostdlib main.o libmath.a -o program

  • 动态链接:程序运行时需要能找到对应的 .so 文件。

    1
    2
    nasm -f elf64 main.asm -o main.o
    ld main.o -L. -lmath -dynamic-linker /lib64/ld-linux-x86-64.so.2 -o program

    或使用更简单的 gcc 命令:

    1
    gcc -no-pie main.o -L. -lmath -o program
    • -L.:告诉链接器在当前目录(.)查找库。
    • -lmath:链接名为 libmath.so(或 libmath.a)的库。

    运行动态链接的程序:如果库不在系统默认路径,需要告知动态加载器库的位置:

    1
    2
    export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:."   # 临时设置
    ./program

四、关键细节与避坑指南

  1. 入口点问题:如果完全用汇编编写程序,入口点通常是 _start。如果使用 gcc 进行链接,它会默认寻找 main 函数作为入口,并链接额外的初始化代码(crt 对象)。如果你使用 _start 又想用 gcc 链接,需要使用 nostartfiles 选项。
  2. 调用 C 库函数:如果要在汇编中调用 printf 等 C 库函数,情况会更复杂,需要正确处理栈对齐等 ABI 细节。建议先从纯汇编库开始练习。
  3. 静态链接的代码膨胀:使用 gcc -static 静态链接 libc 会产生巨大的可执行文件,因为它会包含大量初始化代码。如果不需要 C 库,务必使用 nostdlib。

在源文件中使用动态链接过程时 需要以下方法进行相对位置调用

1
2
3
4
5
6
7
8
9
10
11
section .data
msg db "Hello", 0

section .text
global myfunc ; 将该文件内的过程导出
extern printf ; 引用外部printf符号

myfunc:
lea rdi, [rel msg] ; ✅ 使用 RIP 相对寻址加载地址
call printf wrt ..plt ; ✅ 显式使用 PLT 调用外部函数
ret

wrt 与 plt

  • wrt 是 NASM 的关键字,全称 “With Respect To”,表示“相对于……”。它用来指定一个符号的重定位方式。
  • ..plt 是一个特殊的段(section)或符号,代表过程链接表(Procedure Linkage Table)。PLT 是动态链接机制的一部分,用于延迟绑定外部函数(如 C 库函数 printf、print 等)。

为什么需要 wrt ..plt?

在动态链接的可执行文件或共享库中,对外部函数的调用地址在链接时无法确定(因为函数在另一个共享库中)。直接写 call print 会生成一个对 print 符号的绝对地址引用,这会导致链接器在生成共享库时产生需要重定位的代码段,从而触发你之前遇到的警告(relocation in read-only section)。

使用 call print wrt ..plt 后,汇编器生成的指令会跳转到 PLT 中与该函数对应的桩代码(stub)。PLT 的代码在运行时由动态链接器负责填充正确的函数地址,从而:

  1. 保持代码段只读:PLT 本身在代码段,但其内部的重定位条目指向 GOT(全局偏移表),GOT 是可写的。
  2. 实现延迟绑定:第一次调用时解析函数地址,后续调用直接使用已解析的地址。
  3. 满足位置无关代码(PIC)要求:避免了在只读代码段中插入绝对地址重定位。

何时必须使用 wrt ..plt?

  • 在共享库(.so)的代码中,对外部函数(定义在其他库中)的调用必须通过 PLT,否则会产生不可重定位的代码,导致共享库无法正常加载或触发警告。
  • 在可执行文件中,如果可执行文件是动态链接的且调用了外部库函数,链接器通常会自动处理 PLT 重定位,因此显式写 wrt ..plt 并非总是强制,但显式指定能让代码意图更清晰,并避免某些 NASM 模式下的默认行为问题。
1
2
3
4
5
6
7
8
9
10
11
extern printf           ; 声明外部函数

section .text
global myfunc
myfunc:
lea rdi, [rel msg] ; 使用 RIP 相对寻址(位置无关)
call printf wrt ..plt ; 通过 PLT 调用 printf
ret

section .data
msg db "Hello", 0

补充:..got 和 ..plt 的关系

  • ..plt 用于函数调用。
  • ..got 用于访问外部全局变量。例如 mov rax, [rel myvar wrt ..got] 会从 GOT 中获取变量 myvar 的实际地址。

链接汇编与C代码

关于汇编代码,其处理与上述内容一致

asm_fn.asm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
section .data
asm_greet: db 'Hello Fedora Linux Assembly & C Language Linking!',10
.len: equ $ - asm_greet

section .text

global asm_fn

asm_fn:

push rbp
mov rbp, rsp
push rbp
push rax
push rdi
push rsi
push rdx
push rcx

mov rax, 0x1
mov rdi, 0x1
mov rsi, asm_greet
mov rdx, asm_greet.len
syscall

pop rcx
pop rdx
pop rsi
pop rdi
pop rax
pop rbp
mov rsp, rbp
pop rbp

ret

关于,C代码,需要使用 extern 语句,预定义,声明函数原型,最好是包装一个.h的C语言头文件,直接在C代码中调用该头文件几乎不涉及makefile的改变,因为.c源代码直接预处理包含了.h头文件中的extern内容

asm_fn.h

1
2
3
4
5
6
#ifndef ASM_FN_H
#define ASM_FN_H

extern void asm_fn();

#endfi

main.c

1
2
3
4
5
6
7
8
9
10
11
12
#include <stdio.h>

// #include "asm_fn.h"

extern void asm_fn(); // 若使用了头文件包装,无需使用该行

int main(int argc, char** argv)
{
asm_fn();

return 0;
}

makefile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
CC=gcc
ASMC=nasm

main: main.o libasm_fn.a
$(CC) main.o -L. -lasm_fn -o $@

main.o: main.c
$(CC) -c main.c -o main.o

libasm_fn.a: asm_fn.o
ar rcs $@ $^

asm_fn.o: asm_fn.asm
$(ASMC) -f elf64 $^ -o $@

.PHONY:
clean

clean:
rm *.o *.a

字符串指令

对于系统汇编来说,字符串是:
内存中任何连续的字节组,包含任意类型的数据,大小任意。即,字节连续排列,无中断

字符串指令是 x86/x86-64 汇编语言中专门用于处理连续内存块(字符串或数组)的一类指令。它们通常与重复前缀配合,能够高效地执行内存复制、比较、扫描、填充等操作。

一、核心字符串指令

指令 全称 功能简述
MOVS Move String 从源地址(DS:RSI)复制一个元素到目的地址(ES:RDI),并自动更新指针。*字符串复制
CMPS Compare String 比较源地址和目标地址的元素,影响标志位,并更新指针。两字符串的前缀检查,查找第一个相同/不同的字符所处的位置,根据rcx计数值
SCAS Scan String 将累加器(AL/AX/EAX/RAX)与目标地址的元素比较,影响标志位,更新指针。查找给定值在字符串中出现的位置,或第一个未出现的位置
LODS Load String 从源地址加载一个元素到累加器,更新源指针。只保留最后一个被加载到rax中的字符值
STOS Store String 将累加器的值存储到目标地址,更新目标指针。字符串初始化填充

重复前缀rep repe/z repne/z指明rcx控制的重复条件

这些指令都有**字节(B)、字(W)、双字(D)、四字(Q)**版本,例如 MOVSB(字节)、MOVSW(字)、MOVSD(双字)、MOVSQ(四字,64位)。

二、重复前缀

重复前缀使字符串指令可以自动循环执行,从而处理整个内存块。常用前缀有:

前缀 含义 适用指令
REP repeat 重复执行直到 RCX 变为 0 MOVS、STOS、LODS
REPE / REPZ repeat equal/zero 相等时重复(ZF=1 且 RCX≠0) CMPS、SCAS(用于查找不相等)
REPNE / REPNZ repeat not equal/zero 不相等时重复(ZF=0 且 RCX≠0) CMPS、SCAS(用于查找相等)

工作原理:每次执行指令后,RCX 减 1,并根据指令类型和前缀条件判断是否继续。同时,RSI 和 RDI 会根据方向标志自动增减。

三、方向标志 DF

方向标志 DF 控制指针的增减方向:

  • DF=0(使用 CLD 清除):指针递增(向高地址移动)。clean direction flag
  • DF=1(使用 STD 置位):指针递减(向低地址移动)。set direction flag

在操作字符串时,务必根据需要设置正确的方向。

四、需要掌握的知识点

  1. 指令用法
    • 会用 REP MOVSB 实现内存复制。
    • 会用 REP STOSB 清空缓冲区或设置初始值。
    • 会用 REPE CMPSB 比较两个字符串是否相等。
    • 会用 REPNE SCASB 在字符串中查找特定字符。
  2. 寄存器约定
    • RSI 指向源地址,RDI 指向目标地址,RCX 存放计数器。
    • 累加器(AL/AX/EAX/RAX)用于 LODS/STOS/SCAS。
  3. 与高级语言对应
    • 理解 memcpy、memcmp、memset、strlen、strchr 等 C 库函数的底层实现可能用到这些指令。
  4. 性能考量
    • 现代 CPU 对 REP MOVS/STOS 有优化(如 ERMSB、快速字符串操作),在复制大块内存时可能比普通循环更快。
    • 但对于小尺寸或复杂逻辑,手写循环可能更灵活。
  5. 实际应用场景
    • 操作系统内核、引导加载器、嵌入式代码中频繁使用(因为无法依赖 C 库)。
    • 手写优化某些内存密集型算法。

五、示例:用 REP MOVSB 复制内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
section .data
src db 'Hello, World!',0
len equ $ - src

section .bss
dest resb len

section .text
global _start
_start:
cld ; 方向递增
mov rsi, src ; 源地址
mov rdi, dest ; 目的地址
mov rcx, len ; 字节数
rep movsb ; 复制

; 程序退出...

六、学习建议

  • 在调试器(如 GDB)中单步执行带重复前缀的指令,观察 RSI、RDI、RCX 的变化,以及标志位如何影响循环。
  • 尝试用字符串指令实现 strlen 或 strcpy,比较与手写循环的差异。
  • 阅读编译器生成的汇编代码,看看优化后的内存操作是否使用了这些指令。

掌握字符串指令后,能更深入地理解底层内存操作,并能在特定场景下手写优化代码。它们也是后续学习操作系统、编写设备驱动等的基础知识之一。

七、字符串指令详解

字符串指令是 x86/x86-64 汇编中用于处理连续内存块(字符串或数组)的专用指令,它们与重复前缀配合可以高效地完成批量内存操作。下面详细描述每个核心字符串指令与不同重复前缀组合时的功能,并说明其执行过程。


一、字符串指令基础

所有字符串指令都会根据方向标志 DF 自动更新源指针 RSI 和目标指针 RDI(或仅其中一个):

  • DF=0(CLD):指针递增(向高地址移动)。
  • DF=1(STD):指针递减(向低地址移动)。

更新的步长由指令操作数大小决定:

  • B(字节):±1
  • W(字):±2
  • D(双字):±4
  • Q(四字):±8

重复前缀 REP、REPE/REPZ、REPNE/REPNZ 使指令在 RCX ≠ 0 的条件下循环执行,每次执行后 RCX 自动减 1,并根据前缀条件决定是否继续。


二、各指令与重复前缀的组合功能

1. MOVS(Move String)

功能:从 [RSI] 复制一个元素到 [RDI],并更新两个指针。

组合 功能描述 类比 C 语言操作
REP MOVS 将 RCX 个元素从源地址复制到目标地址。 memcpy(dest, src, count * element_size)
无其他前缀 (无条件重复) -

执行细节:

  • 每复制一个元素,RSI 和 RDI 根据 DF 增减,RCX 减 1。

  • 当 RCX 变为 0 时停止。


2. STOS(Store String)

功能:将累加器(AL/AX/EAX/RAX)的值存储到 [RDI],并更新目标指针。

组合 功能描述 类比 C 语言操作
REP STOS 用累加器的值填充 RCX 个目标元素。 memset(dest, value, count * element_size)
无其他前缀 (无条件重复) -

执行细节:

  • 每次存储后 RDI 更新,RCX 减 1,直到 RCX=0。

  • 累加器值保持不变。


3. LODS(Load String)

功能:从 [RSI] 加载一个元素到累加器,并更新源指针。

组合 功能描述 类比 C 语言操作
REP LODS 连续加载 RCX 个元素到累加器,但最终只保留最后一个值。 无直接对应,实际很少用
无其他前缀 (无条件重复) -

执行细节:

  • 每次加载后累加器被覆盖,RSI 更新,RCX 减 1。

  • 循环结束后,累加器存放最后一个元素的值,之前的全部丢失。

  • 因此 REP LODS 实用价值很低,通常配合其他指令在循环中使用。


4. CMPS(Compare String)

功能:比较 [RSI] 和 [RDI] 的两个元素,影响标志位,并更新两个指针。

组合 功能描述 类比 C 语言操作
REPE CMPS / REPZ CMPS 当两个元素相等时继续比较,直到遇到不相等的元素或 RCX=0。 memcmp 的前缀检测,或查找第一个不同处
REPNE CMPS / REPNZ CMPS 当两个元素不相等时继续比较,直到遇到相等的元素或 RCX=0。 查找第一个相同处

执行细节:

  • 每次比较后更新指针和 RCX,并根据比较结果设置 ZF。

  • REPE:循环继续的条件是 ZF=1(相等)且 RCX≠0。

  • 若因 ZF=0(不相等)停止,则 RSI/RDI 指向不相等的位置。

  • 若因 RCX=0 停止且一直相等,则 ZF=1 表示全部相等。

  • REPNE:循环继续的条件是 ZF=0(不相等)且 RCX≠0。

  • 若因 ZF=1(相等)停止,则指针指向相等的位置。

  • 若因 RCX=0 停止且从未相等,则 ZF=0。


5. SCAS(Scan String)

功能:将累加器(AL/AX/EAX/RAX)与 [RDI] 的元素比较,影响标志位,并更新目标指针。

组合 功能描述 类比 C 语言操作
REPE SCAS / REPZ SCAS 当累加器与目标元素相等时继续扫描,直到遇到不相等或 RCX=0。 查找第一个不等于给定值的元素
REPNE SCAS / REPNZ SCAS 当累加器与目标元素不相等时继续扫描,直到遇到相等或 RCX=0。 查找第一个等于给定值的元素(如 strchr)

执行细节:

  • 每次比较后更新 RDI 和 RCX,并根据比较结果设置 ZF。

  • REPE:继续条件为 ZF=1(相等)且 RCX≠0。

  • 若因 ZF=0 停止,RDI 指向第一个不相等的位置,且 ZF=0。

  • 若因 RCX=0 停止,则所有元素都与累加器相等,ZF=1。

  • REPNE:继续条件为 ZF=0(不相等)且 RCX≠0。

  • 若因 ZF=1 停止,RDI 指向第一个相等的位置,且 ZF=1。

  • 若因 RCX=0 停止,则未找到相等元素,ZF=0。


三、总结与常用组合

指令 常用前缀 功能 典型用途
MOVS REP 批量内存拷贝 memcpy
STOS REP 内存填充 memset
CMPS REPE / REPNE 字符串比较 / 查找差异 memcmp、差异检测
SCAS REPE / REPNE 查找特定字符或寻找不等 strlen(需配合其他指令)、strchr、strcspn
LODS (很少用REP) 单次加载 通常手动循环

注意事项:

  • 使用前必须正确设置方向标志(CLD 或 STD)。
  • 确保 RCX 存放的是元素个数,而非字节数(除非使用字节指令)。
  • 所有重复前缀都会在每次迭代后自动修改指针和 RCX,无需手动干预。
  • 若要在循环中保存中间结果,应避免使用 REP LODS,而改用普通 LODS 配合其他指令。

掌握这些组合后,你可以高效地实现底层内存操作,并深入理解 C 库函数(如 memcpy、memset、strchr 等)的汇编级实现原理。


汇编文件后缀汇总

  • 源文件
    • .asm 汇编文件,过程文件
    • .mac / .inc 宏定义文件
  • 中间文件
    • .o obj文件
  • 最终目标文件
    • .o / 可执行文件
    • .a 静态链接库文件
    • .so 动态链接库文件