1. 拆弹之前，先把“炸弹”的构造摸清楚

第一次听到“拆炸弹”这个说法，很多人的反应是：这不是逆向工程吗？跟 MIPS 有什么关系？说白了，这是一道典型的二进制逆向训练题——给你一个没有源码的可执行文件，里面藏着若干关卡，每关都在等你喂一个“密码”，喂不对就当场引爆。你要做的，就是对着 objdump 吐出来的 MIPS 反汇编一行行读，把每关的判断条件逆推出来，最后把六个（有时是七个）正确输入写进一个文本文件里，一次性交上去。

这类题目在教育圈里流传很广，最初的原版跑在 x86 上，后来有人把它移植到了 MIPS 平台，专门用来训练体系结构课程里的汇编阅读能力。我这里手上这份就是 MIPS 版本，走的是标准的 O32 调用约定，大端小端两种编译产物都见过。文章要讲清楚的东西很具体：怎么用 objdump 和 gdb 把一个陌生 MIPS 二进制读透，怎么识别编译器留下的固定套路，怎么把每一关的判定条件还原成可验证的表达式。适合正在上体系结构课、刚接触汇编不久、对着反汇编窗口发愣的同学，也适合工作几年后想重新捡起底层阅读能力的人。

我下面会按“准备—基本功—逐关拆解—调试提速—避坑”这条线走。需要先声明一点：各版本炸弹的关卡内部实现差异不小，同一关卡不同编译器的产物能差出三成以上。我描述的是读法和方法论，具体的常数、地址、函数名以你手上那份二进制为准，别照抄我这里的数值。

1.1 一份 MIPS 二进制的六个关卡长什么样

先建立全局直觉。MIPS 版本的程序入口会依次调用phase_1到phase_6，中间穿插read_line（读一行输入）、explode_bomb（引爆）和phase_defused（关卡通过后的确认）。引爆函数本身很简单，通常是打印一行提示然后调exit，所以你在反汇编里看到某个函数只有一个打印加一个退出调用，那它就是引爆器，记住它的入口地址，后面在 gdb 里对它下断点，一旦命中就说明你的猜测错了，立刻停下重来。

关卡结构上有很强的规律性。每一关都是：read_line拿到你输入的字符串，做一点预处理（可能是sscanf、strtol、strcmp），然后逐项比对，全对就返回，有一处不对就调explode_bomb。因此读反汇编的第一件事永远是找调用引爆器的那几条路径，那几条路径上对应的比较指令，就是你要解开的锁。

从难度曲线上看，前两关基本是送分，第三关开始引入跳转表，第四关引入递归，第五关引入指针数组和链表，第六关变成排序或结构体遍历。隐藏关通常是第四关或第五关的输入后面多挂一个特定字符串触发的，我这份是在第四关的输入里追加了一个固定短词。这一整套设计的目的很明确：让你依次接触常量比较、循环、switch 展开、递归栈帧、指针解引用，这几乎就是“读懂 C 代码编译产物”的完整技能树。

1.2 为什么用 MIPS 做反汇编训练更“难”也更有意思

换成 MIPS 之后，难度其实是上升的，原因有三点，每一点都值得单独拿出来说。第一是指令定长。x86 的指令长度可变，反汇编器输出的地址是不连续的，读的时候容易迷路；MIPS 每条指令固定 4 字节，地址必然是 4 的倍数，这个规律帮了大忙——但它同时带来一个新麻烦：数据也常常按 4 字节对齐，你在.rodata段里看到的一串十六进制，到底是字符串还是整数表，得靠上下文判断。

第二是分支延迟槽。这是 MIPS 最经典的坑。beq $t0, $t1, label这条指令执行完之后，它下一条指令（延迟槽指令）无论跳不跳都会先执行一次，然后才真正跳转。这意味着你按顺序读反汇编，读到分支指令的下一行时不能想当然地认为“跳走了就不会执行这行”——它一定会执行。编译器会精心安排延迟槽，塞进去一条有用的指令（比如一条addu），也可能塞一条nop。读错延迟槽，几乎必错，因为它直接影响寄存器里的值。

第三是伪指令与真实指令的混排。li、la、move、b这些让你看着舒服的助记符，全是反汇编器给你翻译出来的，机器码里并不存在。一个li $t0, 0x12345678在反汇编里可能显示成一条，实际上被展开成lui加ori两条。看清楚这一点，你在 gdb 里单步的时候才不会被“一条指令怎么走了两步”搞懵。

好处也不是没有。MIPS 的寄存器约定极其规整，$a0–$a3传参、$v0接返回值、$ra存返回地址、$sp指向栈顶，这套规则从头到尾不变。你只要把这几个寄存器的含义记熟，函数调用关系在反汇编里几乎是自解释的，比读 x86 那种寄存器复用严重的代码轻松得多。

1.3 开工前的最小工具清单

工具不需要多，但得对。我常用的是这一套，缺一件都会卡住：

端序这件事我必须单独强调，因为它坑过我一次，浪费了整整一个下午。MIPS 有大小端两种变体，编译出来的二进制端序不同，反汇编时用的objdump前缀也不同。我第一次用错了前缀，反汇编出来的指令全是乱的，lw变成了一堆莫名其妙的sll，一开始还以为是二进制被做了混淆，后来用readelf -h看了一眼 EI_DATA 字段才发现是端序搞错。所以开工第一步永远是：readelf -h ./bomb，看Data:那一行写的是2's complement, big endian还是little endian，然后再决定用哪个前缀的 objdump。这一步花三十秒，能省三小时。

提示：把反汇编结果重定向到文件里，用编辑器打开慢慢读，比在终端里翻页强得多。命令大致是objdump -d ./bomb > bomb.asm，数据段再来一份objdump -s -j .rodata ./bomb > rodata.txt。两份文件对着看，效率翻倍。

2. 读懂 MIPS 反汇编的三个基本功

工具装好只是开始，真正决定你读得快慢的，是能不能在几百行汇编里迅速抓住“这一段在干什么”。我总结下来，靠的是三个基本功：认寄存器、认指令模式、认地址计算。

2.1 寄存器约定：谁传参、谁返回值、谁不能乱动

O32 调用约定里，寄存器分工是死的，背下来收益极高。$a0到$a3是前四个参数，多出来的参数走栈；返回值放$v0（64 位结果用$v0/$v1拼接）；$t0–$t9是调用者保存的临时寄存器，函数调用之后可以认为被改掉了；$s0–$s7是被调用者保存的，一个函数如果用了$s寄存器，入口处一定会先把它压栈、出口处再恢复，看到这对“压栈-恢复”就能判断这个函数体量不小。

还有两个特殊角色。$ra保存返回地址，jal指令会自动把下一条指令的地址写进去；$sp是栈指针，MIPS 的栈向下生长，函数入口常见的addiu $sp, $sp, -32就是在开栈帧。至于$fp（也叫$s8），在优化等级不高的情况下会作为帧指针使用，方便调试时回溯，优化过的代码里经常被省掉。

这套约定给你的最大便利是：看到一个jal之前，看$a0–$a3是怎么赋值的，就知道传了什么参数。比如phase_1里如果先move $a1, $s0再jal strcmp，那$a1就是你输入的字符串，$a0是程序内置的那个参照串。反过来，看到函数返回后立刻bne $v0, $zero, ...，那就是在判断返回值是否为零，典型的字符串相等判断。

我建议做一张小卡片贴在屏幕边上，把这几个寄存器写上，读的时候随时对照。读够二十个函数之后，这张卡片就长在脑子里了。

2.2 高频指令模式识别：从 lui/ori 到分支延迟槽

编译器生成代码是有惯性的，同一类 C 语句在不同关卡里会产出几乎一样的指令序列。认出这些“指纹”，比逐行分析快十倍。下面这几个模式我必须点名：

模式一：构造 32 位立即数。你会看到连续两条lui $at, 0x0041和ori $at, $at, 0x0008，拼起来就是0x00410008。为什么用$at？因为lui和ori的立即数字段只有 16 位，装不下 32 位常量，编译器只能用汇编器的临时寄存器$at（寄存器 1，专为此保留）做中转。看到$at，几乎可以断定这里有地址或大常量的构造，往下一两条指令，大概率跟一个lw或addiu。

模式二：伪指令展开。li $t0, 6这种小常数，机器码里其实是一条addiu $t0, $zero, 6或者ori。反汇编器为了可读性显示成li，你在 gdb 里单步时看到的是addiu，不要以为是两回事。

模式三：数组下标转字节偏移。这是第三关和第五关的核心。C 语言里arr[i]，其中arr是int数组，编译器一定会先算i * 4，指令序列固定是sll $t1, $t0, 2（左移两位等于乘四），接着addu $t1, $t1, $s0（加上数组基址），最后lw $t2, 0($t1)。看到sll后跟addu再跟lw这三连，脑子里立刻翻译成“取数组元素”。

模式四：跳转表。sll算偏移、addu加表基址、lw取出目标地址、jr $t2跳过去。这四步就是 switch 语句的跳转表展开，第四种模式一出现，你就知道这关在判断一个有限取值的输入。

模式五：分支延迟槽。读到beq/bne之后，一定要看紧接着的那条指令，它是延迟槽，无条件先执行。编译器有时会在延迟槽里塞一条addiu $sp, $sp, 32（出栈），这时候如果你以为“跳走了就不用管栈”，栈就会算错。

这些模式不需要死记，读个十几遍自然就条件反射了。我最初也是硬啃，第三关啃完之后，后面几关看到sll就知道该往哪看。

2.3 objdump 三列输出的阅读方法与地址换算

objdump -d的输出通常长这样：

00400f2c: 3c1c0042 lui gp,0x42 00400f30: 279c8f30 addiu gp,gp,-28880 00400f34: 27bdffe0 addiu sp,sp,-32 00400f38: afbf001c sw ra,28(sp)

第一列是地址，第二列是 32 位机器码（十六进制），第三列是助记符加操作数。地址是 4 字节对齐的，这一点让你可以用一个很实用的技巧：分支指令的跳转目标，通常在反汇编里显示成一个绝对地址，比如beq $t0, $t1, 0x400f60。如果你想知道这个地址对应的是哪个函数，直接去反汇编文件里搜00400f60:这一行，就是跳转落点。反过来，jal 0x400a20里的地址就是被调函数入口，搜一下就能定位函数体。

还有一个细节：MIPS 的分支指令用的是相对偏移（以延迟槽之后的下一条指令为基准），但 objdump 已经帮你算好了绝对地址显示出来，省心。不过你如果自己手工验算机器码，得记住基址是“分支指令地址 + 4”。

数据段的读法不一样。objdump -s -j .rodata输出的是十六进制字节加右侧的 ASCII 预览。字符串常量通常一眼可见；但整数数组就是一堆小端（或大端）排列的字节，需要你自己换算。比如看到00000006 00000001 0000000e，在大端机器上就是 6、1、14 三个整数；小端机器上字节序反过来读。这个换算我一开始总错，后来养成习惯：先确认端序，再逐组按 4 字节切分，切完之后在纸上写下十进制值，比对反汇编里的比较指令，两个方向互相验证，错误率立刻降下来。

3. 六个关卡的拆解思路与实操记录

下面进入正题。我按关卡顺序讲，每关给出“从哪下手、看到什么、怎么验证”的完整链条。这里的内容基于我这份 MIPS 版本的实际记录，也标注了不同实现下可能出现的变体。

3.1 第一关：字符串刀法，从 strcmp 入手

第一关最简单，也最适合用来建立信心。打开phase_1的反汇编，你会看到大致这样的骨架：

phase_1: addiu sp,sp,-24 sw ra,20(sp) move a1,a0 # 你输入的字符串挪到 a1 lui a0,0x40 # 装载参照串地址高位 addiu a0,a0,0x0d20 # 拼出完整地址 jal strcmp nop # 延迟槽 beq v0,zero,ok # 返回 0 表示相等 nop jal explode_bomb nop ok: lw ra,20(sp) jr ra addiu sp,sp,24 # 延迟槽里恢复栈

流程非常干净：把两个指针传给strcmp，判断返回值是否为零。零就通过，非零就引爆。那么参照串是什么？就是$a0里那个地址指向的内容。拿这个地址去数据段里找，objdump -s -j .rodata之后按地址对齐找到那一行，右侧 ASCII 直接给你答案。

如果字符串不太长，还有更快的办法：在 gdb 里断到jal strcmp那一行，p (char*)$a0直接打出内容。这一步我强烈推荐，比翻十六进制快得多，也不容易读错。

这一关值得注意的地方只有两点。一是$a0的构造方式，lui加addiu的组合里，addiu有符号扩展的问题：如果低 16 位的最高位是 1，编译器会先把高 16 位加一，再用负数偏移。你在反汇编里看到addiu a0, a0, -3xxx这种负数，不要以为是错的，那是正常的地址修正。二是延迟槽里那句nop，有了它就不用操心。有些优化版本会把nop换成有用的指令，那时候就得小心了。

3.2 第二关：循环里的算术构造，把累加器读出来

第二关开始有意思了。典型形态是读入若干整数，然后在一个循环里依次处理，最后和某个目标值比较。反汇编里的骨架长这样：

phase_2: ... jal read_six_numbers ... li s3,0 # 循环计数器 i = 0 loop: slti t0,s3,6 # i < 6 ? beq t0,zero,done nop sll t1,s3,2 # i * 4 addu t1,s0,t1 # + 数组基址 lw t2,0(t1) # 取 a[i] ...

这一关的核心读法是盯住累加器和比较点。循环体里一定有一处bne或beq把当前元素跟某个由前一元素算出来的值做比较，或者在累加器上做addu、mult、sll之类的运算。你要做的是把这个表达式还原成数学式。

举个具体的：我这份的第二关是先要求第一个输入为 1，然后从第二个开始，每个元素等于前一个元素乘 2。反汇编里的关键三行是sll t2,t2,1（左移一位等于乘二）、addu（累加）、bne（和当前输入比较）。看到sll x, x, 1，基本可以确定是乘二，配合循环下标往前推即可。

这里的实操技巧是：不要试图一次看懂整个循环。先定位循环条件（slti加beq），确定循环次数；再定位循环体里的比较指令，确定“当前项要满足什么”；最后看比较之前的那几条运算指令，把公式写出来。三步拆开，每一步只关注两三行，压力立刻小很多。

还有一个小坑：sll左移一位是乘二，但如果操作数是负数，左移的行为和乘二仍然一致（补码左移等价于乘二再取模），所以不用担心符号问题。真正需要注意的是mult和mflo的组合，乘法的结果在hi/lo两个特殊寄存器里，必须用mflo取出来才能用，看到mflo就知道前面有个乘法。

3.3 第三关：跳转表与 switch 展开，读懂四行连招

第三关是很多人卡住的地方。输入一两个整数，然后根据第一个数做一个switch分支，每个分支里再对第二个数做运算，最后把结果跟目标值比较。C 代码大致是：

switch (a) { case 0: b = b + 100; break; case 1: b = b - 20; break; ... } if (b != target) explode_bomb();

编译成 MIPS 之后，跳转表的标准展开是这样的：

li t0,7 sltu t1,a0,t0 # 越界检查 beq t1,zero,default nop sll t2,a0,2 # 下标 * 4 lui t3,0x40 # 跳转表基址高位 addiu t3,t3,0x0f00 addu t2,t2,t3 lw t4,0(t2) # 取出目标地址 jr t4 # 跳过去 nop

这四行连招sll→addu→lw→jr是 switch 的招牌。看懂它之后，你要做的事就变成了：找到跳转表的基址，把表里每一项的目标地址读出来，然后逐个去看每个case分支里做了什么运算。

读表的方法有静态和动态两种。静态的：用objdump -s看.rodata里那个地址附近的内容，每 4 字节一个地址，按端序还原。动态的更快：在 gdb 里断到jr之前，x/8wx 0x400f00直接把表打出来。我通常用动态法，因为静态读表要处理端序和重定位，容易出岔子。

拿到地址之后，逐项case分析。每个分支通常是addiu或addu一次运算，然后跳到统一的比较点。把每个分支的运算结果列成一张表，再对照最后那个目标值，反推每个case对应的第二个输入应该是多少。

注意：有些版本的第三关在越界检查之后还有一个额外的取反，sltu的结果如果为真才继续，说明是“小于等于 7 就合法”。这个边界条件要仔细看，我第一次读的时候把<和<=搞反，白白多试了好几轮。

3.4 第四关：递归与栈帧还原，跟着 $ra 走

第四关开始上强度，函数变成递归的。C 代码通常形如：

int func(int a, int b) { if (a <= 0) return b; return func(a - 1, b * 2) + ...; }

编译出来的反汇编里，递归函数一定有这几个特征：入口处开较大的栈帧（addiu sp,sp,-32或更多）、保存$ra和$s寄存器、函数体中间有一条jal跳到自己的地址、返回前恢复现场。我这份的第四关递归深度是 3 层，每层做一次乘法累加。

读递归函数的顺序是这样的：先看递归终止条件，再看递归调用前参数怎么变，最后看返回值怎么组装。终止条件通常在函数最前面，一条blez或slti加beq；递归调用的两个参数一定在jal之前被修改过，改法就是递推关系；返回值通常是$v0加一个常数，或者两次调用结果相加。

举个具体的，我这份的递归是f(n) = f(n-1) * 2 + 3这类结构，反汇编里的关键行是sll v0,v0,1（乘二）和addiu v0,v0,3（加三）。看清楚这两行，递推式就出来了，然后手算或者写个两行的小脚本就能算出目标输入。

这一关强烈建议手算加验证，不要直接在脑子里推。比如要求f(3) == 某个值，你就从f(0)开始一层层往上写，写到f(3)，再反推输入。我见过太多人在这里心算出错，明明思路对，结果差个 2，白白多试几轮。

栈帧的读法也在这里派上用场。递归函数入口addiu sp,sp,-32之后紧跟着几条sw，把$ra、$s0–$s2存进去；出口前反过来lw恢复。看见这对结构，说明这个函数确实是递归或者调用了别的函数。如果栈帧只有 24 字节并且只存了$ra，那多半是个叶子函数，不递归。

3.5 第五关：指针、数组与链表，跟着 lw 走两层

第五关的形态有几种，常见的是“输入一个字符串，根据字符的低位去数组里取数，最后拼成一个目标值”，或者是链表的遍历排序。核心都是指针解引用，反汇编里表现为连续两层lw。

数组版本的骨架：

andi t0,t0,0xf # 取低 4 位 la t1,array # 数组基址 sll t0,t0,2 addu t1,t1,t0 lw t2,0(t1) # 取元素 addu s1,s1,t2 # 累加

这个套路很清楚：andi取低四位，sll乘四，addu加基址，lw取值，然后累加到某个寄存器。你要做的是找到数组的内容和目标累加值，反推出每一位输入字符应该取什么下标。这一步可以完全手算，把数组打出来，然后贪心地从目标值里减。

链表版本更难一点，会出现两层lw：第一层取节点里的值，第二层从节点里取next指针。C 结构体大致是{int value; struct node *next;}，偏移 0 是值，偏移 4 是下一个指针。反汇编里表现为lw t2,0(t1)和lw t1,4(t1)一起出现，t1既是基址又是结果，这是典型的指针追赶。看到这种“自己给自己的偏移赋值”的写法，就可以断定是在走链表。

提示：第五关如果要求按某种顺序排列，别急着写求解脚本，先用 gdb 把链表或数组的完整内容打出来。x/8wx 地址一条命令，比读反汇编十分钟快。数据拿到手，剩下的就是纯数学题。

3.6 隐藏关：二叉树与结构体遍历

隐藏关一般需要你在前面某一关的输入后面追加一个特定字符串才能触发，触发之后会多出一个关卡，通常是二叉树遍历。节点结构大致是{int value; node *left; node *right;}，每个节点 12 字节，偏移 0 是值，4 是左子，8 是右子。递归函数长这样：

int fun(node *p) { if (!p) return -1; if (val < p->value) return 2 * fun(p->left); if (val > p->value) return 2 * fun(p->right) + 1; return 0; }

反汇编里的特征很好认：开头beq a0,zero,ret_neg（空指针返回 -1），然后是lw t0,0(a0)取值比较，接着两次jal分别对应左子树和右子树，中间夹着sll v0,v0,1（乘二）和addiu v0,v0,1（加一）。这套“乘以二再加零或一”的编码方式，实际上是在记录路径：往左走记 0，往右走记 1，返回值就是从根到目标节点的二进制路径。

破解方法是把树的结构完整还原出来，然后在树里搜索那条路径，反推出每个节点该走哪边。树不大的话，直接把树画出来最快。我一般用 gdb 打节点地址，手工画一棵小树，十分钟就能搞定。

这一关的输入格式也需要注意：通常是你前面某关的正确输入加上一个固定短词，中间用空格分隔。触发点在phase_defused里，它会做一次sscanf，格式串里有%d %d %s这样的三段，第三段匹配上了才调隐藏关。读phase_defused的反汇编就能看到这个格式串的地址，去数据段里取出来即可。

4. 调试现场：gdb 断点、寄存器观察与自动化

静态读反汇编能解决八成问题，剩下两成必须靠动态调试。尤其是涉及运行时才确定的值，比如链表地址、递归中间结果，动态看比静态推可靠得多。

4.1 远程调试环境怎么搭

MIPS 二进制不能直接在本机跑，需要一个模拟器提供运行环境，同时开一个调试端口。常见做法是模拟器启动时带上-g <端口>参数，然后本地用gdb-multiarch连上去：

# 终端一：启动模拟器并挂起等待调试器 qemu-mipsel -g 1234 ./bomb # 终端二：连接并加载符号 gdb-multiarch ./bomb (gdb) set architecture mips (gdb) target remote localhost:1234 (gdb) break phase_1 (gdb) continue

这里两个细节容易踩坑。第一，set architecture必须和实际架构一致，是mips还是mipsel，端序不同命令不同，写错了gdb会拒绝连接或者读到乱码。第二，模拟器加载的二进制路径和 gdb 加载的必须是同一个文件，否则符号地址对不上，break phase_1会告诉你找不到符号。我吃过这个亏：gdb 里加载的是备份文件，模拟器跑的是重新编译过的版本，断点位置差了 4 个字节，单步跳得莫名其妙。

连上之后，第一件事是确认入口点。info files看Entry point，和你readelf -h看到的入口地址对一下，一致就说明环境正常。

4.2 断点、单步与栈帧查看

调试这类程序，断点不要乱下，下在关键位置才有价值。我的习惯是三个位置必下：explode_bomb（防爆）、每一关的入口（进入即停）、每关里那个比较指令（看两边操作数）。前两个是安全网，第三个是解题关键。

explode_bomb的断点尤其重要，原因很实际：程序引爆时会直接退出，如果不在这里停住，你试错一次就得重启模拟器重新连 gdb，效率极低。在这个断点上加一段命令，让它停下来并打印当前关卡号，就能快速定位是哪一关错了。

gdb里查看寄存器用info registers，简写i r；查看特定寄存器用p $a0；查看内存用x/8wx 0x400f00（8 个字，十六进制）。查看字符串用x/s 地址。这几个命令覆盖九成场景，剩下的用x/i $pc看当前指令，单步用stepi（进入函数）或nexti（跳过函数）。

stepi在 MIPS 上有一个必须提醒的地方：因为分支延迟槽的存在，stepi一次只执行一条指令，你在beq上按一次stepi，$pc会先走到延迟槽那条指令，再按一次才跳到目标地址。很多人第一次用会觉得“跳转没生效”，其实是没有把延迟槽那一步算进去。理解这一点，单步就不会迷路。

栈帧查看用bt看调用栈，info frame看当前帧的信息。MIPS 上回溯有时不准，尤其是优化过的代码，因为帧指针可能被省掉了。这时候就靠手工读$sp和$ra推，虽然麻烦但可靠。

4.3 写脚本批量爆破，比手算快十倍

有些关卡用脚本跑比手算省事得多。思路是：让程序依次尝试候选项，命中就通过，引爆就换下一个。具体实现上，可以用 gdb 的批处理模式，也可以用 shell 循环配合超时检测。

一个朴素的思路是把候选输入写进文件，然后循环执行：

for candidate in $(seq 0 999); do echo "$candidate" > /tmp/input.txt timeout 2 ./run_bomb.sh < /tmp/input.txt > /tmp/out.txt 2>&1 if grep -q "phase_1" /tmp/out.txt; then echo "hit: $candidate" break fi done

这个套路适合搜索空间不大的关卡，比如第四关的输入范围只有几十种可能。搜索空间大的关卡还是老老实实静态分析，算准了再输，别硬跑。

还有更精细的做法：用gdb的commands在断点命中时自动读寄存器、自动continue，把每轮的值打到日志里。这样一次运行能采集大量数据，事后统一分析。我拆第五关时就是这么干的，让程序在循环里跑，每个元素的实际值都记录在案，出问题时直接翻日志。

注意：自动化脚本一定要加超时。有些错误输入会让程序卡在一个很长的循环里，没有超时就会一直挂着，把你的时间全吃掉。

5. 常见问题速查与我的避坑清单

拆弹过程中踩的坑，教训比经验更值钱。下面这张表是我自己整理的高频问题清单，覆盖了从环境搭建到最后一关的绝大多数卡点。

5.1 高频问题排查表

这张表里最容易被忽略的是“输入格式”那一条。很多人在纸面上把六个答案都推对了，一提交还是炸，折腾半天发现是每行多了一个空格或者少了最后一行。read_line这类函数的实现细节要看清楚：有的版本用fgets读到换行就截断，有的会一直读到文件结束。写答案文件时，每关一行、末尾不要多余空行，是最稳妥的做法。

5.2 几条用血换来的经验

第一，先跑通再读，别一上来就啃反汇编。我最初的做法是拿到文件就objdump，结果几百行刷屏，看得头晕。后来改成先跑一遍，看程序提示什么、在哪一步炸，有了行为反馈再回去读对应的那段代码，效率翻倍。行为是最好的导航。

第二，每关都写一份推导笔记。笔记里记清楚：输入格式、关键比较指令的地址、涉及的常量、推导出的答案、验证结果。这份笔记在你回头修改前几关答案时会救命，尤其是隐藏关需要拼接前面某关答案的时候，直接抄就行。

第三，gdb 里给引爆函数下断点后，加一条自动打印当前关卡的命令。这样每次命中都能知道错在哪一关，不用来回看日志。十几秒的配置，省掉后面无数次重启。

第四，别迷信静态分析的结论。有些地址在静态反汇编里显示成一个值，运行时经过重定位会变。凡是涉及lui拼地址的地方，最好在 gdb 里p/x打一次实际值确认。我在这上面翻过车，静态算出来的跳转表地址差了 0x1000，导致读了一堆垃圾数据，怀疑人生了一小时。

第五，把$ra当导航用。读一个陌生函数时，先找jal指令，再看它前后$a0–$a3的赋值，函数之间的关系就串起来了。这比从头读到尾快得多，尤其是函数体很长的时候。

第六，时间分配要有取舍。前四关应该在一小时内解决，把时间留给第五关和隐藏关。如果某一关卡超过四十分钟，先放一放，去看下一关，很多时候理解加深之后回来一眼就通了。我拆第五关就是卡了很久，出去吃了一顿饭，回来重新看那两层lw，五分钟就明白了。

第七，答案文件最后统一验证一次。把六个（七个）答案从头到尾跑一遍，确认一次性到达结束提示，中间没有任何引爆。这一步别省，我见过好几次前面几关单独跑都对、合在一起就出问题的情况，原因是答案文件的行尾或者顺序错了。

从我个人这几轮的体验来看，这类题目真正的价值不在于最后那串答案，而在于你被迫反复练习“读汇编—提出假设—动态验证—修正假设”这个闭环。这个闭环练熟了，以后看任何陌生的二进制、任何崩溃栈、任何没有源码的现场，心里都有底。第一次拆的时候我盯着sll和addu发呆，第五次拆的时候看到这两行就知道后面跟着数组访问，这种肌肉记忆是刷题刷不出来的，只能一行一行读出来。

如果读完之后还想继续加练，我的建议是自己给自己出题：拿一段简单的 C 代码，编译成 MIPS，然后不看源码，只靠反汇编把它还原回 C 函数。一开始只写三五行的小函数，慢慢加到带循环、带递归的版本，难度自己控制，比被动做题有意思得多。