自己动手写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的值,选择其中逻辑运算或移位运算的结果作为最终运算结果。

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

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

时间: 2024-10-07 16:39:15

自己动手写CPU之第五阶段(4)——逻辑、移位与空指令的实现的相关文章

自己动手写CPU之第五阶段(2)——OpenMIPS对数据相关问题的解决措施

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第16篇,我尽量每周四篇 5.2 OpenMIPS对数据相关问题的解决措施 OpenMIPS处理器采用数据前推的方法来解决流水线数据相关问题.通过补充完善图4-4原始的数据流图,添加部分信号使得可以完成数据前推的工作,如图5-7所示.主要是将执行阶段的结果.访存阶段的结果前推到译码阶段,参与译码阶段选择运算源操作数的过程. 图5-8给出了为实现数据前推而对OpenMIPS系统结构所做的修改.有两个方面. (1)将处于流水线执行阶段的

自己动手写CPU之第五阶段(3)——MIPS指令集中的逻辑、移位与空指令

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第17篇,我尽量每周四篇 5.4 逻辑.移位操作与空指令说明 MIPS32指令集架构中定义的逻辑操作指令有8条:and.andi.or.ori.xor.xori.nor.lui,其中ori指令已经实现了,本章要实现其余7条指令. MIPS32指令集架构中定义的移位操作指令有6条:sll.sllv.sra.srav.srl.srlv. MIPS32指令集架构中定义的空指令有2条:nop.ssnop.其中ssnop是一种特殊类型的空操作

自己动手写CPU之第五阶段(1)——流水线数据相关问题

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第15篇,我尽量每周四篇 上一章建立了原始的OpenMIPS五级流水线结构,但是只实现了一条ori指令,从本章开始,将逐步完善.本章首先讨论了流水线数据相关问题,然后修改OpenMIPS以解决该问题,并在5.3节验证了解决效果.接着对逻辑.移位操作与空指令的指令格式.用法.作用进行了一一说明,在5.5节通过扩展OpenMIPS实现了这些指令,最后编写测试程序,对实现效果进行了检验. 5.1 流水线数据相关问题 我们在第4章实现的五级

自己动手写CPU之第五阶段(5)——测试逻辑、移位与空指令的实现

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第19篇,我尽量每周四篇 5.6 测试程序1--测试逻辑操作实现效果 编写如下测试程序用于检验逻辑操作指令是否实现正确,文件名命名为inst_rom.S,在本附带光盘Code\Chapter5_2\AsmTest\LogicInstTest目录下有测试程序源文件. .org 0x0 .global _start .set noat _start: lui $1,0x0101 # $1 = 0x01010000 ori $1,$1,0

自己动手写CPU之第七阶段(2)——简单算术操作指令实现过程

将陆续上传本人写的新书<自己动手写CPU>,今天是第25篇,我尽量每周四篇 亚马逊的预售地址如下,欢迎大家围观呵! http://www.amazon.cn/dp/b00mqkrlg8/ref=cm_sw_r_si_dp_5kq8tb1gyhja4 China-pub的预售地址如下: http://product.china-pub.com/3804025 7.2 简单算术操作指令实现思路 虽然简单算术操作指令的数目比较多,有15条,但实现方式都是相似的,与前几章逻辑.移位操作指令的实现方式也

自己动手写CPU之第七阶段(3)——简单算术操作指令实现过程(续)

将陆续上传本人写的新书<自己动手写CPU>,今天是第26篇,我尽量每周四篇 China-pub的预售地址如下(有目录.内容简介.前言): http://product.china-pub.com/3804025 亚马逊的预售地址如下,欢迎大家围观呵! http://www.amazon.cn/dp/b00mqkrlg8/ref=cm_sw_r_si_dp_5kq8tb1gyhja4 为了实现简单算术指令,需要修改译码阶段的ID模块.执行阶段的EX模块,上一篇博文中已经介绍了对译码阶段ID模块的

自己动手写CPU之第七阶段(1)——简单算术操作指令说明

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第24篇,我尽量每周四篇 本章将实现MIPS32指令集架构定义的所有算术操作指令,共有21条,按照OpenMIPS实现这些指令的方式,可以分为三类,分别介绍如下. (1)简单算术操作指令 共有15条,包括加法.减法.比较.乘法等指令,这些指令在流水线的执行阶段都只需要一个时钟周期,而且实现思路很直观,与第4章添加逻辑操作指令类似,只需修改译码阶段的ID模块.执行阶段的EX模块,即可实现. (2)乘累加.乘累减指令 共有4条:乘累加m

自己动手写CPU之第六阶段(4)——验证移动操作指令实现效果

将陆续上传本人写的新书<自己动手写CPU>(尚未出版),今天是第23篇,我尽量每周四篇 6.4 测试程序 本节将通过一个测试程序验证为OpenMIPS处理器添加的移动操作指令是否实现正确,测试程序如下,对应本书附带光盘Code\Chapter6\AsmTest目录下的inst_rom.S文件. .org 0x0 .set noat .global _start _start: // 给寄存器$1.$2.$3.$4赋初值 lui $1,0x0000 # $1 = 0x00000000 lui $

自己动手写CPU之第七阶段(7)——乘累加指令的实现

将陆续上传本人写的新书<自己动手写CPU>,今天是第30篇,我尽量每周四篇 亚马逊的销售地址如下,欢迎大家围观呵! http://www.amazon.cn/dp/b00mqkrlg8/ref=cm_sw_r_si_dp_5kq8tb1gyhja4 China-pub的销售地址如下: http://product.china-pub.com/3804025 北发的销售地址如下: http://book.beifabook.com/Product/BookDetail.aspx?Plucode=