企业官网建设流程全解析

每年到了这个季节，总有一批计算机专业的学生被同一个大作业折磨得睡不着觉：单周期MIPS CPU的设计。我当年做这个课设的时候也是从一头雾水开始，拿着教材翻来翻去，脑子里全是“取指、译码、执行、访存、写回”这些词，但就是不知道该怎么把它们变成一张能通电、能跑程序的电路图。这篇文章围绕单周期MIPS CPU设计这个核心题目，把从指令集拆分、数据通路搭建、控制信号生成到最终调试通过的全过程详细展开，既讲原理也讲实操，适合计算机组成原理的课设学生、想补硬件基础的软件方向同学，以及对CPU内部工作机制好奇的任何人。因为单周期架构是所有CPU设计里最直观、最接近教材的一种，把它吃透了，后面再去理解流水线、多周期、乱序执行都会轻松不少。

1. 为什么要学习设计单周期MIPS CPU：这门课设的真正价值

很多人第一反应是：都什么年代了，还有人在学MIPS？现在主流不是x86就是ARM，RISC-V也在崛起，MIPS早就过时了。这个问题我当年也问过。但做完整个设计之后我的看法完全变了——MIPS存在的意义从来就不是“让你以后用MIPS写代码”，而是“用最简单的指令集让你看清CPU的本质”。

1.1 MIPS指令集为什么适合做教学：越简单越能看清本质

MIPS的设计哲学是“精简”，每条指令长度固定为32位，指令格式规整，寻址方式少，指令数量也不多。对比一下x86那种变长指令、复杂寻址的架构，MIPS简直是一张白纸。固定长度指令带来一个巨大的好处：取指阶段根本不需要“判断这条指令有多长”，每次直接读4个字节就行，这让取指路径变得极其简单。

我举一个具体对比。x86里你看到一串二进制，不解析前缀、操作码、ModRM、SIB、位移和立即数根本不知道这条指令占几个字节。而MIPS里只要看opcode高6位就知道是哪一类指令，再看rs、rt、rd、funct这些字段，每条指令的语义就清楚了。这种规整性对硬件实现是致命的友好——控制单元的输入信号可以直接从指令的固定字段切出来，不需要复杂的状态判断。

如果你是一个从来没看过CPU内部结构的人，我建议你从MIPS入手，因为你能用最短的时间把一条指令从“内存里的二进制”变成“CPU内部各个部件的动作”。这种从软件层到硬件层的穿透感，是学x86很难获得的。

1.2 硬布线与微程序：单周期通常选硬布线的原因

MIPS CPU的实现路线主要有两条：硬布线（hardwired）控制和微程序（microprogrammed）控制。单周期CPU基本都会选硬布线。原因是：单周期CPU里每条指令的执行只需要一次译码、一组控制信号，控制逻辑是组合逻辑直接生成，不需要像微程序那样把控制信号存到ROM里一条一条读出来。

当时我的课程设计要求“硬布线”，用Logisim搭建电路。硬布线的本质是用逻辑门电路把指令opcode和funct字段翻译成一组控制信号。你可以把它理解成一个“真值表转电路”的过程——输入是指令的某些位，输出是RegDst、ALUSrc、MemWrite等控制信号。这个过程看着简单，但真正画电路的时候，一堆与门或门的组合会把你的图纸塞得密密麻麻，这也是后面调试时最容易出问题的地方。

微程序路线就相对“软”一些，把控制信号的序列提前存好，CPU按状态机的节奏一条条读出来。逻辑上更灵活，但多了一层ROM访问的时序开销，在单周期这种“一拍走完”的架构里显得绕了一圈。所以如果你做的是单周期，基本锁定硬布线；如果做的是多周期CPU，那微程序控制会更自然一些。

1.3 课程设计里最容易被低估的工作量

说句实话，很多人以为做单周期CPU最难的是设计，其实最花时间的是调试。写一个单周期CPU，设计阶段可能只需要三到五天，但调试阶段卡上一个星期都是常态。原因很简单：你面对的是一个组合逻辑+时序逻辑混合的系统，任何一个控制信号错了，表现出来的现象可能都差不多——程序跑出来的结果不对，或者根本一跳不出循环。

我当年调一个beq分支指令跳不过去的问题，查了两天才发现是RegWrite信号没连到寄存器堆的使能端，导致目标寄存器根本没写进去，后续所有比较都是基于旧数据做的。这种问题你用仿真波形看半天都不一定看得见，因为信号“看起来”都连上了，但实际上某个使能端悬空了。所以我建议做这个课设时，把所有关键控制信号的默认值提前想好，后面能省下大把时间。

2. 核心架构思路：数据通路与控制器如何分工

单周期MIPS CPU的框架，可以用一句话概括：一个数据通路，一个控制器。数据通路负责数据的搬运和计算，控制器负责决定“数据走哪条路”。两条部分各管各的，最终在控制信号上汇合。理解好这个分工，整个设计就成功了一半。

2.1 什么叫做“单周期”：一条指令在一个时钟周期内完成全流程

“单周期”这个名字很容易让人误解，以为CPU一个时钟周期就运行一条指令。实际上一条指令要经历取指、译码、执行、访存、写回这些阶段，单周期架构的意思是所有阶段在一个时钟周期内全部完成，而且整个周期里CPU只能执行这一条指令，下一条必须等下一个时钟上升沿到来才能开始。

你可以把单周期CPU的运行想象成一顿饭的全部流程必须在一分钟内做完：洗菜、切菜、下锅、上桌，全都在这60秒内干完，下一道菜必须等这60秒结束才能开始做。好处是控制逻辑简单粗暴，每个部件都在同一拍内动作；坏处是时钟周期必须拉到“最长那条指令”的长度——比如load指令又要访存又要写回寄存器，时序最长，那所有指令都按这个最长的时间算，导致CPU主频上不去。这也是为什么现实中几乎没人用单周期架构做量产CPU，它更适合教学。

但正是这种“慢”带来了绝大多数人需要的清晰：每一步的先后顺序清晰，信号的建立时间和保持时间好理解，调试的时候拿着示波器或者仿真波形一条指令一条指令对，非常直观。

2.2 从取指到写回：一条指令完整走过的物理路径

以一条加法指令add $t0, $t1, $t2为例，看看指令在单周期CPU里怎样变成物理动作：

1. PC把当前指令地址送到指令存储器，取出32位指令。
2. 指令里opcode和funct字段送进控制单元，控制单元生成RegDst、ALUSrc、ALUOp等信号。
3. 指令的rs、rt字段作为寄存器堆的读地址，读出两个操作数$t1和$t2。
4. ALU根据ALUOp执行加法运算。
5. 运算结果走回寄存器堆的写数据端口，按rd字段写进$t0。

这五步全部在一个时钟周期内完成。注意最后写寄存器的动作发生在时钟上升沿，其他动作都是组合逻辑，在时钟沿到来前数据就已经稳定在寄存器堆的写端口上了。

这里有个关键点：寄存器的写入只能是边沿触发。单周期CPU的所有写操作（寄存器堆写入、存储器写入、PC更新）都发生在时钟沿，而读写地址、读数据等组合逻辑在整个周期内都是“电平敏感”的。这两类信号必须严格匹配，否则就会出现“数据还没稳定就写进去了”或者“数据稳定之后错过了时钟沿”的bug。

2.3 数据通路草图怎么画：从骨架到血肉的顺序

画数据通路图是设计CPU的第一步，也是很多人不会下手的地方。我的个人经验是：先画主骨架，再往上面挂分支和额外部件，不要一上来就想画完整的控制信号线。

骨架是这样一步步生长出来的：

1. 先画程序计数器PC，右边连着指令存储器，PC的输入来自一个多路选择器，选择的是下一条指令地址。
2. 指令存储器出来之后，把指令的关键字段标出来：opcode、rs、rt、rd、shamt、funct、immediate。
3. 然后把寄存器堆画出来，rs和rt接读地址，rt和rd经过RegDst选择器接写地址。
4. 寄存器堆的输出接ALU的输入A，ALU的输入B来自寄存器堆的rt输出或者立即数扩展之后的结果（由ALUSrc选择）。
5. ALU输出再接数据存储器的地址，数据存储器的写数据来自寄存器堆的rt输出，读数据最终又和ALU输出经过MemToReg选择器回到寄存器堆的写数据端口。
6. 最后画控制单元，把指令的opcode和funct引进去，把各条控制信号引出来分配到对应的多路选择器和使能端上。

这样一张图下来，整个数据通路就清楚了。画图的时候我强烈建议把你画的所有多路选择器和控制信号的名称规范命名，后面在Logisim或者Verilog里写的时候能直接对应上，不用来回查。

3. 组成部件逐个拆解：寄存器堆、ALU、存储器、PC与控制单元

很多人的理解障碍出在“每个部件我都知道，但拼在一起就不知道谁该干什么”。所以这一章我把每个部件的内部结构、接口信号和设计要点拆开讲清楚，你再回头看整条数据通路就会顺畅很多。

3.1 寄存器堆（Register File）：两个读端口，一个写端口

MIPS有32个32位通用寄存器，寄存器堆就是一个多端口RAM。两个读端口让我们能在同一周期内读出rs和rt两个源操作数，一个写端口用来在时钟沿写入结果。这对应R型指令“两个来源一个目标”的典型结构。

寄存器堆的核心信号包括：

一个容易忽略的细节是：$zero寄存器永远是0。硬件上要么强制它的输出为0，要么禁止对它写入。我当时在Logisim里直接把它当成普通寄存器处理，结果手误用一条指令往$zero里写了个值，导致后面所有依赖0的运算全部出错。后来我在寄存器堆内部做了个判断：如果写地址是0，则忽略写入。这种实现虽然不够“教科书”，但在调试阶段很管用。

寄存器堆的写入是同步的，也就是必须在时钟上升沿且RegWrite=1时才把Write Data锁存进对应寄存器。如果做成电平触发，那整个周期内数据一变就会持续写入，逻辑直接崩掉。这一点在画电路和写代码时都要小心。

3.2 ALU：计算核心的功能表与实现

ALU（算术逻辑单元）是CPU的“计算器”，输入两个32位操作数，输出运算结果以及零标志（Zero）。MIPS单周期CPU的ALU至少需要以下功能：

这里我用的是三位ALUOp控制信号。实际设计里，ALUOp从控制单元出来后还会根据funct字段进一步译码。比如R型指令的funct字段不同，ALU要做的事就不同；而lw/sw这类指令只需要加法。 所以一般会有一个“ALU控制单元”模块，输入ALUOp（来自主控制单元）和funct字段（来自指令的低6位），输出最终的ALU control三位信号。

实现上，加减法用加法器配合二进制补码即可。减法就是“A + (~B) + 1”。SLT可以用减法判断：如果A-B结果为负数，则结果置1，否则置0。Logical和or都是按位操作，门电路一拉就出来了。如果你用Verilog写，一个always块加一个case语句就能实现。

3.3 指令存储器与数据存储器：分离还是合并

单周期MIPS的数据通路里有两个存储器：指令存储器和数据存储器。指令存储器只读，接口只有读地址和指令输出；数据存储器可读可写，但没有读使能也可以——因为只要地址稳定，读数据就有效，写则需要MemWrite信号和时钟沿配合。

这里必须强调：指令存储器和数据存储器是物理分离的。很多人初学的时候会问：“CPU不是只接一个内存条吗？”没错，真实系统里指令和数据共用主存，不会物理分离。但单周期教学CPU选择了分离设计，原因很简单：如果指令和数据混在一个存储器里，取指的读操作和load/store的读操作会冲突，同一个周期内一个地址用来取指令，另一个地址用来读写数据，单端口存储器根本忙不过来。双端口存储器虽然在真实系统中存在，但教学上分离设计更能简化问题。

你画存储器的时候还要注意字节序问题。MIPS指令固定4字节对齐，所以指令存储器的地址可以按字节标，也可以按字标。如果按字标，PC送到存储器的地址就不用右移两位；如果按字节标，PC的值需要右移两位才能索引到对应字。很多第一次做的人就栽在这个“PC要不要右移两位”上，不同的参考书画法还不一样，做之前一定弄清楚你的设计是哪种，不然取到的指令永远是对的但PC+4变成PC+16。

3.4 程序计数器PC：分支跳转怎么算地址

PC是整个CPU的“方向舵”，每个时钟周期它都要更新为下一条指令的地址。正常情况下是PC+4，因为每条指令占4字节。遇到分支指令beq，如果条件成立，目标地址是(PC+4) + (sign_extend(immediate) << 2)；遇到跳转指令j，目标地址是{(PC+4)[31:28], address, 2'b00}。

很多人的困惑都在“为什么分支偏移要左移两位”。因为MIPS的beq指令里立即数字段的位置是“相对于下一条指令的指令数偏移”，不是字节偏移。每条指令占4字节，所以一个单位的指令偏移等于4字节，也就是二进制里左移2位。举个例子，beq就从当前指令的下一条开始向前跳三条指令，那实际上跳了3×4=12个字节。

单周期CPU里PC更新的逻辑是组合电路：

• 默认情况：PC_next = PC + 4。
• beq且零标志为1：PC_next = (PC + 4) + (sign_extend(immediate) << 2)。
• j：PC_next = {(PC + 4)[31:28], instruction[25:0], 2'b00}。

实现方法是把PC+4做成加法器输出，同时单独做一个分支目标地址加法器，最后用多路选择器根据Branch和Zero信号挑一条路径。很多人为了省事会复用主ALU来做分支地址加法，这样在单周期里经常会引发资源冲突，因为ALU的数据通路已经被占用着做其他运算了。稳妥做法是单独加一个加法器，成本低但能少掉一半的时序问题。

3.5 控制单元：真值表驱动的决策中心

控制单元是单周期CPU里的“大脑”，输入opcode和funct，输出各条控制信号。下表是我当时设计的控制信号真值表，基本上覆盖了最常用的MIPS核心指令：

这里每个信号的含义我得解释一下，因为这是整个设计最容易糊涂的地方：

• RegDst：为1时写地址取rd字段，为0时取rt字段。R型用rd，lw用rt。
• ALUSrc：为1时ALU的B端输入来自立即数扩展，为0时来自寄存器堆的rt输出。
• MemToReg：为1时写回寄存器的数据来自数据存储器读取结果，为0时来自ALU结果。
• RegWrite：控制寄存器堆写入使能。
• Branch：为1时如果ALU零标志为1，则PC跳转到分支目标。
• Jump：为1时PC直接跳转到指令中地址字段指定的位置。
• ALUOp：两位信号，给ALU控制单元做进一步译码用。

大量的人看到这张表会觉得“这些值怎么记啊”。不需要记，你就盯着每条指令的功能去推：R型要写寄存器、要寄存器操作数、结果来自ALU；lw要从内存读数据写到寄存器；sw要从寄存器写内存；beq要比较、决定是否跳转。推理一遍之后，你会发现这张表自己就能填出来。

4. 控制信号的来龙去脉：指令译码与真值表构建

控制单元的设计，本质上就是构建一个从指令编码到控制信号的真值表，然后把真值表变成逻辑电路。这一章我详细讲一下每个信号怎么一步步推出来，而不是直接甩给你一张表去背。

4.1 指令字段定位：opcode、funct和各个段的含义

MIPS指令有R型、I型、J型三种格式，单周期CPU设计里主要用到前两种。R型指令布局：

• bit[31:26]：opcode，全为0表示R型
• bit[25:21]：rs，源寄存器1编号
• bit[20:16]：rt，源寄存器2编号
• bit[15:11]：rd，目标寄存器编号
• bit[10:6]：shamt，移位量
• bit[5:0]：funct，功能码

I型指令布局：

• bit[31:26]：opcode
• bit[25:21]：rs，源寄存器1编号
• bit[20:16]：rt，源寄存器2编号（在lw中作为目标寄存器）
• bit[15:0]：immediate，16位立即数

J型指令布局：

• bit[31:26]：opcode，为000010表示j
• bit[25:0]：address，26位目标地址

有了字段定义，我们才能分析每条指令“该干什么”。

4.2 逐条指令推演：add、lw、sw、beq的控制信号生成过程

我拿代表性的四条指令走一遍推演逻辑，你走一遍这个思路，剩下的指令基本都能自己推出来。

add是R型指令，opcode为0，funct为32。它的行为是先把寄存器堆的rs和rt地址对应的数据读出来，送进ALU做加法，结果写回rd寄存器。所以：

• RegDst必须为1，因为写地址用rd字段；
• ALUSrc必须为0，因为第二个操作数来自寄存器堆，不是立即数；
• MemToReg为0，因为写回的数据是ALU结果不是存储器读出的数据；
• RegWrite必须为1，否则结果写不进去；
• ALUOp要能告诉ALU控制单元“这是一个R型指令，具体干什么看funct”，所以ALUOp=10。

lw指令是I型，opcode为100011。它的行为是先算出内存地址（rs + 符号扩展的立即数），再从该地址读取32位数据，写进rt寄存器。所以：

• RegDst为0，因为写地址用rt，不是rd；
• ALUSrc为1，因为ALU的B端要接立即数扩展后的值；
• MemToReg为1，因为写回寄存器的数据来自数据存储器的读数据端口；
• RegWrite为1；
• ALUOp=00，让ALU做加法，算出地址。

sw指令opcode为101011。它的行为是把rt寄存器的数据写入内存地址（rs + 立即数）。所以：

• RegWrite为0，不写寄存器；
• ALUSrc为1，ALU的B端接立即数；
• MemWrite为1；
• MemRead为0，不读数据存储器；
• ALUOp=00，做加法算地址。

beq指令opcode为000100。行为是比较rs和rt，如果相等就跳转。所以：

• ALUSrc为0，第二个操作数来自寄存器堆rt；
• RegWrite为0，不写任何寄存器；
• Branch为1，是否跳转看ALU的Zero标志；
• ALUOp=01，告诉ALU控制单元做减法，用Zero判断是否相等；
• RegDst和MemToReg在这个指令里没有意义，可以置为任意值，我习惯置0避免悬空引脚。

这套“逐条指令推演”的办法，比我当年直接抄参考书高效得多。因为参考书只给你结果，不给你推理过程，一旦你的指令集和参考书不完全一致，抄了个寂寞。

4.3 用卡诺图化简控制信号：从真值表到逻辑门

有了真值表之后，最传统的方法是用卡诺图化简，得到每个控制信号的与或表达式，然后用逻辑门搭出来。在Logisim里你可以用PLA元件或者布尔逻辑模块直接加载真值表，也可以手动用与门或门实现。

比如RegWrite这个信号，在4条指令里只有add和lw时为1，其余为0。它的逻辑表达式可以写成：

RegWrite = (opcode == 0) | (opcode == 0b100011)

翻译成电路就是：判断opcode是否为0，再判断opcode是否为100011，两个结果做一个或门。实际设计时控制单元内部会有一组“译码器”，把opcode译成一条指令对应的独热码，再用独热码去组合成各个控制信号。这样比直接对opcode做逻辑判断要好理解得多，也方便你后期增加指令。

我当时用Logisim的常量值比较器来做opcode匹配，配合拆分器把指令每个字段引出来。电路确实比较占地方，但胜在直观，每根线的含义都非常清楚。如果你想挑战一下，可以用Verilog写一个case语句，一样的效果，代码量还少一截。

5. 从设计图到能跑通的实验台：Logisim实操与Verilog可选路线

设计图和理论分析都到位了，接下来就是真正动手搭电路。这一章我讲两种落地方式对比，以及Logisim里的分步实操流程。

5.1 工具选型：Logisim、Logisim Evolution 还是 Verilog

不同学校对课设的提交形式要求不一样，有的要求纯电路图，有的接受Verilog或VHDL，有的两者都行。我的经验是：

如果你能做到“会写Verilog但画不出电路图”，说明你其实没掌握硬件设计思维。反过来，如果你能画电路图但写不出代码，那你需要的是再往前跨半步的抽象能力。作为课设，我建议遵循学校要求，但私下里强烈建议两种方式都做一遍——先用Logisim搭一遍，再用Verilog复现一遍，你对CPU的理解会完全不一样。

5.2 Logisim实操步骤：按模块从无到有搭完整CPU

以Logisim（或Logisim Evolution）为例，我建议按下面的顺序搭建：

1. 新建文件，把时钟元件拖出来，放在画布边缘。设置时钟频率时先调低一点，比如2Hz，这样你肉眼能看到PC在跳。

2. 添加程序计数器PC。PC的输出接到一个常量加法器的输入端，加法器的另一个输入固定为4，输出是PC+4。PC+4再接回到多路选择器的一端，作为“默认下一条地址”。

3. 添加指令存储器。Logisim里有内置的ROM元件，双击配置初始化文件，里面用十六进制写入你的测试程序。把PC输出作为ROM的地址输入。

4. 添加寄存器堆。Logisim的RegFile元件自带两个读端口和一个写端口，设置好数据位宽（32位）和寄存器数量（32个）。把指令的rs、rt、rd字段分别接上去，RegWrite信号接写使能。

5. 添加ALU和控制单元。我这里用一种比较快捷的方法：Logisim自带ALU元件，支持多种运算用控制位选择。如果有现成元件就直接用，没有的话就自己用加法器、与门、或门搭一个简化版。

6. 连接数据存储器。数据存储器用RAM元件，地址输入接ALU结果，写数据接寄存器堆的Read Data 2，MemWrite接写使能。

7. 添加多路选择器：RegDst选rd还是rt，ALUSrc选rt数据还是立即数，MemToReg选ALU结果还是内存读数据。这三个多路选择器是最容易接错的地方，接完反复检查一遍。

8. 把指令低位16位经过“符号扩展”模块变32位。Logisim里用扩展器元件，注意选择“符号扩展”而不是零扩展，否则lw/sw的负偏移会算错地址。

9. 最后把控制单元的各个输出引到对应使能端和多路选择器的选择端。调完时序，接好时钟，把PC的时钟、寄存器堆的时钟、数据存储器的时钟连到同一个时钟源。

做完这些，按一次单步时钟，看看PC跳到哪了，寄存器值变成多少，RAM有没有写进去，通常一轮下来就能发现很多问题。

5.3 一段调试用汇编测试程序：怎么验证CPU是正确的

电路搭好之后，最重要的事就是“用指令序列验证正确性”。我当年用的一个非常经典的测试序列，覆盖了R型、lw、sw、beq、j这五类核心指令：

# 假设下面是内存里的机器码 # addi 采用I型指令，先用简易方式初始化寄存器 addi $t0, $zero, 5 # $t0 = 5 addi $t1, $zero, 7 # $t1 = 7 add $t2, $t0, $t1 # $t2 = 12 sw $t2, 0($zero) # 内存[0] = 12 lw $t3, 0($zero) # $t3 = 12 sub $t4, $t1, $t0 # $t4 = 2 beq $t2, $t3, L1 # 因为$t2==$t3，跳转到L1 add $t5, $zero, $zero # 不该执行 L1: addi $t6, $zero, 99 # 执行到这里 j L1 # 死循环，模拟结束

如果你用的MIPS指令集没有addi，可以先用R型指令把立即数通过寄存器构造出来。核心是观察每一条指令执行完之后各寄存器和内存的值。只要有一条对不上，就用单步时钟把PC、控制信号、寄存器值全部拉出来看。

这里的验证逻辑是“由简到繁”：先跑纯R型指令，确认加法器和寄存器堆没问题；再跑sw和lw，确认存储器通路没问题；再加分支，确认PC跳转逻辑没问题；最后加j，确认跳转指令和PC拼接算法没问题。分层验证能让你在出问题的时候快速定位到具体是哪一类指令、哪一个模块犯了错。

6. 单周期CPU调试的常见坑：实测排查链路与经验

这一章是我最想写给后来人看的。因为我发现大部分人做这个课设，真正崩溃的环节不是设计，而是“明明电路长得和书上一样，为什么它就是不对”。这里我把最常见的问题和我的排查链路整理成了一篇“踩坑记录”，希望能帮你少走至少三天弯路。

6.1 寄存器写入时机：为什么结果总是慢一拍或者根本写不进去

很多人会在仿真时发现：某条指令的ALU结果明明算出来了，但寄存器堆里的值没变，或者变成了一个奇怪的值。第一个要查的就是RegWrite信号和控制时钟。

寄存器堆的写入必须在时钟上升沿发生。如果在时钟上升沿到来的时刻，写地址和写数据还没有稳定下来，那么写入的就是一个“旧数据”或者“中间数据”。单周期CPU的逻辑是：所有组合逻辑（ALU计算、多路选择器选择、控制信号生成）在时钟沿到来之前已经稳定，然后时钟沿把结果锁存进寄存器。如果你把“时钟沿”放在组合逻辑还没稳定的时候就触发，就会出现上面说的“写不进”或“写错值”。

排查方法：用Logisim的仿真波形或单步时钟，盯着寄存器的写数据端口和写地址端口看，确认它们稳定之后再点时钟。如果写地址一直不对，检查RegDst选择器——很多人的RegDst多路选择器反了，导致原本该写rd的结果写进了rt。

6.2 控制信号悬空：最隐蔽的“逻辑炸弹”

Logisim里如果你没有给某根控制线接上默认值，它会处于浮动状态（红色或蓝色线）。这种问题在仿真截图里看不太出来，但实际运行时它可能被当作0，也可能被当作1，完全取决于Logisim的内部处理。所以一旦发现指令行为“看起来很有规律但就是不对”，第一件事就是检查所有悬空引脚。

我用过一个笨办法但非常有效：把控制单元的每一个输出信号都用探针（Probe）或者LED指示灯接出来，逐步执行每条指令，现场比对控制信号真值表。比如执行lw时，RegWrite应该为1，MemToReg应该为1，如果LED灯显示RegWrite为0，那就去查控制单元的译码逻辑，而不是去查寄存器堆。

6.3 beq分支跳不出去：Zero标志的“时间差”问题

beq指令需要ALU的Zero信号来判断是否分支。在单周期CPU里，Zero信号来自当前指令的ALU运算结果。这里有一个隐蔽的问题：如果ALU一直在跑，Zero信号其实也是“实时变化”的。其他指令在执行的时候，ALU输出的Zero可能是0也可能是1，这本来无所谓，因为Branch信号为0时PC不会理会Zero。

但如果你把Branch信号和Zero信号直接相与之后接入PC多路选择器，就必须保证“这个Zero是当前这条beq指令的Zero，不是上一条指令的残留”。在单周期里，由于整条指令在一个周期内完成，这个问题其实不太容易出现，前提是你的控制信号没有出现毛刺。一旦你看到beq该跳的时候不跳，不该跳的时候乱跳，优先用示波器或者仿真器检查Branch信号有没有毛刺，控制单元的输出有没有竞争冒险。

我当时遇到的问题更蠢：把Zero信号接到了ALU的进位输出而不是结果为零的标志。结果beq永远判断失败，我还一直以为是跳转地址算错了，查了整整一下午才反应过来。

6.4 load-use冲突：单周期的“伪冲突”与真实时序问题

load-use冲突在流水线CPU里是个大问题，但单周期CPU里不存在流水线，所以理论上是没有“load之后马上使用该数据”的冲突的。因为整条lw指令在一个周期内完成，数据在同一个周期结束的时钟沿就已经写回寄存器，下一条指令读取的时候自然读得到。

但单周期里有一个“伪冲突”：数据存储器的读数据信号，在MemToReg多路选择器切换的时候如果出现毛刺，可能把一个不稳定的值写进寄存器。解决方法是保证时钟沿只在所有信号稳定之后到来。如果你的时钟上升沿来得太早，比如前面组合逻辑传播延迟较长，那lw的数据可能还没从RAM里读出来，时钟沿就到了，结果写进去的是乱码。

我当时调试的时候遇到过一个现象：单独跑lw指令结果正确，连着跑lw+add就错了。查了半天发现是Logisim里RAM元件的仿真延迟比我想象中大，导致MemToReg选择器已经在选择“存储器读数据”，但数据还没稳定。后来我把时钟频率调得更低，问题就消失了。如果你用的是FPGA或Verilog仿真，这个问题会表现为时序违规（timing violation），需要调整时钟约束。

6.5 符号扩展与零扩展：负立即数算错地址的根源

这是新手最高发的错误之一。lw/sw指令的16位立即数，补码范围是-32768到32767。计算地址的时候，必须把立即数符号扩展成32位再参与加法。如果你做成了零扩展，地址就会比预期大65536，数据自然读写到错误的位置。

Logisim里的扩展器有“Signed”和“Unsigned”两种模式，务必为lw/sw选择Signed。更恶心的是，不同版本的Logisim中“扩展器”元件默认值可能不一样，所以每次新建元件时都要习惯性地检查扩展模式。

怎么快速验证？用一条lw $t0, -4($zero)，如果地址算成了0xFFFFFFFC而非0x0000FFFC，说明符号扩展正确，反之就是零扩展。这一步验证只要花你一分钟，但能节省一小时。

6.6 PC多路选择器的优先级：j、beq、PC+4如何排序

单周期CPU的PC更新通常有很多个选择源：PC+4、分支目标地址、跳转目标地址。多路选择器不可能永远只有两个输入，所以你需要一个级联选择结构，比如先选出“PC+4或分支目标”，再用Jump信号决定最终选“刚才的结果”还是“跳转地址”。

这里有一个常见的逻辑错误：把Jump和Branch当成并列的两个选择端接到同一个多路选择器上，结果信号互相干扰，谁也控制不了。正确的优先级是：Jump优先级最高，其次是Branch，最后才是PC+4。也就是说：

• 如果Jump=1，PC无条件跳转；
• 否则如果Branch=1且Zero=1，PC跳转到分支目标；
• 否则PC=PC+4。

这个优先级必须用级联多路选择器实现，不能偷懒用一个多位选择器一把梭，否则遇到beq和j指令同时出现时，跳转行为会完全不可预测。

结语：调试完毕，回头再看这张电路图的体会

整个单周期MIPS CPU从设计到跑通，我前前后后花了大约十天。现在回头看，最有价值的收获并不是“我学会搭了一块电路”，而是我终于理解了程序是怎么在硬件上流动的——你写的每一行高级语言，最终都会变成某个控制信号、某条数据通路、某个时钟沿上一个确定的动作。后来我再学操作系统、编译器、体系结构，很多原来只能死记的概念都自动串起来了，因为底层那幅图已经刻在脑子里了。

如果你正在做这个课设，我的建议很朴素：先别急着抄代码或复刻网上现成的电路图，把每条指令从取指到写回走一遍流程，把控制信号真值表自己推一遍，再动手搭电路。这个过程可能多花两天时间，但能救你后面两周的调试时间。还有一个小技巧，所有控制信号都加个探针或LED，执行每条指令的时候盯着看，直到它和你推真值表时的预期完全一致，再做下一步。这种笨办法反而是做课设最快的捷径。