URL https://opencores.org/ocsvn/yacc/yacc/trunk

Subversion Repositories yacc

[/] [yacc/] [trunk/] [rtl/] [pipelined_rfile.v] - Blame information for rev 4

Details | Compare with Previous | View Log


//Jun.30.2004 Mux sentibity list bug fix
//Jul.2.2004 Cleanup
//Jul.7.2004 int bug fix
//Jan.20.2005 apply @*
`include "define.h"
module Pipelined_RegFile(clock,sync_reset,
        dest_addrD2,source_addr,target_addr,    wren,memory_wdata,
      A_Right_SELD1,A_Left_SELD1,PCD1,IMMD1,ALU_FuncD2,Shift_FuncD2,
      Shift_amountD2,RRegSelD1,MOUT,RF_inputD2,alu_source,alu_target,
        MWriteD2,MWriteD1,mul_alu_selD2,mul_div_funcD2,pause_out,
        Shift_Amount_selD2,int_stateD1,PCCDD
        );
    parameter adder_type="GENERIC";
`ifdef RAM4K
        input   [11:0]  PCD1;
`else
        input   [25:0]  PCD1;
`endif
        input     [15:0] IMMD1;//Jul.6.2004
        input   [4:0]  dest_addrD2;
        input   [4:0]  source_addr;
        input   [4:0]  target_addr;
        input   wren;
        input   clock;
        input   A_Left_SELD1;
        input  [3:0] ALU_FuncD2;
        input  [4:0] Shift_amountD2;
        input  [1:0]  Shift_FuncD2;
        input [1:0] A_Right_SELD1;
        input sync_reset;
        input [1:0] RRegSelD1;
        output  [31:0]  alu_target,alu_source;
        output  [31:0]  memory_wdata;
        input [31:0] MOUT;
        input [1:0] RF_inputD2;
        input MWriteD2,MWriteD1;
        input   [1:0] mul_alu_selD2;
        input [3:0]  mul_div_funcD2;
        output pause_out;
        input Shift_Amount_selD2;
        input int_stateD1;
 
        reg [31:0] AReg,NReg,RReg,DReg;
        reg [31:0] alu_left_latch,alu_right_latch;
        reg [31:0] memory_wdata;
 
`ifdef RAM4K
        input [11:0] PCCDD;
        reg [11:0] PCD2;
`else
        input [25:0] PCCDD;
        reg [25:0] PCD2;
`endif
 
        reg [15:0] IMMD2;//Jul.6.2004
 
        reg [4:0]  dadrD3,dadrD4,dadrD5,dadrD6;
        reg [4:0]  sadrD1,sadrD2;
        reg [4:0]  tadrD1,tadrD2;
        reg WD3,WD4,WD5,WD6;
        reg [1:0] A_Right_SELD2;
        reg [1:0] RRegSelD2,  RRegSelD3, RRegSelD4;
        reg [31:0] RRegin;
        reg test1D,test2D;
        wire  [31:0] alu_right;
        reg [31:0] alu_left;
 
        wire [31:0] source_out,target_out;
        wire [31:0] alu_out,shift_out;
        wire [31:0] alu_source=alu_left;
        wire [31:0] alu_target=alu_right;
        wire [31:0] regfile_in;
        wire [31:0] test,test2;
        wire test1;
 
        reg  stest1D,stest2D;
        reg  stest1D_dup1,stest1D_dup2,stest1D_dup3,stest1D_dup4;
        reg [31:0] mul_alu_out;
        reg div_mode_ff;
        reg sign_ff;
        reg RRegSelD4_dup1,RRegSelD4_dup2,RRegSelD4_dup3;
 
 
        wire  mul_div_enable,mul_div_sign,mul_div_mode;
 
        wire  [31:0] mul_div_out;
        wire [31:0] c_mult;
        wire [4:0] Shift_Amount;
 
        localparam [4:0] zero_=0,
                                     at_=1,
                                     v0_=2,
                                     v1_=3,
                                     a0_=4,
                                     a1_=5,
                                     a2_=6,
                                     a3_=7,
                                     t0_=8, t1_=9,t2_=10,t3_=11,t4_=12,t5_=13,t6_=14,t7_=15,
                                     s0_=16,s1_=17,s2_=18,s3_=19,s4_=20,s5_=21,s6_=22,s7_=23,t8_=24,t9_=25,
                                     k0_=26,k1_=27,gp_=28,sp_=29,s8_=30,ra_=31;
 
 
 
 
 
        always @(posedge clock) begin
 
                        dadrD3<=dest_addrD2;
                        dadrD4<=dadrD3;
                        dadrD5<=dadrD4;
                        dadrD6<=dadrD5;
 
                        tadrD1<=target_addr;
                        tadrD2<=tadrD1;
 
                        sadrD1<=source_addr;
                        sadrD2<=sadrD1;
 
 
                        if ( (mul_div_funcD2 ==4'b0000 ) ||
                             (mul_div_funcD2 ==4'b0001 ) ||
                             (mul_div_funcD2 ==4'b0010 ) ) WD3<=wren;//NOTHING,READLO/HI �ȊO�ł̓��C�g���~�߂�
                        else                    WD3<=1'b0;
 
                        WD4<=WD3;
                        WD5<=WD4;
                        WD6<=WD5;
 
                        A_Right_SELD2<=A_Right_SELD1;
 
                        IMMD2<=IMMD1;
                        if (int_stateD1) PCD2<=PCCDD;//Jul.7.2004
                        else PCD2<=PCD1;
 
 
                        RRegSelD2<=RRegSelD1;
                        RRegSelD3<=RRegSelD2;
                        RRegSelD4<=RRegSelD3;
                        RRegSelD4_dup1<=RRegSelD3[0];
                        RRegSelD4_dup2<=RRegSelD3[0];
                        RRegSelD4_dup3<=RRegSelD3[0];
 
 
        end
 
 
 
//AReg
        always @(posedge clock) begin
 
                        case (RF_inputD2)
                                `RF_ALU_sel :     AReg<=alu_out;
                                `RF_Shifter_sel:  AReg<=shift_out;
                                `SHIFT16_SEL:     AReg<= {IMMD2[15:0],16'h00};
                                `RF_PC_SEL :      AReg<=mul_alu_out;
                        endcase
        end
 
//ARegSel
        always @(*) begin//Mar.5.2005
                        if (! mul_alu_selD2[1] ) mul_alu_out={6'b00_0000,PCD2};
                        else    mul_alu_out=c_mult;
        end
 
 
 
 
//NReg
        always @(posedge clock)         NReg<=AReg;
 
 
//RReg
        always @(posedge clock)         begin
                case (RRegSelD4_dup1)
                                `MOUT_SEL :     RReg<=MOUT;
                                `NREG_SEL:      RReg<=NReg;
                                default :       RReg<=MOUT;
                        endcase
        end
 
//DReg
        always @(posedge clock)         begin
                                        DReg<=RReg;
        end
 
 
 
 
        always @(*) begin
                        case (RRegSelD4_dup2)
                                `MOUT_SEL :     RRegin=MOUT;
                                `NREG_SEL:      RRegin=NReg;
                                 default :      RRegin=MOUT;
                        endcase
        end
//target_reg
        always @(*)     memory_wdata=alu_right;
 
mul_div MulDiv(.clock(clock),.sync_reset(sync_reset),.a(alu_left),.b(alu_right),
                          .mul_div_out(c_mult),.mul_div_sign(mul_div_funcD2[1]),
                          .mul_div_word(1'b1),.mul_div_mode(mul_div_funcD2[2]),
                          .stop_state(pause_out),.mul_div_enable(mul_div_funcD2[3]),.lohi(mul_div_funcD2[0]));
 
assign mul_div_enable= mul_div_funcD2;
        always @(posedge clock) begin
                if (sync_reset) div_mode_ff<=1'b0;
                else if (mul_div_enable) div_mode_ff<=mul_div_mode;
        end
 
        always @(posedge clock) begin
                if (sync_reset) sign_ff<=1'b0;
                else if (mul_div_enable) sign_ff<=mul_div_sign;
        end
 
assign mul_div_mode=!(IMMD2[1] ==`MUL_DIV_MUL_SEL);//div high / mul low
assign mul_div_sign=!IMMD2[0];
 
 
 
alu  alu1(.a(alu_left),.b(alu_right),.alu_func(ALU_FuncD2),.alu_out(alu_out));
 
 
 
shifter sh1(.a(alu_right),.shift_out(shift_out),.shift_func(Shift_FuncD2),
                                                .shift_amount(Shift_Amount));
 
        assign Shift_Amount=Shift_Amount_selD2==`SHIFT_AMOUNT_REG_SEL ?
                                                alu_left[4:0] : Shift_amountD2;
 
 
//alu left latch
        always @(posedge clock) begin
        begin
                        if (sadrD1==dadrD4 && WD4) alu_left_latch<=RRegin;
//OK
                        else if       (sadrD1==dadrD5 && WD5)   alu_left_latch<=RReg;//This must be priority encoder
                        else if    (sadrD1==dadrD6 && WD6)   alu_left_latch<=DReg;
                        else  alu_left_latch<=source_out;
                                end
        end
 
 
//alu right latch
        always @(posedge clock) begin
        begin
                        case (A_Right_SELD1)
                                `Imm_signed   :         alu_right_latch<={ {16{IMMD1[15]}},IMMD1[15:0]};
                                `Imm_unsigned :         alu_right_latch<={ 16'h000,IMMD1[15:0]};
                                `A_RIGHT_ERT  : begin
 
                                                                                                        if (tadrD1==dadrD4 && WD4 ) alu_right_latch<=RRegin;
                                                                                                        else   //OK
                                                                                                                if (tadrD1==dadrD5 && WD5 )  alu_right_latch<=RReg;
                                                                                                                else if (tadrD1==dadrD6 && WD6) alu_right_latch<=DReg;
                                                                                                                else alu_right_latch<=target_out;
                                                                                        end
                                `IMM_26_SEL             : begin
                                                                                                        alu_right_latch<={6'b00_0000,IMMD1};
                                                                                                end
                                default                         : alu_right_latch<={ {16{IMMD1[15]}},IMMD1[15:0]};
                        endcase
                end
        end
`ifdef ALTERA
ram_regfile32xx32 RFile(
        .data(regfile_in),
        .wraddress(dadrD5),
        .rdaddress_a(target_addr),
        .rdaddress_b(source_addr),
        .wren(WD5),
        .clock(clock),
        .qa(target_out),
        .qb(source_out));
`else
 
ram32x32_xilinx  RFile (
        .data(regfile_in),
        .wraddress(dadrD5),
        .rdaddress_a(target_addr),
        .rdaddress_b(source_addr),
        .wren(WD5),
        .clock(clock),
        .qa(target_out),
        .qb(source_out));
`endif
        assign regfile_in=dadrD5==5'b0_0000 ? 32'h0000_0000 :RReg;
 
 
 
 
        always @* begin //
                case (stest1D_dup1)
                        1'b1: alu_left[7:0]=AReg[7:0];
                        1'b0:
                                case(stest2D)
                                        1'b1:
                                                case (RRegSelD4_dup3)
                                                        `MOUT_SEL :     alu_left[7:0]=MOUT[7:0];
                                                        `NREG_SEL:      alu_left[7:0]=NReg[7:0];
                                                endcase
                                        1'b0:   alu_left[7:0]=alu_left_latch[7:0];
                                endcase
                endcase
        end
 
      always @* begin //
                case (stest1D_dup2)
                        1'b1: alu_left[15:8]=AReg[15:8];
                        1'b0:
                                case(stest2D)
                                        1'b1:
                                                case (RRegSelD4_dup3)
                                                        `MOUT_SEL :     alu_left[15:8]=MOUT[15:8];
                                                        `NREG_SEL:      alu_left[15:8]=NReg[15:8];
                                                endcase
                                        1'b0:   alu_left[15:8]=alu_left_latch[15:8];
                                endcase
                endcase
        end
 
always @* begin//
                case (stest1D_dup3)
                        1'b1: alu_left[23:16]=AReg[23:16];
                        1'b0:
                                case(stest2D)
                                        1'b1:
                                                case (RRegSelD4_dup3)
                                                        `MOUT_SEL :     alu_left[23:16]=MOUT[23:16];
                                                        `NREG_SEL:      alu_left[23:16]=NReg[23:16];
                                                endcase
                                        1'b0:   alu_left[23:16]=alu_left_latch[23:16];
                                endcase
                endcase
        end
 
always @* begin //
                case (stest1D_dup4)
                        1'b1: alu_left[31:24]=AReg[31:24];
                        1'b0:
                                case(stest2D)
                                        1'b1:
                                                case (RRegSelD4_dup3)
                                                        `MOUT_SEL :     alu_left[31:24]=MOUT[31:24];
                                                        `NREG_SEL:      alu_left[31:24]=NReg[31:24];
                                                endcase
                                        1'b0:   alu_left[31:24]=alu_left_latch[31:24];
                                endcase
                endcase
        end
 
 
 
 
        assign alu_right=test1D ? AReg :
                         test2D ?   RRegin : alu_right_latch;
 
        always @(posedge clock) begin
                        stest1D<=(sadrD1==dest_addrD2) && wren;
                        stest1D_dup1<=(sadrD1==dest_addrD2) && wren;
                        stest1D_dup2<=(sadrD1==dest_addrD2) && wren;
                        stest1D_dup3<=(sadrD1==dest_addrD2) && wren;
                        stest1D_dup4<=(sadrD1==dest_addrD2) && wren;
 
        end
        always @(posedge clock) begin
                stest2D<=(sadrD1==dadrD3) && WD3  ;
        end
 
 
 
 
        always @(posedge clock) begin
                        test1D<=tadrD1==dest_addrD2 && (wren )  && A_Right_SELD1==`A_RIGHT_ERT;
        end
 
        always @(posedge clock) begin
                        test2D<=tadrD1==dadrD3 && (WD3 )  && A_Right_SELD1==`A_RIGHT_ERT;
        end
 
 
`ifdef Veritak
        reg [30*8:1] alu_function;
        reg [30*8:1] shift_function;
        reg [30*8:1] AReg_Input_Sel;
 
        always @*//Jan.20.2005 @(ALU_FuncD2,alu_left,alu_right)
                case (ALU_FuncD2)
                        `ALU_NOTHING : $sprintf(alu_function,"non_operation");
                        `ALU_ADD        : $sprintf(alu_function,"ADD %h,%h",alu_left,alu_right);
                        `ALU_SUBTRACT :$sprintf(alu_function,"SUB %h,%h,alu_left,alu_right");
                        `ALU_LESS_THAN_UNSIGNED :$sprintf(alu_function ,"LT_Unsigned %h,%h",alu_left,alu_right);
                        `ALU_LESS_THAN_SIGNED   : $sprintf(alu_function,"LT_Signed %h,%h",alu_left,alu_right);
                        `ALU_OR   : $sprintf(alu_function,"OR %h,%h",alu_left,alu_right);
                        `ALU_AND : $sprintf(alu_function,"XOR %h,%h,alu_left,alu_right");
                        `ALU_XOR : $sprintf(alu_function,"AND %h,%h",alu_left,alu_right);
                        `ALU_NOR : $sprintf(alu_function,"NOR %h,%h",alu_left,alu_right);
                        default: $sprintf(alu_function,"non_operation");
                endcase
 
        always @* begin //
                case (Shift_FuncD2)
                        `SHIFT_LEFT : $sprintf(shift_function,"SLL %d",Shift_Amount);
                        `SHIFT_RIGHT_UNSIGNED : $sprintf(shift_function,"SLR %d",Shift_Amount);
                        `SHIFT_RIGHT_SIGNED : $sprintf(shift_function,"SAR %d",Shift_Amount);
                        default: $sprintf(shift_function,"non_operation");
                endcase
        end
 
 
        always @* begin //
                        case (RF_inputD2)
                                `RF_ALU_sel :     $sprintf(AReg_Input_Sel,"ALU");
                                `RF_Shifter_sel:  $sprintf(AReg_Input_Sel,"Shifter");
                                `SHIFT16_SEL:     $sprintf(AReg_Input_Sel,"IMM16<<16");
                                `RF_PC_SEL :      $sprintf(AReg_Input_Sel,"PC/MulOutSEL");
                        endcase
        end
 
 
`endif
 
 
 
 
endmodule

Browse

Tools

Subversion Repositories yacc

[/] [yacc/] [trunk/] [rtl/] [pipelined_rfile.v] - Blame information for rev 4

Line No.	Rev	Author	Line
1	2	tak.sugawa	`//Jun.30.2004 Mux sentibity list bug fix`
2			`//Jul.2.2004 Cleanup`
3			`//Jul.7.2004 int bug fix`
4			`//Jan.20.2005 apply @*`
5			`include "define.h"
6			`module Pipelined_RegFile(clock,sync_reset,`
7			`dest_addrD2,source_addr,target_addr, wren,memory_wdata,`
8			`A_Right_SELD1,A_Left_SELD1,PCD1,IMMD1,ALU_FuncD2,Shift_FuncD2,`
9			`Shift_amountD2,RRegSelD1,MOUT,RF_inputD2,alu_source,alu_target,`
10			`MWriteD2,MWriteD1,mul_alu_selD2,mul_div_funcD2,pause_out,`
11			`Shift_Amount_selD2,int_stateD1,PCCDD`
12			`);`
13			`parameter adder_type="GENERIC";`
14			`ifdef RAM4K
15			`input [11:0] PCD1;`
16			`else
17			`input [25:0] PCD1;`
18			`endif
19			`input [15:0] IMMD1;//Jul.6.2004`
20			`input [4:0] dest_addrD2;`
21			`input [4:0] source_addr;`
22			`input [4:0] target_addr;`
23			`input wren;`
24			`input clock;`
25			`input A_Left_SELD1;`
26			`input [3:0] ALU_FuncD2;`
27			`input [4:0] Shift_amountD2;`
28			`input [1:0] Shift_FuncD2;`
29			`input [1:0] A_Right_SELD1;`
30			`input sync_reset;`
31			`input [1:0] RRegSelD1;`
32			`output [31:0] alu_target,alu_source;`
33			`output [31:0] memory_wdata;`
34			`input [31:0] MOUT;`
35			`input [1:0] RF_inputD2;`
36			`input MWriteD2,MWriteD1;`
37			`input [1:0] mul_alu_selD2;`
38			`input [3:0] mul_div_funcD2;`
39			`output pause_out;`
40			`input Shift_Amount_selD2;`
41			`input int_stateD1;`
42
43			`reg [31:0] AReg,NReg,RReg,DReg;`
44			`reg [31:0] alu_left_latch,alu_right_latch;`
45			`reg [31:0] memory_wdata;`
46
47			`ifdef RAM4K
48			`input [11:0] PCCDD;`
49			`reg [11:0] PCD2;`
50			`else
51			`input [25:0] PCCDD;`
52			`reg [25:0] PCD2;`
53			`endif
54
55			`reg [15:0] IMMD2;//Jul.6.2004`
56
57			`reg [4:0] dadrD3,dadrD4,dadrD5,dadrD6;`
58			`reg [4:0] sadrD1,sadrD2;`
59			`reg [4:0] tadrD1,tadrD2;`
60			`reg WD3,WD4,WD5,WD6;`
61			`reg [1:0] A_Right_SELD2;`
62			`reg [1:0] RRegSelD2, RRegSelD3, RRegSelD4;`
63			`reg [31:0] RRegin;`
64			`reg test1D,test2D;`
65			`wire [31:0] alu_right;`
66			`reg [31:0] alu_left;`
67
68			`wire [31:0] source_out,target_out;`
69			`wire [31:0] alu_out,shift_out;`
70			`wire [31:0] alu_source=alu_left;`
71			`wire [31:0] alu_target=alu_right;`
72			`wire [31:0] regfile_in;`
73			`wire [31:0] test,test2;`
74			`wire test1;`
75
76			`reg stest1D,stest2D;`
77			`reg stest1D_dup1,stest1D_dup2,stest1D_dup3,stest1D_dup4;`
78			`reg [31:0] mul_alu_out;`
79			`reg div_mode_ff;`
80			`reg sign_ff;`
81			`reg RRegSelD4_dup1,RRegSelD4_dup2,RRegSelD4_dup3;`
82
83
84			`wire mul_div_enable,mul_div_sign,mul_div_mode;`
85
86			`wire [31:0] mul_div_out;`
87			`wire [31:0] c_mult;`
88			`wire [4:0] Shift_Amount;`
89
90			`localparam [4:0] zero_=0,`
91			`at_=1,`
92			`v0_=2,`
93			`v1_=3,`
94			`a0_=4,`
95			`a1_=5,`
96			`a2_=6,`
97			`a3_=7,`
98			`t0_=8, t1_=9,t2_=10,t3_=11,t4_=12,t5_=13,t6_=14,t7_=15,`
99			`s0_=16,s1_=17,s2_=18,s3_=19,s4_=20,s5_=21,s6_=22,s7_=23,t8_=24,t9_=25,`
100			`k0_=26,k1_=27,gp_=28,sp_=29,s8_=30,ra_=31;`
101
102
103
104
105
106			`always @(posedge clock) begin`
107
108			`dadrD3<=dest_addrD2;`
109			`dadrD4<=dadrD3;`
110			`dadrD5<=dadrD4;`
111			`dadrD6<=dadrD5;`
112
113			`tadrD1<=target_addr;`
114			`tadrD2<=tadrD1;`
115
116			`sadrD1<=source_addr;`
117			`sadrD2<=sadrD1;`
118
119
120			`if ( (mul_div_funcD2 ==4'b0000 ) \|\|`
121			`(mul_div_funcD2 ==4'b0001 ) \|\|`
122			`(mul_div_funcD2 ==4'b0010 ) ) WD3<=wren;//NOTHING,READLO/HI �ȊO�ł̓��C�g��~�߂�`
123			`else WD3<=1'b0;`
124
125			`WD4<=WD3;`
126			`WD5<=WD4;`
127			`WD6<=WD5;`
128
129			`A_Right_SELD2<=A_Right_SELD1;`
130
131			`IMMD2<=IMMD1;`
132			`if (int_stateD1) PCD2<=PCCDD;//Jul.7.2004`
133			`else PCD2<=PCD1;`
134
135
136			`RRegSelD2<=RRegSelD1;`
137			`RRegSelD3<=RRegSelD2;`
138			`RRegSelD4<=RRegSelD3;`
139			`RRegSelD4_dup1<=RRegSelD3[0];`
140			`RRegSelD4_dup2<=RRegSelD3[0];`
141			`RRegSelD4_dup3<=RRegSelD3[0];`
142
143
144			`end`
145
146
147
148			`//AReg`
149			`always @(posedge clock) begin`
150
151			`case (RF_inputD2)`
152			`RF_ALU_sel : AReg<=alu_out;
153			`RF_Shifter_sel: AReg<=shift_out;
154			`SHIFT16_SEL: AReg<= {IMMD2[15:0],16'h00};
155			`RF_PC_SEL : AReg<=mul_alu_out;
156			`endcase`
157			`end`
158
159			`//ARegSel`
160			`always @(*) begin//Mar.5.2005`
161			`if (! mul_alu_selD2[1] ) mul_alu_out={6'b00_0000,PCD2};`
162			`else mul_alu_out=c_mult;`
163			`end`
164
165
166
167
168			`//NReg`
169			`always @(posedge clock) NReg<=AReg;`
170
171
172			`//RReg`
173			`always @(posedge clock) begin`
174			`case (RRegSelD4_dup1)`
175			`MOUT_SEL : RReg<=MOUT;
176			`NREG_SEL: RReg<=NReg;
177			`default : RReg<=MOUT;`
178			`endcase`
179			`end`
180
181			`//DReg`
182			`always @(posedge clock) begin`
183			`DReg<=RReg;`
184			`end`
185
186
187
188
189			`always @(*) begin`
190			`case (RRegSelD4_dup2)`
191			`MOUT_SEL : RRegin=MOUT;
192			`NREG_SEL: RRegin=NReg;
193			`default : RRegin=MOUT;`
194			`endcase`
195			`end`
196			`//target_reg`
197			`always @(*) memory_wdata=alu_right;`
198
199			`mul_div MulDiv(.clock(clock),.sync_reset(sync_reset),.a(alu_left),.b(alu_right),`
200			`.mul_div_out(c_mult),.mul_div_sign(mul_div_funcD2[1]),`
201			`.mul_div_word(1'b1),.mul_div_mode(mul_div_funcD2[2]),`
202			`.stop_state(pause_out),.mul_div_enable(mul_div_funcD2[3]),.lohi(mul_div_funcD2[0]));`
203
204			`assign mul_div_enable= mul_div_funcD2;`
205			`always @(posedge clock) begin`
206			`if (sync_reset) div_mode_ff<=1'b0;`
207			`else if (mul_div_enable) div_mode_ff<=mul_div_mode;`
208			`end`
209
210			`always @(posedge clock) begin`
211			`if (sync_reset) sign_ff<=1'b0;`
212			`else if (mul_div_enable) sign_ff<=mul_div_sign;`
213			`end`
214
215			assign mul_div_mode=!(IMMD2[1] ==`MUL_DIV_MUL_SEL);//div high / mul low
216			`assign mul_div_sign=!IMMD2[0];`
217
218
219
220			`alu alu1(.a(alu_left),.b(alu_right),.alu_func(ALU_FuncD2),.alu_out(alu_out));`
221
222
223
224			`shifter sh1(.a(alu_right),.shift_out(shift_out),.shift_func(Shift_FuncD2),`
225			`.shift_amount(Shift_Amount));`
226
227			assign Shift_Amount=Shift_Amount_selD2==`SHIFT_AMOUNT_REG_SEL ?
228			`alu_left[4:0] : Shift_amountD2;`
229
230
231			`//alu left latch`
232			`always @(posedge clock) begin`
233			`begin`
234			`if (sadrD1==dadrD4 && WD4) alu_left_latch<=RRegin;`
235			`//OK`
236			`else if (sadrD1==dadrD5 && WD5) alu_left_latch<=RReg;//This must be priority encoder`
237			`else if (sadrD1==dadrD6 && WD6) alu_left_latch<=DReg;`
238			`else alu_left_latch<=source_out;`
239			`end`
240			`end`
241
242
243			`//alu right latch`
244			`always @(posedge clock) begin`
245			`begin`
246			`case (A_Right_SELD1)`
247			`Imm_signed : alu_right_latch<={ {16{IMMD1[15]}},IMMD1[15:0]};
248			`Imm_unsigned : alu_right_latch<={ 16'h000,IMMD1[15:0]};
249			`A_RIGHT_ERT : begin
250
251			`if (tadrD1==dadrD4 && WD4 ) alu_right_latch<=RRegin;`
252			`else //OK`
253			`if (tadrD1==dadrD5 && WD5 ) alu_right_latch<=RReg;`
254			`else if (tadrD1==dadrD6 && WD6) alu_right_latch<=DReg;`
255			`else alu_right_latch<=target_out;`
256			`end`
257			`IMM_26_SEL : begin
258			`alu_right_latch<={6'b00_0000,IMMD1};`
259			`end`
260			`default : alu_right_latch<={ {16{IMMD1[15]}},IMMD1[15:0]};`
261			`endcase`
262			`end`
263			`end`
264			`ifdef ALTERA
265			`ram_regfile32xx32 RFile(`
266			`.data(regfile_in),`
267			`.wraddress(dadrD5),`
268			`.rdaddress_a(target_addr),`
269			`.rdaddress_b(source_addr),`
270			`.wren(WD5),`
271			`.clock(clock),`
272			`.qa(target_out),`
273			`.qb(source_out));`
274			`else
275
276			`ram32x32_xilinx RFile (`
277			`.data(regfile_in),`
278			`.wraddress(dadrD5),`
279			`.rdaddress_a(target_addr),`
280			`.rdaddress_b(source_addr),`
281			`.wren(WD5),`
282			`.clock(clock),`
283			`.qa(target_out),`
284			`.qb(source_out));`
285			`endif
286			`assign regfile_in=dadrD5==5'b0_0000 ? 32'h0000_0000 :RReg;`
287
288
289
290
291			`always @* begin //`
292			`case (stest1D_dup1)`
293			`1'b1: alu_left[7:0]=AReg[7:0];`
294			`1'b0:`
295			`case(stest2D)`
296			`1'b1:`
297			`case (RRegSelD4_dup3)`
298			`MOUT_SEL : alu_left[7:0]=MOUT[7:0];
299			`NREG_SEL: alu_left[7:0]=NReg[7:0];
300			`endcase`
301			`1'b0: alu_left[7:0]=alu_left_latch[7:0];`
302			`endcase`
303			`endcase`
304			`end`
305
306			`always @* begin //`
307			`case (stest1D_dup2)`
308			`1'b1: alu_left[15:8]=AReg[15:8];`
309			`1'b0:`
310			`case(stest2D)`
311			`1'b1:`
312			`case (RRegSelD4_dup3)`
313			`MOUT_SEL : alu_left[15:8]=MOUT[15:8];
314			`NREG_SEL: alu_left[15:8]=NReg[15:8];
315			`endcase`
316			`1'b0: alu_left[15:8]=alu_left_latch[15:8];`
317			`endcase`
318			`endcase`
319			`end`
320
321			`always @* begin//`
322			`case (stest1D_dup3)`
323			`1'b1: alu_left[23:16]=AReg[23:16];`
324			`1'b0:`
325			`case(stest2D)`
326			`1'b1:`
327			`case (RRegSelD4_dup3)`
328			`MOUT_SEL : alu_left[23:16]=MOUT[23:16];
329			`NREG_SEL: alu_left[23:16]=NReg[23:16];
330			`endcase`
331			`1'b0: alu_left[23:16]=alu_left_latch[23:16];`
332			`endcase`
333			`endcase`
334			`end`
335
336			`always @* begin //`
337			`case (stest1D_dup4)`
338			`1'b1: alu_left[31:24]=AReg[31:24];`
339			`1'b0:`
340			`case(stest2D)`
341			`1'b1:`
342			`case (RRegSelD4_dup3)`
343			`MOUT_SEL : alu_left[31:24]=MOUT[31:24];
344			`NREG_SEL: alu_left[31:24]=NReg[31:24];
345			`endcase`
346			`1'b0: alu_left[31:24]=alu_left_latch[31:24];`
347			`endcase`
348			`endcase`
349			`end`
350
351
352
353
354			`assign alu_right=test1D ? AReg :`
355			`test2D ? RRegin : alu_right_latch;`
356
357			`always @(posedge clock) begin`
358			`stest1D<=(sadrD1==dest_addrD2) && wren;`
359			`stest1D_dup1<=(sadrD1==dest_addrD2) && wren;`
360			`stest1D_dup2<=(sadrD1==dest_addrD2) && wren;`
361			`stest1D_dup3<=(sadrD1==dest_addrD2) && wren;`
362			`stest1D_dup4<=(sadrD1==dest_addrD2) && wren;`
363
364			`end`
365			`always @(posedge clock) begin`
366			`stest2D<=(sadrD1==dadrD3) && WD3 ;`
367			`end`
368
369
370
371
372			`always @(posedge clock) begin`
373			test1D<=tadrD1==dest_addrD2 && (wren ) && A_Right_SELD1==`A_RIGHT_ERT;
374			`end`
375
376			`always @(posedge clock) begin`
377			test2D<=tadrD1==dadrD3 && (WD3 ) && A_Right_SELD1==`A_RIGHT_ERT;
378			`end`
379
380
381			`ifdef Veritak
382			`reg [30*8:1] alu_function;`
383			`reg [30*8:1] shift_function;`
384			`reg [30*8:1] AReg_Input_Sel;`
385
386			`always @*//Jan.20.2005 @(ALU_FuncD2,alu_left,alu_right)`
387			`case (ALU_FuncD2)`
388			`ALU_NOTHING : $sprintf(alu_function,"non_operation");
389			`ALU_ADD : $sprintf(alu_function,"ADD %h,%h",alu_left,alu_right);
390			`ALU_SUBTRACT :$sprintf(alu_function,"SUB %h,%h,alu_left,alu_right");
391			`ALU_LESS_THAN_UNSIGNED :$sprintf(alu_function ,"LT_Unsigned %h,%h",alu_left,alu_right);
392			`ALU_LESS_THAN_SIGNED : $sprintf(alu_function,"LT_Signed %h,%h",alu_left,alu_right);
393			`ALU_OR : $sprintf(alu_function,"OR %h,%h",alu_left,alu_right);
394			`ALU_AND : $sprintf(alu_function,"XOR %h,%h,alu_left,alu_right");
395			`ALU_XOR : $sprintf(alu_function,"AND %h,%h",alu_left,alu_right);
396			`ALU_NOR : $sprintf(alu_function,"NOR %h,%h",alu_left,alu_right);
397			`default: $sprintf(alu_function,"non_operation");`
398			`endcase`
399
400			`always @* begin //`
401			`case (Shift_FuncD2)`
402			`SHIFT_LEFT : $sprintf(shift_function,"SLL %d",Shift_Amount);
403			`SHIFT_RIGHT_UNSIGNED : $sprintf(shift_function,"SLR %d",Shift_Amount);
404			`SHIFT_RIGHT_SIGNED : $sprintf(shift_function,"SAR %d",Shift_Amount);
405			`default: $sprintf(shift_function,"non_operation");`
406			`endcase`
407			`end`
408
409
410			`always @* begin //`
411			`case (RF_inputD2)`
412			`RF_ALU_sel : $sprintf(AReg_Input_Sel,"ALU");
413			`RF_Shifter_sel: $sprintf(AReg_Input_Sel,"Shifter");
414			`SHIFT16_SEL: $sprintf(AReg_Input_Sel,"IMM16<<16");
415			`RF_PC_SEL : $sprintf(AReg_Input_Sel,"PC/MulOutSEL");
416			`endcase`
417			`end`
418
419
420			`endif
421
422
423
424
425			`endmodule`