自己动手写CPU之第五阶段（4）——逻辑、移位与空指令的实现

将陆续上传本人写的新书《自己动手写CPU》（尚未出版），今天是第18篇，我尽量每周四篇

5.5 修改OpenMIPS以实现逻辑、移位操作与空指令

为了实现逻辑、移位操作与空指令（其中nop、ssnop不用特意实现，可以认为是特殊的逻辑左移指令sll），只需要修改OpenMIPS的如下两个模块。

修改译码阶段的ID模块，用以实现对上述指令的译码。
修改执行阶段的EX模块，使其按照译码结果进行运算。

5.5.1 修改译码阶段的ID模块

首先给出如下宏定义，都在文件defines.v中定义，读者可以在本书附带光盘的Code\Chapter5_2目录下找到该文件。

`define EXE_AND  6'b100100          // and指令的功能码
`define EXE_OR   6'b100101          //  or指令的功能码
`define EXE_XOR  6'b100110          // xor指令的功能码
`define EXE_NOR  6'b100111          // nor指令的功能码
`define EXE_ANDI 6'b001100          //andi指令的指令码
`define EXE_ORI  6'b001101          // ori指令的指令码
`define EXE_XORI 6'b001110          //xori指令的指令码
`define EXE_LUI  6'b001111          // lui指令的指令码

`define EXE_SLL  6'b000000          // sll指令的功能码
`define EXE_SLLV 6'b000100          //sllv指令的功能码
`define EXE_SRL  6'b000010          // sra指令的功能码
`define EXE_SRLV 6'b000110          //srlv指令的功能码
`define EXE_SRA  6'b000011          // sra指令的功能码
`define EXE_SRAV 6'b000111          //srav指令的功能码

`define EXE_SYNC  6'b001111         //sync指令的功能码
`define EXE_PREF  6'b110011         //pref指令的指令码
`define EXE_SPECIAL_INST 6'b000000  //SPECIAL类指令的指令码

对指令进行译码的前提是能判断出指令种类，这个过程如图5-15所示。其中op就是指令的26-31bit，即指令码，op2就是指令的6-10 bit，op3就是指令的0-5bit，即功能码，op4就是指令的16-20bit，定义如下。

wire[5:0] op  = inst_i[31:26];    // 指令码
wire[4:0] op2 = inst_i[10:6];
wire[5:0] op3 = inst_i[5:0];      // 功能码
wire[4:0] op4 = inst_i[20:16];

首先依据指令码op进行判断，如果是SPECIAL类指令，再判断指令的6-10bit（即op2）是否为0，如果为0，那么再依据功能码op3的值，进行最终判断，确定指令类型。如果指令码op不为SPECIAL，那么就直接依据指令码op的值进行判断。

只有在确定指令sll、srl、sra的时候有一点特殊，从图5-13可知这3条指令都是SPECIAL类指令，但是这3条指令还要求第21-25bit为0，而且第6-10bit为移位位数，所以这3条指令的判断过程是：判断指令的21-31bit是否全为0，如果全为0，那么再依据功能码op3进行最终判断，确定指令类型。

ID模块主要修改内容如下，完整的代码可以参考本书附带光盘Code\Chapter5_2目录下的id.v文件。

module id(
......
);

wire[5:0] op  = inst_i[31:26];
wire[4:0] op2 = inst_i[10:6];
wire[5:0] op3 = inst_i[5:0];
wire[4:0] op4 = inst_i[20:16];
reg[`RegBus]	imm;
reg instvalid;

always @ (*) begin
if (rst == `RstEnable) begin
aluop_o     <= `EXE_NOP_OP;
alusel_o    <= `EXE_RES_NOP;
wd_o        <= `NOPRegAddr;
wreg_o      <= `WriteDisable;
instvalid   <= `InstValid;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b0;
reg1_addr_o <= `NOPRegAddr;
reg2_addr_o <= `NOPRegAddr;
imm         <= 32'h0;
end else begin
aluop_o     <= `EXE_NOP_OP;
alusel_o    <= `EXE_RES_NOP;
wd_o        <= inst_i[15:11];           //默认目的寄存器地址wd_o
wreg_o      <= `WriteDisable;
instvalid   <= `InstInvalid;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b0;
reg1_addr_o <= inst_i[25:21];           //默认的reg1_addr_o
reg2_addr_o <= inst_i[20:16];           //默认的reg2_addr_o
imm         <= `ZeroWord;
case (op)
`EXE_SPECIAL_INST:    begin           //指令码是SPECIAL
case (op2)
5'b00000:	      begin
case (op3)                     //依据功能码判断是哪种指令
`EXE_OR:	begin          //or指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_OR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_AND:	begin          //and指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_AND_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_XOR:	begin          //xor指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_XOR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_NOR:	begin          //nor指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_NOR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_SLLV:    begin         //sllv指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SLL_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_SRLV:    begin         //srlv指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SRL_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_SRAV:     begin        //srav指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SRA_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
`EXE_SYNC: begin            //sync指令
wreg_o      <= `WriteDisable;
aluop_o     <= `EXE_NOP_OP;
alusel_o    <= `EXE_RES_NOP;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b1;
instvalid   <= `InstValid;
end
default:	begin
end
endcase
end
default: begin
end
endcase
end
`EXE_ORI:	begin             //ori指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_OR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b0;
imm         <= {16'h0, inst_i[15:0]};
wd_o        <= inst_i[20:16];
instvalid   <= `InstValid;
end
`EXE_ANDI:	begin              //andi指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_AND_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b0;
imm         <= {16'h0, inst_i[15:0]};
wd_o        <= inst_i[20:16];
instvalid   <= `InstValid;
end
`EXE_XORI:	begin              //xori指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_XOR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b0;
imm         <= {16'h0, inst_i[15:0]};
wd_o        <= inst_i[20:16];
instvalid   <= `InstValid;
end
`EXE_LUI:	begin              //lui指令
reg_o       <= `WriteEnable;
aluop_o     <= `EXE_OR_OP;
alusel_o    <= `EXE_RES_LOGIC;
reg1_read_o <= 1'b1;
reg2_read_o <= 1'b0;
imm         <= {inst_i[15:0], 16'h0};
wd_o        <= inst_i[20:16];
instvalid   <= `InstValid;
end
`EXE_PREF:	begin             //pref指令
wreg_o      <= `WriteDisable;
aluop_o     <= `EXE_NOP_OP;
alusel_o    <= `EXE_RES_NOP;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b0;
instvalid   <= `InstValid;
end
default:			begin
end
endcase		  //case op

if (inst_i[31:21] == 11'b00000000000) begin
if (op3 == `EXE_SLL) begin              //sll指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SLL_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b1;
imm[4:0]    <= inst_i[10:6];
wd_o        <= inst_i[15:11];
instvalid   <= `InstValid;
end else if ( op3 == `EXE_SRL ) begin   //srl指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SRL_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b1;
imm[4:0]    <= inst_i[10:6];
wd_o        <= inst_i[15:11];
instvalid   <= `InstValid;
end else if ( op3 == `EXE_SRA ) begin   //sra指令
wreg_o      <= `WriteEnable;
aluop_o     <= `EXE_SRA_OP;
alusel_o    <= `EXE_RES_SHIFT;
reg1_read_o <= 1'b0;
reg2_read_o <= 1'b1;
imm[4:0]    <= inst_i[10:6];
wd_o        <= inst_i[15:11];
instvalid   <= `InstValid;
end
end
end       //if
end         //always

......

endmodule

对任一条指令而言，译码工作的主要内容是：确定要读取的寄存器情况、要执行的运算、要写的目的寄存器等三个方面的信息。下面对其中几个典型指令的译码过程进行解释。

1、and指令的译码过程

and指令译码需要设置的三个方面内容如下，or、xor、nor指令的译码过程可以参考and指令。

（1）要读取的寄存器情况：and指令需要读取rs、rt寄存器的值，所以设置reg1_read_o、reg2_read_o为1。默认通过Regfile模块读端口1读取的寄存器地址reg1_addr_o的值是指令的21-25bit，正是and指令中的rs，默认通过Regfile模块读端口2读取的寄存器地址reg2_addr_o的值是指令的16-20bit，正是and指令中的rt。

（2）要执行的运算：and指令要进行的是逻辑“与”操作，所以设置alusel_o为EXE_RES_LOGIC，设置aluop_o为EXE_AND_OP。

（3）要写入的目的寄存器：and指令需要将结果写入目的寄存器，所以设置wreg_o为WriteEnable，设置wd_o为要写入的目的寄存器地址，默认是指令字的11-15bit，正是and指令中rd的位置。

2、andi指令的译码过程

andi指令译码需要设置的三个方面内容如下。xori指令的译码过程可以参考andi指令。

（1）要读取的寄存器情况：andi指令只需要读取rs寄存器的值，所以设置reg1_read_o为1、reg2_read_o为0。默认通过Regfile模块读端口1读取的寄存器地址reg1_addr_o的值是指令的21-25bit，正是andi指令中的rs。设置reg2_read_o为0，暗含使用立即数作为运算的操作数。imm就是指令中的立即数进行零扩展后的值。

（2）要执行的运算：andi指令要进行的是逻辑“与”操作，所以设置alusel_o为EXE_RES_LOGIC，设置aluop_o为EXE_AND_OP。这一点与and指令译码过程一样。

（3）要写入的目的寄存器：andi指令需要将结果写入目的寄存器，所以设置wreg_o为WriteEnable，设置wd_o为要写入的目的寄存器地址，默认是指令字的11-15bit，在此需要修改，对andi指令而言，目的寄存器地址是指令字的16-20bit。

3、sllv指令的译码过程

sllv指令译码需要设置的三个方面内容如下，srlv、srav指令的译码过程可以参考sllv指令。

（1）要读取的寄存器情况：同and指令一样，设置reg1_read_o为1、reg2_read_o为1。

（2）要执行的运算：sllv指令要进行的是逻辑左移操作，所以设置alusel_o为EXE_RES_SHIFT，设置aluop_o为EXE_SLL_OP。

（3）要写入的目的寄存器：同and指令一样，设置wreg_o为WriteEnable。设置wd_o为要写入的目的寄存器地址，默认是指令字的11-15bit，正是sllv指令中rd的位置。

4、lui指令的译码过程

OpenMIPS将lui指令转化为ori 指令来执行，如下。

lui rt,immediate   =   ori rt,$0,(immediate || 0^16)

也就是将指令中的立即数左移16bit，然后与$0寄存器进行逻辑“或”运算。需要设置的三个方面内容如下。

（1）要读取的寄存器情况：需要读取寄存器$0的值，所以设置reg1_read_o为1、reg2_read_o为0。默认通过Regfile模块读端口1读取的寄存器地址reg1_addr_o的值是指令的21-25bit，参考图5-10可知，正是0。设置imm为指令中的立即数左移16位的值。

（2）要执行的运算：是逻辑“或”操作，所以alusel_o赋值为EXE_RES_LOGIC，aluop_o赋值为EXE_OR_OP。

（3）要写入的目的寄存器：lui指令需要将结果写入目的寄存器，所以设置wreg_o为WriteEnable，设置wd_o为要写入的目的寄存器地址，默认是指令字的11-15bit，在此需要修改，对lui指令而言，目的寄存器地址是指令字的16-20bit。

5、sll指令的译码过程

sll指令译码需要设置的三个方面内容如下，srl、sra指令的译码过程可以参考sll指令。

（1）要读取的寄存器情况：sll指令只需要读取rt寄存器的值，所以设置reg1_read_o为0、reg2_read_o为1。默认通过Regfile模块读端口2读取的寄存器地址reg2_addr_o的值是指令的16-20bit，正是sll指令中的rt。imm就是指令中的6-10bit的值，参考图5-11可知，正是移位位数sa的值。

（2）要执行的运算：sll指令要进行的是逻辑左移操作，所以设置alusel_o为EXE_RES_SHIFT，设置aluop_o为EXE_SLL_OP。

（3）要写入的目的寄存器：sll指令需要将结果写入目的寄存器，所以设置wreg_o为WriteEnable，设置wd_o为要写入的目的寄存器地址，等于指令字的11-15bit，正是sll指令中rd的位置。

5.5.2 修改执行阶段的EX模块

修改执行阶段EX模块的代码，主要修改内容如下，完整的代码可以参考本书光盘的Code\Chapter5_2目录下的ex.v文件。

module ex(
......
);

reg[`RegBus] logicout;       // 保存逻辑运算结果
reg[`RegBus] shiftres;       // 保存移位运算结果

// 进行逻辑运算
always @ (*) begin
if(rst == `RstEnable) begin
logicout <= `ZeroWord;
end else begin
case (aluop_i)
`EXE_OR_OP:		begin       // 逻辑或运算
logicout <= reg1_i | reg2_i;
end
`EXE_AND_OP:		begin       // 逻辑与运算
logicout <= reg1_i & reg2_i;
end
`EXE_NOR_OP:		begin       // 逻辑或非运算
logicout <= ~(reg1_i |reg2_i);
end
`EXE_XOR_OP:		begin       // 逻辑异或运算
logicout <= reg1_i ^ reg2_i;
end
default:		begin
logicout <= `ZeroWord;
end
endcase
end    //if
end      //always

// 进行移位运算
always @ (*) begin
if(rst == `RstEnable) begin
shiftres <= `ZeroWord;
end else begin
case (aluop_i)
`EXE_SLL_OP:		begin       // 逻辑左移
shiftres <= reg2_i << reg1_i[4:0] ;
end
`EXE_SRL_OP:		begin       // 逻辑右移
shiftres <= reg2_i >> reg1_i[4:0];
end
`EXE_SRA_OP:		begin       // 算术右移
shiftres <= ({32{reg2_i[31]}}<<(6'd32-{1'b0,reg1_i[4:0]}))
| reg2_i >> reg1_i[4:0];
end
default:		begin
shiftres <= `ZeroWord;
end
endcase
end    //if
end      //always

// 依据alusel_i选择最终的运算结果
always @ (*) begin
wd_o   <= wd_i;
wreg_o <= wreg_i;
case ( alusel_i )
`EXE_RES_LOGIC:	begin
wdata_o <= logicout;        // 选择逻辑运算结果为最终运算结果
end
`EXE_RES_SHIFT:	begin
wdata_o <= shiftres;        // 选择移位运算结果为最终运算结果
end
default:			begin
wdata_o <= `ZeroWord;
end
endcase
end

endmodule

上述代码主要是扩展了逻辑运算的过程，同时增加了进行移位运算的过程，最后，依据alusel_i的值，选择其中逻辑运算或移位运算的结果作为最终运算结果。

经过以上修改就实现了逻辑、移位和空指令，是不是很简单、直观？下一次将验证实现效果。