简介：这份资源面向学习计算机组成原理、嵌入式开发及MIPS指令集的学生与开发者，聚焦汇编语言与机器码之间的双向转换。包内提供可运行的汇编/反汇编工具及其Java源码，能帮助读者把「add $t1,$t2,$t3」这类助记符指令翻译成32位机器码，也能将已有二进制反汇编回汇编语句，便于理解指令字段、寄存器分配与控制流标签的处理方式。资源共5个文件，以jar应用程序、java源代码、png界面或示例截图和txt使用说明为主，压缩包约81KB，体积轻巧便于本地运行与二次修改。目前已有351人学习下载。借助源码与说明，读者可对照工具输出验证指令编码，在调试、作业或课程实验中快速完成汇编与机器码的互查，加深对MIPS底层执行机制的理解。
1. MIPS 汇编与机器码互转：从 Asm.zip 这个标题能拆出什么
手头拿到一个叫Asm.zip的包，标题写着「MIPS转机器码 / mips反汇编 / mips汇编器 / 机器码转汇编 / 汇编转机器码」，第一反应往往是：这不就是个汇编器加反汇编器吗？但真正做过 MIPS 底层工具链的人知道，这五个词其实对应了三条完全不同的技术路径——汇编器（汇编转机器码）、反汇编器（机器码转汇编）、以及两者之间的编码表映射。MIPS 和 x86 最大的区别在于指令定长 32 位、寄存器编号固定、立即数字段位置规整，这让手工实现一个最小可用的汇编/反汇编器成为可能，而不需要像 x86 那样依赖庞大的指令表数据库。
这篇文章面向的是需要自己动手做 MIPS 指令编解码的工程师：可能是在做嵌入式固件分析、CTF 逆向题、模拟器开发，或者单纯想搞懂一条addiu $t0, $t1, 0x10到底怎么变成0x25280010这四个字节。我会从 MIPS 指令格式讲起，然后给出汇编器和反汇编器的最小实现，最后把实际编码中最容易翻车的地方一条条列出来。读完你应该能自己写出一个覆盖 MIPS32 常用指令的子集工具，并且知道哪些指令格式是坑。
2. MIPS32 指令编码格式：三条路径共用的底层账本
2.1 三种指令格式与字段分布
MIPS32 的所有指令都是 32 位定长，按操作数类型分为三种格式：R 型（寄存器型）、I 型（立即数型）、J 型（跳转型）。理解这三张字段表，是后面写汇编器和反汇编器的前提，因为编码和解码本质上就是按位段读写。
R 型格式的字段分布是：opcode（6 位，恒为 0）、rs（5 位）、rt（5 位）、rd（5 位）、shamt（5 位）、funct（6 位）。R 型指令靠 funct 字段区分具体操作，比如add的 funct 是 0x20，sub是 0x22，jr是 0x08。
I 型格式是：opcode（6 位）、rs（5 位）、rt（5 位）、immediate（16 位）。addi、lw、sw、beq、bne都是 I 型，靠 opcode 区分。
J 型格式最简单：opcode（6 位）、target（26 位）。只有j和jal两条指令用这种格式。
| 格式 | opcode | rs | rt | rd | shamt | funct | immediate/target |
|---|---|---|---|---|---|---|---|
| R 型 | 6 bit | 5 bit | 5 bit | 5 bit | 5 bit | 6 bit | — |
| I 型 | 6 bit | 5 bit | 5 bit | — | — | — | 16 bit |
| J 型 | 6 bit | — | — | — | — | — | 26 bit |
寄存器编号是固定的：$zero=0，$at=1，$v0-$v1=2-3，$a0-$a3=4-7，$t0-$t7=8-15，$s0-$s7=16-23，$t8-$t9=24-25，$k0-$k1=26-27，$gp=28，$sp=29，$fp=30，$ra=31。写汇编器时这张表就是字符串到整数的映射，写反汇编器时反过来用。
2.2 为什么 MIPS 适合手工实现编解码
x86 指令长度从 1 字节到 15 字节不等，还有前缀、ModRM、SIB 等复杂结构，手工写编解码器几乎不现实。MIPS 的定长 32 位设计让每条指令的解析变成纯粹的位运算：取高 6 位看 opcode，如果是 0 就继续看低 6 位 funct，否则按 I 型或 J 型解析。整个解码逻辑用几十行代码就能覆盖 MIPS32 的常用子集。
这也是为什么很多教学模拟器（比如 SPIM、MARS）和嵌入式 Bootloader 里的简易汇编器都选择 MIPS 作为目标架构。你不需要维护一张几千条的指令表，只需要把 opcode 和 funct 的映射关系写清楚就行。
2.3 编码表：opcode 与 funct 的映射关系
下面这张表覆盖了 MIPS32 最常用的指令，写汇编器和反汇编器时直接拿来做字典：
| 指令 | 格式 | opcode | funct | 说明 |
|---|---|---|---|---|
| add | R | 0x00 | 0x20 | 寄存器加法 |
| addu | R | 0x00 | 0x21 | 无符号加法 |
| sub | R | 0x00 | 0x22 | 寄存器减法 |
| subu | R | 0x00 | 0x23 | 无符号减法 |
| and | R | 0x00 | 0x24 | 按位与 |
| or | R | 0x00 | 0x25 | 按位或 |
| xor | R | 0x00 | 0x26 | 按位异或 |
| slt | R | 0x00 | 0x2a | 小于则置 1 |
| jr | R | 0x00 | 0x08 | 跳转到寄存器 |
| sll | R | 0x00 | 0x00 | 逻辑左移 |
| srl | R | 0x00 | 0x02 | 逻辑右移 |
| addi | I | 0x08 | — | 立即数加法 |
| addiu | I | 0x09 | — | 无符号立即数加法 |
| andi | I | 0x0c | — | 立即数按位与 |
| ori | I | 0x0d | — | 立即数按位或 |
| lw | I | 0x23 | — | 加载字 |
| sw | I | 0x2b | — | 存储字 |
| beq | I | 0x04 | — | 相等则跳转 |
| bne | I | 0x05 | — | 不等则跳转 |
| j | J | 0x02 | — | 无条件跳转 |
| jal | J | 0x03 | — | 跳转并链接 |
这张表不需要背，写代码时直接定义成 Python 字典即可。关键是理解每个字段的位宽和位置，后面编码解码都围绕这个来。
3. 汇编转机器码：从文本到 32 位整数的完整实现
3.1 解析汇编行的最小流程
一条 MIPS 汇编语句的典型形式是addiu $t0, $t1, 0x10或lw $t0, 0($sp)。解析流程分四步：去掉注释和多余空白、提取助记符、按逗号拆分操作数、根据指令格式把操作数映射到对应字段。
我一般会先把寄存器名到编号的映射写成字典，然后把指令按格式分类。R 型指令需要 rs、rt、rd 三个寄存器操作数（移位指令例外，需要 rt、rd、shamt），I 型需要 rs、rt 和一个立即数，J 型只需要一个目标地址。
import re REG_MAP = { '$zero': 0, '$at': 1, '$v0': 2, '$v1': 3, '$a0': 4, '$a1': 5, '$a2': 6, '$a3': 7, '$t0': 8, '$t1': 9, '$t2': 10, '$t3': 11, '$t4': 12, '$t5': 13, '$t6': 14, '$t7': 15, '$s0': 16, '$s1': 17, '$s2': 18, '$s3': 19, '$s4': 20, '$s5': 21, '$s6': 22, '$s7': 23, '$t8': 24, '$t9': 25, '$k0': 26, '$k1': 27, '$gp': 28, '$sp': 29, '$fp': 30, '$ra': 31, } def parse_reg(token): token = token.strip() if token not in REG_MAP: raise ValueError(f"未知寄存器: {token}") return REG_MAP[token] def parse_imm(token): token = token.strip() if token.startswith('0x') or token.startswith('0X'): return int(token, 16) return int(token)这段代码做了两件事：寄存器名到编号的映射，以及立即数的解析（支持十六进制和十进制）。parse_reg里如果遇到未注册的寄存器名会直接抛异常，这是故意的——宁可报错也不要静默产生错误编码。
3.2 R 型指令编码：位运算拼接
R 型指令的编码公式是：(0 << 26) | (rs << 21) | (rt << 16) | (rd << 11) | (shamt << 6) | funct。opcode 恒为 0，所以高 6 位不用管。
R_FUNCT = { 'add': 0x20, 'addu': 0x21, 'sub': 0x22, 'subu': 0x23, 'and': 0x24, 'or': 0x25, 'xor': 0x26, 'slt': 0x2a, 'jr': 0x08, 'sll': 0x00, 'srl': 0x02, } def encode_r_type(mnemonic, operands): funct = R_FUNCT[mnemonic] if mnemonic in ('sll', 'srl'): # 移位指令: rd, rt, shamt rd = parse_reg(operands[0]) rt = parse_reg(operands[1]) shamt = parse_imm(operands[2]) rs = 0 elif mnemonic == 'jr': rs = parse_reg(operands[0]) rt = rd = shamt = 0 else: rd = parse_reg(operands[0]) rs = parse_reg(operands[1]) rt = parse_reg(operands[2]) shamt = 0 code = (0 << 26) | (rs << 21) | (rt << 16) | (rd << 11) | (shamt << 6) | funct return code & 0xFFFFFFFF这里的关键是移位指令和jr的操作数顺序跟普通 R 型不一样。sll $t0, $t1, 2的操作数是 rd、rt、shamt，而add $t0, $t1, $t2是 rd、rs、rt。如果搞混了，编码结果会完全错误但不会报错，这是最常见的翻车点之一。
3.3 I 型与 J 型指令编码
I 型指令的编码公式是：(opcode << 26) | (rs << 21) | (rt << 16) | (imm & 0xFFFF)。立即数需要做 16 位截断，负数用补码表示。
I_OPCODE = { 'addi': 0x08, 'addiu': 0x09, 'andi': 0x0c, 'ori': 0x0d, 'lw': 0x23, 'sw': 0x2b, 'beq': 0x04, 'bne': 0x05, } def encode_i_type(mnemonic, operands): opcode = I_OPCODE[mnemonic] if mnemonic in ('lw', 'sw'): # lw $t0, offset($base) rt = parse_reg(operands[0]) m = re.match(r'(-?\w+)\((\$\w+)\)', operands[1].strip()) if not m: raise ValueError(f"内存操作数格式错误: {operands[1]}") imm = parse_imm(m.group(1)) rs = parse_reg(m.group(2)) else: rt = parse_reg(operands[0]) rs = parse_reg(operands[1]) imm = parse_imm(operands[2]) code = (opcode << 26) | (rs << 21) | (rt << 16) | (imm & 0xFFFF) return code & 0xFFFFFFFF def encode_j_type(mnemonic, operands): opcode = 0x02 if mnemonic == 'j' else 0x03 target = parse_imm(operands[0]) # J 型目标地址是字地址，需要右移 2 位后取低 26 位 code = (opcode << 26) | ((target >> 2) & 0x03FFFFFF) return code & 0xFFFFFFFFI 型里lw和sw的操作数格式是offset($base)，需要用正则拆出偏移量和基址寄存器。J 型的目标地址处理有个容易忽略的点：MIPS 的 J 型指令存的是字地址（目标地址右移 2 位），不是字节地址。如果你直接把字节地址填进去，跳转目标会偏到四倍远的地方。
3.4 完整汇编流程与验证
把上面的函数串起来，加上一个主循环，就能处理一个简单的汇编文件：
def assemble_line(line): line = re.sub(r'#.*$', '', line).strip() if not line: return None parts = line.split(None, 1) mnemonic = parts[0].lower() operands = [o.strip() for o in parts[1].split(',')] if len(parts) > 1 else [] if mnemonic in R_FUNCT: return encode_r_type(mnemonic, operands) elif mnemonic in I_OPCODE: return encode_i_type(mnemonic, operands) elif mnemonic in ('j', 'jal'): return encode_j_type(mnemonic, operands) else: raise ValueError(f"不支持的指令: {mnemonic}") # 验证: addiu $t0, $t1, 0x10 应该得到 0x25280010 code = assemble_line("addiu $t0, $t1, 0x10") print(f"0x{code:08X}") # 输出 0x25280010验证方法是手工算一遍：addiu的 opcode 是 0x09，$t1编号 9，$t0编号 8，立即数 0x10。拼接结果(0x09 << 26) | (9 << 21) | (8 << 16) | 0x10=0x24000000 | 0x01200000 | 0x00080000 | 0x10=0x25280010。跟代码输出一致，说明编码逻辑正确。
提示：写完编码器后，至少手工验证 5 条不同类型的指令（R 型、I 型、J 型、移位、内存访问各一条），确认位段拼接没有错位。
4. 机器码转汇编：反汇编器的解码逻辑与输出格式
4.1 从 32 位整数提取字段
反汇编是编码的逆过程：拿到一个 32 位整数，先取高 6 位看 opcode。如果 opcode 是 0，说明是 R 型，继续取低 6 位看 funct；如果 opcode 是 2 或 3，是 J 型；否则按 I 型处理。
def decode_instruction(code): code = code & 0xFFFFFFFF opcode = (code >> 26) & 0x3F rs = (code >> 21) & 0x1F rt = (code >> 16) & 0x1F rd = (code >> 11) & 0x1F shamt = (code >> 6) & 0x1F funct = code & 0x3F imm = code & 0xFFFF # 立即数符号扩展 if imm & 0x8000: imm_signed = imm - 0x10000 else: imm_signed = imm return opcode, rs, rt, rd, shamt, funct, imm_signed符号扩展是反汇编里必须处理的细节。16 位立即数如果最高位是 1，表示负数，需要扩展到 32 位有符号数。比如0xFFF0应该被解释为 -16 而不是 65520。如果忘了这一步，反汇编出来的addi指令立即数会全部变成大正数。
4.2 反向查表与格式化输出
有了字段值之后，需要反向查表得到助记符。R 型用 funct 查，I 型和 J 型用 opcode 查。然后把寄存器编号转回名称，按对应格式拼成汇编字符串。
REG_NAMES = {v: k for k, v in REG_MAP.items()} FUNCT_R = {v: k for k, v in R_FUNCT.items()} OPCODE_I = {v: k for k, v in I_OPCODE.items()} def disassemble(code): opcode, rs, rt, rd, shamt, funct, imm = decode_instruction(code) if opcode == 0: if funct not in FUNCT_R: return f".word 0x{code:08X} # 未知 R 型 funct=0x{funct:02X}" name = FUNCT_R[funct] if name in ('sll', 'srl'): return f"{name} {REG_NAMES[rd]}, {REG_NAMES[rt]}, {shamt}" elif name == 'jr': return f"jr {REG_NAMES[rs]}" else: return f"{name} {REG_NAMES[rd]}, {REG_NAMES[rs]}, {REG_NAMES[rt]}" elif opcode in (0x02, 0x03): name = 'j' if opcode == 0x02 else 'jal' target = (code & 0x03FFFFFF) << 2 return f"{name} 0x{target:08X}" elif opcode in OPCODE_I: name = OPCODE_I[opcode] if name in ('lw', 'sw'): return f"{name} {REG_NAMES[rt]}, {imm}({REG_NAMES[rs]})" else: return f"{name} {REG_NAMES[rt]}, {REG_NAMES[rs]}, {imm}" else: return f".word 0x{code:08X} # 未知 opcode=0x{opcode:02X}"对于无法识别的指令，输出.word伪指令加上原始十六进制值和注释，这样反汇编结果仍然可以被重新汇编回去，不会丢失信息。这是做固件分析时的一个实用习惯——反汇编器不需要理解所有指令，但必须保证输出是完整的。
4.3 批量反汇编与地址标注
实际使用中通常是对一段二进制数据做批量反汇编，并且需要标注每条指令的地址。地址从基址开始，每条指令加 4。
def disassemble_block(data, base_addr=0x00400000): lines = [] for i in range(0, len(data), 4): if i + 4 > len(data): break word = int.from_bytes(data[i:i+4], byteorder='big') addr = base_addr + i asm = disassemble(word) lines.append(f"{addr:08X}: {word:08X} {asm}") return '\n'.join(lines)MIPS 默认是大端序（big-endian），但有些嵌入式设备用 little-endian。如果反汇编出来的指令全是未知 opcode，第一件事就是检查字节序。把byteorder='big'改成'little'试试，很多时候问题就出在这里。
注意：反汇编器不需要覆盖全部 MIPS 指令集。先支持常用子集，遇到未知指令输出
.word保留原始数据，比强行解码成错误指令要安全得多。
5. 避坑与排查：MIPS 编解码中最容易翻车的五个地方
5.1 现象：反汇编结果全是未知 opcode
原因：字节序搞反了。MIPS 架构同时存在大端和小端实现，Asm.zip这类工具如果没有明确标注字节序，很容易在解析时用错。大端下0x25280010的字节序列是25 28 00 10，小端下是10 00 28 25，用错字节序读出来的 opcode 完全不对。
解决：先确认目标平台的字节序。嵌入式设备看芯片手册，CTF 题目看题目描述，实在不确定就两种都试一遍，看哪种能解出合理指令。代码里把字节序做成参数，不要硬编码。
5.2 现象：addi的立即数变成大正数
原因：忘了做符号扩展。16 位立即数0xFFF0在无符号解释下是 65520，但有符号解释下是 -16。MIPS 的addi、addiu（虽然叫无符号但立即数仍然符号扩展）、beq偏移量、lw/sw偏移量都需要符号扩展。
解决：解码时检查 bit 15，如果为 1 就减去 0x10000。编码时用imm & 0xFFFF截断，Python 的负数按位与会自动得到正确的补码表示。
5.3 现象：J 型指令跳转目标偏了四倍
原因：J 型指令的 26 位 target 字段存的是字地址（目标地址右移 2 位），不是字节地址。编码时如果直接把字节地址填进去，解码出来的目标地址会变成原来的四倍。
解决：编码时(target >> 2) & 0x03FFFFFF，解码时(code & 0x03FFFFFF) << 2。另外注意 J 型跳转的目标地址高 4 位来自当前 PC，不是完整 32 位地址，做完整模拟时需要拼接 PC 高位。
5.4 现象：lw/sw的偏移量解析失败
原因：内存操作数的格式是offset($base)，但实际汇编代码里可能有空格、可能有负偏移、可能偏移是十六进制。简单的split处理不了这些情况。
解决：用正则(-?\w+)\((\$\w+)\)提取偏移量和基址寄存器，提取后分别调用parse_imm和parse_reg。如果正则匹配失败，直接报错并打印原始操作数，不要静默跳过。
5.5 现象：移位指令编码结果跟预期不符
原因：sll、srl、sra的操作数顺序是rd, rt, shamt，而普通 R 型是rd, rs, rt。如果按普通 R 型处理，会把 rt 当成 rs、shamt 当成 rt，编码结果完全错误。
解决：在编码函数里对移位指令单独分支处理，rs 字段填 0，shamt 从第三个操作数取。反汇编时同理，移位指令的输出格式是sll $rd, $rt, shamt，不要套用三寄存器格式。
6. 进阶技巧：用差分测试验证编解码器的一致性
写完汇编器和反汇编器之后，怎么确认它们是对的？手工验证几条指令只能覆盖个别情况，真正可靠的方法是做差分测试：随机生成一批合法指令，编码后再解码，看是否能还原成原始汇编文本。
import random def random_r_type(): name = random.choice(list(R_FUNCT.keys())) if name in ('sll', 'srl'): rd = random.randint(0, 31) rt = random.randint(0, 31) shamt = random.randint(0, 31) return f"{name} {REG_NAMES[rd]}, {REG_NAMES[rt]}, {shamt}" elif name == 'jr': rs = random.randint(0, 31) return f"jr {REG_NAMES[rs]}" else: rd, rs, rt = [random.randint(0, 31) for _ in range(3)] return f"{name} {REG_NAMES[rd]}, {REG_NAMES[rs]}, {REG_NAMES[rt]}" def roundtrip_test(n=1000): fails = [] for _ in range(n): asm = random_r_type() code = assemble_line(asm) decoded = disassemble(code) if decoded != asm: fails.append((asm, f"0x{code:08X}", decoded)) return fails fails = roundtrip_test() print(f"失败数: {len(fails)}") for f in fails[:5]: print(f" 原始: {f[0]} 编码: {f[1]} 解码: {f[2]}")这个测试的逻辑是：如果编码和解码的位段处理完全对称，那么任意合法指令经过一轮编解码后应该还原成原始文本。如果出现不一致，说明某个字段的位偏移或符号处理有问题。我一般会跑 1000 条随机指令，失败率应该是 0。如果有失败，打印出来的三元组能直接定位到是哪条指令、哪个字段出了问题。
对于 I 型指令，测试时要注意立即数范围限制在 -32768 到 32767 之间，超出范围会被截断导致 roundtrip 失败——这不是 bug，是 16 位字段的物理限制。J 型指令的目标地址需要 4 字节对齐，随机生成时先随机一个地址再& ~3对齐。
这套差分测试方法不只适用于 MIPS，任何定长指令集的编解码器都可以用。核心思路就是：编码和解码互为逆运算，随机采样加自动比对，比手工写测试用例覆盖率高得多。我自己的习惯是每次改了编码逻辑就跑一遍 roundtrip，确认没有回归再继续。希望帮到你。
本文还有配套的精品资源，点击获取
