ID
OP（IR）->ID

博客简介
本篇博客是实验设计:《模型机CPU设计》整套实验报告内容之一，包括构架，分部件和性能分析三个大的模块，每个模块又细分为小的部分，历时1.5周完成。最后实验验收的分为满分。现在将其分享出来，希望能给后续的实验同学一个参考，少走不必要的弯路，设计出性能更优的CPU。
资源下载
设计CPU时，一路做了有三个版本，链接如下：

CPU1.0版本是第一代版本，由于刚开始设计，没有做性能的优化，此版本的优点是布局间隙大，线路较为清晰，如果你刚开始设计，那么这个版本可以更好地让你迅速设计出一个CPU CPU1.0版本压缩包下载
CPU2.0版本是第二代版本，也是我验收的版本，这个版本对版本一做了布局和时序性能的优化，性能达到了作者当时的巅峰CPU2.0版本压缩包下载
CPU3.0版本是第三代版本，对第2代版本做了更深层次的优化，解决了RAM不稳定的问题CPU3.0版本压缩包下载
这篇博客是整个实验的一部分，全套内容请参考：逻辑与计算机设计基础CPU实验

组合部件：

1指令译码器：

（1）部件功能：

通过指令系统表设计一个由指令码映射到指令信号的译码器。对IR传送的机器码进行译码，产生相应的控制信号以及为下一个部件提供输入，其中指令码为8位二进制码，译码器的输出端为指令操作。

（2）接口设计：



输入：

a,b表示由IR传送来的数据

EN是使能信号

输出：

MOVA用来传送（R2）→ R1操作的使能信号

MOVB用来传送（R2）→（C）操作的使能信号

MOV用来传送（（C））→R1操作的使能信号

ALU分别用来传送（R1）+（R2）→R1操作（R1）-（R2）→ R1操作（R1）∨（R2）→ R1操作的使能信号

NOT用来传送R1 /（R1）→ R1操作的使能信号

SHL和SHR用来传送循环左右移位操作的使能信号

JMP，JC，JZ 则用来传送PC跳转到指定address操作的使能信号

IN传送向R1写入操作的指令

OUT传送由寄存器中读出R1的操作的指令

HALT传送停机指令
（2）功能实现：

对每一种输入情况进行译码，对应每一种二进制编码，存储在一个临时变量temp里，在对temp讨论输出结果：





指令的汇编符号	指令的功能	指令的二进制编码





（4）功能仿真验证：







仿真结果：

输入1111  R1 R2 执行MOV  M操作，此时MOVA=1

输入1111  11 R2 执行MOV  R1，M的操作此时MOVB=1

输入1111  R1 11 执行MOVC的操作，此时MOVC=1

输入1001  R1 R2执行（R1）+（R2）→ R1 ALU=1

输入0110  R1 R2执行（R1）-（R2）→ R1 ALU=1

输入1011  R1 R2执行（R1）∨（R2）→ R1 ALU=1

输入0101  R1执行 /（R1）→ R1 ALU=1

输入1010  R1 00执行循环右移一位RSL=1

输入1010  R1 00执行循环右移一位RSR=1

输入0001  00 00，0001  00 01，JMP为1或JZ为1或JC为1

输入0010 R1XX 执行输入操作IN=1

输入0100 R1XX 执行输出操作OUT=1

输入01110000执行NOP操作NOP=1

输入10000000 执行停机操作HALT=1

对于其他输入，这里用了一个小的技巧，都译码为NOP表示跳转到下一条指令表示跳过这条指令，也就是译码结果为NOP=1

结论：仿真结果满足功能要求，设计正确
希望大家能够合理借鉴，少走弯路，重在创新，设计出更加优秀的CPU.

实验背景：通过指令系统表我们可以设计一个由指令码映射到指令信号的译码器。其中指令码为 8 位二进制码，译码器的输出端为指令操作。



VHDL代码
library ieee;
use ieee.std_logic_1164.all;

entity moxingji is
port(a: in std_logic_vector(7 downto 0);
	 en:in std_logic;
	 MOVA,MOVB,MOVC,ADD,SUB,OR0,NOT0,RSR,RSL,JMP,JZ,JC,IN0,OUT0,NOP,HALT: out std_logic);
end moxingji;

architecture aaa of moxingji is
  signal x: std_logic_vector(0 to 7);
  signal R1,R2: std_logic;
  begin
    x<=not a;
    R1<=not(a(0)and a(1)and a(2)and a(3)and a(4)and a(5)and en); 
    R2<=not(a(0)and a(1)and a(2)and a(3)and a(6)and a(7)and en);
    MOVA<=a(0)and a(1)and a(2)and a(3)and R1 and R2 and en;		--1111xxxx-111111xx-1111xx11
    MOVB<=a(0)and a(1)and a(2)and a(3)and a(4)and a(5)and en;	--111111xx
    MOVC<=a(0)and a(1)and a(2)and a(3)and a(6)and a(7)and en;	--1111xx11
    ADD<=a(0)and x(1)and x(2)and a(3)and en;		--1001
    SUB<=x(0)and a(1)and a(2)and x(3)and en;		--0110
    OR0<=a(0)and x(1)and a(2)and a(3)and en;		--1011
    NOT0<=x(0)and a(1)and x(2)and a(3)and en;		--0101
    RSR<=a(0)and x(1)and a(2)and x(3)and x(6)and x(7)and en;		--101000
    RSL<=a(0)and x(1)and a(2)and x(3)and a(6)and a(7)and en;		--101011
    JMP<=x(0)and x(1)and a(2)and a(3)and x(4)and x(5)and x(6)and x(7)and en;	--00110000
    JZ<=x(0)and x(1)and a(2)and a(3)and x(4)and x(5)and x(6)and a(7)and en;		--00110001
    JC<=x(0)and x(1)and a(2)and a(3)and x(4)and x(5)and a(6)and x(7)and en;		--00110010
    IN0<=x(0)and x(1)and a(2)and x(3)and en;		--0010
    OUT0<=x(0)and a(1)and x(2)and x(3)and en;		--0100
    NOP<=x(0)and a(1)and a(2)and a(3)and x(4)and x(5)and x(6)and x(7)and en;	--01110000
    HALT<=a(0)and x (1)and x(2)and x(3)and x(4)and x(5)and x(6)and x(7)and en;	--10000000
end aaa;

说在前面

开发环境：Vivado

语言：Verilog

cpu框架：Mips

控制器：组合逻辑


 指令译码器
我们需要根据一条32位的指令的结构确定是哪一条指令



可以根据操作码(op)以及功能码（func），使用case语句确定（下述代码中case语句顺序与上表相同）

`timescale 1ns / 1ns
module instr_dec(
    input [31:0] instr_code,
    output reg [31:0] i
    );
    wire [11:0] t;
    assign t = {instr_code[31:26],instr_code[5:0]};
    always @ (*)
    begin
        casez(t)
            12'b000000100000 :i = 32'b00000000000000000000000000000001;
            12'b000000100001 :i = 32'b00000000000000000000000000000010;
            12'b000000100010 :i = 32'b00000000000000000000000000000100;
            12'b000000100011 :i = 32'b00000000000000000000000000001000;
            12'b000000100100 :i = 32'b00000000000000000000000000010000;
            12'b000000100101 :i = 32'b00000000000000000000000000100000;
            12'b000000100110 :i = 32'b00000000000000000000000001000000;
            12'b000000100111 :i = 32'b00000000000000000000000010000000;
            12'b000000101010 :i = 32'b00000000000000000000000100000000;
            12'b000000101011 :i = 32'b00000000000000000000001000000000;
            12'b000000000000 :i = 32'b00000000000000000000010000000000;
            12'b000000000010 :i = 32'b00000000000000000000100000000000;
            12'b000000000011 :i = 32'b00000000000000000001000000000000;
            12'b000000000100 :i = 32'b00000000000000000010000000000000;
            12'b000000000110 :i = 32'b00000000000000000100000000000000;
            12'b000000000111 :i = 32'b00000000000000001000000000000000;
            12'b000000001000 :i = 32'b00000000000000010000000000000000;
            12'b001000?????? :i = 32'b00000000000000100000000000000000;
            12'b001001?????? :i = 32'b00000000000001000000000000000000;
            12'b001100?????? :i = 32'b00000000000010000000000000000000;
            12'b001101?????? :i = 32'b00000000000100000000000000000000;
            12'b001110?????? :i = 32'b00000000001000000000000000000000;
            12'b100011?????? :i = 32'b00000000010000000000000000000000;
            12'b101011?????? :i = 32'b00000000100000000000000000000000;
            12'b000100?????? :i = 32'b00000001000000000000000000000000;
            12'b000101?????? :i = 32'b00000010000000000000000000000000;
            12'b001010?????? :i = 32'b00000100000000000000000000000000;
            12'b001011?????? :i = 32'b00001000000000000000000000000000;
            12'b001111?????? :i = 32'b00010000000000000000000000000000;
            12'b000010?????? :i = 32'b00100000000000000000000000000000;
            12'b000011?????? :i = 32'b01000000000000000000000000000000;
            default:          i = 32'bx;
        endcase
    end
    
endmodule


 

控制器
输入为指令译码器的输出

输出为控制信号，依据指令操作时间表进行设计；

逻辑表达式为：

PC_CLK = 1

IM_R = 1

Rsc4-0 = IM25-21

Rtc4-0 = IM20-16

M1 = ~(jr + j + jal)

M2 = beq + bne

M3 = jr

M4 = sllv + srlv + srav

M5 = addi + addiu + andi + ori + xori + lw + sw + slti + sltiu + lui

M6 = jal

M7 = lw

M9 = ~(sll + srl + sra + sllv + srlv + srav)

M10 = addi + addiu + andi + ori + xori + lw + sw + slti + sltiu + lui

A0 = sub + subu + or + nor + slt + srl + srlv + ori + beq + bne + slti

A1 = add + sub + xor + nor + slt + sltu + sll + sllv + addi + xori + lw + sw +beq +bne + slti +sltiu

A2 = and + or + xor + nor + sll + srl + sra + sllv + srlv +srav + andi + ori + xori

A3 = slt + sltu + sll + srl + sra +sllv + srlv + srav + slti + sltiu + lui

RF_W = ~(jr + sw + beq + bne + j)

RF_CLK = ~(jr + sw + beq + bne + j) clk

DM_w = sw

DM_r = lw

DM_cs = lw +sw

`timescale 1ns / 1ns
module operation(
    input clk,
    input z,
    input [31:0] i,
    output PC_CLK,    
    output IM_R,     
    output M1,       
    output M2,        
    output M3,        
    output M4,        
    output M5,        
    output M6,       
    output M7,       
    output M9,      
    output M10,      
    output [3:0] ALUC,
    output RF_W,     
    output RF_CLK,   
    output DM_w,   
    output DM_r,     
    output DM_cs,
    output C_EXT16
    );
    assign PC_CLK = clk;
    assign IM_R = 1;
    assign M1 = ~(i[16] | i[29] | i[30]);
    assign M2 = ( i[24] & z) | (i[25] & ~z);
    assign M3 = i[16];
    assign M4 = i[13] | i[14] | i[15];
    assign M5 = i[17] | i[18] | i[19] | i[20] | i[21] | i[22] | i[23] | i[26] | i[27] | i[28];
    assign M6 = i[30];
    assign M7 = i[22];
    assign M9 = ~(i[10] | i[11] | i[12] | i[13] | i[14] | i[15]);
    assign M10 = i[17] | i[18] | i[19] | i[20] | i[21] | i[22] | i[23] | i[26] | i[27] | i[28];
    assign ALUC[0] = i[2] | i[3] | i[5] | i[7] | i[8] | i[11] | i[14] | i[20] | i[24] | i[25] | i[26];
    assign ALUC[1] = i[0] | i[2] | i[6] | i[7] | i[8] | i[9] | i[10] | i[13] | i[17] | i[21] | i[22] | i[23] | i[24] | i[25] | i[26] | i[27];
    assign ALUC[2] = i[4] | i[5] | i[6] | i[7] | i[10] | i[11] | i[12] | i[13] | i[14] | i[15] | i[19] | i[20] | i[21];
    assign ALUC[3] = i[8] | i[9] | i[10] | i[11] | i[12] | i[13] | i[14] | i[15] | i[26] | i[27] | i[28];
    assign RF_W = ~(i[16] | i[23] | i[24] | i[25] | i[29]);
    assign RF_CLK = ~clk;
    assign DM_w = i[23];
    assign DM_r = i[22];
    assign DM_cs = i[22] | i[23];
    assign C_EXT16 = ~(i[19] | i[20] | i[21]);
endmodule