本文是为完全不了解CPU的朋友所写的入门级教程，对于较为精通的朋友，多数章节均为赘述，完整代码在下一篇博客中，请见谅哈

一、实现功能

实现了部分RV32I指令集中的部分指令类型，如下表

具体指令如下（不包括LB,LH,LBU,LHU,SB,SH指令）：

实现了单周期CPU和五级流水线。其中，五级流水线为顺序读取、顺序放回；跳转指令可以冲刷流水线；没有预测跳转功能；占用资源较多，微架构面积较大。

编程软件：Quartus Prime
编程语言：SystemVerilog
仿真软件：vivado 2018.3

二、认识CPU

1、什么是CPU？

CPU即中央处理器，是计算机系统的运算和控制中心，是信息处理、程序运行的最终执行单元。

常见的CPU有Intel公司的Core芯片，ARM公司的Cortex芯片，华为海思的麒麟芯片等等……

什么是芯片？通俗的来说，芯片就是封装起来的，可以实现一定功能的集成电路。例如，CPU能够实现运算与控制，GPU能够实现图像处理等。

如图，中央的封装即为一块芯片，这是用来将计算机的逻辑电平转换为硬件的逻辑电平，从而实现传递信息的一个芯片。由于这是十分常用的一个电路，于是将其封装为芯片。芯片右侧为一个下载电路，用来下载指令。若该功能也是一个常用功能，也可以将这些元件封装在芯片中。
CPU的数字电路结构实际十分简单，最主要的模块有PC（地址生成），ALU（运算），Register（寄存），Decode（译码），Control（控制信号生成）。CPU在工作时会与外部存储器Instr_mem（指令存储器）和Data_mem（数据存储器）交互，完成计算机生成的指令。下图为CPU的工作架构图。

2、CPU是怎么工作的？

#include<iostream>
using namespace std;

int func(int x)
{
    
	x = x + 1;
	return x;
}

int main()
{
    
	int a = 1;
	int b = func(a);
}

引上述C++代码为例，当运行代码指令下发时，计算机会生成相应指令实现代码功能。如int b = func(a)运行时，首先会执行跳转指令JAL，跳转到函数func存储的地址；再执行立即数加法指令ADDI，得到所要的结果；最后执行跳转指令JALR，回到原先地址的下一个地址，对b赋值。
实际的CPU可能会执行更复杂的指令，上述分析仅是便于读者更好理解，具体工作原理博主也不能给出准确说明。

3、如何设计CPU？

CPU是基于指令集架构设计的，旨在执行指令。为助于理解，我讲述一个假想的关于CPU起源的故事（流水账）：

在很久很久以前，一个工程师想让计算机完成一个加法运算，于是，他设计了一个加法器，将存储器中的两个数据相加，写到了一个新的存储单元。这个想法很轻易得到了实现，他并不满足；接着，他希望计算机完成一系列运算，为了使计算有序的进行，他设计了一个地址自动迭代的数字电路，每执行完一条运算后，计算机会自动读取下一个地址的运算指令并进行运算，这就是PC模块。根据不同的计算指令，他设计了加法器，减法器，与运算器，或运算器，异或运算器，乘法器等等，由于这些都是用于计算的数字电路，于是将这些统称为ALU模块。在实际操作时，工程师发现，不断地读写存储器，对元件的损伤很大，并且执行速度慢¹，而在计算过程中，真正要存储的只有最终结果，计算过程中的数字刚存储完就要被擦除，十分浪费。所以，工程师设计了寄存器组Register²，将计算过程中的结果暂时输入，解决了问题。读存储器指令与写存储器指令也相继而生。后来，指令越来越多，很多都是重复的一套运算指令，在高级编程语言中可以用函数、类等模块化解决，于是设计师设计了跳转指令，如此，一套繁复的指令只用写一次，需要时通过一条跳转指令跳到该位置即可。这些繁多的指令在执行时，不一定需要所有的模块，比如跳转指令就不需要ALU模块，更无需向存储器存储数据，那么很多的模块都在做无用功甚至存入会不该存储的数据，那么就需要一个Control模块，根据不同的指令，生成不同的控制信号来控制各个模块的工作状态。随着指令不断地增多，指令的架构也愈发清晰起来，指令每一个数位都有了对应的意义（下文会讲到），为了更方便电路的设计，工程师加入了一个译码器，将指令拆分成多节，每一节传输到对应模块执行。工程师的故事还有很长，但本文要达到的技术到此就结束了。

(1)眼见为实

如图为常见的两种指令集：MIPS指令集与RISC-V指令集

可以看出，两种指令集的架构有异同之处，整体相似，细节有差。如MIPS的op码（指令类型）在31~26位，而RISC-V的op码在6~0位。对不同指令各数位的功能，会在后文解析。

(2)深入了解

指令集分为CISC(复杂指令集)与RISC(精简指令集)。

CPU诞生早期，CISC因其可以用较少的指令完成更多的操作煊赫一时，但随着指令集发展，越来越多特殊指令加入到CISC指令集中。而运算中使用的80%指令，只占指令集中的20%，其余80%很少用到。但为了实现这些少用的特殊指令，又需要花费大量的研究时间、开销更大的硬件面积。而RISC只包含常用指令。对于特殊的操作，与CISC用一条特殊指令完成不同，RISC是通过多条常用指令配合完成的。

简单来讲，假如1就是CISC中一条跳转+加法+存储指令，那的确十分方便，因为RISC需要3条32位的指令来执行。但CISC要根据跳转+减法+存储、跳转+乘法+读取……一系列不同组合设计不同的指令。指令数位不统一、数位模块不分明使得设计译码器十分艰难，CISC失宠了。而RISC的数位统一，均为16位，32位或64位(电脑是32位还是64位处理器的说法就是意思)，而且每段数位有规定的功能，硬件设计就十分方便。但现在，我们用的电脑的CPU是基于x86指令集架构的，是一款CISC指令集。这是因为Intel公司在硬件中加入了硬件解码器，将指令微码化(CISC转RISC)。

4、CPU的现状与前景

本节内容为博主了解到的片面之词，尽量做到所说的是经考证核实的，但肯定不能讲该领域的整个情况介绍完全(我还是个没见过世面的孩子，呜呜~)

(1)被垄断的产业链

Intel公司与AMD公司先发制人，在CPU诞生之初逐步排挤掉竞争对手，在计算机领域(PC)垄断了整个市场。现如今所有个人计算机的CPU都以x86为指令集架构，构建了城宽池阔的软件生态环境。对于如今已经成熟的计算机体系，想要插足简直是痴人说梦。首先，x86架构归Intel和AMD所有，若想设计相关CPU必须由Intel或AMD授权，交付费用，受制于人是在所难免的。如果威胁到其的产业链，想必一切努力都将付诸东流。其次，如果要用自己设计指令集设计CPU，那么一没技术，二没用户，现在的PC软件十分完善，娱乐、办公等软件深入到所有人的生活当中，除非再大费周折设计几千几万个对应的软件，否则用户是不可能倒戈的。
在手持设备(Mobile)领域，ARM公司的ARM指令集架构击败了MIPS这位昔日风流，成为了当今属实的霸主。不仅在Mobile领域，在生活中任何地方，小到手环、智能电器，延至工业、电子产业，均被ARM架构渗透。其成功的原因在于ARM公司的经营形式与卓越的眼光，将ARM架构作为知识产权授权给无数个合作伙伴，其中有芯片制造公司和买芯片的不同领域的生产商。华为海思的麒麟芯片便是基于ARM架构的。而近年美国对我国的打压，很可能使ISA(指令集架构)成为扼住国企脖颈的拴绳。

(2)打满补丁的袋子

Intel公司虽然称霸着PC领域，并在高性能服务器领域叱咤风云，但由于该公司的指令集架构是复杂指令集架构，就像装货前没有计算好货物大小的袋子，起初在试探性装载的时候，尚可轻松纳入，但随着装入的货物越来越多，袋子被撑破，Intel只好不断地打上补丁修补，但小袋子终究是小袋子，终有一天会达到极限。
为了优化硬件，减小空间开销并提升性能，指令集中的指令会被修改，那么可能会导致软件不兼容，运行出错。Intel可不能冒着失去用户的风险，那么就必须额外设计，兼容以往软件。Intel公司凭着尖端的技术优化了所有芯片的面积，并设计出极高性能的处理器，使得如今仍稳居产业链顶层，但终究有一天，CPU的面积要再度缩小，Intel只能放下手中这块肉，另辟蹊径了。

(3)翻身仗是一次长征——艰难但有希望

RISC-V的出现开辟了一条新的道路，给了我们不被别人牵着鼻子走的机会。这个完全开源，任何公司、个人都能免费使用的指令集架构可以作为打翻身仗的第一记炮响。

①眼光

主流的电子产品领域已经被瓜分完，各界大佬稳稳当当地享用着属于自己的战利品。于其虎口夺食，不如看看盘子里还剩下什么。5G正大张旗鼓地步入我们的生活，曾处于理念中的应用将随之而生。自动驾驶、虚拟现实、机器人等市场将逐渐扩大，成为新一代的主流产业。我们要高瞻远瞩，锁定目标，在起跑阶段就要取得领先。我国君正公司正是有卓越的眼光，看到了可穿戴设备以及物联网领域等市场，才有了鲸吞美国豪威的实力。

②创新

个人认为，PC会不久的将来永久失去市场，被新兴技术取而代之。小说《三体》危机纪元末期中，科技水平达到可以让一切事物智能化的程度。任何表面都是一个电子屏幕，人们可以随时随地使用身边的设施，计算机、笔记本已经绝迹了。亦或是科幻电影中的3D全息投影技术，不需要触摸键盘携带屏幕，所需信息以三维形式呈现在眼前，操作更直观化。还有电影《头号玩家》里那个可以取代现实世界的虚拟世界，是极有可能实现的。上述三种技术都可以取代PC、Mobile，开辟一个新的天地。我们需要积极创新，发展新兴技术，为取得未来市场做准备。

③决心

如此大型、尖端的科研技术想要获得一定的成果，离不开国家的投资与调控，时代很难再蕴育出像埃隆·马斯克这样的人才了。想要研究CPU，研究芯片，一定要投入大量资金，创造良好的科研环境，才能吸引人才进行基础研究。同时，国家也要宏观调控，带动产业链的发展，发展出一套完备的体系。路漫漫其修远兮，如此任重道远的使命，是每一位专业人士的责任与义务。只要国家下定决心，付诸行动，我辈当全力以赴，帮助国家弯道超车。

三、单周期CPU

上文说了那么多高大上的话，现在要接接地气了。我连设计一个芯片都设计不出来，哪敢有那样的雄心壮志，哈哈。

下文我将分享自己做CPU的思路。文字的表现能力有限，编写的思路可能不会十分清晰。我的b站视频展示了编写CPU的流程，但是没有提前做好功课，表达能力欠佳，建议博客与视频共同食用(把视频声音关上)。
基于RISC-V架构CPU的设计
github源码

1、运算指令

我们不妨跟随那位工程师的脚步，先从最基础的运算指令做起。

	rs2	rs1	func3	rd	op	指令名称
0000000	rs2	rs1	000	rd	0110011	ADD
31~25	24~20	19~15	14~12	11~7	6~0	instruction

上述为一条整数变量加法指令，可通过如下代码理解：

int c = a + b;

rs1与rs2为int a和int b在寄存器数组中的索引，即a = register[rs1]，b = register[rs2]。
op为0110011，代表这是整数变量运算类型指令，func3为000，代表这是加减法运算，31~25位的0000000为待扩展的功能码，本文所使用的指令中只会用到30位。
rd为int c在寄存器数组中的索引，当完成加法运算后，要将数值存入该地址当中。

执行此指令需要经过如下步骤：

PC生成地址，Instr_mem输出对应的指令，Decode翻译分解指令，从Register读取两个运算数a和b，送入ALU进行运算，经Control判断，允许将结果c写回到Register

我在录制视频时使用过这张图片，不方便修改，请见谅

在PC端生成地址

module PC();
	always@(negedge clk or posedge rst) //时钟下降沿时生成新的地址(便于下文跳转指令执行)
			if(rst) next_addr <= 32'd0;
			else next_addr <= addr + 4;
	
	always@(posedge clk or posedge rst) //时钟上升沿指向新的地址
			if(rst) addr <= 32'd0;
			else addr <= next_addr;
endmodule 

取指

module Instr_mem();
	initial $readmemb("C:/Users/86136/Desktop/vivado/Quartus/cpu/cpu.txt",instr_mem); //初始化时将我们编写的指令写入存储器
	
	always@(addr)begin
		instr[7:0] <= instr_mem[addr+3];
		instr[15:8] <= instr_mem[addr+2];
		instr[23:16] <= instr_mem[addr+1];
		instr[31:24] <= instr_mem[addr];
	end
endmodule 

译码

module Decode();
	assign op = instr[6:0];
	assign rd = instr[11:7];
	assign func3 = instr[14:12];
	assign rs1 = instr[19:15];
	assign rs2 = instr[24:20];
	assign func = instr[30];
endmodule 

在存储器中读取数据

module Register();
	assign data1 = (rs1 != 0) ? register[rs1] : 0;
	assign data2 = (rs2 != 0) ? register[rs2] : 0;
endmodule 

执行

module ALU();
	always@(*)
		case(func3)
			3'b000:
			case(sub_en)
				1'b0: data_out <= data_in1 + data_in2;
			endcase
		endcase
endmodule 

产生控制信号，此代码需要wr_en(寄存器写使能)信号

module Control();
	assign wr_en = (op == 7'b0_110_011) ? 1'b1 : 1'b0;
endmodule 

写回

module Register();
	always@(negedge clk)
		if(wr_en) register[rd] <= wr_data;
endmodule 

这就是完成一条指令的流程，下表为该类型指令的其他指令：

	rs2	rs1	func3	rd	op	指令名称	功能
0100000	rs2	rs1	000	rd	0110011	SUB	c = a - b
0000000	rs2	rs1	001	rd	0110011	SLL	对操作数寄存器rs1中的整数值进行逻辑左移运算(低位补入0)，移位量为寄存器rs2中整数值的低5位，结果写回寄存器rd中
0000000	rs2	rs1	010	rd	0110011	SLT	将操作数寄存器rs1中的整数值与寄存器rs2中的整数值当作有符号数进行比较。如果rs1中的值小于rs2中的值，则结果为1，否则为0，结果写回寄存器rd中
0000000	rs2	rs1	011	rd	0110011	SLTU	将操作数寄存器rs1中的整数值与寄存器rs2中的整数值当作无符号数进行比较。如果rs1中的值小于rs2中的值，则结果为1，否则为0，结果写回寄存器rd中
0000000	rs2	rs1	100	rd	0110011	XOR	c = a ^ b
0000000	rs2	rs1	101	rd	0110011	SRL	对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入0)，移位量为寄存器rs2中整数值的低5位，结果写回寄存器rd中
0100000	rs2	rs1	101	rd	0110011	SRA	对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入符号位)，移位量为寄存器rs2中整数值的低5位，结果写回寄存器rd中
0000000	rs2	rs1	110	rd	0110011	OR	c = a
0000000	rs2	rs1	111	rd	0110011	AND	c = a & b

为完成这些指令，添加了如下代码：

ALU中增加了多种运算

module ALU();
	assign shamt = data_in2[4:0];
	
	always@(*)
		case(func3)
			3'b000: //ADD,SUB,ADDI
				case(sub_en)
					1'b0: data_out <= data_in1 + data_in2;
					1'b1: data_out <= data_in1 - data_in2;
				endcase
			3'b001: data_out <= data_in1 << shamt; //SLL,SLLI
			3'b010: //SLT,SLTI
				if(data_in1[31] > data_in2[31]) data_out <= 32'd1;
				else if(data_in1[31] == data_in2[31])begin
					if(data_in1[31] < data_in2) data_out <= 32'd1;
					else data_out <= 32'd0;
				end else data_out <= 32'd0;
			3'b011: //SLTU,SLTIU
				if(data_in1 < data_in2) data_out <= 32'd1;
				else data_out <= 32'd0;
			3'b100: data_out <= data_in1 ^ data_in2; //XOR,XORI
			3'b101: //SRL,SRA,SRLI,SRAI
				case(func)
					1'b0: data_out <= data_in1 >> shamt;
					1'b1: data_out <= {
    {
    31{
    data_in1[31]}},data_in1} >> shamt;
				endcase
			3'b110: data_out <= data_in1 | data_in2; //OR,ORI
			3'b111: data_out <= data_in1 & data_in2; //AND,ANDI
			default: data_out <= 32'd0;
		endcase
endmodule 

Control中增加了sub_en(减法使能)信号

module Control();
	assign wr_en = (op == 7'b0_110_011) ? 1'b1 : 1'b0;
	assign sub_en = ((op == 7'b0_110_011)&func) ? 1'b1 : 1'b0;
endmodule 

运算指令中还有另一个类型：操作数与立即数的运算

imm[11:0]	rs1	func3	rd	op	指令名称
imm[11:0]	rs1	000	rd	0010011	ADDI
31~20	19~15	14~12	11~7	6~0	instruction

通过下述指令可用来理解指令的作用

int c = a + 1;

立即数即直接可以用的数，不需要从寄存器读取。下图是指令流程图。
经分析，会发现一个矛盾。ALU中data_in2的来源有两处，一处为符号位扩展器Ext32输出的ext_imm，另一处为寄存器Register输出的data2。这里就需要加入一个数据选择器解决此矛盾。在操作数运算指令执行时，需要输入data2；在操作数与立即数运算指令执行时，需要输入ext_imm。因此，可以使用op作为判断的依据。op分别为0110011、0010011，只需取op[5]即可。

module data_in2_sel();
	assign data_in2 = sel ? data2 : ext_imm; //sel = op[5]
endmodule 

下表为该指令类型的其他指令

imm[11:0]	rs1	func3	rd	op	指令名称	功能
0000000|shamt	rs1	001	rd	0010011	SLLI	对操作数寄存器rs1中的整数值进行逻辑左移运算(低位补入0)，移位量为5位立即数shamt，结果写回寄存器rd中
imm[11:0]	rs1	010	rd	0010011	SLTI	将操作数寄存器rs1中的整数值与12位立即数(进行符号位扩展)当作有符号数进行比较。如果rs1中的值小于立即数的值，结果为1，否则为0，结果写回寄存器中
imm[11:0]	rs1	011	rd	0010011	SLTIU	将操作数寄存器rs1中的整数值与12位立即数(仍进行符号位扩展)当作无符号数进行比较。如果rs1中的值小于立即数的值，结果为1，否则为0，结果写回寄存器中
imm[11:0]	rs1	100	rd	0010011	XORI	c = a ^ imm
0000000|shamt	rs1	101	rd	0010011	SRLI	对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入0)，移位量为5位立即数shamt，结果写回寄存器rd中
0100000|shamt	rs1	101	rd	0010011	SRAI	对操作数寄存器rs1中的整数值进行逻辑右移运算(高位补入符号位)，移位量为5位立即数shamt，结果写回寄存器rd中
imm[11:0]	rs1	110	rd	0010011	ORI	c = a
imm[11:0]	rs1	111	rd	0010011	ANDI	c = a & imm

为完成这些指令，增添了如下代码：

译码时分解出立即数

module Decode();
	assign op = instr[6:0];
	assign rd = instr[11:7];
	assign func3 = instr[14:12];
	assign rs1 = instr[19:15];
	assign rs2 = instr[24:20];
	assign func = instr[30];
	assign imm =  (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20];
endmodule 

立即数符号位扩展

module Ext32();
	assign ext_imm = {
    {
    20{
    imm[11]}},imm};
endmodule 

控制端产生wr_en信号

module Control();
	assign wr_en = ((op == 7'b0_110_011)||(op == 7'b0_010_011)) ? 1'b1 : 1'b0;
endmodule 

2、读、写存储器指令

imm[11:0]	rs1	func3	rd	op	指令名称	指令功能
imm[11:0]	rs1	010	rd	0000011	LW	从存储器中读回一个32位数据，写回寄存器rd中，访问存储器的地址由操作数寄存器rs1中的值与12位的立即数(进行符号位扩展)相加所得
31~20	19~15	14~12	11~7	6~0	instruction

imm[11:5]	rs2	rs1	func3	imm[4:0]	op	指令名称	指令功能
imm[11:5]	rs2	rs1	010	imm[4:0]	0100011	SW	将操作数寄存器rs2中的32位数据，写回存储器中，访问存储器的地址由操作数寄存器rs1中的值与12位的立即数(进行符号位扩展)相加所得
31~25	24~20	19~15	14~12	11~7	6~0	instruction

在计算过程中，最开始的两个运算数是存储在Data_mem(数据存储器)当中的，需要用LW指令将其读取，写回到寄存器中；计算的最终结果需要SW指令从寄存器中读取，存放到存储器中。

下面是指令流程图。

与运算指令类型相比，访问存储器指令没有执行阶段，新增访问阶段。

数据存储器

module Data_mem();
	assign addr = ext_imm + data1;
	
	always@(lw_en)begin
		data_mem[7:0] <= data[addr];
		data_mem[15:8] <= data[addr+1];
		data_mem[23:16] <= data[addr+2];
		data_mem[31:24] <= data[addr+3];
	end
	
	always@(sw_en)begin
		data[addr+3] <= data2[7:0];
		data[addr+2] <= data2[15:8];
		data[addr+1] <= data2[23:16];
		data[addr] <= data2[31:24];
	end
endmodule 

经分析，发现一个矛盾。写回寄存器的数据来源有两处。一处为ALU运算后输出的data_out，另一处为存储器读取的data_mem。此处需要添加一个数据选择器。

module wr_data_sel();
	assign wr_data = sel1 ? data_out : data_mem; //sel1 = op[4]
endmodule 

为完成指令，对代码做了如下改动：

module Decode();
	assign op = instr[6:0];
	assign rd = instr[11:7];
	assign func3 = instr[14:12];
	assign rs1 = instr[19:15];
	assign rs2 = instr[24:20];
	assign func = instr[30];
	assign imm =  (~op[6]&~op[5]&op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+
				  (~op[6]&~op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*instr[31:20]+
	 			  (~op[6]&op[5]&~op[4]&~op[3]&~op[2]&op[1]&op[0])*{
    instr[31:25],instr[11:7]};
endmodule 

module Control();
	assign wr_en = ((op == 7'b0_110_011)||(op == 7'b0_010_011)||(op == 7'b0_000_011)) ? 1'b1 : 1'b0;
	assign sub_en = ((op == 7'b0_110_011)&func) ? 1'b1 : 1'b0;
	assign lw_en = (op == 7'b0_000_011) ? 1'b1 : 1'b0;
	assign sw_en = (op == 7'b0_100_011) ? 1'b1 : 1'b0;
endmodule 

3、跳转指令

以下是无条件跳转指令。

imm[20|10:1|11|19:12]	rd	op	指令名称	指令功能
imm[20|10:1|11|19:12]	rd	1101111	JAL	使用20位立即数(有符号数)作为偏移量，乘以2，然后与该指令的PC相加，生成得到最终的跳转目标地址。同时，将其下一条指令的PC(即当前指令PC+4)的值写入寄存器rd中
31~12	11~7	6~0	instruction

imm[11:0]	rs1	func3	rd	op	指令名称	指令功能
imm[11:0]	rs1	000	rd	1100111	JALR	使用12位立即数(有符号数)作为偏移量，与操作数寄存器rs1中的值相加，得到最终的跳转目标地址。同时，将其下一条指令的PC(即当前指令PC+4)的值写入寄存器rd中
31~20	19~15	14~12	11~7	6~0	instruction

以下是有条件指令。使用12位立即数(有符号数)作为偏移量，乘以2，然后与该指令的PC相加，生成得到最终的跳转目标地址。

imm[12|10:5]	rs2	rs1	func3	imm[4:1|11]	op	指令名称	指令功能
imm[12|10:5]	rs2	rs1	000	imm[4:1|11]	1100011	BEQ	只有操作数寄存器rs1中的数值与操作数寄存器rs2中的数值相等时，才会跳转
imm[12|10:5]	rs2	rs1	001	imm[4:1|11]	1100011	BNE	只有操作数寄存器rs1中的数值与操作数寄存器rs2中的数值不相等时，才会跳转
imm[12|10:5]	rs2	rs1	100	imm[4:1|11]	1100011	BLT	只有操作数寄存器rs1中的有符号数小于操作数寄存器rs2中的有符号数时，才会跳转
imm[12|10:5]	rs2	rs1	101	imm[4:1|11]	1100011	BGE	只有操作数寄存器rs1中的有符号数大于或等于操作数寄存器rs2中的有符号数时，才会跳转
imm[12|10:5]	rs2	rs1	110	imm[4:1|11]	1100011	BLTU	只有操作数寄存器rs1中的无符号数小于操作数寄存器rs2中的无符号数时，才会跳转
imm[12|10:5]	rs2	rs1	111	imm[4:1|11]	1100011	BGEU	只有操作数寄存器rs1中的无符号数大于或等于操作数寄存器rs2中的无符号数时，才会跳转
31~25	24~20	19~15	14~12	11~7	6~0	instruction

下面是无条件跳转指令的流程图。

这两条指令通常搭配使用，JAL指令从主函数跳至子函数，JALR指令从子函数跳回主函数。对CPU最大的改动就是PC模块，让下一条地址指向跳转地址。代码如下。

module PC();
	always@(negedge clk or posedge rst)
		if(rst) next_addr <= 32'd0;
		else if(jmp_en) next_addr <= addr + (offset << 1);
		else if(jmpr_en) next_addr <= offset;
		else next_addr <= addr + 4;
	
	always@(posedge clk or posedge rst)
		if(rst) addr <= 32'd0;
		else addr <= next_addr;
endmodule 

offset是数据选择器输出的偏移量，该数据选择器代码如下：

module offset_sel();
	always@(*)
		case(sel) //sel = op[3:2]
			2'b11: offset <= jmp;
			2'b01: offset <= ext_imm + data1;
			default: offset <= 31'd0;
		endcase
endmodule 

实现有条件跳转指令只需额外加一个判断模块，决定是否跳转，这里只列出一个判断，全部代码详见下一篇博客(放一个网页里面是不是不太方便看呀)。

module pass_jud();
	always@(*)
		case(func3)
			3'b000: 
				if(data1 == data2) pass <= 1'b1;
				else pass <= 1'b0;
			default: pass <= 1'b0;
		endcase
endmodule 

将判断信号pass传输都Control决定是否跳转

module Control();
	assign jmpb_en = ((op == 7'b1_100_011)&pass) ? 1'b1 : 1'b0;
endmodule 

为完成以上指令，又需要在Decode中分解出对应的立即数，在Control中产生相应的控制信号。并且，一些端口的数据来源又扩大了。比如wr_data_sel(写回寄存器选择器)增加了跳转指令要存储的下一条地址，offset_sel(偏移量选择器)增加了有条件跳转指令的偏移量。这些都需要对代码块进行微调。在混乱不知所措的时候，从头到尾将指令的执行过程大声读出来检查就好了。

四、五级流水线

我做的b站视频在该部分的编写过程个人认为可以看一下，展现方式会比文字清晰，关上声音，下面的文字更善于与您沟通

1、五级流水线与单周期的差别

为方便起见，下文均以指令1，指令2，指令3，指令4来讲述四条顺序且连续执行的指令。
单周期CPU是在一个周期内执行一条完整的指令，在时钟上升沿时取指，高电平期间译码、执行、访问，时钟下降沿时写回；而五级流水线一个周期只用完成一个阶段。完成的任务少，所需的电路模块就会少，执行的时间短，处理器就可以有更高的频率。五级流水线，顾名思义，就是把一系列指令传入一条流水线中，高效、紧凑地完成每一条指令。当指令1在执行时，指令2已经在译码了。假设单周期的时钟周期为10s，五级流水线的时钟周期为2s，则单周期完成两条指令需要20s，而五级流水线只需12s，指令更多，节省的时间可想而知。
但是，每一级都是独立存在的，要确保一条指令正确地执行，就要做好级与级之间的交互(倘若能避免一些交互，自然是极好的)。比如指令1为ADD指令，当指令1进行到写回周期时，需要将数据写回到存储器rd中，而此时Decode输出的rd为指令4的rd，这就产生了错误。因此，在指令1的译码周期，就需要将指令1的rd放入寄存器中，等到写回周期时取出使用。本代码使用寄存器、移位寄存器完成这类操作，微架构(硬件)面积大，占用资源多，是比较笨拙的流水线。

2、举个栗子

思路：时钟上升沿输入数据，时钟下降沿输出数据。

使用名为receive的寄存器取出输入数据

module receive #(parameter N = 32)(
	input clk,
	input [N-1:0]data,
	output reg [N-1:0]data_r
);

	always@(posedge clk) data_r <= data;

endmodule 

使用名为delay的寄存器存入输出数据

module delay #(parameter N = 32)(
	input clk,
	input [N-1:0]data,
	output reg [N-1:0]data_d
);

	always@(negedge clk) data_d <= data;

endmodule 

使用名为shift的移位寄存器取出搁置多个周期的输入数据

module shift #(parameter M = 3, N = 32)(
	input clk,
	input [N-1:0]data,
	output [N-1:0]data_s
);

	reg [M*N-1:0]shift;
	
	always@(posedge clk) shift <= {
    shift[(M-1)*N-1:0],data};
	
	assign data_s = shift[M*N-1:(M-1)*N];

endmodule 

以ADD指令为例

周期一：取指，下降沿将指令instr放入delay寄存器中

module PC();
	always@(negedge clk or posedge rst)
		if(rst) addr <= 32'd0;
		else addr <= addr + 4;
endmodule 

module Instr_mem();
	always@(addr)begin
		instr[7:0] <= instr_mem[addr+3];
		instr[15:8] <= instr_mem[addr+2];
		instr[23:16] <= instr_mem[addr+1];
		instr[31:24] <= instr_mem[addr];
	end
endmodule 

周期二：译码，上升沿用receive寄存器取出指令，下降沿将data1，data2，rd等后续周期需要使用的数据放入delay寄存器，由于Control模块本身就是下降沿执行，因此不需要将控制使能存入delay寄存器

module Decode();
	assign op = instr[6:0];
	assign rd = instr[11:7];
	assign func3 = instr[14:12];
	assign rs1 = instr[19:15];
	assign rs2 = instr[24:20];
	assign func = instr[30];
endmodule 

module Control();
	always@(negedge clk)
			case(op)
				7'b0_110_011: begin sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end
				default: begin sub_en <= 1'b0; wr_en <= 1'b0; end
			endcase
endmodule 

module Register();
	assign data1 = (rs1 != 0) ? register[rs1] : 0;
	assign data2 = (rs2 != 0) ? register[rs2] : 0;
endmodule 

周期三：执行，上升沿用receive寄存器取出data1，data2等数据，将rd，wr_en等数据放入shift寄存器，在周期五使用。下降沿将计算结果data_out放入delay寄存器

module ALU();
	always@(*)
		case(func3)
			3'b000:
				case(sub_en)
					1'b0: data_out <= data_in1 + data_in2;
					1'b1: data_out <= data_in1 - data_in2;
				endcase
			default: data_out <= 32'd0;
		endcase
endmodule 

周期四：访问，ADD指令无需访问存储器，该周期组件做无用功
周期五：写回，上升沿shift寄存器输出的数据为该指令的rd与wr_en，下降沿写回数据

module Register();
	always@(negedge clk)
		if(wr_en) register[rd] <= wr_data;
endmodule 

大体框架编写完成，次级顶层文件如下(写回到寄存器的数据来源没有写出，因为这个数据要经过两级的筛选)：

module cpu();
	//第一级
	pc pc_cpu(clk,rst,cancel,offset_r,addr);
	//第二级
	receive #32 r_instr(clk,instr,instr_r);
	decode decode_cpu(instr_r,op,rd,func3,rs1,rs2,func);
	control control_cpu(clk,op,func,sub_en,wr_en);
	delay #32 d_data1(clk,data1,data1_d);
	delay #32 d_data2(clk,data2,data2_d);
	delay #5 d_rd(clk,rd,rd_d);
	delay #3 d_func3(clk,func3,func3_d);
	delay #1 d_func(clk,func,func_d);
	//第三级
	shift #(3,5) s_rd(clk,rd_d,rd_s);
	shift #(3,1) s_wr_en(clk,wr_en,wr_en_s);
	receive #32 r_data1(clk,data1_d,data1_r);
	receive #32 r_data_in2(clk,data_in2,data_in2_r);
	receive #3 r_func3(clk,func3_d,func3_r);
	receive #1 r_func(clk,func_d,func_r);
	receive #1 r_sub_en(clk,sub_en,sub_en_r);
	alu alu(data1_r,data_in2_r,func3_r,func_r,sub_en_r,data_out);
	//第四级
	//第五级
	register register_cpu(clk,rs1,rs2,rd_s,data_r,wr_en_s,data1,data2);
endmodule 

写完上述代码，读者对五级流水线的架构有了初步的理解，就可以思考本代码中delay寄存器与receive寄存器的用途了。
如上图，指令1在周期一产生数据a1，数据a1是周期二需要用到的，于是，在时钟下降沿时，让a_d = a1，在周期二时钟上升沿时，让a_r = a_d = a1。此时，第二条指令产生数据a2，在周期二时钟下降沿时,a_d = a2，但这不会影响到指令1对a_r = a1的使用，因为a_r在周期三的时钟上升沿时，才会更新数据，让a_r = a_d = a2。可见，数据a1可以作用于一整个周期。失去delay或receive寄存器都会产生逻辑冒险，发生问题。

3、稍作修改

(1)操作数与立即数运算指令

周期二完成关于输入到ALU中运算数的数据选择

module data_in2_sel();
	always@(negedge clk) data_in2 <= sel ? data2 : ext_imm;
endmodule 

(2)跳转指令

周期二将跳转地址算出，而不是在PC中计算；

module offset_sel();
	always@(negedge clk)
		case(sel)
			2'b11: offset <= addr + (jmp << 1);
			2'b01: offset <= ext_imm + data1;
			2'b00: offset <= addr + (ext_imm << 1);
			default: offset <= 32'd0;
		endcase
endmodule 

周期二完成有条件跳转指令的判断；

module pass_jud();
	always@(*)
		case(func3)
			3'b000: 
				if(data1 == data2) pass <= 1'b1;
				else pass <= 1'b0;
			default: pass <= 1'b0;
		endcase
endmodule 

周期三上升沿读取跳转使能，实现以下控制：指令2在周期二产生的控制信号全部清零，达到冲刷流水线的目的。改变PC读取的地址，达到跳转的目的；(即指令2会进行，但做的是无用功。指令3不会执行，而是执行跳转地址存储的指令)

module Control();
	always@(negedge clk)
			if(cancel)begin
				jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0;
			end else begin
				case(op)
					7'b0_110_011: begin jmp_en <= 1'b0; sub_en <= func ? 1'b1 : 1'b0; wr_en <= 1'b1; end
					7'b0_010_011: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b1; end
					7'b1_101_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
					7'b1_100_111: begin jmp_en <= 1'b1; sub_en <= 1'b0; wr_en <= 1'b1; end
					7'b1_100_011: begin jmp_en <= pass; sub_en <= 1'b0; wr_en <= 1'b0; end
					default: begin jmp_en <= 1'b0; sub_en <= 1'b0; wr_en <= 1'b0; end
				endcase
			end
endmodule 

module PC();
	always@(negedge clk or posedge rst)
		if(rst) addr <= 32'd0;
		else if(cancel) addr <= offset;
		else addr <= addr + 4;
endmodule 

周期三完成第一次写回存储器的数据选择；

module wr_data_sel();
	always@(negedge clk) wr_data <= sel ? addr : data_out;
endmodule 

(3)读、写存储器指令

周期二将访问地址算出；

module wr_addr();
	always@(negedge clk) wr_addr <= ext_imm + data1;
endmodule 

周期四完成第二次写回存储器的数据选择；

module wr_data_sel();
	always@(negedge clk) wr_data <= sel ? addr : data_out;
endmodule 

上述是我的五级流水线设计思路，完整代码详见下一篇文章或我的github。

4、存在问题

本文所述的五级流水线是顺序读取、顺序放回模式，这样的传输模式本身就存在一个漏洞，举一例：指令1的计算结果为指令2的加数。指令1需要在周期五将计算结果存入寄存器。指令2在周期三需要用到计算结果。但是指令2在周期三时，指令1仍在周期四，会造成使用数据的错误。不仅是寄存器的读写，存储器的读写也有这个问题。
解决方法：
①别写会造成冲突的指令
②加入fence指令，写入前不允许读取
③使用顺序读取乱序放回、乱序读取乱许放回模式。
感兴趣的朋友可以阅读《教你设计CPU——RISC-V处理器》深入了解

五、仿真

1、写一个指令文档

指令文档

@000

00000000 00000000

00000000 00000000

@004

00000001 00000000

00000010 01101111

@008

00000000 00000000

00000000 00000000

@00c

00000000 00000000

00000000 00000000

@010

00000000 00000000

00000000 00000000

@014

00000000 00000000

00000000 00000000

@018

00000000 00000000

00000000 00000000

@01c

00000000 01000010

00000101 00110011

@020

00000000 00000000

00000000 00000000

@024

00000000 00000000

00000000 00000000

@028

00000000 00000000

00000000 00000000

@02c

00000000 10100010

00100000 10100011

2、写一个仿真文件

`timescale 1ns/1ns
`define clk_period 20

module sim;

	reg clk;
	reg rst;

	cpu_1 cpu_1(.clk(clk),.rst(rst));
	
	initial clk = 1'b1;
	
	always#(`clk_period/2) clk = ~clk;
	
	initial begin
		rst = 1'b0;
		#100;
		rst = 1'b1;
		#100;
		rst = 1'b0;
	end

endmodule 

3、仿真

(1)单周期CPU

(2)五级流水线

4、大功告成！！！

由衷希望我的分享可以帮助到大家，感谢观看✧٩(ˊωˋ*)و✧

---

1. 存储器的种类有很多，在此举两个例子助于理解：(1)熔丝型ROM 由晶体管构成，出厂时发射级熔丝呈连接状态，即全部存储为"1"，若要写入数据"0"，就需要通过大电流将熔丝烧断 (2)闪存Flash 由MOS管构成，写入数据时，通过电信号，使MOS管栅极发生化学反应和物理结构的改变，产生隧道效应，转移电荷，从而写入"0"或"1"。 ︎

2. 寄存器是由若干触发器组成的时序电路，通过电平控制输入与输出，与存储器性质截然不同。Verilog语言的always模块就是用来控制寄存器的。 ︎