006-汇编语言中的寻址模式

汇编语言中的寻址模式

寻址模式是汇编语言中用于指定指令操作数位置的方法。它们定义了处理器如何计算操作数的有效地址，是理解和使用汇编语言的核心概念之一。本文将详细介绍各种寻址模式的工作原理、语法、应用场景以及不同处理器架构的寻址特点。

1. 寻址模式基础概念

1.1 什么是寻址模式

寻址模式是指令用来确定操作数位置的机制。它告诉处理器如何计算操作数的有效地址，从而找到指令需要的数据。不同的寻址模式提供了不同的方式来指定数据位置，使程序员能够灵活高效地访问寄存器、内存和立即数。

1.2 寻址模式的重要性

寻址模式对汇编编程至关重要，因为它们：

1. 决定数据访问效率：不同寻址模式有不同的执行时间和内存需求
2. 影响代码大小：某些寻址模式产生更紧凑的机器码
3. 提供编程灵活性：支持数组、结构体、指针等高级数据结构
4. 影响优化策略：优化编译器和汇编程序员会选择最高效的寻址模式

1.3 基本术语

在深入探讨寻址模式前，先了解一些基本术语：

• 操作数(Operand)：指令处理的数据或其位置
• 有效地址(Effective Address)：操作数在内存中的实际地址
• 基址(Base)：用作地址计算起始点的寄存器值
• 变址(Index)：用于偏移计算的寄存器值
• 比例因子(Scale Factor)：乘以变址值的倍数
• 偏移量(Displacement/Offset)：地址计算中添加的常数值

2. 通用寻址模式

虽然不同处理器架构支持不同的寻址模式，但以下是几乎所有汇编语言中常见的基本寻址模式：

2.1 立即寻址(Immediate Addressing)

操作数的值直接编码在指令中，不需要内存访问。

原理：操作数就是指令的一部分
优点：快速，不需要额外的内存访问
缺点：操作数大小受指令格式限制

示例：

assembly

; Intel语法
MOV EAX, 42         ; 将立即数42加载到EAX寄存器

; AT&T语法
movl $42, %eax      ; 将立即数42加载到EAX寄存器

2.2 寄存器寻址(Register Addressing)

操作数位于处理器的寄存器中。

原理：指令直接指定寄存器作为操作数
优点：非常快速，最小的执行时间
缺点：寄存器数量有限

示例：

assembly

; Intel语法
MOV EAX, EBX        ; 将EBX的内容复制到EAX

; AT&T语法
movl %ebx, %eax     ; 将EBX的内容复制到EAX

2.3 直接寻址(Direct Addressing)

指令直接指定操作数在内存中的地址。

原理：地址作为指令的一部分直接编码
优点：简单，不需要额外计算
缺点：只能访问固定位置，缺乏灵活性

示例：

assembly

; Intel语法
MOV EAX, [0x12345678]    ; 从内存地址0x12345678加载值到EAX

; AT&T语法
movl 0x12345678, %eax    ; 从内存地址0x12345678加载值到EAX

2.4 间接寻址(Indirect Addressing)

操作数的地址存储在寄存器中。

原理：使用寄存器的内容作为内存地址
优点：支持动态地址计算，可实现指针功能
缺点：需要额外的寄存器存储地址

示例：

assembly

; Intel语法
MOV EAX, [EBX]      ; 加载EBX指向的内存位置的值到EAX

; AT&T语法
movl (%ebx), %eax   ; 加载EBX指向的内存位置的值到EAX

2.5 变址寻址(Indexed Addressing)

地址通过基址加变址寄存器计算。

原理：有效地址 = 基址寄存器 + 变址寄存器
优点：适合访问数组元素
缺点：需要两个寄存器

示例：

assembly

; Intel语法
MOV EAX, [EBX+ESI]      ; 加载地址(EBX+ESI)处的值到EAX

; AT&T语法
movl (%ebx,%esi), %eax  ; 加载地址(EBX+ESI)处的值到EAX

2.6 基址加偏移量寻址(Base-Displacement Addressing)

地址通过基址寄存器加上固定偏移量计算。

原理：有效地址 = 基址寄存器 + 偏移量
优点：适合访问结构体成员和局部变量
缺点：偏移量大小可能受限

示例：

assembly

; Intel语法
MOV EAX, [EBX+20]       ; 加载地址(EBX+20)处的值到EAX

; AT&T语法
movl 20(%ebx), %eax     ; 加载地址(EBX+20)处的值到EAX

3. x86/x64架构寻址模式

x86和x64架构提供了丰富的寻址模式，为程序员提供极大的灵活性。

3.1 x86基本寻址模式

除了上述通用模式外，x86还支持：

3.1.1 比例变址寻址(Scaled Index Addressing)

原理：有效地址 = 基址 + 变址 × 比例
比例因子：可以是1、2、4或8

示例：

assembly

; Intel语法
MOV EAX, [EBX+ECX*4]        ; 加载地址(EBX+ECX*4)处的值到EAX
                            ; 适合访问4字节元素的数组，ECX为索引

; AT&T语法
movl (%ebx,%ecx,4), %eax    ; 加载地址(EBX+ECX*4)处的值到EAX

3.1.2 比例变址加偏移量寻址(Scaled Index with Displacement)

原理：有效地址 = 基址 + 变址 × 比例 + 偏移量

示例：

assembly

; Intel语法
MOV EAX, [EBX+ECX*4+20]         ; 加载地址(EBX+ECX*4+20)处的值到EAX

; AT&T语法
movl 20(%ebx,%ecx,4), %eax      ; 加载地址(EBX+ECX*4+20)处的值到EAX

3.1.3 RIP相对寻址(RIP-Relative Addressing, x64特有)

原理：有效地址 = RIP(指令指针) + 偏移量
优点：支持位置无关代码，高效访问全局变量

示例：

assembly

; Intel语法(64位模式)
MOV RAX, [RIP+offset]       ; 加载相对于当前指令指针的地址

; AT&T语法(64位模式)
movq offset(%rip), %rax     ; 加载相对于当前指令指针的地址

3.2 x86-64扩展寻址能力

x86-64架构扩展了寻址能力：

1. 64位地址空间：支持访问高达16EB (2^64字节)的内存
2. 更多通用寄存器：提供16个通用64位寄存器(RAX, RBX, ..., R15)
3. 支持更大的偏移量：指令可以包含32位偏移量

示例：

assembly

; 使用扩展寄存器的寻址(Intel语法)
MOV RAX, [R12+R13*8+0x1234]    ; 使用R12作为基址，R13作为变址

; 使用扩展寄存器的寻址(AT&T语法)
movq 0x1234(%r12,%r13,8), %rax

3.3 x86实际应用示例

以下是x86/x64寻址模式在实际编程中的应用：

3.3.1 访问数组元素

assembly

; 32位x86，访问int array[i]，假设：
; EBX = array基址
; ECX = i (索引)

; 方法1：手动计算偏移
SHL ECX, 2              ; ECX *= 4 (每个int 4字节)
MOV EAX, [EBX+ECX]      ; EAX = array[i]

; 方法2：使用比例变址(更高效)
MOV EAX, [EBX+ECX*4]    ; EAX = array[i]

3.3.2 访问结构体成员

assembly

; 假设结构体：
; struct Person {
;    int id;     // 偏移0
;    char name[8]; // 偏移4
;    int age;    // 偏移12
; };
; EBX = 指向Person的指针

; 访问person->id
MOV EAX, [EBX]          ; EAX = person->id

; 访问person->age
MOV EAX, [EBX+12]       ; EAX = person->age

; 修改person->name的第2个字符
MOV BYTE PTR [EBX+5], 'A'   ; person->name[1] = 'A'

3.3.3 访问二维数组

assembly

; 访问int matrix[row][col]，假设：
; EBX = matrix基址
; ECX = row (行索引)
; EDX = col (列索引)
; 每行有10个int (40字节)

; 方法1：手动计算地址
IMUL EDI, ECX, 40       ; EDI = row * 40 (每行字节数)
ADD EDI, EDX            ; 添加列偏移
SHL EDI, 2              ; 乘以4 (每个int 4字节)
ADD EDI, EBX            ; 加上基址
MOV EAX, [EDI]          ; 加载值

; 方法2：使用比例变址和LEA
LEA EDI, [ECX*10]       ; EDI = row * 10 (每行元素数)
ADD EDI, EDX            ; EDI = 元素线性索引
MOV EAX, [EBX+EDI*4]    ; 加载matrix[row][col]

4. ARM架构寻址模式

ARM架构使用不同于x86的寻址模式集，各版本之间也有差异。

4.1 ARM 32位(ARMv7及以前)寻址模式

4.1.1 立即数寻址和寄存器寻址

与其他架构类似，支持立即数和寄存器操作数。

assembly

MOV R0, #42         @ 立即数寻址
MOV R0, R1          @ 寄存器寻址

4.1.2 基址寄存器寻址

使用方括号表示内存访问，括号内是地址。

assembly

LDR R0, [R1]        @ 加载R1指向的内存内容到R0
STR R0, [R1]        @ 存储R0的值到R1指向的内存

4.1.3 预索引寻址(Pre-indexed Addressing)

在访问内存前先计算有效地址。

assembly

LDR R0, [R1, #8]    @ R0 = Memory[R1+8]
LDR R0, [R1, R2]    @ R0 = Memory[R1+R2]

4.1.4 预索引自动更新(Pre-indexed with Write-back)

在访问内存前计算地址，并将新地址写回基址寄存器。

assembly

LDR R0, [R1, #8]!   @ R0 = Memory[R1+8], 然后R1 += 8

4.1.5 后索引寻址(Post-indexed Addressing)

先使用基址寄存器中的地址访问内存，然后更新基址寄存器。

assembly

LDR R0, [R1], #8    @ R0 = Memory[R1], 然后R1 += 8
LDR R0, [R1], R2    @ R0 = Memory[R1], 然后R1 += R2

4.2 ARM 64位(AArch64)寻址模式

ARM 64位架构(ARMv8及以后)简化了寻址模式，但仍保留了核心功能。

4.2.1 基本寻址

assembly

// 基本寄存器寻址
LDR X0, [X1]            // X0 = Memory[X1]

// 基址加偏移量寻址
LDR X0, [X1, #16]       // X0 = Memory[X1+16]

// 基址加寄存器寻址
LDR X0, [X1, X2]        // X0 = Memory[X1+X2]

// 比例变址寻址
LDR X0, [X1, X2, LSL #3]    // X0 = Memory[X1+(X2<<3)]
                            // 相当于X0 = Memory[X1+X2*8]

4.2.2 预索引和后索引

AArch64仍然支持预索引和后索引寻址：

assembly

// 预索引自动更新
LDR X0, [X1, #16]!      // X0 = Memory[X1+16], 然后X1 += 16

// 后索引
LDR X0, [X1], #16       // X0 = Memory[X1], 然后X1 += 16

4.3 ARM实际应用示例

4.3.1 数组遍历

assembly

; ARM 32位数组遍历
    MOV R0, #0          @ 累加器初始化为0
    MOV R1, #array      @ R1指向数组
    MOV R2, #10         @ 元素计数
loop:
    LDR R3, [R1], #4    @ 加载当前元素并自增R1
    ADD R0, R0, R3      @ 累加元素
    SUBS R2, R2, #1     @ 减少计数并设置标志
    BNE loop            @ 继续直到所有元素处理完毕
    
; ARM 64位数组遍历
    MOV X0, #0          // 累加器初始化为0
    MOV X1, #array      // X1指向数组
    MOV X2, #10         // 元素计数
loop:
    LDR W3, [X1], #4    // 加载32位元素并自增X1
    ADD X0, X0, X3      // 累加元素
    SUBS X2, X2, #1     // 减少计数并设置标志
    B.NE loop           // 继续直到所有元素处理完毕

4.3.2 结构体访问

assembly

; 假设结构体：
; struct Person {
;    int id;       // 偏移0
;    char name[8]; // 偏移4
;    int age;      // 偏移12
; };
; R0 = 指向Person的指针

; ARM 32位
LDR R1, [R0]            @ R1 = person->id
LDR R2, [R0, #12]       @ R2 = person->age
ADD R3, R0, #4          @ R3 = &person->name
LDRB R4, [R3, #1]       @ R4 = person->name[1]

; ARM 64位
LDR W1, [X0]            // W1 = person->id
LDR W2, [X0, #12]       // W2 = person->age
ADD X3, X0, #4          // X3 = &person->name
LDRB W4, [X3, #1]       // W4 = person->name[1]

4.3.3 堆栈操作

assembly

; ARM 32位 - 保存寄存器到栈
PUSH {R0-R7, LR}        @ 将9个寄存器压栈
; 等同于:
STMDB SP!, {R0-R7, LR}  @ 降序，预递减

; ARM 32位 - 从栈恢复寄存器
POP {R0-R7, PC}         @ 从栈弹出值到9个寄存器(包括PC以返回)
; 等同于:
LDMIA SP!, {R0-R7, PC}  @ 升序，预递增

; ARM 64位 - 保存寄存器到栈
STP X0, X1, [SP, #-16]! // 将X0和X1压栈，SP-=16
STP X2, X3, [SP, #-16]! // 将X2和X3压栈，SP-=16

; ARM 64位 - 从栈恢复寄存器
LDP X2, X3, [SP], #16   // 弹出X2和X3，SP+=16
LDP X0, X1, [SP], #16   // 弹出X0和X1，SP+=16

5. RISC-V架构寻址模式

RISC-V是一种开放标准指令集架构，提供简洁优雅的寻址模式。

5.1 RISC-V基本寻址模式

RISC-V设计简单，寻址模式较少但功能完备。

5.1.1 立即数寻址

assembly

ADDI a0, zero, 42     # a0 = 0 + 42
LI   a0, 42           # 伪指令：a0 = 42

5.1.2 寄存器寻址

assembly

ADD a0, a1, a2        # a0 = a1 + a2
MV  a0, a1            # 伪指令：a0 = a1

5.1.3 基址加偏移量寻址

assembly

LW  a0, 8(a1)         # a0 = Memory[a1+8]
SW  a0, 12(a1)        # Memory[a1+12] = a0

5.2 RISC-V实际应用示例

5.2.1 数组访问

assembly

# 访问int array[i]，假设:
# a0 = array基址
# a1 = i (索引)

# 计算元素地址并加载
SLLI a2, a1, 2        # a2 = i * 4 (每个int 4字节)
ADD  a3, a0, a2       # a3 = &array[i]
LW   a4, 0(a3)        # a4 = array[i]

# 或者，更紧凑:
SLLI a1, a1, 2        # a1 = i * 4
ADD  a1, a0, a1       # a1 = &array[i]
LW   a0, 0(a1)        # a0 = array[i]

# 甚至更紧凑:
SLLI a1, a1, 2        # a1 = i * 4
LW   a0, 0(a0, a1)    # 伪指令：a0 = Memory[a0+a1]

5.2.2 结构体访问

assembly

# 假设结构体：
# struct Person {
#    int id;       // 偏移0
#    char name[8]; // 偏移4
#    int age;      // 偏移12
# };
# a0 = 指向Person的指针

LW   a1, 0(a0)        # a1 = person->id
LW   a2, 12(a0)       # a2 = person->age
ADDI a3, a0, 4        # a3 = &person->name
LB   a4, 1(a3)        # a4 = person->name[1]

5.2.3 函数调用与栈帧

assembly

# 函数序言：保存寄存器和设置栈帧
ADDI sp, sp, -24      # 分配24字节栈空间
SW   ra, 20(sp)       # 保存返回地址
SW   s0, 16(sp)       # 保存帧指针
SW   s1, 12(sp)       # 保存被调用者保存寄存器
SW   s2, 8(sp)        # 保存更多寄存器
ADDI s0, sp, 24       # 建立新的帧指针

# 函数尾声：恢复寄存器和释放栈帧
LW   s2, 8(sp)        # 恢复寄存器
LW   s1, 12(sp)
LW   s0, 16(sp)
LW   ra, 20(sp)
ADDI sp, sp, 24       # 释放栈空间
RET                   # 返回

6. 其他架构的寻址模式

不同架构有各自特色的寻址模式，以下是一些其他常见架构的寻址特点。

6.1 MIPS寻址模式

MIPS使用三地址指令格式，支持以下寻址模式：

1. 寄存器寻址：操作数在寄存器中
2. 立即数寻址：常数值编码在指令中
3. 基址寻址：基址寄存器加偏移量
4. PC相对寻址：相对于程序计数器的偏移(用于分支)

assembly

# MIPS示例
ADDI $t0, $zero, 42    # t0 = 0 + 42 (立即数寻址)
ADD  $t0, $t1, $t2     # t0 = t1 + t2 (寄存器寻址)
LW   $t0, 4($t1)       # t0 = Memory[t1+4] (基址寻址)
BEQ  $t0, $t1, label   # 如果t0==t1，跳转到label (PC相对寻址)

6.2 PowerPC寻址模式

PowerPC支持多种寻址模式：

1. 立即数和寄存器寻址：与其他架构类似
2. 基址寻址：使用基址寄存器加偏移量
3. 索引寻址：使用基址加索引寄存器
4. 更新形式：可以同时更新基址寄存器

assembly

# PowerPC示例
li    r3, 42           # r3 = 42 (立即数寻址)
lwz   r3, 0(r4)        # r3 = Memory[r4+0] (基址寻址)
lwzx  r3, r4, r5       # r3 = Memory[r4+r5] (索引寻址)
lwzu  r3, 4(r4)        # r3 = Memory[r4+4], 然后r4+=4 (更新形式)

7. 寻址模式的高级应用和优化

寻址模式的选择对性能和代码大小有重要影响。这里介绍一些高级应用和优化技巧。

7.1 数据结构优化

7.1.1 数组访问优化

assembly

; 访问大型数组时，保留基址和索引在寄存器中
; x86-64示例 - 对int array[1000]求和：

; 低效方式:
MOV RAX, 0          ; 累加器
MOV RCX, 0          ; 索引
array_loop1:
    MOV RBX, [array + RCX*4]  ; 每次重新计算地址
    ADD RAX, RBX
    INC RCX
    CMP RCX, 1000
    JL array_loop1

; 优化方式:
MOV RAX, 0          ; 累加器
MOV RBX, array      ; 数组起始地址
MOV RCX, 1000       ; 元素计数
array_loop2:
    ADD RAX, [RBX]  ; 直接使用指针
    ADD RBX, 4      ; 自增指针
    DEC RCX
    JNZ array_loop2

7.1.2 链表遍历优化

assembly

; x86-64链表遍历 - 假设结构体:
; struct Node {
;    int data;        // 偏移0
;    struct Node* next; // 偏移8
; };

; 低效方式(重复加载):
MOV RBX, list_head   ; 头指针
list_loop1:
    TEST RBX, RBX    ; 检查是否为NULL
    JZ end_list1
    
    MOV EAX, [RBX]   ; 加载data
    CALL process_data
    
    MOV RBX, [RBX+8] ; 加载next指针
    JMP list_loop1
end_list1:

; 优化方式(预取下一节点):
MOV RBX, list_head   ; 头指针
TEST RBX, RBX        ; 检查是否为NULL
JZ end_list2
    
list_loop2:
    MOV R12, [RBX+8] ; 预取next指针
    MOV EAX, [RBX]   ; 加载data
    CALL process_data
    
    MOV RBX, R12     ; 移动到下一节点
    TEST RBX, RBX    ; 检查是否为NULL
    JNZ list_loop2
end_list2:

7.2 指令选择优化

选择最高效的寻址模式可以减少指令数和执行时间：

7.2.1 使用LEA指令计算地址

assembly

; x86-64中，LEA可以高效计算复杂表达式
; 计算 x = 5*i + j

; 低效方式:
MOV EAX, EDI        ; EAX = i
IMUL EAX, 5         ; EAX = 5*i
ADD EAX, ESI        ; EAX = 5*i + j

; 高效方式(单指令):
LEA EAX, [RDI*4+RDI+RSI] ; EAX = 4*i + i + j = 5*i + j

7.2.2 避免复杂寻址性能问题

某些复杂寻址模式可能在特定CPU上有性能问题：

assembly

; x86-64上，某些多部分地址可能导致地址计算延迟

; 可能有延迟的复杂地址:
MOV EAX, [RBX+RCX*8+0x1234]

; 对于热点代码，可能更高效的拆分方式:
LEA RDX, [RBX+RCX*8]  ; 预先计算部分地址
MOV EAX, [RDX+0x1234] ; 使用更简单的寻址模式

7.3 代码定位优化

寻址模式也影响指令的大小和定位：

7.3.1 RIP相对寻址优化(x86-64)

assembly

; 访问全局变量
section .data
global_var: dd 42

section .text
; 绝对寻址(较大指令):
MOV EAX, [global_var]  ; 需要重定位

; RIP相对寻址(更小，位置无关):
MOV EAX, [RIP+global_var wrt ..gotpc] ; 较小指令，无需重定位

7.3.2 小偏移量优化

assembly

; 一些指令格式对小偏移量有特殊编码

; 常规偏移量:
MOV EAX, [RBX+256]  ; 可能使用4字节偏移量编码

; 小偏移量:
MOV EAX, [RBX+4]    ; 可能使用1字节偏移量编码，生成更小指令

8. 寻址模式对内存管理的影响

寻址模式不仅影响代码执行效率，也影响内存管理策略。

8.1 栈帧和局部变量布局

合理安排栈帧可以简化寻址：

assembly

; x86-64栈帧示例
push rbp
mov rbp, rsp
sub rsp, 32         ; 分配32字节本地变量空间

; 访问参数(System V ABI):
; RDI, RSI, RDX, RCX, R8, R9 = 前6个参数
; [RBP+16], [RBP+24], ... = 额外参数

; 访问局部变量:
mov QWORD [rbp-8], 42   ; 第一个局部变量 = 42
mov QWORD [rbp-16], rax ; 第二个局部变量 = RAX

8.2 全局偏移表(GOT)和重定位

动态链接的可执行文件使用特殊寻址技术访问全局数据：

assembly

; ELF x86-64位置无关代码(PIC)示例
        call get_pc
get_pc: pop rbx           ; 获取程序计数器到RBX
        
        ; 使用GOT访问全局变量
        mov r12, QWORD [rbx + global_var wrt ..got]
        mov eax, DWORD [r12]   ; 加载global_var的值

8.3 线程局部存储(TLS)访问

不同架构有不同方式访问线程局部存储：

assembly

; x86-64 TLS访问 - 使用FS/GS段寄存器
mov rax, QWORD [fs:0]    ; 获取TLS基址(Linux)
mov eax, DWORD [fs:8]    ; 访问TLS变量

; 也可以在Windows上使用
mov rax, QWORD [gs:0x30] ; 获取TEB地址(Windows)

9. 不同汇编器和语法的寻址模式表示

不同汇编器和语法对寻址模式有不同的表示方法。

9.1 Intel vs AT&T语法

两种主要的x86汇编语法有很大差异：

寻址模式	Intel语法	AT&T语法
立即数	MOV EAX, 42	movl $42, %eax
寄存器	MOV EAX, EBX	movl %ebx, %eax
直接	MOV EAX, [addr]	movl addr, %eax
间接	MOV EAX, [EBX]	movl (%ebx), %eax
基址+偏移	MOV EAX, [EBX+20]	movl 20(%ebx), %eax
基址+变址	MOV EAX, [EBX+ECX]	movl (%ebx,%ecx), %eax
比例变址	MOV EAX, [EBX+ECX*4]	movl (%ebx,%ecx,4), %eax
全地址	MOV EAX, [EBX+ECX*4+20]	movl 20(%ebx,%ecx,4), %eax

9.2 NASM, MASM和GAS语法区别

不同的汇编器也有自己的语法特点：

NASM (Intel语法)

assembly

; NASM示例
mov eax, [ebx]          ; 寄存器间接
mov eax, [ebx+20]       ; 基址+偏移
mov eax, [ebx+ecx]      ; 基址+变址
mov eax, [ebx+ecx*4]    ; 比例变址
mov eax, [ebx+ecx*4+20] ; 全地址

MASM (Intel语法)

assembly

; MASM示例
mov eax, [ebx]          ; 寄存器间接
mov eax, [ebx+20]       ; 基址+偏移
mov eax, [ebx+ecx]      ; 基址+变址
mov eax, [ebx+ecx*4]    ; 比例变址
mov eax, [ebx+ecx*4+20] ; 全地址

; MASM也支持替代语法
mov eax, [ebx]          ; 寄存器间接
mov eax, 20[ebx]        ; 基址+偏移
mov eax, [ebx][ecx]     ; 基址+变址(替代)

GAS (AT&T语法)

assembly

# GAS示例
movl (%ebx), %eax         # 寄存器间接
movl 20(%ebx), %eax       # 基址+偏移
movl (%ebx,%ecx), %eax    # 基址+变址
movl (%ebx,%ecx,4), %eax  # 比例变址
movl 20(%ebx,%ecx,4), %eax # 全地址

10. 实际编程示例

10.1 字符串复制函数

一个使用不同寻址模式的简单字符串复制实现：

assembly

; x86-64字符串复制函数
; 参数: RDI=目标地址, RSI=源地址, RDX=最大长度
; 返回: RAX=复制的字节数
string_copy:
    xor rcx, rcx            ; 初始化计数器
    
copy_loop:
    cmp rcx, rdx            ; 检查是否达到最大长度
    jae copy_done
    
    mov al, [rsi+rcx]       ; 基址+变址: 加载当前源字符
    test al, al             ; 检查是否到达字符串结束
    jz copy_done
    
    mov [rdi+rcx], al       ; 基址+变址: 存储到目标位置
    inc rcx                 ; 增加计数器
    jmp copy_loop
    
copy_done:
    mov [rdi+rcx], byte 0   ; 确保目标字符串以NULL结尾
    mov rax, rcx            ; 返回复制的字节数
    ret

10.2 内存复制函数

优化的内存复制函数，使用不同的寻址模式：

assembly

; x86-64内存复制函数
; 参数: RDI=目标地址, RSI=源地址, RDX=字节数
; 返回: RDI=目标地址(末尾)
memcpy_fast:
    mov rcx, rdx            ; 复制长度
    
    ; 检查小块复制(小于16字节)
    cmp rcx, 16
    jb small_copy
    
    ; 检查和优化对齐
    mov r8, rdi             ; 保存目标起始地址
    mov r9, rsi             ; 保存源起始地址
    
    ; 复制8字节块
qword_loop:
    cmp rcx, 8
    jb bytes_loop
    
    mov rax, [rsi]          ; 加载8字节
    mov [rdi], rax          ; 存储8字节
    add rsi, 8              ; 更新源指针
    add rdi, 8              ; 更新目标指针
    sub rcx, 8              ; 减少计数
    jmp qword_loop
    
    ; 复制剩余字节
bytes_loop:
    test rcx, rcx
    jz copy_done
    
    mov al, [rsi]           ; 加载一个字节
    mov [rdi], al           ; 存储一个字节
    inc rsi                 ; 更新源指针
    inc rdi                 ; 更新目标指针
    dec rcx                 ; 减少计数
    jmp bytes_loop
    
    ; 处理小块复制
small_copy:
    test rcx, rcx
    jz copy_done
    
    mov al, [rsi]           ; 加载一个字节
    mov [rdi], al           ; 存储一个字节
    inc rsi                 ; 更新源指针
    inc rdi                 ; 更新目标指针
    dec rcx                 ; 减少计数
    jmp small_copy
    
copy_done:
    mov rax, r8             ; 返回目标起始地址
    ret

10.3 多维数组处理

处理二维数组的示例：

assembly

; x86-64二维数组求和
; 参数: RDI=数组基址, RSI=行数, RDX=每行的元素数
; 返回: RAX=所有元素的总和
array2d_sum:
    xor rax, rax            ; 初始化总和
    xor rcx, rcx            ; 行索引 = 0
    
row_loop:
    cmp rcx, rsi            ; 检查是否处理完所有行
    jae sum_done
    
    xor r8, r8              ; 列索引 = 0
    
column_loop:
    cmp r8, rdx             ; 检查是否处理完当前行
    jae next_row
    
    ; 计算元素地址: base + (row * columns + col) * 4
    mov r9, rcx             ; r9 = 行索引
    imul r9, rdx            ; r9 = 行索引 * 列数
    add r9, r8              ; r9 = 行索引 * 列数 + 列索引
    
    ; 加载和累加元素
    add eax, [rdi + r9*4]   ; 比例变址: 使用r9作为元素索引
    
    inc r8                  ; 下一列
    jmp column_loop
    
next_row:
    inc rcx                 ; 下一行
    jmp row_loop
    
sum_done:
    ret

11. 寻址模式评估标准

选择最佳寻址模式时应考虑多个因素：

11.1 性能因素

1. CPU周期: 不同寻址模式需要不同数量的CPU周期
2. 内存访问次数: 影响缓存性能和总延迟
3. 指令长度: 较长指令可能导致取指瓶颈
4. 地址计算开销: 复杂地址计算可能有额外延迟

11.2 代码大小因素

1. 指令编码长度: 不同寻址模式产生不同长度的机器码
2. 地址表示方式: 直接地址通常需要更多字节
3. 前缀和修饰符: 某些寻址模式需要额外前缀

11.3 实用性因素

1. 易读性: 直观的寻址模式更易于理解和维护
2. 灵活性: 能否适应不同数据结构需求
3. 可移植性: 跨平台/编译器的兼容性

12. 寻址模式最佳实践

12.1 代码可读性

1. 使用有意义的名称: 使用标签和符号而非硬编码地址
2. 添加注释: 特别是对复杂寻址方式
3. 一致性: 在整个程序中保持一致的寻址方式风格

assembly

; 避免:
mov eax, [ebx+0Ch]         ; 加载某个字段

; 改善:
mov eax, [ebx+PERSON.age]  ; 加载person->age字段

12.2 性能优化

1. 减少内存访问: 尽可能将值保存在寄存器中
2. 计算重用: 预计算重复使用的地址
3. 利用硬件功能: 使用架构支持的高效寻址模式

assembly

; 低效方式(每次都计算地址):
mov eax, [array+ecx*4]
inc ecx
mov ebx, [array+ecx*4]
inc ecx
mov edx, [array+ecx*4]

; 优化方式(保存和递增指针):
lea edi, [array+ecx*4]
mov eax, [edi]
mov ebx, [edi+4]
mov edx, [edi+8]

12.3 平台特定优化

不同处理器可能对不同寻址模式有优化：

1. 利用RIP相对寻址: 在x86-64代码中生成更紧凑的位置无关代码
2. ARM32的自动更新寻址: 使用预/后索引更高效地遍历数组
3. 针对特定微架构: 特定CPU可能对某些寻址模式有硬件优化

13. 小结

寻址模式是汇编语言的核心机制，直接影响代码的执行效率、大小和可读性。本文详细介绍了各主要处理器架构的寻址模式，以及它们的应用和优化技巧。

主要要点回顾：

1. 寻址模式功能: 不同的寻址模式提供访问立即数、寄存器、内存的不同方式
2. 架构差异: 各CPU架构提供不同的寻址能力，但核心概念相似
3. 优化实践: 选择合适的寻址模式可显著影响性能和代码质量
4. 实际应用: 不同数据结构和算法可能需要不同的寻址策略

掌握寻址模式是成为熟练汇编程序员的重要一步。通过深入理解这些技术，可以编写既高效又可维护的低级代码。