码迷,mamicode.com
首页 > 其他好文 > 详细

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

时间:2014-08-04 14:22:06      阅读:232      评论:0      收藏:0      [点我收藏+]

标签:mips   处理器   开源   软核   自己动手写cpu   

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


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

      为了实现逻辑、移位操作与空指令(其中nopssnop不用特意实现,可以认为是特殊的逻辑左移指令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 bitop3就是指令的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];

bubuko.com,布布扣

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

      只有在确定指令sllsrlsra的时候有一点特殊,从图5-13可知这3条指令都是SPECIAL类指令,但是这3条指令还要求第21-25bit0,而且第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

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

      1and指令的译码过程

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

      (1)要读取的寄存器情况:and指令需要读取rsrt寄存器的值,所以设置reg1_read_oreg2_read_o1。默认通过Regfile模块读端口1读取的寄存器地址reg1_addr_o的值是指令的21-25bit,正是and指令中的rs,默认通过Regfile模块读端口2读取的寄存器地址reg2_addr_o的值是指令的16-20bit,正是and指令中的rt

      (2)要执行的运算:and指令要进行的是逻辑“与”操作,所以设置alusel_oEXE_RES_LOGIC,设置aluop_oEXE_AND_OP

      (3)要写入的目的寄存器:and指令需要将结果写入目的寄存器,所以设置wreg_oWriteEnable,设置wd_o为要写入的目的寄存器地址,默认是指令字的11-15bit,正是and指令中rd的位置。

      2andi指令的译码过程

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

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

      (2)要执行的运算:andi指令要进行的是逻辑“与”操作,所以设置alusel_oEXE_RES_LOGIC,设置aluop_oEXE_AND_OP。这一点与and指令译码过程一样。

      (3)要写入的目的寄存器:andi指令需要将结果写入目的寄存器,所以设置wreg_oWriteEnable,设置wd_o为要写入的目的寄存器地址,默认是指令字的11-15bit,在此需要修改,对andi指令而言,目的寄存器地址是指令字的16-20bit

      3sllv指令的译码过程

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

      (1)要读取的寄存器情况:同and指令一样,设置reg1_read_o1reg2_read_o1

      (2)要执行的运算:sllv指令要进行的是逻辑左移操作,所以设置alusel_oEXE_RES_SHIFT,设置aluop_oEXE_SLL_OP

      (3)要写入的目的寄存器:同and指令一样,设置wreg_oWriteEnable。设置wd_o为要写入的目的寄存器地址,默认是指令字的11-15bit,正是sllv指令中rd的位置。

      4lui指令的译码过程

      OpenMIPSlui指令转化为ori 指令来执行,如下。

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

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

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

      (2)要执行的运算:是逻辑“或”操作,所以alusel_o赋值为EXE_RES_LOGICaluop_o赋值为EXE_OR_OP

      (3)要写入的目的寄存器:lui指令需要将结果写入目的寄存器,所以设置wreg_oWriteEnable,设置wd_o为要写入的目的寄存器地址,默认是指令字的11-15bit,在此需要修改,对lui指令而言,目的寄存器地址是指令字的16-20bit

      5sll指令的译码过程

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

      (1)要读取的寄存器情况:sll指令只需要读取rt寄存器的值,所以设置reg1_read_o0reg2_read_o1。默认通过Regfile模块读端口2读取的寄存器地址reg2_addr_o的值是指令的16-20bit,正是sll指令中的rtimm就是指令中的6-10bit的值,参考图5-11可知,正是移位位数sa的值。

      (2)要执行的运算:sll指令要进行的是逻辑左移操作,所以设置alusel_oEXE_RES_SHIFT,设置aluop_oEXE_SLL_OP

      (3)要写入的目的寄存器:sll指令需要将结果写入目的寄存器,所以设置wreg_oWriteEnable,设置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)——逻辑、移位与空指令的实现,布布扣,bubuko.com

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

标签:mips   处理器   开源   软核   自己动手写cpu   

原文地址:http://blog.csdn.net/leishangwen/article/details/38368011

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!