4、RISC-V汇编编程：汇编语法、伪指令、函数调用约定、栈帧管理，以及一个简单的汇编程序实战

4.3 汇编程序实战：计算斐波那契数列

4.3.1 案例背景与目标

为了综合运用本章知识，我们编写一个 RISC-V 汇编程序，计算第 n 个斐波那契数（n 从 0 开始，F(0)=0, F(1)=1）。程序从标准输入读取 n，调用递归函数 fib 计算结果，并打印输出。该案例覆盖了函数调用、栈帧管理、参数传递、递归调用等核心知识点。

4.3.2 完整汇编代码

.section .text
.globl _start

_start:
    # 读取 n（简化：直接使用 li 模拟输入）
    li   a0, 10           # 计算 F(10)
    call fib              # 调用 fib 函数
    mv   a1, a0           # 将结果移到 a1 准备打印
    # 此处省略 printf 调用，实际可调用 ecall 或 libc
    li   a0, 1            # stdout
    # 调用 print_int 系统调用（假设环境支持）
    li   a7, 1            # 系统调用号 1 = print_int
    ecall
    # 退出程序
    li   a0, 0
    li   a7, 93           # 系统调用号 93 = exit
    ecall

# 函数：fib(n)
# 参数：a0 = n
# 返回值：a0 = F(n)
fib:
    addi sp, sp, -32      # 分配栈帧
    sw   ra, 28(sp)       # 保存返回地址
    sw   s0, 24(sp)       # 保存 s0（将被用作 n 的副本）
    sw   s1, 20(sp)       # 保存 s1（存储 F(n-1)）
    sw   s2, 16(sp)       # 保存 s2（存储 F(n-2)）
    addi s0, sp, 32       # 设置帧指针

    # 基本情况：if (n <= 1) return n
    li   t0, 1
    bgt  a0, t0, .Lrecur  # 如果 n > 1 则递归
    # n <= 1，直接返回 n
    j    .Lreturn

.Lrecur:
    # 递归计算 F(n-1)
    addi a0, a0, -1       # n-1
    call fib              # 调用 fib(n-1)
    mv   s1, a0           # s1 = F(n-1)

    # 递归计算 F(n-2)
    lw   a0, 0(s0)        # 从栈帧恢复原始 n（通过帧指针）
    addi a0, a0, -2       # n-2
    call fib              # 调用 fib(n-2)
    mv   s2, a0           # s2 = F(n-2)

    # 结果 = F(n-1) + F(n-2)
    add  a0, s1, s2       # a0 = s1 + s2

.Lreturn:
    # 恢复寄存器并返回
    lw   ra, 28(sp)
    lw   s0, 24(sp)
    lw   s1, 20(sp)
    lw   s2, 16(sp)
    addi sp, sp, 32
    ret

4.3.3 案例拆解与关键点分析

该递归实现的时间复杂度为 O(2^n)，仅用于教学演示。实际工程中应使用迭代或记忆化搜索。但递归版本完美展示了栈帧的嵌套使用：每次递归调用都会创建新的栈帧，sp 不断下移，返回时逐层释放。

4.3.4 编译与调试方法

使用 RISC-V 工具链编译上述代码：

# 编译为可执行文件（使用 newlib 或裸机环境）
riscv64-unknown-elf-gcc -march=rv32im -mabi=ilp32 -nostdlib -o fib fib.S

# 使用 QEMU 模拟运行
qemu-riscv32 ./fib

# 使用 Spike 调试（可单步执行）
spike -d pk fib

调试时，重点关注 sp 和 ra 的变化。在 GDB 中可使用 info registers sp ra 查看，或使用 x/8wx $sp 查看栈内存内容。若发现 ra 被意外覆盖，通常是因为函数内调用其他函数前未保存 ra。

4.4 常见误区与工程实践建议

4.4.1 常见误区清单

• 误区一：混淆调用者保存与被调用者保存寄存器。若在函数中使用 t0 且未保存，调用者后续使用 t0 时数据已被破坏。反之，若使用 s0 未保存，则破坏调用者的数据。
• 误区二：栈帧分配未对齐。若分配 20 字节栈帧，sp 变为非 16 字节对齐，某些指令（如 lw）可能触发异常。
• 误区三：忘记保存 ra。在非叶子函数（调用其他函数的函数）中，jal 会覆盖 ra，若不保存则无法正确返回。
• 误区四：使用 sp 而非 fp 访问局部变量。若函数内有动态栈调整，sp 偏移会变化，导致访问错误。
• 误区五：忽略 x0 的特殊性。对 x0 写入无效，但读取始终为 0。某些伪指令（如 nop）正是利用这一特性。

4.4.2 工程实践建议

在实际项目中，直接编写汇编的场景较少，更多是阅读反汇编代码、编写启动代码（Startup Code）或优化关键路径。以下建议可供参考：

1. 善用伪指令：伪指令能提高代码可读性，但需理解其展开方式，避免在性能敏感区域产生意外开销。
2. 保持栈帧规整：即使编译器优化了帧指针，也应保持栈帧结构的逻辑清晰，便于调试。
3. 使用宏封装常用操作：例如定义 .macro PUSH reg 和 .macro POP reg 宏，减少重复代码。
4. 结合高级语言调试：在 C 代码中嵌入汇编时，使用 asm volatile 并明确标注 clobber 列表，防止编译器误用寄存器。
5. 利用模拟器验证：在 QEMU 或 Spike 上运行汇编程序，配合 GDB 单步调试，观察寄存器与内存变化，是学习汇编最有效的方式。