从零开始设计RISC-V处理器——单周期处理器的设计
系列文章目录（一）从零开始设计RISC-V处理器——指令系统（二）从零开始设计RISC-V处理器——单周期处理器的数据通路（三）从零开始设计RISC-V处理器——单周期处理器的控制器（四）从零开始设计RISC-V处理器——单周期处理器的指令仿真文章目录系列文章目录前言一、CPU如何执行指令？二、存储器1.指令存储器2.数据存储器总结前言上一篇文章 中已经详细介绍了计划实现的37条指令，今天开始设计
·
系列文章目录
（一）从零开始设计RISC-V处理器——指令系统
（二）从零开始设计RISC-V处理器——单周期处理器的设计
（三）从零开始设计RISC-V处理器——单周期处理器的仿真
（四）从零开始设计RISC-V处理器——ALU的优化
（五）从零开始设计RISC-V处理器——五级流水线之数据通路的设计
（六）从零开始设计RISC-V处理器——五级流水线之控制器的设计
（七）从零开始设计RISC-V处理器——五级流水线之数据冒险
（八）从零开始设计RISC-V处理器——五级流水线之控制冒险
（九）从零开始设计RISC-V处理器——五级流水线之分支计算前移
（十）从零开始设计RISC-V处理器——五级流水线之静态预测
文章目录
前言
上一篇文章 中已经详细介绍了计划实现的37条指令，今天开始进行单周期的处理器设计
（目前单周期代码已经更新完成，点击链接直达：基于RISC-V指令集的单周期处理器的设计）
（视频版正在更新中~
1.基于RISC-V指令集的处理器设计——CPU的基本原理
2.基于RISC-V指令集的处理器设计——指令集的介绍
）
一、CPU如何执行指令？
CPU包括控制器和数据通路，数据通路从字面意思理解，就是指处理器中数据流通的路径。不同类型的指令的数据通路不一样，具体由控制器产生的控制信号决定。
下面以一个简单的数据通路为例，介绍以下处理器执行指令的过程。
1.CPU执行指令的过程如下：
（1）pc做为地址，输入到指令存储器，读取一条指令出来。这条指令是一个32bit的二进制数，里面包含了将要执行的指令的所有信息，包括指令类型（opcode），指令执行的功能（func3,func7）,立即数部分（imme）,源寄存器（rs1,rs2），目的寄存器（rd）。
（2）将读出来的指令进行译码，输入到不同的部件。比如，rs1,rs2,rd输入到寄存器堆，将立即数部分进行立即数扩展，将opcode输入到控制部件，产生控制信号。将func3,func7输入到子控制模块，产生ALU的控制信号。
（3）译码出来的寄存器号，输入到寄存器堆，读出寄存器号对应的数据Read_data1和Read_data2。
对于R-type指令，进行的操作就是两个寄存器的数据进行运算。
对于I-type指令，进行的操作是一个寄存器的数据与立即数进行运算。
因此这里要产生立即数，并且需要一个二选一选择器进行数据的选择。
（4）ALU即是运算单元，对输入的两个数据进行运算操作并且将运算结果输出，具体进行什么运算，由ALU_control产生的控制信号决定。
（5）将计算结果写回寄存器，写入到目标寄存器号对应的寄存器中。
（6）对于访存指令，如lb,lh,lw,sb,sh,sw,指令，还需要与数据存储器进行数据交换。
对于load指令，执行的操作是将数据从数据存储器的某个地址读出数据并讲这个数据写回到寄存器。
对于store指令，执行的操作是将寄存器的数据写入到数据存储器的某个地址内。
这个数据存储器的地址怎么产生呢？
地址以基地址加偏移的形式给出，基地址从寄存器中取得，偏移量从立即数中得到，因此ALU进行加法运算的结果便是数据存储器的地址。
因此ALU的运算结果有两个去向，一是写回寄存器，二是作为数据存储器的地址。
（7）对于load指令，是将数据存储器的数据写回到寄存器。
因此寄存器的数据来源有两个，一是ALU的运算结果，二是从数据存储器读出的数据。
（8）对于不进行跳转的指令，每个周期pc+4,指令按顺序执行，因此需要一个加法器。为什么是加4呢？
一条指令有32bit,CPU的内存空间按字节编址，所以一条指令4个字节实际上占了4个地址空间。
（9）对于条件跳转指令，如BEQ,BNE等，满足跳转的条件时，跳转的新地址由pc加左移一位的立即数产生，又需要一个加法器。因此，pc的来源有两个，一是顺序执行，pc+4,二是条件跳转，pc+(imme2)。
（10）对于无条件跳转指令，如jal,pc+4写回寄存器，将pc+(imme2)作为新地址。对于jalr,将pc+4写回寄存器，将源寄存器的数据与立即数相加并将最低位置0，作为下一个pc。
因此，写入寄存器的数据来源变成3个：ALU的运算结果，数据存储器读出的数据，pc+4。
pc的来源也变成3个：pc+4,pc+imme,Read_data1+imme。
（11）再考虑U-type，即lui,auipc。对于lui,将立即数进行处理，写入寄存器。对于auipc,将pc+imme写入寄存器。
因此，写入寄存器的数据来源变成5个，分别是：ALU的运算结果，数据存储器读出的数据，pc+4,lui的立即数 ，auipc的pc+imme。
上图所示的数据通路并不完整，如果想实现我们提到的37条指令，必须逐条分析指令，在上图的基础上添加相应的部件。
完整的数据通路如下所示（图中不包含控制器）：
2.从以上的分析中，可以将CPU的关键部件总结如下：
（1）指令存储器
（2）译码单元
（3）寄存器堆
（4）ALU
（5）数据存储器
（6）控制器
其中指令存储器和数据存储器为CPU外部的存储器，CPU的核心为数据通路+控制器。
因此，我们设计完的顶层模块应该是这样的：
下面来进行具体设计。
二、存储器
1.指令存储器
指令存储器属于只读存储器（rom）,可读不可写。
实现方式有两种：
（1）用硬件描述性语言设计
（2）用FPGA工具调用专用的rom IP核。
此处为了提高代码的通用性，采用第一种方式设计。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| addr | 8bit | input | 存储器读地址 |
| instr | 32bit | output | 读出的指令 |
对rom进行初始化，只需要将二进制指令存到文件“rom_binary_file.txt”中。如下所示：
代码如下：
module instr_memory(
addr,
instr
);
input [7:0]addr;
output [31:0]instr;
reg[31:0] rom[255:0];
//rom进行初始化
initial begin
$readmemb("./rom_binary_file.txt", rom);
//$readmemh("rom_hex_file.txt", rom);
end
assign instr = rom[addr];
endmodule
2.数据存储器
数据存储器属于随机读写存储器（ram）,可读可写，同样是两种实现方式。
这里用硬件描述语言设计。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| clk | 1bit | input | 时钟信号 |
| rst_n | 1bit | input | 读出的指令 |
| W_en | 1bit | input | 写使能 |
| addr | 32bit | input | 读（写）地址 |
| RW_tyoe | 3bit | input | 读（写）类型，字节，半字，字，双字 |
| din | 32bit | input | 要写入存储器的数据 |
| dout | 32bit | output | 从数据存储器中读出的数据 |
由于指令集中包含多位宽的读写指令，所以这里数据存储器的设计也应该支持多位宽读写。
根据输入的RW_type信号来确定读写类型。这里的RW_type信号，其实就是指令中的func3信号。
| RW_type | 对应指令 | 读写类型 |
|---|---|---|
| 000 | lb,sb | 读取或写入一个字节，读取时将8bit符号扩展为32bit |
| 001 | lh,sh | 读取或写入两个字节，读取时将16bit符号扩展为32bit |
| 010 | lw ,sw | 读取或写入32bit |
| 100 | lbu | 读取一个字节，将8bit无符号扩展为32bit |
| 101 | lhu | 读取两个字节，将16bit无符号扩展为32bit |
代码如下：
`include "define.v"
module data_memory(
clk,
rst_n,
W_en,
R_en,
addr,
RW_type,
din,
dout
);
input clk;
input rst_n;
input W_en;
input R_en;
input [31:0]addr;
input [2:0]RW_type;
input [31:0]din;
output [31:0]dout;
reg [31:0]ram[255:0];
wire [31:0]Rd_data;reference
//
reg [31:0]Wr_data_B;//字节拼接
wire [31:0]Wr_data_H;//半字拼接
wire [31:0]Wr_data;
assign Rd_data=ram[addr[31:2]];/读基准
always@(*)
begin
case(addr[1:0])
2'b00:Wr_data_B={Rd_data[31:8],din[7:0]};
2'b01:Wr_data_B={Rd_data[31:16],din[7:0],Rd_data[7:0]};
2'b10:Wr_data_B={Rd_data[31:24],din[7:0],Rd_data[15:0]};
2'b11:Wr_data_B={din[7:0],Rd_data[23:0]};
endcase
end
assign Wr_data_H=(addr[1]) ? {din[15:0],Rd_data[15:0]} : {Rd_data[31:16],din[15:0]} ;
///根据写类型，选择写入的数捿
assign Wr_data=(RW_type[1:0]==2'b00) ? Wr_data_B :( (RW_type[1:0]==2'b01) ? Wr_data_H : din );
///上升沿写入数捿
always@(posedge clk)
begin
if(W_en)
ram[addr[9:2]]<=Wr_data;
end
//读部刿
reg [7:0]Rd_data_B;
wire [15:0]Rd_data_H;
wire [31:0] Rd_data_B_ext;
wire [31:0] Rd_data_H_ext;
根据写地坿，实现截叿
always@(*)
begin
case(addr[1:0])
2'b00:Rd_data_B=Rd_data[7:0];
2'b01:Rd_data_B=Rd_data[15:8];
2'b10:Rd_data_B=Rd_data[23:16];
2'b11:Rd_data_B=Rd_data[31:24];
endcase
end
assign Rd_data_H=(addr[1])? Rd_data[31:16]:Rd_data[15:0];
///扩展丿32使
assign Rd_data_B_ext=(RW_type[2]) ? {24'd0,Rd_data_B} : {{24{Rd_data_B[7]}},Rd_data_B};
assign Rd_data_H_ext=(RW_type[2]) ? {16'd0,Rd_data_H} : {{16{Rd_data_H[15]}},Rd_data_H};
/
assign dout=(RW_type[1:0]==2'b00) ? Rd_data_B_ext : ((RW_type[1:0]==2'b01) ? Rd_data_H_ext : Rd_data );
endmodule
上面代码中出现的define.v文件里面定义了一些参数，该文件展示如下：
`define zero_word 32'd0
`define lui 7'b0110111
`define auipc 7'b0010111
`define jal 7'b1101111
`define jalr 7'b1100111
`define B_type 7'b1100011
`define load 7'b0000011
`define store 7'b0100011
`define I_type 7'b0010011
`define R_type 7'b0110011
`define ADD 4'b0001
`define SUB 4'b0011
`define SLL 4'b1100
`define SLT 4'b1001
`define SLTU 4'b1000
`define XOR 4'b0110
`define SRL 4'b1101
`define SRA 4'b1110
`define OR 4'b0101
`define AND 4'b0100
三.数据通路
1.寄存器堆
寄存器堆由快速的静态随机读写存储器（sram）实现，这种ram可以多路并发访问不同的寄存器。
寄存器堆由32个寄存器阵列组成，其中0号寄存器的值恒为0，只读不写。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| clk | 1bit | input | 时钟信号 |
| Rs1 | 5bit | input | 源寄存器1 |
| Rs2 | 5bit | input | 源寄存器2 |
| W_en | 1bit | input | 读使能 |
| Rd | 5bit | input | 目标寄存器 |
| Wr_data | 32bit | input | 写入寄存器的数据 |
| Rd_data1 | 32bit | output | 源寄存器1的数据 |
| Rd_data2 | 32bit | output | 源寄存器2的数据 |
代码如下：
`include "define.v"
module registers(
clk,
W_en,
Rs1,
Rs2,
Rd,
Wr_data,
Rd_data1,
Rd_data2
);
input clk;
input W_en;
input [4:0]Rs1;
input [4:0]Rs2;
input [4:0]Rd;
input [31:0]Wr_data;
output [31:0]Rd_data1;
output [31:0]Rd_data2;
reg [31:0] regs [31:0];
///write
always@(posedge clk )
begin
if(W_en & (Rd!=0))
regs[Rd]<=Wr_data;
end
//read
assign Rd_data1=(Rs1==5'd0)?`zero_word: regs[Rs1];
assign Rd_data2=(Rs2==5'd0)?`zero_word: regs[Rs2];
endmodule
2.译码模块
该模块对指令存储器输出的32位指令进行译码，得到opcode,Rs1,Rs2,Rd,imme，func3,func7等信息。
按照以下格式进行译码：
这里补充以下上一篇文中中提到的问题：
对于jal指令(UJ-type)和条件跳转指令（SB-type），他们的立即数表示方法是[20:1]或[12:1]，这里其实就是把最低位默认成0了。
如果按照最低位为0来扩展立即数，那么这个立即数直接与pc相加，即为跳转地址。如果最低位不进行补0，那么就如本篇刚开始提到的数据通路所示，必须将立即数左移一位之后与立即数相加。其最终效果是一样的。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| instr | 32bit | input | 32位指令 |
| opcde | 7bit | output | 7位操作码 |
| func3 | 3bit | output | func3 |
| func7 | 1bit | output | func7的第6位 |
| Rs1 | 5bit | output | 源寄存器1 |
| Rs2 | 5bit | output | 源寄存器2 |
| Rd | 5bit | output | 目标寄存器 |
| imme | 32bit | output | 符号扩展后的32位立即数 |
代码如下：
`include "define.v"
module instr_decode(
input [31:0]instr,
output [6:0]opcode,
output [2:0]func3,
output func7,
output [4:0]Rs1,
output [4:0]Rs2,
output [4:0]Rd,
output [31:0]imme
);
wire I_type;
wire U_type;
wire J_type;
wire B_type;
wire S_type;
wire [31:0]I_imme;
wire [31:0]U_imme;
wire [31:0]J_imme;
wire [31:0]B_imme;
wire [31:0]S_imme;
assign opcode=instr[6:0];
assign func3=instr[14:12];
assign func7=instr[30];
assign Rs1=instr[19:15];
assign Rs2=instr[24:20];
assign Rd =instr[11:7];
assign I_type=(instr[6:0]==`jalr) | (instr[6:0]==`load) | (instr[6:0]==`I_type);
assign U_type=(instr[6:0]==`lui) | (instr[6:0]==`auipc);
assign J_type=(instr[6:0]==`jal);
assign B_type=(instr[6:0]==`B_type);
assign S_type=(instr[6:0]==`store);
assign I_imme={{20{instr[31]}},instr[31:20]};
assign U_imme={instr[31:12],{12{1'b0}}};
assign J_imme={{12{instr[31]}},instr[19:12],instr[20],instr[30:21],1'b0};
assign B_imme={{20{instr[31]}},instr[7],instr[30:25],instr[11:8],1'b0};
assign S_imme={{20{instr[31]}},instr[31:25],instr[11:7]};
assign imme= I_type?I_imme :
U_type?U_imme :
J_type?J_imme :
B_type?B_imme :
S_type?S_imme : 32'd0;
endmodule
3.ALU模块
ALU模块主要进行数据的运算，根据ALU的控制模块产生的控制信ALU_CTL决定ALU进行的运算类型。
ALU_CTL对应的运算关系如下：
| ALU_CTL | 运算类型 | 具体的运算 |
|---|---|---|
| 0000 | 加法运算 | + |
| 0011 | 加法运算 | - |
| 0100 | 逻辑运算 | & |
| 0101 | 逻辑运算 | 或 |
| 0110 | 逻辑运算 | ^ |
| 0111 | 逻辑运算 | 或非 |
| 1000 | 小于置一 | 无符号小于置一 |
| 1001 | 小于置一 | 有符号小于置一 |
| 1100 | 移位运算 | 逻辑左移 |
| 1101 | 移位运算 | 逻辑右移 |
| 1110 | 移位运算 | 算数右移 |
由以上表格可以看出，ALU的运算类型分为加法运算，逻辑运算，小于置一，移位运算，根据ALU_CTL的高两位便可以判断出要执行的运算类型。
（1）加法运算：由加法器实现，减法实质上也是加法。
对于A-B，可以看作A+(-B)。
对于补码表示的二进制数，天然地有如下关系：
A+(~A)=32’b1111_1111_1111_1111_1111_1111_1111_1111=-1;
因此，-A=(~A)+1，这便是我们常说的补码等于反码加1，其实更严谨的说法应该是，一个数的相反数，等于这个数按位取反再加一。
于是，对于减法运算，可以做如下转换：
A-B=A+(-B)=A+（B的补码）+1；
另外，加法运算还应检测是否溢出，检测依据就是：当数为负数时，最左侧的位为0，或者数为正数时，最左侧的位为1。
具体细分位以下四种情况：
a.正数+正数=负数，则溢出
b.负数+负数=正数，则溢出
c.正数-负数=负数，则溢出
d.负数-正数=正数，则溢出
（2）逻辑运算，用逻辑门阵列实现即可。
（3）小于置一，实质上是减法运算。根据加法器的运算结果，进一步判断是否小于。
（4）移位运算，这里直接使用移位运算符（>>,<<）。
以上就是ALU的主要运算部件的设计，可以看到，加法器和移位运算比较复杂，但这里直接用Verilog的运算符实现的，后续会尝试设计超前进位加法器代替“+”以及用位拼接运算代替“>>,<<”,以提升CPU的性能。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| ALU_DA | 32bit | input | ALU的操作数1 |
| ALU_DB | 32bit | input | ALU的操作数2 |
| ALU_CTL | 4bit | input | ALU的控制信号 |
| ALU_ZERO | 1bit | output | ALU运算结果为0的标志 |
| ALU_Overflow | 1bit | output | 溢出标志 |
| ALU_DC | 32bit | output | ALU的运算结果 |
代码如下：
module alu(
ALU_DA,
ALU_DB,
ALU_CTL,
ALU_ZERO,
ALU_OverFlow,
ALU_DC
);
input [31:0] ALU_DA;
input [31:0] ALU_DB;
input [3:0] ALU_CTL;
output ALU_ZERO;
output ALU_OverFlow;
output reg [31:0] ALU_DC;
//********************generate ctr***********************
wire SUBctr;
wire SIGctr;
wire Ovctr;
wire [1:0] Opctr;
wire [1:0] Logicctr;
wire [1:0] Shiftctr;
assign SUBctr = (~ ALU_CTL[3] & ~ALU_CTL[2] & ALU_CTL[1]) | ( ALU_CTL[3] & ~ALU_CTL[2]);
assign Opctr = ALU_CTL[3:2];
assign Ovctr = ALU_CTL[0] & ~ ALU_CTL[3] & ~ALU_CTL[2] ;
assign SIGctr = ALU_CTL[0];
assign Logicctr = ALU_CTL[1:0];
assign Shiftctr = ALU_CTL[1:0];
//********************************************************
//*********************logic op***************************
reg [31:0] logic_result;
always@(*) begin
case(Logicctr)
2'b00:logic_result = ALU_DA & ALU_DB;
2'b01:logic_result = ALU_DA | ALU_DB;
2'b10:logic_result = ALU_DA ^ ALU_DB;
2'b11:logic_result = ~(ALU_DA | ALU_DB);
endcase
end
//********************************************************
//************************shift op************************
wire [4:0] ALU_SHIFT;
wire [31:0] shift_result;
assign ALU_SHIFT=ALU_DB[4:0];
Shifter Shifter(.ALU_DA(ALU_DA),
.ALU_SHIFT(ALU_SHIFT),
.Shiftctr(Shiftctr),
.shift_result(shift_result));
//********************************************************
//************************add sub op**********************
wire [31:0] BIT_M,XOR_M;
wire ADD_carry,ADD_OverFlow;
wire [31:0] ADD_result;
assign BIT_M={32{SUBctr}};
assign XOR_M=BIT_M^ALU_DB;
Adder Adder(.A(ALU_DA),
.B(XOR_M),
.Cin(SUBctr),
.ALU_CTL(ALU_CTL),
.ADD_carry(ADD_carry),
.ADD_OverFlow(ADD_OverFlow),
.ADD_zero(ALU_ZERO),
.ADD_result(ADD_result));
assign ALU_OverFlow = ADD_OverFlow & Ovctr;
//********************************************************
//**************************slt op************************
wire [31:0] SLT_result;
wire LESS_M1,LESS_M2,LESS_S,SLT_M;
assign LESS_M1 = ADD_carry ^ SUBctr;
assign LESS_M2 = ADD_OverFlow ^ ADD_result[31];
assign LESS_S = (SIGctr==1'b0)?LESS_M1:LESS_M2;
assign SLT_result = (LESS_S)?32'h00000001:32'h00000000;
//********************************************************
//**************************ALU result********************
always @(*)
begin
case(Opctr)
2'b00:ALU_DC<=ADD_result;
2'b01:ALU_DC<=logic_result;
2'b10:ALU_DC<=SLT_result;
2'b11:ALU_DC<=shift_result;
endcase
end
//********************************************************
endmodule
//********************************************************
//*************************shifter************************
module Shifter(input [31:0] ALU_DA,
input [4:0] ALU_SHIFT,
input [1:0] Shiftctr,
output reg [31:0] shift_result);
wire [5:0] shift_n;
assign shift_n = 6'd32 - Shiftctr;
always@(*) begin
case(Shiftctr)
2'b00:shift_result = ALU_DA << ALU_SHIFT;
2'b01:shift_result = ALU_DA >> ALU_SHIFT;
2'b10:shift_result = ({32{ALU_DA[31]}} << shift_n) | (ALU_DA >> ALU_SHIFT);
default:shift_result = ALU_DA;
endcase
end
endmodule
//*************************************************************
//***********************************adder*********************
module Adder(input [31:0] A,
input [31:0] B,
input Cin,
input [3:0] ALU_CTL,
output ADD_carry,
output ADD_OverFlow,
output ADD_zero,
output [31:0] ADD_result);
assign {ADD_carry,ADD_result}=A+B+Cin;
assign ADD_zero = ~(|ADD_result);
assign ADD_OverFlow=((ALU_CTL==4'b0001) & ~A[31] & ~B[31] & ADD_result[31])
| ((ALU_CTL==4'b0001) & A[31] & B[31] & ~ADD_result[31])
| ((ALU_CTL==4'b0011) & A[31] & ~B[31] & ~ADD_result[31])
| ((ALU_CTL==4'b0011) & ~A[31] & B[31] & ADD_result[31]);
endmodule
4.PC寄存器
PC寄存器用以更新pc的值。
顺序执行时，pc_new=pc+4,条件跳转时，pc_new=pc+imme。
jalr时，pc_new=data(Rs1)+imme。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| clk | 1bit | input | 时钟信号 |
| rst_n | 1bit | input | 读出的指令 |
| pc_new | 32bit | input | 下一个时钟周期的pc值 |
| pc_out | 32bit | output | 更新后的pc值 |
代码如下：
`include "define.v"
module pc_reg(
clk,
rst_n,
pc_new,
pc_out
);
input clk;
input rst_n;
input [31:0]pc_new;
output reg [31:0]pc_out;
always@(posedge clk or negedge rst_n)
begin
if(!rst_n)
pc_out<=`zero_word;
else
pc_out<=pc_new;
end
endmodule
5.数据通路
数据通路就是将以上的几个关键的部件进行连接，为了形成完整的数据通路，还必须添加一些多路选择器，作用是对不同信号的来源进行选择，并输出到相应的模块。
比如：写入寄存器的数据来源有5个，分别是：ALU的运算结果，数据存储器读出的数据，pc+4,lui的立即数 ，auipc的pc+imme。
pc的来源有3个：pc+4,pc+imme,Read_data1+imme。
另外，还需要加入两个加法器，分别计算pc+4和pc+imme。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| clk | 1bit | input | 时钟信号 |
| rst_n | 1bit | input | 读出的指令 |
| instr | 32bit | input | 指令存储器读出的指令 |
| MemtoReg | 1bit | input | 写回寄存器的数据选择器控制信号 |
| ALUSrc | 1bit | input | ALU的数据来源的数据选择器控制信号 |
| RegWrite | 1bit | input | 寄存器的写使能控制信号 |
| lui | 1bit | input | lui指令标志，写回寄存器的数据选择器的控制信号 |
| U_type | 1bit | input | U-type指令标志，写回寄存器的数据选择器的控制信号 |
| jal | 1bit | input | jal指令标志，选择pc的数据选择器的控制信号，同时也是写回寄存器的数据选择器的控制信号 |
| jalr | 1bit | input | jal指令标志，选择pc的数据选择器的控制信号，同时也是写回寄存器的数据选择器的控制信号 |
| beq | 1bit | input | beq指令标志，判断是否跳转的控制信号 |
| bne | 1bit | input | bne指令标志，判断是否跳转的控制信号 |
| blt | 1bit | input | blt指令标志，判断是否跳转的控制信号 |
| bge | 1bit | input | bge指令标志，判断是否跳转的控制信号 |
| bltu | 1bit | input | bltu指令标志，判断是否跳转的控制信号 |
| bgeu | 1bit | input | bgeu指令标志，判断是否跳转的控制信号 |
| ALUctl | 4bit | input | ALU的控制信号，决定ALU进行什么运算 |
| Rd_mem_data | 32bit | input | 从数据存储器读出的数据，作为写回寄存器的数据来源之一 |
| rom_addr | 8bit | output | 指令存储器的地址 |
| Wr_mem_data | 32bit | output | 数据存储器的写数据 |
| ALU_result | 32bit | output | ALU的运算结果，作为数据存储器的读（写）地址 |
| opcode | 7bit | output | 7位操作码 |
| func3 | 3bit | output | func3 |
| func7 | 1bit | output | func7 |
代码如下：
module datapath(
input clk,
input rst_n,
input [31:0]instr,
input MemtoReg,
input ALUSrc,
input RegWrite,
input lui,
input U_type,
input jal,
input jalr,
input beq,
input bne,
input blt,
input bge,
input bltu,
input bgeu,
input [3:0]ALUctl,
input [31:0]Rd_mem_data,
output [7:0]rom_addr,
output [31:0]Wr_mem_data,
output [31:0]ALU_result,
output [6:0]opcode,
output [2:0]func3,
output func7
);
wire [4:0]Rs1;
wire [4:0]Rs2;
wire [4:0]Rd;
wire [31:0]imme;
wire [31:0] Wr_reg_data;
wire [31:0] Rd_data1;
wire [31:0] Rd_data2;
wire zero;
wire [31:0]pc_order;
wire [31:0]pc_jump;
wire [31:0]pc_new;
wire [31:0]pc_out;
wire jump_flag;
wire [31:0]ALU_DB;
wire [31:0]WB_data;
wire reg_sel;
wire [31:0]Wr_reg_data1;
wire [31:0]Wr_reg_data2;
wire [31:0]pc_jump_order;
wire [31:0]pc_jalr;
assign reg_sel=jal | jalr ;
assign Wr_mem_data=Rd_data2;
assign rom_addr=pc_out[9:2];
assign pc_jalr={ALU_result[31:1],1'b0};
pc_reg pc_reg_inst (
.clk(clk),
.rst_n(rst_n),
.pc_new(pc_new),
.pc_out(pc_out)
);
instr_decode instr_decode_inst (
.instr(instr),
.opcode(opcode),
.func3(func3),
.func7(func7),
.Rs1(Rs1),
.Rs2(Rs2),
.Rd(Rd),
.imme(imme)
);
registers registers_inst (
.clk(clk),
.W_en(RegWrite),
.Rs1(Rs1),
.Rs2(Rs2),
.Rd(Rd),
.Wr_data(Wr_reg_data),
.Rd_data1(Rd_data1),
.Rd_data2(Rd_data2)
);
alu alu_inst (
.ALU_DA(Rd_data1),
.ALU_DB(ALU_DB),
.ALU_CTL(ALUctl),
.ALU_ZERO(zero),
.ALU_OverFlow(),
.ALU_DC(ALU_result)
);
branch_judge branch_judge_inst (
.beq(beq),
.bne(bne),
.blt(blt),
.bge(bge),
.bltu(bltu),
.bgeu(bgeu),
.jal(jal),
.jalr(jalr),
.zero(zero),
.ALU_result(ALU_result),
.jump_flag(jump_flag)
);
//pc+4
cla_adder32 pc_adder_4 (
.A(pc_out),
.B(32'd4),
.cin(1'd0),
.result(pc_order),
.cout()
);
/pc+imme
cla_adder32 pc_adder_imme (
.A(pc_out),
.B(imme),
.cin(1'd0),
.result(pc_jump),
.cout()
);
/pc_sel
mux pc_mux (
.data1(pc_jump),
.data2(pc_order),
.sel(jump_flag),
.dout(pc_jump_order)
);
///pc_jalr
mux pc_jalr_mux (
.data1(pc_jalr),
.data2(pc_jump_order),
.sel(jalr),
.dout(pc_new)
);
ALUdata_sel
mux ALU_data_mux (
.data1(imme),
.data2(Rd_data2),
.sel(ALUSrc),
.dout(ALU_DB)
);
/ALU_result or datamem
mux WB_data_mux (
.data1(Rd_mem_data),
.data2(ALU_result),
.sel(MemtoReg),
.dout(WB_data)
);
Wr_data_sel
mux jalr_mux (
.data1(pc_order),
.data2(WB_data),
.sel(reg_sel),
.dout(Wr_reg_data2)
);
mux lui_mux (
.data1(imme),
.data2(pc_jump),
.sel(lui),
.dout(Wr_reg_data1)
);
mux Wr_reg_mux (
.data1(Wr_reg_data1),
.data2(Wr_reg_data2),
.sel(U_type),
.dout(Wr_reg_data)
);
endmodule
四.控制器
1.主控制器
由于不同类型的指令所经过的数据通路不同，所以需要有控制信号控制数据通路，使得数据经过正确的通路，得到正确的运算结果。
本设计将控制器分为两级控制，主控制器产生大部分的控制信号，子控制器是ALU控制器，产生控制ALU进行正确运算的信号。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| opcode | 7bit | input | 7位操作码 |
| func3 | 3bit | input | func3 |
| Memread | 1bit | output | 数据存储器读使能 |
| ALUop | 2bit | output | 子控制器的控制信号 |
| MemtoReg | 1bit | output | 写回寄存器的数据选择器控制信号 |
| Memwrite | 1bit | output | 数据存储器写使能 |
| ALUSrc | 1bit | output | ALU的数据来源的数据选择器控制信号 |
| RegWrite | 1bit | output | 寄存器的写使能控制信号 |
| lui | 1bit | output | lui指令标志，写回寄存器的数据选择器的控制信号 |
| U_type | 1bit | output | U-type指令标志，写回寄存器的数据选择器的控制信号 |
| jal | 1bit | output | jal指令标志，选择pc的数据选择器的控制信号，同时也是写回寄存器的数据选择器的控制信号 |
| jalr | 1bit | output | jal指令标志，选择pc的数据选择器的控制信号，同时也是写回寄存器的数据选择器的控制信号 |
| beq | 1bit | output | beq指令标志，判断是否跳转的控制信号 |
| bne | 1bit | output | bne指令标志，判断是否跳转的控制信号 |
| blt | 1bit | output | blt指令标志，判断是否跳转的控制信号 |
| bge | 1bit | output | bge指令标志，判断是否跳转的控制信号 |
| bltu | 1bit | output | bltu指令标志，判断是否跳转的控制信号 |
| bgeu | 1bit | output | bgeu指令标志，判断是否跳转的控制信号 |
| RW_type | 3bit | output | 数据存储器的读（写）类型 |
代码如下：
module main_control(
opcode,
func3,
MemRead,
MemtoReg,
ALUop,
MemWrite,
ALUSrc,
RegWrite,
lui,
U_type,
jal,
jalr,
beq,
bne,
blt,
bge,
bltu,
bgeu,
RW_type
);
input [6:0]opcode;
input [2:0]func3;
output MemRead;
output MemtoReg;
output [1:0]ALUop;
output MemWrite;
output ALUSrc;
output RegWrite;
output lui;
output U_type;
output jal;
output jalr;
output beq;
output bne;
output blt;
output bge;
output bltu;
output bgeu;
output [2:0]RW_type;
wire branch;
wire R_type;
wire I_type;
wire load;
wire store;
wire lui;
wire auipc;
assign branch=(opcode==`B_type)?1'b1:1'b0;
assign R_type=(opcode==`R_type)?1'b1:1'b0;
assign I_type=(opcode==`I_type)?1'b1:1'b0;
assign U_type=(lui | auipc)? 1'b1:1'b0;
assign load=(opcode==`load)?1'b1:1'b0;
assign store=(opcode==`store)?1'b1:1'b0;
assign jal=(opcode==`jal)?1'b1:1'b0;
assign jalr=(opcode==`jalr)?1'b1:1'b0;
assign lui=(opcode==`lui)?1'b1:1'b0;
assign auipc=(opcode==`auipc)?1'b1:1'b0;
assign beq= branch & (func3==3'b000);
assign bne= branch & (func3==3'b001);
assign blt= branch & (func3==3'b100);
assign bge= branch & (func3==3'b101);
assign bltu= branch & (func3==3'b110);
assign bgeu= branch & (func3==3'b111);
assign RW_type=func3;
enable
assign MemRead= load;
assign MemWrite= store;
assign RegWrite= jal| jalr | load | I_type |R_type | U_type;
MUX
assign ALUSrc=load | store |I_type | jalr; //select imme
assign MemtoReg= load; //select datamemory data
ALUop
assign ALUop[1]= R_type|branch; //R 10 I 01 B 11 add 00
assign ALUop[0]= I_type|branch;
endmodule
2.子控制器
子控制器根据主控制器产生的ALUop信号，结合func3和func7信号来产生ALUctl信号。
ALUop信号的设置如下：
| ALUop | 子控制器的操作 |
|---|---|
| 00 | 加法运算 |
| 10 | R-type指令，根据func3和func7判断运算类型 |
| 01 | R-type指令，根据func3和func7判断运算类型 |
| 11 | 条件跳转信号，根据func3判断运算类型 |
| ALUctl信号设置如下： | |
| ALUctl | 运算类型 |
| – | – |
| 0000 | 加法运算 |
| 0011 | 加法运算 |
| 0100 | 逻辑运算 |
| 0101 | 逻辑运算 |
| 0110 | 逻辑运算 |
| 0111 | 逻辑运算 |
| 1000 | 小于置一 |
| 1001 | 小于置一 |
| 1100 | 移位运算 |
| 1101 | 移位运算 |
| 1110 | 移位运算 |
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| opcode | 7bit | input | 7位操作码 |
| func3 | 3bit | input | func3 |
| Memread | 1bit | output | 数据存储器读使能 |
| ALUop | 2bit | output | 子控制器的控制信号 |
| MemtoReg | 1bit | output | 写回寄存器的数据选择器控制信号 |
代码如下：
module alu_control(
ALUop,
func3,
func7,
ALUctl
);
input [1:0]ALUop;
input [2:0]func3;
input func7;
output [3:0]ALUctl;
wire [3:0]branchop;
reg [3:0]RIop;
assign branchop=(func3[2] & func3[1])? `SLTU : (func3[2] ^ func3[1])? `SLT : `SUB;
always@(*)
begin
case(func3)
3'b000: if(ALUop[1] & func7) //R
RIop=`SUB;
else //I
RIop=`ADD;
3'b001: RIop=`SLL;
3'b010: RIop=`SLT;
3'b011: RIop=`SLTU;
3'b100: RIop=`XOR;
3'b101: if(func7)
RIop=`SRA;
else
RIop=`SRL;
3'b110: RIop=`OR;
3'b111: RIop=`AND;
default:RIop=`ADD;
endcase
end
assign ALUctl=(ALUop[1]^ALUop[0])? RIop:(ALUop[1]&ALUop[0])?branchop:`ADD;
endmodule
3.控制器
将主控制模块和子控制模块进行实例化，得到控制模块。
代码如下：
`include "define.v"
module control(
opcode,
func3,
func7,
MemRead,
MemtoReg,
MemWrite,
ALUSrc,
RegWrite,
lui,
U_type,
jal,
jalr,
beq,
bne,
blt,
bge,
bltu,
bgeu,
RW_type,
ALUctl
);
input [6:0]opcode;
input [2:0]func3;
input func7;
output MemRead;
output MemtoReg;
output MemWrite;
output ALUSrc;
output RegWrite;
output lui;
output U_type;
output jal;
output jalr;
output beq;
output bne;
output blt;
output bge;
output bltu;
output bgeu;
output [2:0]RW_type;
output [3:0]ALUctl;
wire [1:0]ALUop;
main_control main_control_inst(
.opcode(opcode),
.func3(func3),
.MemRead(MemRead),
.MemtoReg(MemtoReg),
.ALUop(ALUop),
.MemWrite(MemWrite),
.ALUSrc(ALUSrc),
.RegWrite(RegWrite),
.lui(lui),
.U_type(U_type),
.jal(jal),
.jalr(jalr),
.beq(beq),
.bne(bne),
.blt(blt),
.bge(bge),
.bltu(bltu),
.bgeu(bgeu),
.RW_type(RW_type)
);
alu_control alu_control_inst(
.ALUop(ALUop),
.func3(func3),
.func7(func7),
.ALUctl(ALUctl)
);
endmodule
五.CPU的实现
1. RISC-V核心
将数据通路和及控制信号连接。
模块的输入输出端口定义如下：
| 信号名 | 位宽 | 输入输出 | 说明 |
|---|---|---|---|
| clk | 1bit | input | 系统时钟 |
| rst_n | 1bit | input | 复位信号 |
| instr | 32bit | input | 来自指令存储器的指令 |
| Rd_mem_data | 32bit | input | 来自数据存储器的读数据 |
| rom_addr | 8bit | output | 指令存储器的读地址 |
| Wr_mem_data | 32bit | output | 写入数据存储器的数据 |
| R_en | 1bit | output | 数据存储器的读使能信号 |
| W_en | 1bit | output | 数据存储器的写使能信号 |
| ram_addr | 32bit | output | 数据存储器的读（写）地址 |
| RW_type | 3bit | output | 数据存储器的读写类型 |
代码如下：
module riscv(
input clk,
input rst_n,
input [31:0]instr,
input [31:0]Rd_mem_data,
output [7:0]rom_addr,
output [31:0]Wr_mem_data,
output W_en,
output R_en,
output [31:0]ram_addr,
output [2:0]RW_type
);
wire [6:0]opcode;
wire [2:0]func3;
wire func7;
wire MemtoReg;
wire ALUSrc;
wire RegWrite;
wire lui;
wire U_type;
wire jal;
wire jalr;
wire beq;
wire bne;
wire blt;
wire bge;
wire bltu;
wire bgeu;
wire [3:0]ALUctl;
control control_inst (
.opcode(opcode),
.func3(func3),
.func7(func7),
.MemRead(R_en),
.MemtoReg(MemtoReg),
.MemWrite(W_en),
.ALUSrc(ALUSrc),
.RegWrite(RegWrite),
.lui(lui),
.U_type(U_type),
.jal(jal),
.jalr(jalr),
.beq(beq),
.bne(bne),
.blt(blt),
.bge(bge),
.bltu(bltu),
.bgeu(bgeu),
.RW_type(RW_type),
.ALUctl(ALUctl)
);
datapath datapath_inst (
.clk(clk),
.rst_n(rst_n),
.instr(instr),
.MemtoReg(MemtoReg),
.ALUSrc(ALUSrc),
.RegWrite(RegWrite),
.lui(lui),
.U_type(U_type),
.jal(jal),
.jalr(jalr),
.beq(beq),
.bne(bne),
.blt(blt),
.bge(bge),
.bltu(bltu),
.bgeu(bgeu),
.ALUctl(ALUctl),
.Rd_mem_data(Rd_mem_data),
.rom_addr(rom_addr),
.Wr_mem_data(Wr_mem_data),
.ALU_result(ram_addr),
.opcode(opcode),
.func3(func3),
.func7(func7)
);
endmodule
2.完整CPU
接入指令存储器和数据存储器。
代码如下：
module riscv_top(
input clk,
input rst_n,
output [7:0]rom_addr
);
// wire [7:0]rom_addr;
wire [31:0]ram_addr;
wire [31:0]instr;
wire [31:0]Rd_mem_data;
wire [31:0]Wr_mem_data;
wire W_en;
wire R_en;
wire [2:0]RW_type;
instr_memory instr_memory_inst (
.addr(rom_addr),
.instr(instr)
);
riscv riscv_inst (
.clk(clk),
.rst_n(rst_n),
.instr(instr),
.Rd_mem_data(Rd_mem_data),
.rom_addr(rom_addr),
.Wr_mem_data(Wr_mem_data),
.W_en(W_en),
.R_en(R_en),
.ram_addr(ram_addr),
.RW_type(RW_type)
);
data_memory data_memory_inst (
.clk(clk),
.rst_n(rst_n),
.W_en(W_en),
.R_en(R_en),
.addr(ram_addr),
.RW_type(RW_type),
.din(Wr_mem_data),
.dout(Rd_mem_data)
);
endmodule
3.整体预览
最终的代码结构如下：
FPGA工具生成的RTL图如下：
总结
以上就是今天要讲的内容，本文仅仅简单介绍了单周期处理器的设计，后续还需要在此基础上不断改善。 下一篇文章介绍对这个处理器的整体仿真。
华为开发者空间，是为全球开发者打造的专属开发空间，汇聚了华为优质开发资源及工具，致力于让每一位开发者拥有一台云主机，基于华为根生态开发、创新。
更多推荐
105
0- 0
已为社区贡献5条内容
所有评论(0)