从零开始设计RISC-V处理器——单周期处理器的设计

`include "define.v"

module instr_decode(

        input [31:0]instr,

        output [6:0]opcode,

        output [2:0]func3,

        output func7,

        output [4:0]Rs1,

        output [4:0]Rs2,

        output [4:0]Rd,

        output [31:0]imme

         );

         

        wire I_type;

        wire U_type;

        wire J_type;

        wire B_type;

        wire S_type;

        

        wire [31:0]I_imme;

        wire [31:0]U_imme;

        wire [31:0]J_imme;

        wire [31:0]B_imme;

        wire [31:0]S_imme;

        

        

        assign opcode=instr[6:0];

        assign func3=instr[14:12];

        assign func7=instr[30];

        assign Rs1=instr[19:15];

        assign Rs2=instr[24:20];

        assign Rd =instr[11:7];

        

        assign I_type=(instr[6:0]==`jalr) | (instr[6:0]==`load) | (instr[6:0]==`I_type);

        assign U_type=(instr[6:0]==`lui) | (instr[6:0]==`auipc);

        assign J_type=(instr[6:0]==`jal);

        assign B_type=(instr[6:0]==`B_type);

        assign S_type=(instr[6:0]==`store);

        

        

        assign I_imme={{20{instr[31]}},instr[31:20]}; 

        assign U_imme={instr[31:12],{12{1'b0}}};

        assign J_imme={{12{instr[31]}},instr[19:12],instr[20],instr[30:21],1'b0};   

        assign B_imme={{20{instr[31]}},instr[7],instr[30:25],instr[11:8],1'b0};

        assign S_imme={{20{instr[31]}},instr[31:25],instr[11:7]}; 

        

        assign imme= I_type?I_imme :

                                 U_type?U_imme :

                                 J_type?J_imme :

                                 B_type?B_imme :

                                 S_type?S_imme : 32'd0;





endmodule

module alu(

           ALU_DA,

       ALU_DB,

       ALU_CTL,

       ALU_ZERO,

       ALU_OverFlow,

       ALU_DC   

        );

        input [31:0]    ALU_DA;

    input [31:0]    ALU_DB;

    input [3:0]     ALU_CTL;

    output          ALU_ZERO;

    output          ALU_OverFlow;

    output reg [31:0]   ALU_DC;

                   

//********************generate ctr***********************

wire SUBctr;

wire SIGctr;

wire Ovctr;

wire [1:0] Opctr;

wire [1:0] Logicctr;

wire [1:0] Shiftctr;



assign SUBctr = (~ ALU_CTL[3]  & ~ALU_CTL[2]  & ALU_CTL[1]) | ( ALU_CTL[3]  & ~ALU_CTL[2]);

assign Opctr = ALU_CTL[3:2];

assign Ovctr = ALU_CTL[0] & ~ ALU_CTL[3]  & ~ALU_CTL[2] ;

assign SIGctr = ALU_CTL[0];

assign Logicctr = ALU_CTL[1:0]; 

assign Shiftctr = ALU_CTL[1:0]; 



//********************************************************



//*********************logic op***************************

reg [31:0] logic_result;



always@(*) begin

    case(Logicctr)

        2'b00:logic_result = ALU_DA & ALU_DB;

        2'b01:logic_result = ALU_DA | ALU_DB;

        2'b10:logic_result = ALU_DA ^ ALU_DB;

        2'b11:logic_result = ~(ALU_DA | ALU_DB);

        endcase

end 



//********************************************************

//************************shift op************************

wire [4:0]     ALU_SHIFT;

wire [31:0] shift_result;

assign ALU_SHIFT=ALU_DB[4:0];



Shifter Shifter(.ALU_DA(ALU_DA),

                .ALU_SHIFT(ALU_SHIFT),

                                .Shiftctr(Shiftctr),

                                .shift_result(shift_result));



//********************************************************

//************************add sub op**********************

wire [31:0] BIT_M,XOR_M;

wire ADD_carry,ADD_OverFlow;

wire [31:0] ADD_result;



assign BIT_M={32{SUBctr}};

assign XOR_M=BIT_M^ALU_DB;



Adder Adder(.A(ALU_DA),

            .B(XOR_M),

                        .Cin(SUBctr),

                        .ALU_CTL(ALU_CTL),

                        .ADD_carry(ADD_carry),

                        .ADD_OverFlow(ADD_OverFlow),

                        .ADD_zero(ALU_ZERO),

                        .ADD_result(ADD_result));



assign ALU_OverFlow = ADD_OverFlow & Ovctr;



//********************************************************

//**************************slt op************************

wire [31:0] SLT_result;

wire LESS_M1,LESS_M2,LESS_S,SLT_M;



assign LESS_M1 = ADD_carry ^ SUBctr;

assign LESS_M2 = ADD_OverFlow ^ ADD_result[31];

assign LESS_S = (SIGctr==1'b0)?LESS_M1:LESS_M2;

assign SLT_result = (LESS_S)?32'h00000001:32'h00000000;



//********************************************************

//**************************ALU result********************

always @(*) 

begin

  case(Opctr)

     2'b00:ALU_DC<=ADD_result;

     2'b01:ALU_DC<=logic_result;

     2'b10:ALU_DC<=SLT_result;

     2'b11:ALU_DC<=shift_result; 

  endcase

end



//********************************************************

endmodule





//********************************************************

//*************************shifter************************

module Shifter(input [31:0] ALU_DA,

               input [4:0] ALU_SHIFT,

                           input [1:0] Shiftctr,

                           output reg [31:0] shift_result);

                           



     wire [5:0] shift_n;

         assign shift_n = 6'd32 - Shiftctr;

     always@(*) begin

           case(Shiftctr)

           2'b00:shift_result = ALU_DA << ALU_SHIFT;

           2'b01:shift_result = ALU_DA >> ALU_SHIFT;

           2'b10:shift_result = ({32{ALU_DA[31]}} << shift_n) | (ALU_DA >> ALU_SHIFT);

           default:shift_result = ALU_DA;

           endcase

         end





endmodule



//*************************************************************

//***********************************adder*********************

module Adder(input [31:0] A,

             input [31:0] B,

                         input Cin,

                         input [3:0] ALU_CTL,

                         output ADD_carry,

                         output ADD_OverFlow,

                         output ADD_zero,

                         output [31:0] ADD_result);





    assign {ADD_carry,ADD_result}=A+B+Cin;

   assign ADD_zero = ~(|ADD_result);

   assign ADD_OverFlow=((ALU_CTL==4'b0001) & ~A[31] & ~B[31] & ADD_result[31]) 

                      | ((ALU_CTL==4'b0001) & A[31] & B[31] & ~ADD_result[31])

                      | ((ALU_CTL==4'b0011) & A[31] & ~B[31] & ~ADD_result[31]) 

                                          | ((ALU_CTL==4'b0011) & ~A[31] & B[31] & ADD_result[31]);

endmodule

`include "define.v"

module pc_reg(

        clk,

        rst_n,

        pc_new,

        pc_out

    );

        input clk;

        input rst_n;

        input [31:0]pc_new;

        

        output reg [31:0]pc_out;

        

        always@(posedge clk or negedge rst_n)

        begin

                if(!rst_n)

                        pc_out<=`zero_word;

                else

                        pc_out<=pc_new;

        end        



endmodule