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

自己动手写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模块的修改过程,本文继续介绍执行阶段EX模块的修改过程。


7.3.2 修改执行阶段的EX模块

      译码阶段的结果会传递到执行阶段,执行阶段的EX模块会据此进行运算,所以需要修改执行阶段EX模块的代码,主要修改内容如下,完整代码可以参考本书附带光盘Code\Chapter7_1目录下的ex.v文件。

module ex(
	......	
);

  reg[`RegBus]  logicout;
	reg[`RegBus]  shiftres;
	reg[`RegBus]  moveres;
	reg[`RegBus]  HI;
	reg[`RegBus]  LO;

  // 新定义了一些变量
  wire          ov_sum;          // 保存溢出情况
	wire          reg1_eq_reg2;    // 第一个操作数是否等于第二个操作数
	wire          reg1_lt_reg2;    // 第一个操作数是否小于第二个操作数
	reg[`RegBus]  arithmeticres;   // 保存算术运算的结果
	wire[`RegBus] reg2_i_mux;      // 保存输入的第二个操作数reg2_i的补码
	wire[`RegBus] reg1_i_not;      // 保存输入的第一个操作数reg1_i取反后的值
	wire[`RegBus] result_sum;      // 保存加法结果
	wire[`RegBus] opdata1_mult;    // 乘法操作中的被乘数
	wire[`RegBus] opdata2_mult;    // 乘法操作中的乘数
	wire[`DoubleRegBus] hilo_temp; // 临时保存乘法结果,宽度为64位
  reg[`DoubleRegBus] mulres;     // 保存乘法结果,宽度为64位
		
	......

/****************************************************************
***********           第一段:计算以下5个变量的值          *********
*****************************************************************/

//(1)如果是减法或者有符号比较运算,那么reg2_i_mux等于第二个操作数
//    reg2_i的补码,否则reg2_i_mux就等于第二个操作数reg2_i
	assign reg2_i_mux = ((aluop_i == `EXE_SUB_OP)  || 
                      (aluop_i == `EXE_SUBU_OP) ||
                      (aluop_i == `EXE_SLT_OP)) ? 
                      (~reg2_i)+1 : reg2_i;

//(2)分三种情况:
//    A、如果是加法运算,此时reg2_i_mux就是第二个操作数reg2_i,
//       所以result_sum就是加法运算的结果
//    B、如果是减法运算,此时reg2_i_mux是第二个操作数reg2_i的补码,
//       所以result_sum就是减法运算的结果
//    C、如果是有符号比较运算,此时reg2_i_mux也是第二个操作数reg2_i 
//       的补码,所以result_sum也是减法运算的结果,可以通过判断减法
//       的结果是否小于零,进而判断第一个操作数reg1_i是否小于第二个操
//       作数reg2_i
	assign result_sum = reg1_i + reg2_i_mux;
 
//(3)计算是否溢出,加法指令add、addi、减法指令sub执行的时候,
       //    需要判断是否溢出,满足以下两种情况之一时,有溢出:
       //    A、reg1_i为正数,reg2_i_mux为正数,但是两者之和为负数
       //    B、reg1_i为负数,reg2_i_mux为负数,但是两者之和为正数
	assign ov_sum = ((!reg1_i[31] && !reg2_i_mux[31]) && result_sum[31])
                  ||((reg1_i[31] && reg2_i_mux[31]) && (!result_sum[31]));
	
       //(4)计算操作数1是否小于操作数2,分两种情况:
       //    A、aluop_i为EXE_SLT_OP表示有符号比较运算,此时又分3种情况
       //       A1、reg1_i为负数、reg2_i为正数,显然reg1_i小于reg2_i
       //       A2、reg1_i为正数、reg2_i为正数,并且reg1_i减去reg2_i的值小于0
       //           (即result_sum为负),此时也有reg1_i小于reg2_i
       //       A3、reg1_i为负数、reg2_i为负数,并且reg1_i减去reg2_i的值小于0
       //           (即result_sum为负),此时也有reg1_i小于reg2_i
       //     B、无符号数比较的时候,直接使用比较运算符比较reg1_i与reg2_i
	assign reg1_lt_reg2 = ((aluop_i == `EXE_SLT_OP))?
                         ((reg1_i[31] && !reg2_i[31]) || 
                         (!reg1_i[31] && !reg2_i[31] && result_sum[31])||
			                   (reg1_i[31] && reg2_i[31] && result_sum[31]))
                         :(reg1_i < reg2_i);
       
//(5)对操作数1逐位取反,赋给reg1_i_not
   assign reg1_i_not = ~reg1_i;
	
/****************************************************************
****    第二段:依据不同的算术运算类型,给arithmeticres变量赋值  ****
*****************************************************************/

	always @ (*) begin
	   if(rst == `RstEnable) begin
		arithmeticres <= `ZeroWord;
	   end else begin
		case (aluop_i)                         // aluop_i就是运算类型
	 	  `EXE_SLT_OP, `EXE_SLTU_OP: begin
		     arithmeticres <= reg1_lt_reg2 ;   // 比较运算
		   end
		  `EXE_ADD_OP, `EXE_ADDU_OP, `EXE_ADDI_OP, `EXE_ADDIU_OP:
	       begin	
          arithmeticres <= result_sum;      // 加法运算
		   end
		  `EXE_SUB_OP, `EXE_SUBU_OP:  begin
		     arithmeticres <= result_sum;      // 减法运算
		   end		
		  `EXE_CLZ_OP:  begin                  // 计数运算clz
		     arithmeticres <= reg1_i[31] ? 0 : reg1_i[30] ? 1 :
                          reg1_i[29] ? 2 : reg1_i[28] ? 3 :
                          reg1_i[27] ? 4 : reg1_i[26] ? 5 :
                          reg1_i[25] ? 6 : reg1_i[24] ? 7 :
                          reg1_i[23] ? 8 : reg1_i[22] ? 9 :
                          reg1_i[21] ? 10 : reg1_i[20] ? 11 :
                          reg1_i[19] ? 12 : reg1_i[18] ? 13 :
                          reg1_i[17] ? 14 : reg1_i[16] ? 15 :
                          reg1_i[15] ? 16 : reg1_i[14] ? 17 :
                          reg1_i[13] ? 18 : reg1_i[12] ? 19 :
                          reg1_i[11] ? 20 : reg1_i[10] ? 21 :
                          reg1_i[9]  ? 22 : reg1_i[8]  ? 23 :
                          reg1_i[7]  ? 24 : reg1_i[6]  ? 25 :
                          reg1_i[5]  ? 26 : reg1_i[4]  ? 27 :
                          reg1_i[3]  ? 28 : reg1_i[2]  ? 29 :
                          reg1_i[1]  ? 30 : reg1_i[0]  ? 31 : 32 ;
		    end
		   `EXE_CLO_OP:		begin       // 计数运算clo
		      arithmeticres <= (reg1_i_not[31] ? 0 : 
                          reg1_i_not[29] ? 2 :
                          reg1_i_not[28] ? 3 : 
                          reg1_i_not[27] ? 4 : 
                          reg1_i_not[26] ? 5 :
                          reg1_i_not[25] ? 6 : 
                          reg1_i_not[24] ? 7 : 
                          reg1_i_not[23] ? 8 : 
                          reg1_i_not[22] ? 9 : 
                          reg1_i_not[21] ? 10 : 
                          reg1_i_not[20] ? 11 :
                          reg1_i_not[19] ? 12 : 
                          reg1_i_not[18] ? 13 : 
                          reg1_i_not[17] ? 14 : 
                          reg1_i_not[16] ? 15 : 
                          reg1_i_not[15] ? 16 : 
                          reg1_i_not[14] ? 17 : 
                          reg1_i_not[13] ? 18 : 
                          reg1_i_not[12] ? 19 : 
                          reg1_i_not[11] ? 20 :
                          reg1_i_not[10] ? 21 : 
                          reg1_i_not[9] ? 22 : 
                          reg1_i_not[8] ? 23 : 
                          reg1_i_not[7] ? 24 : 
                          reg1_i_not[6] ? 25 : 
                          reg1_i_not[5] ? 26 : 
                          reg1_i_not[4] ? 27 : 
                          reg1_i_not[3] ? 28 : 
                          reg1_i_not[2] ? 29 : 
                          reg1_i_not[1] ? 30 : 
                          reg1_i_not[0] ? 31 : 32) ;
		     end
		     default:	 begin
			 arithmeticres <= `ZeroWord;
		     end
		endcase
	   end
	end

/****************************************************************
************            第三段:进行乘法运算          *************
*****************************************************************/

    //(1)取得乘法运算的被乘数,如果是有符号乘法且被乘数是负数,那么取补码
    assign opdata1_mult=(((aluop_i==`EXE_MUL_OP)||(aluop_i==`EXE_MULT_OP))
                         && (reg1_i[31] == 1'b1)) ? (~reg1_i + 1) : reg1_i;

    //(2)取得乘法运算的乘数,如果是有符号乘法且乘数是负数,那么取补码
    assign opdata2_mult=(((aluop_i==`EXE_MUL_OP)||(aluop_i==`EXE_MULT_OP))
                        && (reg2_i[31] == 1'b1)) ? (~reg2_i + 1) : reg2_i;

    //(3)得到临时乘法结果,保存在变量hilo_temp中
    assign hilo_temp = opdata1_mult * opdata2_mult;

//(4)对临时乘法结果进行修正,最终的乘法结果保存在变量mulres中,主要有两点:
//    A、如果是有符号乘法指令mult、mul,那么需要修正临时乘法结果,如下:
//       A1、如果被乘数与乘数,两者一正一负,那么需要对临时乘法结果
//          hilo_temp求补码,作为最终的乘法结果,赋给变量mulres。
//       A2、如果被乘数与乘数同号,那么hilo_temp的值就作为最终的
//          乘法结果,赋给变量mulres。
//    B、如果是无符号乘法指令multu,那么hilo_temp的值就作为最终的乘法结果,
//       赋给变量mulres。
always @ (*) begin
	if(rst == `RstEnable) begin
	   mulres <= {`ZeroWord,`ZeroWord};
	end else if ((aluop_i == `EXE_MULT_OP)||(aluop_i == `EXE_MUL_OP))
    begin
	    if(reg1_i[31] ^ reg2_i[31] == 1'b1) begin
		      mulres <= ~hilo_temp + 1;
	    end else begin
		      mulres <= hilo_temp;
	    end
	end else begin
	   mulres <= hilo_temp;
	end
end

/****************************************************************
***********        第四段:确定要写入目的寄存器的数据     ************
*****************************************************************/

 always @ (*) begin
	 wd_o <= wd_i;
        
 // 如果是add、addi、sub、subi指令,且发生溢出,那么设置wreg_o为
 //  WriteDisable,表示不写目的寄存器
	 if(((aluop_i == `EXE_ADD_OP) || (aluop_i == `EXE_ADDI_OP) || 
	      (aluop_i == `EXE_SUB_OP)) && (ov_sum == 1'b1)) begin
	    wreg_o <= `WriteDisable;
	 end else begin
	    wreg_o <= wreg_i;
	 end
	 
	 case ( alusel_i ) 
    `EXE_RES_LOGIC:		begin
	 	   wdata_o <= logicout;
	   end
    `EXE_RES_SHIFT:		begin
	 	   wdata_o <= shiftres;
	   end	 	
    `EXE_RES_MOVE:		begin
	 	   wdata_o <= moveres;
	   end	 	
    `EXE_RES_ARITHMETIC:	begin       //除乘法外的简单算术操作指令
	 	   wdata_o <= arithmeticres;
     end
    `EXE_RES_MUL:		begin       //乘法指令mul
	 	   wdata_o <= mulres[31:0];
     end	 	
     default:					begin
	 	   wdata_o <= `ZeroWord;
     end
   endcase
end	

/****************************************************************
***********      第五段:确定对HI、LO寄存器的操作信息   ************
*****************************************************************/

always @ (*) begin
	  if(rst == `RstEnable) begin
	     whilo_o <= `WriteDisable;
       hi_o <= `ZeroWord;
	     lo_o <= `ZeroWord;		
	  end else if((aluop_i == `EXE_MULT_OP) || 
                (aluop_i == `EXE_MULTU_OP)) begin  //mult、multu指令
       whilo_o <= `WriteEnable;
       hi_o <= mulres[63:32];
       lo_o <= mulres[31:0];			
    end else if(aluop_i == `EXE_MTHI_OP) begin
       whilo_o <= `WriteEnable;
       hi_o <= reg1_i;
       lo_o <= LO;
    end else if(aluop_i == `EXE_MTLO_OP) begin
       whilo_o <= `WriteEnable;
       hi_o <= HI;
       lo_o <= reg1_i;
    end else begin
       whilo_o <= `WriteDisable;
       hi_o <= `ZeroWord;
       lo_o <= `ZeroWord;
    end
end

endmodule


      上面的代码可以分为五段,大部分代码的含义都在注释中给出了详细解释,以下只做简要补充。

      (1)第一段代码计算出如下几个变量的值。

  •  reg2_i_mux:如果是减法或者有符号比较运算,那么reg2_i_mux等于第二个操作数reg2_i的补码,否则reg2_i_mux就等于第二个操作数reg2_i
  •  result_sum:加、减法的结果。
  •  ov_sum:指示加、减法是否溢出。
  •  reg1_lt_reg2:操作数1是否小于操作数2
  •  reg1_i_not:操作数1各位取反后的值。

      (2)第二段代码依据不同的算术运算类型,给变量arithmeticres赋值,此处只解释clzclo指令的运算过程,其余指令的运算过程请参考程序注释。

  •  clz指令的作用是从最高位开始计数,直到遇到第一个1,所以在实现的时候就从最高位开始依次判断是否为1,如果为1,就给出当前已经数过的位数,如果没有为1的位,那么输出32
  •  clo指令的作用是从最高位开始计数,直到遇到第一个0,效果等同于先将操作数取反,然后从最高位开始计数,直到遇到第一个1,所以在实现的时候就先对操作数取反,然后从最高位开始依次判断是否为1,如果为1,就给出当前已经数过的位数,如果没有为1的位,那么输出32

      (3)第三段代码进行乘法运算。对于有符号乘法,要先求补码,再相乘,最后进行乘法结果的修正。乘法结果保存在变量mulres中。

      (4)第四段代码确定要写目的寄存器的情况,有以下两点说明。

  •  如果是addaddisubsubi指令,且发生溢出,那么设置wreg_oWriteDisable,这样就不会写目的寄存器。
  •  如果是乘法指令以外的简单算术操作指令,那么将arithmeticres作为要写入目的寄存器的值。
  •  如果是乘法指令mul,那么将乘法结果的低32位作为要写入目的寄存器的值。

      (5)第五段代码确定对HILO寄存器的写信息。如果是乘法指令multmultu,那么需要写HILO寄存器,所以设置whilo_oWriteEnable,写入HI寄存器的值为乘法结果的高32位,写入LO寄存器的值为乘法结果的低32位。


下一步将验证简单算术指令的实现效果,敬请关注!