简介：MIPSAssembler 是一套用 Python 编写的 MIPS 汇编器工具，面向计算机系统、汇编语言课程学习者及嵌入式入门开发者。它能够将 MIPS 架构下的汇编指令转换为可执行的二进制机器码，帮助使用者脱离仿真器直接观察指令编码过程。压缩包共 4 个文件，包括汇编器源码、示例 MIPS 代码、输出结果文本及说明文档，整体大小仅 5KB，轻量易用。目前已有 194 人浏览学习。结合示例代码，读者可以逐步理解 MIPS 指令集、寄存器约定、地址计算、数据段与代码段划分，以及分支跳转和函数调用等核心知识点；通过修改和运行汇编源文件，还能验证不同指令的机器码输出。借助附带的汇编示例与输出文本，读者能直观对照源码与机器码，体会汇编到二进制的映射关系，是辅助课程实验、考前复习或自学底层编程的实用工具。
1. 认识MIPSAssembler：从指令文本到机器码的那一步
写 CPU 课程设计或者自己写模拟器时，很多人卡在同一个环节：汇编代码写好了，却要把每条指令手算成 32 位机器码，再逐行填进 ROM。手算一两次还行，指令一多、标签一多就开始翻车。MIPSAssembler 就是解决这件事的工具：它读取 MIPS 汇编语言，经过注释清理、词法切分、符号表收集、指令编码，最终输出对应的 32 位机器码，让模拟器、测试台或者你正在设计的 CPU 直接使用。这篇文章按照「指令格式 → 工程流水线 → 编码实现 → 踩坑 → 验证」的顺序，把一个最小但能用的 MIPS 汇编器完整拆开讲透。适合做 CPU 实验、写模拟器、或者单纯想把汇编器原理弄明白的开发者。
2. 为什么先定指令集：MIPS 的三种编码格式与伪指令
MIPS 汇编器的输入是文本，输出是 32 位机器码，两者之间只能靠一套固定规则对应起来，这套规则就是指令集编码。动手写代码前先把编码表放在手边，比边写边查要高效得多。一般情况下，汇编器核心需要维护三张表：R 型功能码表、I 型 opcode 表、J 型 opcode 表。后面所有编码函数都只查表，遇到表中不存在的助记符统一报“未知指令”。
2.1 从R型/I型/J型说起：指令编码的三个固定模板
MIPS 指令长度固定 32 位，所有指令按最高 6 位 opcode 分成三类格式。R 型面向寄存器运算，布局为 6 位 opcode、5 位 rs、5 位 rt、5 位 rd、5 位 shamt、6 位 funct，刚好 32 位。add、sub、and、or、slt 等算术逻辑指令都用这种格式，opcode 恒为 0，具体行为由 funct 字段区分。I 型面向立即数和访存，布局为 6 位 opcode、5 位 rs、5 位 rt、16 位立即数，addiu、ori、lw、sw、beq、bne 都走这个模板。J 型只有 6 位 opcode 和 26 位地址，j 和 jal 用它。
这三个模板直接决定了代码结构：R 型需要一张“助记符 → funct”映射表；I 型需要区分 opcode，并且对 16 位立即数做边界处理；J 型只需要把 26 位字地址左移两位后拼接进指令。这里要注意，J 型里的 26 位保存的是“字地址”，真正的指令地址等于它左移两位，因为 MIPS 指令按 4 字节对齐，低两位恒为 0，省出来可以多存两位地址。
| 格式 | 字段布局 | 典型指令 | 编码要点 |
|---|---|---|---|
| R 型 | opcode(6) + rs(5) + rt(5) + rd(5) + shamt(5) + funct(6) | add / sub / sll / jr | funct 决定真实指令 |
| I 型 | opcode(6) + rs(5) + rt(5) + imm(16) | addiu / lw / beq / ori | imm 需要按有符号或无符号截断 |
| J 型 | opcode(6) + addr(26) | j / jal | addr 左移 2 位得到真实目标地址 |
我在做这个汇编器时，先把这三张表写成字典，然后再写任何编码逻辑。这样后面遇到不认识的助记符，直接查表失败并报错，而不是散落在一堆 if-else 里。实际编码时还有一个容易被忽略的点：R 型里 sll、srl 的操作数顺序和 add、sub 不一样，前者是sll $rd, $rt, shamt，后者是add $rd, $rs, $rt。两种顺序如果混在一个编码函数里，最容易产生隐蔽错误。
2.2 伪指令与寄存器别名：汇编器替你做了哪些事
MIPS 汇编语言里大量指令并不是真实机器指令，而是伪指令。伪指令没有直接编码，汇编器负责把它们展开成一条或多条真实指令。典型的如 move：move $t0, $t1本身不存在，真实做法是add $t0, $t1, $zero，利用 $zero 恒为 0 完成数据搬移。li 的展开方式根据立即数大小分两种情况：16 位有符号范围内用addiu $rt, $zero, imm；超出范围用 lui 加载高 16 位、再用 ori 拼接低 16 位。la 加载标签地址，也按高、低半字拆成两步。
寄存器别名是另一个容易被忽略的点。MIPS 汇编器允许程序员写 $t0、$s1、$ra，但机器码里只有数字编号。汇编器必须维护一张别名表，并且在解析操作数的第一步就做转换。$t0 到 $t7 对应寄存器 8 到 15，$t8、$t9 对应 24、25；$s0 到 $s7 对应 16 到 23；$zero 对应 0；$v0 对应 2；$a0 到 $a3 对应 4 到 7；$sp 对应 29；$ra 对应 31。这张表最好放在一个独立的解析函数里，让所有编码函数共用。
| 伪指令 | 展开结果 | 说明 |
|---|---|---|
| move $rd, $rs | add $rd, $rs, $zero | 走 R 型编码 |
| li $rt, 小立即数 | addiu $rt, $zero, imm | imm 须在 -32768~32767 内 |
| li $rt, 大立即数 | lui $rt, high; ori $rt, $rt, low | high / low 各 16 位 |
| la $rt, label | lui $rt, high; addiu $rt, $rt, low | 需要 label 的绝对地址 |
| bgt $rs, $rt, label | slt $at, $rt, $rs; bne $at, $zero, label | 用 $at 暂存比较结果 |
我一般会把伪指令展开放在真正的编码之前，也就是在第二趟扫描开始前先对指令列表做一遍整体展开，这样后面编码函数见到的全是真实指令，分支逻辑大幅减少。只处理 move、li、la 三个伪指令，已经足够支撑大部分教学实验；bgt 这类可以等基础跑通后再补。
2.3 最小指令子集怎么圈定：先支持哪些指令
设计阶段的最后一个核心问题是：第一版到底支持多少指令。我见过不少开发者一上来就想覆盖全部 MIPS 指令集，结果写了一千多行，最后连冒泡排序都没跑通。更可靠的做法是先圈一个能写完整排序和递归调用的最小集：R 型选 add、sub、and、or、slt、sll、srl、jr；I 型选 addiu、ori、andi、lw、sw、beq、bne；J 型选 j、jal；伪指令选 move、li、la。加起来不到二十条，但覆盖了三种格式、访存、分支、跳转、运算。
为什么不一开始支持所有指令？因为每条指令至少对应一次编码测试，指令越多，调试空间越大。先把这不到二十条跑通、和教学模拟器的输出完全一致，再往指令表里加 slti、bgtz、mul 等扩展指令。这样每加一条的边际成本都很低，如果编码出错，也能快速定位是新加的指令问题，还是原有框架的问题。这也是我认为做汇编器项目最省力的路径：先小步跑通闭环，再逐步扩展，而不是一次性覆盖整个指令集。
3. 搭一个能跑的最小汇编器：从汇编文本到机器码的两趟扫描
3.1 总体架构：词法、符号表、两趟扫描
汇编器整体分四步：读取文本并去掉注释；把每一行切成助记符和操作数 token；建立标签符号表；按地址编码输出机器码。其中“两趟扫描”是个关键决策，新手很容易踩坑。第一趟遍历所有行，识别标签并记录地址；第二趟才真正编码机器码。为什么必须两趟？因为分支和跳转指令经常引用后面的标签，单趟扫描遇到 beq 时根本不知道目标标签的地址，只能先跳过，全部扫完再回来补，本质上等于再扫一遍。
更具体地说，第一趟只需要做两件事：一是解析出每条指令所在地址，二是把形如loop:的标签写进符号表。MIPS 真实指令都是 4 字节，地址计算很简单，从文本段基地址开始，每遇到一条指令地址加 4。我一般把文本段和数据段分开处理，文本段从基地址连续存放指令，数据段另行管理 .word、.byte、.asciiz 等数据。如果目标实验只要指令 ROM，数据段可以先不编码，但汇编器架构里要预留接口。下面是一个最小两趟扫描的骨架。
3.2 第一趟：收集标签地址
第一趟的目标是收集标签地址，同时把清洗后的指令行连同地址存下来，供第二趟使用。下面的代码是一个可直接运行的 pass_one 实现，为了便于理解，这里假定文本段基地址可配置，并先只处理指令段。
BASE_ADDR = 0x00400000 # MIPS文本段常见基地址，课程实验可改为0 def strip_comment(line): return line.split('#')[0].strip() def pass_one(lines): symbols = {} raw_items = [] address = BASE_ADDR for raw in lines: line = strip_comment(raw) if not line: continue # 处理标签：一行里可以有 “label: 指令”，也可以只有 “label:” if ':' in line: label_part, rest = line.split(':', 1) label = label_part.strip() if label: if label in symbols: raise ValueError("duplicate label: %s" % label) symbols[label] = address line = rest.strip() if not line: continue raw_items.append((address, line)) address += 4 return symbols, raw_items逻辑说明：输出有两份，一份是符号表 dict，一份是 raw_items 列表，每个元素包含当前指令的绝对地址和去掉注释后的原文。标签地址在这里记录为当前指令的地址，也就是标签所在位置的机器码地址。用split(':', 1)而不是split(':')，是为了只拆第一个冒号，避免误伤后面可能的字符串内容。这里有一个刻意简化：伪指令在地址计算时也占 4 字节，如果之后被展开成两条真实指令，第二趟里地址就会错位，这个小坑我会在下一节说明。
参数说明：BASE_ADDR 是关键常量。校内 CPU 实验的 ROM 通常从 0 地址加载，这时设为 0；如果目标是按 MIPS 约定运行 ELF 或二进制，就设为 0x00400000。它的值同时影响符号表和机器码里的地址前缀，改动后所有测试都要重新比对。第一趟还应检查重复标签和标签名与助记符冲突，越早做这件事，排错成本越低。
3.3 第二趟：编码指令与数据段
第二趟拿到符号表和 raw_items 后，逐条判断这段文本是伪指令、真实指令还是数据定义。为了把伪指令展开和指令编码解耦，我会先做一次伪指令整体展开，得到新的指令列表，然后再编码。这个顺序可以让编码函数保持简单，不用为伪指令单独写分支。展开时要特别注意：展开后的每条指令都要占据独立的地址槽，原地址必须按展开数量递增，否则后一条指令会覆盖前一条。
def pass_two(raw_items, symbols): machine_codes = [] for addr, line in raw_items: parts = [p.strip() for p in line.replace(',', ' ').split()] if not parts: continue mnemonic = parts[0] args = parts[1:] # 伪指令整体展开后再编码 expanded = expand_pseudo(mnemonic, args) pc = addr for sub_mnemonic, sub_args in expanded: code = encode_instruction(sub_mnemonic, sub_args, symbols, pc) machine_codes.append((pc, code)) pc += 4 return machine_codes逻辑说明：expand_pseudo 对 move、li、la 等返回一个或多个真实指令的列表。比如 li $t0, 70000 会返回两条指令lui $t0, high和ori $t0, $t0, low，pc 从原地址开始，每条指令编码完加 4，这样两条真实指令的地址就是连续的。encode_instruction 内部再根据助记符查 R_FUNCT、I_OPCODE、J_OPCODE 三张表，决定用哪种编码函数。
参数说明：encode_instruction 里的第四个参数 pc 是当前指令的实际地址，分支指令编码时必须依赖它计算偏移量。数据段处理也在这个阶段完成：.word 把整数按 4 字节写入，.asciiz 把字符串编码成字节并在末尾补 0。数据段的标签也要进符号表，否则 la $t0, arr 会找不到目标。完整的汇编器通常会把数据单独输出到另一个文件，或者直接接在指令段后面，这取决于目标环境的要求。
4. MIPSAssembler核心编码实现：寄存器编号、立即数与分支偏移
4.1 寄存器编号与R型指令：先解决“寄存器名到编号”
编码的第一步是把 $t0 这种文本变成数字编号，这个函数足够简单，却决定了后面所有编码函数的入参形式。把它独立出来，统一放到一个模块里，所有编码函数都调用它，比在不同函数里重复写解析要好维护得多。下面是我常用的一个寄存器解析函数。
def reg_num(name): if name == '$zero': return 0 if name == '$v0': return 2 if name == '$sp': return 29 if name == '$ra': return 31 if name.startswith('$a') and name[2:].isdigit(): return 4 + int(name[2:]) # $a0-$a3 -> 4-7 if name.startswith('$t') and name[2:].isdigit(): n = int(name[2:]) return 8 + n if n <= 7 else 24 + (n - 8) # $t0-$t7 -> 8-15, $t8-$t9 -> 24-25 if name.startswith('$s') and name[2:].isdigit(): return 16 + int(name[2:]) # $s0-$s7 -> 16-23 if name.startswith('$k') and name[2:].isdigit(): return 26 + int(name[2:]) # $k0-$k1 -> 26-27 raise ValueError("unknown register: %s" % name)注意 $t0-$t7 映射到 8 到 15，$t8 和 $t9 映射到 24 和 25，这是 MIPS 约定里最容易记错的一段，很多人把 $t8 写成 16，编码出来整条指令错位。解析顺序也有讲究：固定名 $zero、$v0、$sp、$ra 要放在前面，带数字前缀的名字放在后面，这样既保证固定名不被误匹配，也能支持像 $0、$1 这样的绝对编号写法。if 语句的判断顺序一旦反了，$t8 会被错误匹配进 $t 前缀分支的 8+8=16，直接踩坑。
接下来是 R 型编码。R 型指令结构固定，直接按位填入即可。这里特别处理 sll、srl 和 jr 三种特殊传参方式，避免和普通三操作数指令混在一起。
R_FUNCT = { 'add': 0x20, 'sub': 0x22, 'and': 0x24, 'or': 0x25, 'slt': 0x2a, 'sll': 0x00, 'srl': 0x02, 'jr': 0x08 } def encode_r(mnemonic, args): if mnemonic in ('sll', 'srl'): rd, rt, shamt = args rs = 0 elif mnemonic == 'jr': rs = reg_num(args[0]) rt = rd = shamt = 0 else: rd, rs, rt = args shamt = 0 op = 0 func = R_FUNCT[mnemonic] return (op << 26) | (reg_num(rs) << 21) | (reg_num(rt) << 16) | \ (reg_num(rd) << 11) | (int(shamt) << 6) | func逻辑说明：普通 R 型指令是add $rd, $rs, $rt，所以第 25 行参数直接按 rd、rs、rt 解析。sll 语法是sll $rd, $rt, shamt，源寄存器在中间，这个顺序容易写反。jr 只有一个源寄存器，rs 字段填目标寄存器，其余字段全部清零。shamt 是 5 位无符号量，范围 0 到 31，编码前最好单独检查一次，超出后直接报错，而不是让位运算悄悄截断。
参数说明：所有寄存器名统一通过 reg_num 转换。这里用 Python 的位或构造 32 位整数，最终输出的 int 数值可以直接按 32 位十六进制打印。funct 字段只有 6 位，R_FUNCT 里的值都在 0x00~0x3f 之间，不会溢出。编码函数不直接处理伪指令，伪指令在第 3 章的 pass_two 阶段已经展开成了真实指令。
4.2 I型指令与立即数符号扩展：负数不能直接拼接
I 型指令编码看起来比 R 型简单，难点全在立即数上。addiu 的立即数是有符号 16 位，范围 -32768 到 32767；lw 和 sw 的偏移也是按有符号处理的，经常会写负数。Python 与 C 语言不一样，整数没有固定位宽，-1 在 Python 里直接参与位运算时不会自动截断成 16 位的 0xffff，而会带着前面的符号位污染 opcode 区域。所以必须在写字段前统一做一次掩码处理。
def slice_imm(value): # 允许带符号负数和无符号正数，统一截断到低16位 if value < -32768 or value > 65535: raise ValueError("immediate out of 16-bit range: %d" % value) return value & 0xffff def encode_i(opcode, rs, rt, imm): return (opcode << 26) | (reg_num(rs) << 21) | (reg_num(rt) << 16) | slice_imm(imm)逻辑说明：slice_imm 的输入范围放宽到 -32768 到 65535，覆盖有符号负数和无符号 16 位数两种情况。它只做低 16 位截断，代表硬件的真实位宽行为：无论这条指令的立即数在语义上是有符号还是无符号，最终写进指令的都是同一份 16 位二进制。lw 的 opcode 是 0x23，sw 是 0x2b，beq 是 0x04，bne 是 0x05，这些值都从 I_OPCODE 表里查，不在编码函数里写死。
参数说明：lw 和 sw 的操作数常常写成lw $t0, 8($sp)这种带括号的形式。解析时需要先把括号内的寄存器名拆出来，再解析括号外的偏移量。我第一次写的时候直接用字符串替换去处理括号，结果遇到-4($sp)这种负偏移时，整个切分逻辑全乱套。后来改成先用正则把imm($reg)拆成两个 token，再分别传给 encode_i，问题才稳定下来。建议在做词法切分时就把括号记法统一处理成独立的操作数，而不是等编码时临时补救。
4.3 分支跳转与标签解析：偏移量到底为什么要除以4
分支指令是汇编器里最容易出错的地方，核心问题在偏移量的计算基准。MIPS 的分支偏移量 imm 字段存的是“从下一条指令开始数，目标指令相隔几条指令”，也就是说，如果当前指令地址是 0x00400000，下一条是 0x00400004，目标是 0x00400010，那偏移量就是 (0x00400010 - 0x00400004) / 4 = 3。这个“当前地址 + 4”的基准，就是 MIPS 流水线里 PC 在取指阶段先加 4 的结果。
def encode_branch(target_label, rs, rt, current_addr, symbols): if target_label not in symbols: raise KeyError("unknown label: %s" % target_label) offset = (symbols[target_label] - current_addr - 4) // 4 if offset < -32768 or offset > 32767: raise ValueError("branch offset out of range: %d" % offset) return encode_i(0x04, rs, rt, offset) # 0x04 是 beq 的 opcode逻辑说明：分母的 4 是最容易漏掉的点，把字节差值直接写进 imm，会导致跳转到 4 倍远的位置。符号表里存的目标地址是绝对地址，current_addr 是当前分支指令地址，两者相减后先减 4 再除以 4，得到的就是指令条数差。理想情况下这个除法应该整除，如果出现余数，说明符号表地址和 current_addr 不是按 4 字节对齐，这是更早的地址计算出了问题，要立即停下来排查。
参数说明：bne 只是 opcode 不同，编码逻辑完全一样，所以 encode_branch 接收 opcode 参数或者拆成两个包装函数都可以。j 和 jal 走 J 型编码，不需要计算相对偏移，直接取目标地址的低 26 位左移两位即可。理论上有 4GB 地址空间时，J 型指令只能覆盖当前 PC 所在 256MB 区域，但校内实验程序通常很小，这个限制很少触发。如果触发，汇编器要给出明确提示，而不是静默截断目标地址。
4.4 伪指令展开与整体拼装：一个可运行的main入口
把上面的函数拼起来，还需要一个入口。我习惯把整个汇编流程封装成一个 assemble 函数，输入汇编文本，输出机器码列表。这样方便被测试脚本反复调用，也方便后面做差分验证。展开伪指令时，li 会根据立即数大小决定返回一条还是两条真实指令，la 会从符号表查出标签地址后再拆高、低 16 位。
def expand_pseudo(mnemonic, args): if mnemonic == 'move': return [('add', [args[0], args[1], '$zero'])] if mnemonic == 'li': imm = int(args[1]) if -32768 <= imm <= 32767: return [('addiu', [args[0], '$zero', str(imm)])] high = (imm >> 16) & 0xffff low = imm & 0xffff return [('lui', [args[0], str(high)]), ('ori', [args[0], args[0], str(low)])] if mnemonic == 'la': label = args[1] value = symbols.get(label) # 需要从外部传入符号表 high = (value >> 16) & 0xffff low = value & 0xffff return [('lui', [args[0], str(high)]), ('addiu', [args[0], args[0], str(low)])] return [(mnemonic, args)]逻辑说明：move 展开成一条 add，li 是小立即数时展开成 addiu，大立即数时展开成 lui + ori。注意大立即数场景里如果 imm 是负数，比如 -1，它的二进制是 0xffffffff，高 16 位 0xffff，低 16 位 0xffff，展开成 lui + ori 也能得到正确结果。这里的 high 和 low 都是无符号 16 位值，直接转成字符串传给后面的 encode_i，不会再做符号扩展，避免过程推理错误。
参数说明：la 依赖符号表，所以 expand_pseudo 需要能访问 symbols，可以在组装函数里把它作为参数传入。伪指令展开后，assemble 主流程会遍历展开结果，逐条调用 encode_instruction，并把 pc 按 4 递增。这一节看起来是收尾，其实是整个汇编器里最容易产生隐蔽 bug 的地方，因为展开后地址重排一旦出错，后续所有指令地址都会错位。我在早期版本里就吃过这上面的亏，li 展开成两条指令后忘了把 pc 加 8，导致后面所有机器码都占到了别人的地址上。
5. MIPS汇编器避坑：从段地址到延迟槽的7个细节
写汇编器最大的感受就是：它不怎么崩溃，但会在模拟器里跑出各种莫名其妙的结果。下面这 7 个细节，几乎每个人都会踩，我按“现象 → 原因 → 解决”三步写，方便你对照排错。这些问题覆盖了解析顺序、立即数边界、地址计算、流水线语义和数据对齐，属于 MIPS 汇编器里最典型的坑。
5.1 标签与寄存器的解析顺序：先查寄存器还是先查符号表
现象：代码里明明定义了标签 loop，汇编器却报 unknown label，或者把标签名当成非法立即数处理。原因：token 解析顺序没有设定，解析器先尝试 int() 转换，再查寄存器别名表，最后才查符号表，一旦输入是纯字母字符串，前面的分支全部误判，最终把标签名扔掉。解决：所有操作数按固定顺序解析，先查寄存器别名表，再查符号表，最后才尝试 int()。这个顺序定死以后，任何标识符都不会因为落在不同的解析分支而产生二义性。
5.2 立即数范围检查：不要等到编码完才发现溢出
现象：addiu $t0, $zero, 70000 编译时不报错，机器码输出也正常，但模拟器里算出来的值完全不对。原因：70000 超过了 16 位有符号立即数的上限 32767，高位被直接截断，数值凭空丢失。解决：在编码函数入口统一做范围检查，有符号指令检查 -32768~32767，无符号指令检查 0~65535，超界就抛出带行号的异常。这个检查应该放在 slice_imm 之前，而不是让截断逻辑静默处理一切输入，否则错误会被拖到模拟阶段才暴露。
5.3 分支偏移的“基址+4”陷阱：差 4 字节就全都偏了
现象：beq 后面紧跟一条指令，预期跳转到这条紧邻指令，结果总跳到前一条或者上上条。原因：分支偏移量的基准是 PC+4，不是当前指令地址。很多人写成“目标地址减当前地址”，少减了 4 字节，再除以 4 后整体偏出一条指令。解决：统一用公式(target_addr - current_addr - 4) // 4计算偏移量。我还会在写完偏移后加一个反向断言：offset * 4 + current_addr + 4 == target_addr，这一行能拦住绝大多数手滑，成本极低。
5.4 延迟槽处理：模拟器不说你不用管，真实CPU上就得管
现象：同一份汇编代码，在课程用的教学模拟器里运行正确，拿到真实流水线实验板上却多执行了一条本不该执行的分支后的指令。原因：MIPS 硬件设计里分支指令后紧接的那条指令始终会被执行，这就是分支延迟槽。部分教学模拟器默认关闭延迟槽，所以表现不出这条语义差异。解决：先确认目标平台是否复用延迟槽。如果复用，汇编器要在每条分支后面自动插入 nop，或者提示程序员在分支后手动写 nop；如果模拟器已关闭延迟槽，就不必处理。
5.5 符号扩展的坑：负数立即数编码后为什么会变成 0xffffffff
现象：手算 lw $t0, -4($sp) 的机器码，怎么对都对不上，模拟器里的表现也像寄存器被写入了错误数据。原因：lw 偏移是 16 位有符号数，-4 要按补码存成 0xfffc。Python 里 -4 参与位运算时不会自动截断成 16 位，而是以 32 位负数的形式存在，跟 opcode 位移后拼接时直接污染高位。解决：所有立即数在写入字段前统一做imm & 0xffff，把负数变成无符号 16 位补码。验证阶段再把 16 位按符号位扩展回来与原输入比较，确认没有丢失信息。
5.6 数据段对齐：.byte 和 .word 交替时地址错乱
现象：先用 .byte 定义字符，再用 .word 定义数组，la 取数组首地址后，读出来的前几个字全部错位。原因：数据段没有强制对齐。MIPS 的 .word 要求 4 字节对齐，.half 要求 2 字节对齐，如果前面 .byte 占了两个字节，.word 就落到了非对齐地址上，有些模拟器直接读出错误数据。解决：汇编器在遇到 .word 前检查当前偏移，不是 4 的倍数就自动补零或报错；也可以要求程序员用 .align 2 显式对齐，汇编器只做检查。自动补零更友好，但会改变数据布局，需要同时调整符号表里的后续地址。
5.7 大小写、逗号与注释：预处理不干净会拖垮整个词法分析
现象：同一份代码里混用了 ADD 和 add，编译出来有的指令缺失；某行注释末尾多了个分号，结果被当成非法字符。原因：MIPS 惯例区分大小写，但练习代码经常大小写混写；不同编辑器里注释符号也可能是 # 或 ;，单按 # 处理就会出现额外 token。解决：在预处理里把 # 和 ; 都当作注释起始符，助记符统一转成小写再查表，操作数统一按逗号和空白切分。这里还要警惕字符串字面量里的 #，所以不能用简单的行内 split，而要用能感知引号的分词函数先处理一遍。
6. 验证MIPSAssembler：用差分测试和手写机器码确认正确性
在把汇编器用于 CPU 实验之前，得先证明它输出的机器码是对的。我习惯做三层验证，难度递增，覆盖也递增。第一层是手算黄金样例，挑三条有代表性的指令，一条 R 型、一条 I 型、一条分支指令，人工按位算出 32 位机器码，写进测试用例。每次改动编码器之后先跑一遍这批样例，能抓住绝大多数回归问题。
def golden_test(): cases = [ ("add $t0, $s1, $s2", 0x02324020), # 手算 R 型样例 ("addiu $t0, $zero, 100", 0x24080064), # 手算 I 型样例 ("beq $t0, $t1, label\nlabel:", 0x11090001), # 分支偏移为1 ] for asm_text, expect in cases: got = assemble(asm_text) assert got[0][1] == expect, \ "%s => %08x, expect %08x" % (asm_text, got[0][1], expect)第二层是参照汇编器差分测试。找一款课程里常用的 MIPS 教学模拟器，把同一份汇编代码放进去汇编，导出机器码；自己的汇编器输出同一份，按行 diff。这一层可以一口气覆盖几十条指令，包括伪指令展开后的编码。第三层是随机差分测试，写脚本生成合法指令序列，喂给两个汇编器逐条对比。这个测试的价值在于覆盖手写样例没考虑到的边界，比如立即数取 -32768、32767，标签紧贴分支指令的上下边界。随机生成指令时要用预定义模板，而不是完全随机拼 token，否则生成的文本多半语法非法，测不到编码逻辑。
分支偏移连续翻车是我做这个项目时最深的教训，后来养成一个习惯：每改完编码逻辑，先跑黄金样例，再跑随机差分，最后才动新功能。汇编器是那种“错一个位就全错”的项目，靠人工排查十六进制效率极低，把验证自动化才是真正省时间的做法。上面的三层测试架子搭好以后，我后面加指令就再没慌过。希望帮到你。
本文还有配套的精品资源，点击获取
