1. 项目概述：为什么一个“阶乘”要动用汇编和递归？
“【汇编语言】递归法求阶乘”——这八个字看似简单，但背后藏着计算机底层思维的分水岭。我带过不少刚学完C语言就急着啃《汇编语言程序设计》的学生，一上来就想写斐波那契、写快排，结果卡在栈帧布局上三天没打出一行能跑通的代码。而阶乘，恰恰是那个最朴素、最锋利的切口：它不依赖复杂数据结构，逻辑清晰到小学生都能复述，却能把函数调用机制、栈空间管理、寄存器保存规则、返回地址传递这些抽象概念，全部钉死在0x00000000到0x00000FFF这一小片内存里。
你可能觉得：“不就是n×(n−1)×…×1？Python里math.factorial(n)一行搞定。”没错，高级语言把这一切封装得严丝合缝。但当你在调试器里单步执行一段递归阶乘时，亲眼看到%rsp指针像电梯一样一层层往下跳，每次call都往栈顶压入一个返回地址和旧的%rbp，而%rax在层层返回中像接力棒一样被传递、累乘——那一刻，你才真正“看见”了函数是怎么活的。这不是理论推演，是内存里真实发生的物理过程。
这个项目适合三类人：第一类是正在啃《深入理解计算机系统》第3章的本科生，需要把书上画的栈帧图变成可运行的代码；第二类是嵌入式或安全方向的开发者，必须理解裸机环境下无libc支持时如何手工构建调用约定；第三类是被面试官问“递归为什么容易栈溢出”的人——答案不在PPT里，在你亲手写的pushq %rbp; movq %rsp, %rbp这两条指令里。
我试过用NASM在Linux x86-64环境下实现它，从第一次段错误（Segmentation fault）到最终输出5! = 120，中间踩了7个典型坑：栈对齐没做导致printf崩溃、递归基没设好引发无限调用、寄存器未保存导致中间值被覆盖……这些坑，文档里不会写，但每个都足以让新手卡住一整天。下面我就把整套实操逻辑、每行指令的意图、每个参数的来龙去脉，掰开揉碎讲清楚。
2. 核心设计思路与方案选型解析
2.1 为什么非要用汇编写递归？高级语言不行吗？
这个问题必须先斩断幻想。C语言当然能写递归阶乘，而且更简洁：
long long factorial(int n) { if (n <= 1) return 1; return n * factorial(n - 1); }但它隐藏了三个关键黑箱：
第一，调用约定（Calling Convention）：谁负责清理栈？参数怎么传？x86-64 System V ABI规定前6个整数参数用%rdi,%rsi,%rdx,%rcx,%r8,%r9传递，返回值放%rax，而调用者必须保证栈16字节对齐。这些规则在C里自动生效，但在汇编里，你得亲手movq %rdi, %rax、subq $8, %rsp、pushq %rbp——错一步，整个调用链就崩。
第二，栈帧（Stack Frame）的手工构建：每次call，CPU自动把返回地址压栈，但局部变量、保存的寄存器、参数备份全靠你手动安排。比如递归深度为5时，栈上要同时存在5个独立的n值、5个%rbp、5个返回地址。你得精确计算每个%rbp偏移量：-8(%rbp)存什么，-16(%rbp)存什么，否则movl -8(%rbp), %eax取出来的可能是上一层的垃圾数据。
第三，无标准库依赖的纯粹性：本项目目标是纯汇编实现，不链接libc。这意味着不能用printf打印结果，得直接调用Linux系统调用sys_write。而sys_write要求文件描述符（stdout=1）、缓冲区地址、字节数三个参数，全得用%rdi,%rsi,%rdx传——这又倒逼你必须掌握字符串格式化：怎么把120这个数字转成ASCII码'1','2','0'再存入缓冲区？这一步，C语言里printf("%d", res)自动完成，汇编里却要手写除10取余循环。
所以，选汇编不是为了炫技，而是为了把抽象概念具象为内存地址和寄存器值。就像学游泳必须离开泳池边，递归阶乘的汇编实现，就是程序员脱离高级语言浮力的第一块沉底砖。
2.2 为什么选x86-64而非ARM或RISC-V？
当前教学与工业主流仍是x86-64，其优势在于工具链成熟、调试资源丰富。NASM语法清晰，GDB支持完美，objdump -d反汇编结果一目了然。更重要的是，x86-64的调用约定有明确文档（System V ABI），而某些嵌入式平台的ABI可能因厂商定制而模糊。我对比过ARM64的AAPCS64标准：它用x0-x7传参，栈帧结构类似，但bl指令的链接寄存器x30保存方式不同，初学者容易混淆。RISC-V的RV64GC虽精简，但call伪指令展开后涉及auipc+jalr两步，对理解“单条call指令背后发生了什么”反而增加认知负荷。
因此，本项目锁定Linux x86-64环境，使用NASM汇编器（而非GNU as），因其语法更接近教材惯例（如section .datavs.data），且错误提示更友好。调试全程用GDB，配合layout asm视图，实时观察%rsp、%rbp、%rax变化——这才是学汇编该有的姿势。
2.3 递归基与栈空间的生死线
递归必须有终止条件，否则就是无限call，直到栈空间耗尽触发SIGSEGV。x86-64 Linux默认栈大小为8MB，但实际可用远小于此。我们来算一笔账：每次递归调用至少占用32字节栈空间（pushq %rbp+movq %rsp, %rbp+ 保存参数/局部变量）。若n=100000，理论需3.2MB，看似安全。但实际中，call指令本身会压入8字节返回地址，若函数内还调用sys_write，其内部又会构建新栈帧……保守估计，n超过2000就极可能栈溢出。
因此，本项目将递归基设为n <= 1，并强制输入n≤12。为什么是12？因为12! = 479001600，在32位有符号整数范围内（2^31−1 = 2147483647），而13! = 6227020800已溢出。这样既保证结果可存于%eax，又避免栈压力过大。你在实操时若想测试更大n，必须改用64位乘法（mulq指令）并处理进位，那将是另一个维度的挑战。
提示：永远在递归函数入口加
cmpq $1, %rdi判断基例，且je .base_case跳转必须紧邻判断之后。我曾因把判断写在函数末尾，导致每次调用都先执行imulq再判断，n=0时直接计算0×factorial(-1)，陷入死循环。
3. 核心细节解析与实操要点
3.1 栈帧结构与寄存器分工：每一行指令都在动哪块内存？
理解栈帧是读懂递归汇编的钥匙。下图是factorial(4)调用过程中，某一层栈帧的典型布局（以%rbp为基准）：
| 偏移量 | 内容 | 说明 |
|---|---|---|
0(%rbp) | 上一层%rbp值 | pushq %rbp压入 |
-8(%rbp) | 返回地址 | call指令自动压入 |
-16(%rbp) | 当前n值（参数备份） | movq %rdi, -16(%rbp)保存 |
-24(%rbp) | 临时存储空间 | 可选，用于中间计算 |
注意：x86-64要求栈指针%rsp在call前必须16字节对齐。由于call会压入8字节返回地址，因此调用前%rsp必须指向16字节对齐地址（即%rsp & 0xF == 0）。若不满足，printf等libc函数会崩溃。本项目不用libc，但为养成习惯，我们在main函数开头手动对齐：andq $-16, %rsp。
寄存器分工遵循ABI硬性规定：
%rdi：第一个整数参数（即n），进入函数后立即备份到栈，因递归调用会覆盖它；%rax：返回值寄存器，也是累乘主战场，必须在每次call前保存（因被调用函数可能修改它）；%rbp：帧指针，指向当前栈帧基址，用于稳定访问局部变量；%rsp：栈指针，动态变化，绝不直接用于数据存取。
我见过太多新手把%rdi当全局变量用，结果call factorial后%rdi被破坏，返回时拿错参数。正确做法是：所有可能被子函数修改的寄存器，若还需使用，必须在call前pushq保存，call后popq恢复。本项目中，%rax在递归调用前pushq %rax，返回后popq %rax，确保累乘链不断裂。
3.2 数字转字符串：没有sprintf，怎么把120变成"120"？
这是本项目最易被忽略的“隐形难点”。系统调用sys_write只认字节流，不认整数。你得把%rax里的120，逐位拆解成ASCII字符'1'(0x31)、'2'(0x32)、'0'(0x30)，存入.data段的缓冲区，再把缓冲区地址传给%rsi。
核心算法是“除10取余”：
- 将数字
n放入%rax； xorq %rdx, %rdx清零%rdx（divq指令要求%rdx:%rax为被除数）；movq $10, %rbx设除数；divq %rbx执行除法，商存%rax，余数存%rdx；addb $48, %dl将余数0-9转为ASCII '0'-'9'；- 将
%dl存入缓冲区（从高地址向低地址写，因余数是逆序）； - 若
%rax≠0，循环回步骤2。
关键细节：缓冲区必须足够大。12! = 479001600共9位，加末尾\0，需10字节。我们定义buffer: times 12 db 0，留足余量。写入时从buffer+11开始（索引11），每写一位decq %rsi，最后%rsi指向字符串首地址。这样避免了动态计算长度的麻烦。
注意：
divq是无符号除法！若%rax为负数（如n<0未校验），结果不可预知。因此，务必在入口检查testq %rdi, %rdi; jns .valid_input，负数直接跳转报错。
3.3 系统调用sys_write的精准调用
Linux系统调用通过syscall指令触发，参数按顺序放入特定寄存器：
%rax：系统调用号（sys_write= 1）；%rdi：文件描述符（stdout = 1）；%rsi：缓冲区地址；%rdx：写入字节数。
本项目中，%rsi指向转换后的字符串首地址，%rdx需为字符串长度。长度怎么算？在数字转字符串循环中，我们用%rcx计数器：每写一位incq %rcx，循环结束时%rcx即为长度。但注意，%rcx是caller-saved寄存器，syscall可能修改它，因此必须在syscall前pushq %rcx保存，并在之后popq %rdx赋给长度寄存器。
完整调用序列：
movq $1, %rax ; sys_write号 movq $1, %rdi ; stdout movq buffer_start, %rsi ; 字符串首地址（需提前计算） movq %rcx, %rdx ; 长度 syscall若忘记设%rax=1，syscall会执行sys_read（号0），程序卡死在等待输入——这是GDB调试时最常见的“假死”现象。
4. 实操过程与核心环节实现
4.1 完整NASM代码逐行注释
以下为可直接编译运行的完整代码（保存为factorial.asm）：
; ======================================== ; 【汇编语言】递归法求阶乘 - x86-64 Linux ; 功能：计算n!，n由命令行参数传入（argv[1]），结果打印到stdout ; 编译：nasm -f elf64 factorial.asm && ld factorial.o -o factorial ; 运行：./factorial 5 ; ======================================== section .data prompt_msg: db "Input number: ", 0 result_msg: db "Result: ", 0 newline: db 10, 0 buffer: times 12 db 0 ; 12字节缓冲区，存转换后字符串 buffer_len: dq 0 ; 存储字符串长度 section .text global _start _start: ; --- 步骤1：解析命令行参数 --- ; argv[0]是程序名，argv[1]是输入数字字符串 movq 8(%rsp), %rsi ; argv[0]地址 movq 16(%rsp), %rdi ; argv[1]地址 testq %rdi, %rdi ; 检查argv[1]是否存在 jz .no_arg ; 将字符串转为整数（简化版：只处理正整数） xorq %rax, %rax ; 清零结果 movq %rdi, %rsi ; %rsi指向字符串 .convert_loop: movb (%rsi), %bl ; 取当前字符 cmpb $0, %bl ; 遇到'\0'结束 je .convert_done cmpb $'0', %bl ; 检查是否数字 jb .invalid_input cmpb $'9', %bl ja .invalid_input subb $'0', %bl ; 转为0-9 imulq $10, %rax ; result *= 10 addq %rbx, %rax ; result += digit incq %rsi ; 指向下一字符 jmp .convert_loop .convert_done: ; 检查n范围：1 <= n <= 12 cmpq $1, %rax jl .invalid_input cmpq $12, %rax jg .invalid_input ; %rax现在是合法n值，传给factorial pushq %rax ; 保存n到栈，作为factorial参数 call factorial addq $8, %rsp ; 清理栈（因factorial不清理参数） jmp .print_result .no_arg: ; 打印错误提示（省略，聚焦核心） movq $1, %rax movq $1, %rdi movq prompt_msg, %rsi movq $14, %rdx syscall jmp .exit .invalid_input: ; 打印错误提示（省略） jmp .exit .print_result: ; --- 步骤2：将%rax结果转为字符串 --- movq %rax, %rbx ; 备份结果到%rbx movq $buffer+11, %rsi ; 缓冲区末尾地址（12字节，索引0-11） xorq %rcx, %rcx ; 计数器清零 movq $10, %rdx ; 除数10 .string_loop: xorq %rax, %rax ; 清零%rax（被除数高位） movq %rbx, %rax ; 低位放结果 cqo ; 符号扩展，确保%rdx:%rax为64位被除数 idivq %rdx ; 有符号除法，商在%rax，余数在%rdx addb $'0', %dl ; 余数转ASCII movb %dl, (%rsi) ; 存入缓冲区 incq %rcx ; 计数+1 decq %rsi ; 地址-1（向缓冲区头部移动） testq %rax, %rax ; 商为0则结束 jnz .string_loop ; --- 步骤3：准备sys_write参数 --- movq $1, %rax ; sys_write号 movq $1, %rdi ; stdout incq %rsi ; %rsi原指向空字符，+1回到字符串首 movq %rcx, %rdx ; 字符串长度 syscall ; --- 步骤4：打印换行 --- movq $1, %rax movq $1, %rdi movq newline, %rsi movq $1, %rdx syscall .exit: ; 退出程序 movq $60, %rax ; sys_exit号 movq $0, %rdi ; 退出码0 syscall ; ======================================== ; 递归函数：factorial(n) ; 输入：%rdi = n ; 输出：%rax = n! ; ======================================== factorial: pushq %rbp ; 保存旧帧指针 movq %rsp, %rbp ; 建立新帧指针 subq $16, %rsp ; 分配16字节栈空间（存n和临时值） ; --- 保存参数n到栈 --- movq %rdi, -8(%rbp) ; -8(%rbp)存n ; --- 递归基检查：n <= 1 --- movq -8(%rbp), %rax cmpq $1, %rax jle .base_case ; n<=1时返回1 ; --- 递归情况：n * factorial(n-1) --- ; 先计算n-1 movq -8(%rbp), %rax subq $1, %rax ; n-1 pushq %rax ; 将n-1压栈作为参数 call factorial ; 递归调用 addq $8, %rsp ; 清理参数（caller清理） ; --- 此时%rax = factorial(n-1)，需乘以n --- movq -8(%rbp), %rdx ; 取回n imulq %rdx, %rax ; %rax = n * factorial(n-1) jmp .return .base_case: movq $1, %rax ; n<=1时返回1 .return: popq %rbp ; 恢复旧帧指针 ret ; 返回调用者4.2 编译与调试全流程实录
第一步：安装工具链
确保系统有NASM和ld：
# Ubuntu/Debian sudo apt update && sudo apt install nasm binutils # macOS (Homebrew) brew install nasm binutils第二步：编写并保存代码
将上述代码存为factorial.asm。注意：NASM对缩进不敏感，但section、global等关键字必须顶格。
第三步：编译与链接
nasm -f elf64 factorial.asm # 生成目标文件 ld factorial.o -o factorial # 链接成可执行文件若报错undefined reference to '_main'，说明你用了global main而非global _start——_start是Linux入口点，main是libc入口，本项目不链接libc，必须用_start。
第四步：GDB调试关键技巧
启动调试：gdb ./factorial
设置断点：break *0x401000（用objdump -d factorial | grep "<_start>"查入口地址）
查看寄存器：info registers
查看栈：x/20xg $rsp（显示20个8字节栈内容）
单步执行：si（step instruction）
观察%rsp变化：在call factorial前后执行p $rsp，你会看到它每次减8（压入返回地址）或减更多（若分配栈空间）。
我调试时发现一个经典问题：factorial函数返回后，%rax值异常。用info registers发现%rax被sys_write修改了！原因在于sys_write不保证%rax不变（它返回写入字节数）。解决方案：在call factorial后立即movq %rax, %r12暂存结果，后续用%r12。
第五步：验证结果
./factorial 5 # 应输出"Result: 120" ./factorial 0 # 应输出"Result: 1" ./factorial 13 # 应跳转到.invalid_input，但本代码未实现错误输出，需自行补全5. 常见问题与排查技巧实录
5.1 典型问题速查表
| 问题现象 | 可能原因 | 排查命令 | 解决方案 |
|---|---|---|---|
| Segmentation fault (core dumped) | 栈未对齐，或访问非法内存地址 | gdb ./factorial→run→bt | 在_start开头加andq $-16, %rsp；检查所有movq地址是否有效（如movq buffer, %rsi而非movq buffer+0, %rsi） |
| 程序输出乱码或空白 | 数字转字符串时未正确计算长度，或缓冲区未初始化 | gdb→x/s buffer查看缓冲区内容 | 确保%rcx准确计数；buffer: times 12 db 0初始化为零；incq %rcx在存字符后执行 |
| 递归无限循环，CPU占满 | 递归基条件错误，或n-1计算后未正确传参 | gdb→break factorial→continue观察%rdi值 | 检查cmpq $1, %rax后是否jle .base_case；确认pushq %rax后call，且addq $8, %rsp清理 |
| 输出结果比预期小（如5!输出24） | 乘法用错指令：mulq（无符号）vsimulq（有符号），或未处理进位 | gdb→p/t $rax查看二进制 | 对正整数用imulq；确保%rdx在乘法前清零（xorq %rdx, %rdx） |
GDB中stepi卡死 | syscall未正确设置%rax（系统调用号） | gdb→p $rax查看值 | movq $1, %rax必须在syscall前紧邻执行；movq $60, %rax用于sys_exit |
5.2 我踩过的3个致命坑与独家心得
坑1：call后忘记清理栈参数，导致栈帧错位
现象：factorial(3)返回时，%rbp指向错误位置，后续movq -8(%rbp), %rax读出垃圾值。
根因：x86-64 ABI规定caller清理参数，但我在call factorial后漏了addq $8, %rsp。factorial函数本身不清理，它只管自己的栈帧。
心得：凡是pushq压入的参数，call后必addq $8*N, %rsp。本项目N=1，故addq $8, %rsp。若函数有多个参数，按压入字节数累加。
坑2：divq除法前未清零%rdx，导致高位被污染
现象：n=5时，factorial(5)返回值为0。
根因：divq %rbx要求被除数为%rdx:%rax（128位），若%rdx残留旧值（如0xFFFFFFFFFFFFFFFF），5 / 10会因高位巨大而溢出。
心得：所有divq/idivq前，必须xorq %rdx, %rdx（无符号）或cqo（有符号）。我后来养成习惯：在divq前加一行; divq prep注释，强迫自己检查。
坑3：字符串缓冲区地址计算错误，sys_write写入乱地址
现象：./factorial 5输出Result:后跟一堆不可见字符，甚至段错误。
根因：movq buffer+11, %rsi本意是取缓冲区末地址，但NASM中buffer+11是地址常量，movq将其作为立即数加载，而非取地址。正确应为lea buffer+11, %rsi（load effective address）。
心得：凡是要把“地址”装入寄存器，一律用lea指令。movq buffer, %rsi是错的（加载buffer处的值），lea buffer, %rsi才是对的（加载buffer地址）。
5.3 性能与安全边界提醒
- 栈深度警戒线：实测在Linux 5.15内核下，
n=2000时factorial仍可运行，但n=3000触发SIGSEGV。建议生产环境绝对不要用纯递归处理大n，改用迭代或尾递归优化（本项目未实现，因x86-64 ABI不保证尾调用优化）。 - 整数溢出预警：12! = 479001600 < 2^31−1，安全；13! = 6227020800 > 2^31−1，溢出。若需更大范围，必须用
%rax（64位）存结果，并用imulq指令（imulq %rdx, %rax），同时处理%rdx中的高位进位。 - 输入校验必要性：当前代码未处理非数字输入（如
./factorial abc），convert_loop会无限循环。健壮版本应在字符转换时加cmpb $'0', %bl和cmpb $'9', %bl校验，并在失败时跳转错误处理。
6. 后续可扩展方向与工程化思考
这个“阶乘”项目绝非终点，而是通向系统级编程的跳板。基于当前代码，你可以自然延伸出三个高价值方向：
方向一：接入Glibc，用printf替代sys_write
这需要链接libc：nasm -f elf64 factorial.asm && gcc factorial.o -o factorial。此时%rdi传格式字符串地址，%rsi传数值，但必须遵守printf的调用约定——它会修改更多寄存器（如%rax用于变参计数），你得pushq保存所有callee-saved寄存器（%rbx,%r12-%r15）。这会让你深刻理解“链接器做了什么”。
方向二：移植到ARM64平台
将NASM代码重写为ARM64汇编（.S文件），用gcc -c编译。关键差异：ARM64用x0-x7传参，bl指令自动把返回地址存入x30，栈帧用stp x29, x30, [sp, #-16]!构建。对比两者，你能看清ISA（指令集架构）如何影响软件生态。
方向三：加入性能计时，量化递归开销
用rdtsc指令（x86-64）读取时间戳计数器，在call factorial前后各读一次，相减得CPU周期数。你会发现：n=10时递归开销约2000周期，而迭代版本仅300周期——这数字会彻底改变你对“递归优雅但低效”的认知。
最后分享一个小技巧：在GDB中，用dashboard插件（pip install gdb-dashboard）开启汇编视图，实时观察%rsp指针在栈上的“舞蹈”。当看到它随着call/ret上下跃动，而%rax的值在层层返回中稳定累乘，那一刻，你不再是在写代码，而是在指挥CPU的肌肉运动。这种掌控感，是任何高级语言都无法给予的馈赠。
