OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [or1200/] [rtl/] [verilog/] [or1200_fpu_pre_norm_addsub.v] - Diff between revs 258 and 364

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 258 Rev 364
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
////                                                              ////
////                                                              ////
////  or1200_fpu_pre_norm_addsub                                  ////
////  or1200_fpu_pre_norm_addsub                                  ////
////                                                              ////
////                                                              ////
////  This file is part of the OpenRISC 1200 project              ////
////  This file is part of the OpenRISC 1200 project              ////
////  http://opencores.org/project,or1k                           ////
////  http://opencores.org/project,or1k                           ////
////                                                              ////
////                                                              ////
////  Description                                                 ////
////  Description                                                 ////
////  pre-normalization entity for the addition/subtraction unit  ////
////  pre-normalization entity for the addition/subtraction unit  ////
////                                                              ////
////                                                              ////
////  To Do:                                                      ////
////  To Do:                                                      ////
////                                                              ////
////                                                              ////
////                                                              ////
////                                                              ////
////  Author(s):                                                  ////
////  Author(s):                                                  ////
////      - Original design (FPU100) -                            ////
////      - Original design (FPU100) -                            ////
////        Jidan Al-eryani, jidan@gmx.net                        ////
////        Jidan Al-eryani, jidan@gmx.net                        ////
////      - Conv. to Verilog and inclusion in OR1200 -            ////
////      - Conv. to Verilog and inclusion in OR1200 -            ////
////        Julius Baxter, julius@opencores.org                   ////
////        Julius Baxter, julius@opencores.org                   ////
////                                                              ////
////                                                              ////
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
//
//
//  Copyright (C) 2006, 2010
//  Copyright (C) 2006, 2010
//
//
//      This source file may be used and distributed without        
//      This source file may be used and distributed without        
//      restriction provided that this copyright statement is not   
//      restriction provided that this copyright statement is not   
//      removed from the file and that any derivative work contains 
//      removed from the file and that any derivative work contains 
//      the original copyright notice and the associated disclaimer.
//      the original copyright notice and the associated disclaimer.
//                                                           
//                                                           
//              THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     
//              THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY     
//      EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   
//      EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED   
//      TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   
//      TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS   
//      FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      
//      FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL THE AUTHOR      
//      OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         
//      OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,         
//      INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    
//      INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES    
//      (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   
//      (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE   
//      GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        
//      GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR        
//      BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  
//      BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF  
//      LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  
//      LIABILITY, WHETHER IN  CONTRACT, STRICT LIABILITY, OR TORT  
//      (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  
//      (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT  
//      OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         
//      OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         
//      POSSIBILITY OF SUCH DAMAGE. 
//      POSSIBILITY OF SUCH DAMAGE. 
//
//
 
 
module or1200_fpu_pre_norm_addsub (
module or1200_fpu_pre_norm_addsub (
 
 
                        clk_i,
                        clk_i,
                        opa_i,
                        opa_i,
                        opb_i,
                        opb_i,
                        fracta_28_o,
                        fracta_28_o,
                        fractb_28_o,
                        fractb_28_o,
                        exp_o
                        exp_o
                        );
                        );
 
 
   parameter FP_WIDTH = 32;
   parameter FP_WIDTH = 32;
   parameter MUL_SERIAL = 0; // 0 for parallel multiplier, 1 for serial
   parameter MUL_SERIAL = 0; // 0 for parallel multiplier, 1 for serial
   parameter MUL_COUNT = 11; //11 for parallel multiplier, 34 for serial
   parameter MUL_COUNT = 11; //11 for parallel multiplier, 34 for serial
   parameter FRAC_WIDTH = 23;
   parameter FRAC_WIDTH = 23;
   parameter EXP_WIDTH = 8;
   parameter EXP_WIDTH = 8;
   parameter ZERO_VECTOR = 31'd0;
   parameter ZERO_VECTOR = 31'd0;
   parameter INF = 31'b1111111100000000000000000000000;
   parameter INF = 31'b1111111100000000000000000000000;
   parameter QNAN = 31'b1111111110000000000000000000000;
   parameter QNAN = 31'b1111111110000000000000000000000;
   parameter SNAN = 31'b1111111100000000000000000000001;
   parameter SNAN = 31'b1111111100000000000000000000001;
 
 
 
 
   input clk_i;
   input clk_i;
   input [FP_WIDTH-1:0] opa_i;
   input [FP_WIDTH-1:0] opa_i;
   input [FP_WIDTH-1:0] opb_i;
   input [FP_WIDTH-1:0] opb_i;
   // carry(1) & hidden(1) & fraction(23) & guard(1) & round(1) & sticky(1)
   // carry(1) & hidden(1) & fraction(23) & guard(1) & round(1) & sticky(1)
   output reg [FRAC_WIDTH+4:0] fracta_28_o;
   output reg [FRAC_WIDTH+4:0] fracta_28_o;
   output reg [FRAC_WIDTH+4:0] fractb_28_o;
   output reg [FRAC_WIDTH+4:0] fractb_28_o;
   output reg [EXP_WIDTH-1:0]  exp_o;
   output reg [EXP_WIDTH-1:0]  exp_o;
 
 
   reg [EXP_WIDTH-1 : 0]       s_exp_o ;
   reg [EXP_WIDTH-1 : 0]       s_exp_o ;
   wire [FRAC_WIDTH+4 : 0]     s_fracta_28_o, s_fractb_28_o ;
   wire [FRAC_WIDTH+4 : 0]     s_fracta_28_o, s_fractb_28_o ;
   wire [EXP_WIDTH-1 : 0]      s_expa;
   wire [EXP_WIDTH-1 : 0]      s_expa;
   wire [EXP_WIDTH-1 : 0]      s_expb ;
   wire [EXP_WIDTH-1 : 0]      s_expb ;
   wire [FRAC_WIDTH-1 : 0]     s_fracta;
   wire [FRAC_WIDTH-1 : 0]     s_fracta;
   wire [FRAC_WIDTH-1 : 0]     s_fractb ;
   wire [FRAC_WIDTH-1 : 0]     s_fractb ;
   wire [FRAC_WIDTH+4 : 0]     s_fracta_28;
   wire [FRAC_WIDTH+4 : 0]     s_fracta_28;
 
 
   wire [FRAC_WIDTH+4 : 0]     s_fractb_28 ;
   wire [FRAC_WIDTH+4 : 0]     s_fractb_28 ;
 
 
   wire [FRAC_WIDTH+4 : 0]     s_fract_sm_28;
   wire [FRAC_WIDTH+4 : 0]     s_fract_sm_28;
   wire [FRAC_WIDTH+4 : 0]     s_fract_shr_28 ;
   wire [FRAC_WIDTH+4 : 0]     s_fract_shr_28 ;
 
 
   reg [EXP_WIDTH-1 : 0]       s_exp_diff ;
   reg [EXP_WIDTH-1 : 0]       s_exp_diff ;
   reg [5 : 0]                  s_rzeros ;
   reg [5 : 0]                  s_rzeros ;
   wire                        s_expa_eq_expb;
   wire                        s_expa_eq_expb;
   wire                        s_expa_gt_expb;
   wire                        s_expa_gt_expb;
   wire                        s_fracta_1;
   wire                        s_fracta_1;
   wire                        s_fractb_1;
   wire                        s_fractb_1;
   wire                        s_op_dn,s_opa_dn, s_opb_dn;
   wire                        s_op_dn,s_opa_dn, s_opb_dn;
   wire [1 : 0]         s_mux_diff ;
   wire [1 : 0]         s_mux_diff ;
   wire                        s_mux_exp;
   wire                        s_mux_exp;
   wire                        s_sticky;
   wire                        s_sticky;
 
 
 
 
   assign s_expa = opa_i[30:23];
   assign s_expa = opa_i[30:23];
   assign s_expb = opb_i[30:23];
   assign s_expb = opb_i[30:23];
   assign s_fracta = opa_i[22:0];
   assign s_fracta = opa_i[22:0];
   assign s_fractb = opb_i[22:0];
   assign s_fractb = opb_i[22:0];
 
 
   always @(posedge clk_i)
   always @(posedge clk_i)
     begin
     begin
        exp_o <= s_exp_o;
        exp_o <= s_exp_o;
        fracta_28_o <= s_fracta_28_o;
        fracta_28_o <= s_fracta_28_o;
        fractb_28_o <= s_fractb_28_o;
        fractb_28_o <= s_fractb_28_o;
     end
     end
 
 
   assign s_expa_eq_expb = (s_expa == s_expb);
   assign s_expa_eq_expb = (s_expa == s_expb);
 
 
   assign s_expa_gt_expb = (s_expa > s_expb);
   assign s_expa_gt_expb = (s_expa > s_expb);
 
 
   // '1' if fraction is not zero
   // '1' if fraction is not zero
   assign s_fracta_1 = |s_fracta;
   assign s_fracta_1 = |s_fracta;
   assign s_fractb_1 = |s_fractb;
   assign s_fractb_1 = |s_fractb;
 
 
   // opa or Opb is denormalized
   // opa or Opb is denormalized
   assign s_opa_dn = !(|s_expa);
   assign s_opa_dn = !(|s_expa);
   assign s_opb_dn = !(|s_expb);
   assign s_opb_dn = !(|s_expb);
   assign s_op_dn = s_opa_dn | s_opb_dn;
   assign s_op_dn = s_opa_dn | s_opb_dn;
 
 
   // Output larger exponent
   // Output larger exponent
   assign s_mux_exp = s_expa_gt_expb;
   assign s_mux_exp = s_expa_gt_expb;
 
 
   always @(posedge clk_i)
   always @(posedge clk_i)
     s_exp_o <= s_mux_exp ? s_expa : s_expb;
     s_exp_o <= s_mux_exp ? s_expa : s_expb;
 
 
   // convert to an easy to handle floating-point format
   // convert to an easy to handle floating-point format
   assign s_fracta_28 = s_opa_dn ?
   assign s_fracta_28 = s_opa_dn ?
                        {2'b00, s_fracta, 3'b000} : {2'b01, s_fracta, 3'b000};
                        {2'b00, s_fracta, 3'b000} : {2'b01, s_fracta, 3'b000};
   assign s_fractb_28 = s_opb_dn ?
   assign s_fractb_28 = s_opb_dn ?
                        {2'b00, s_fractb, 3'b000} : {2'b01, s_fractb, 3'b000};
                        {2'b00, s_fractb, 3'b000} : {2'b01, s_fractb, 3'b000};
 
 
   assign s_mux_diff = {s_expa_gt_expb, s_opa_dn ^ s_opb_dn};
   assign s_mux_diff = {s_expa_gt_expb, s_opa_dn ^ s_opb_dn};
 
 
   // calculate howmany postions the fraction will be shifted
   // calculate howmany postions the fraction will be shifted
   always @(posedge clk_i)
   always @(posedge clk_i)
     begin
     begin
        case(s_mux_diff)
        case(s_mux_diff)
           2'b00: s_exp_diff <= s_expb - s_expa;
           2'b00: s_exp_diff <= s_expb - s_expa;
           2'b01: s_exp_diff <= s_expb - (s_expa + 8'd1);
           2'b01: s_exp_diff <= s_expb - (s_expa + 8'd1);
           2'b10: s_exp_diff <= s_expa - s_expb;
           2'b10: s_exp_diff <= s_expa - s_expb;
           2'b11: s_exp_diff <= s_expa - (s_expb + 8'd1);
           2'b11: s_exp_diff <= s_expa - (s_expb + 8'd1);
        endcase
        endcase
     end
     end
 
 
   assign s_fract_sm_28 =  s_expa_gt_expb ? s_fractb_28 : s_fracta_28;
   assign s_fract_sm_28 =  s_expa_gt_expb ? s_fractb_28 : s_fracta_28;
 
 
   // shift-right the fraction if necessary
   // shift-right the fraction if necessary
   assign s_fract_shr_28 = s_fract_sm_28 >> s_exp_diff;
   assign s_fract_shr_28 = s_fract_sm_28 >> s_exp_diff;
 
 
   // count the zeros from right to check if result is inexact
   // count the zeros from right to check if result is inexact
   always @(s_fract_sm_28)
   always @(s_fract_sm_28)
     casex(s_fract_sm_28) // synopsys full_case parallel_case
     casez(s_fract_sm_28) // synopsys full_case parallel_case
       28'b???????????????????????????1: s_rzeros <= 0;
       28'b???????????????????????????1: s_rzeros = 0;
       28'b??????????????????????????10: s_rzeros <= 1;
       28'b??????????????????????????10: s_rzeros = 1;
       28'b?????????????????????????100: s_rzeros <= 2;
       28'b?????????????????????????100: s_rzeros = 2;
       28'b????????????????????????1000: s_rzeros <= 3;
       28'b????????????????????????1000: s_rzeros = 3;
       28'b???????????????????????10000: s_rzeros <= 4;
       28'b???????????????????????10000: s_rzeros = 4;
       28'b??????????????????????100000: s_rzeros <= 5;
       28'b??????????????????????100000: s_rzeros = 5;
       28'b?????????????????????1000000: s_rzeros <= 6;
       28'b?????????????????????1000000: s_rzeros = 6;
       28'b????????????????????10000000: s_rzeros <= 7;
       28'b????????????????????10000000: s_rzeros = 7;
       28'b???????????????????100000000: s_rzeros <= 8;
       28'b???????????????????100000000: s_rzeros = 8;
       28'b??????????????????1000000000: s_rzeros <= 9;
       28'b??????????????????1000000000: s_rzeros = 9;
       28'b?????????????????10000000000: s_rzeros <= 10;
       28'b?????????????????10000000000: s_rzeros = 10;
       28'b????????????????100000000000: s_rzeros <= 11;
       28'b????????????????100000000000: s_rzeros = 11;
       28'b???????????????1000000000000: s_rzeros <= 12;
       28'b???????????????1000000000000: s_rzeros = 12;
       28'b??????????????10000000000000: s_rzeros <= 13;
       28'b??????????????10000000000000: s_rzeros = 13;
       28'b?????????????100000000000000: s_rzeros <= 14;
       28'b?????????????100000000000000: s_rzeros = 14;
       28'b????????????1000000000000000: s_rzeros <= 15;
       28'b????????????1000000000000000: s_rzeros = 15;
       28'b???????????10000000000000000: s_rzeros <= 16;
       28'b???????????10000000000000000: s_rzeros = 16;
       28'b??????????100000000000000000: s_rzeros <= 17;
       28'b??????????100000000000000000: s_rzeros = 17;
       28'b?????????1000000000000000000: s_rzeros <= 18;
       28'b?????????1000000000000000000: s_rzeros = 18;
       28'b????????10000000000000000000: s_rzeros <= 19;
       28'b????????10000000000000000000: s_rzeros = 19;
       28'b???????100000000000000000000: s_rzeros <= 20;
       28'b???????100000000000000000000: s_rzeros = 20;
       28'b??????1000000000000000000000: s_rzeros <= 21;
       28'b??????1000000000000000000000: s_rzeros = 21;
       28'b?????10000000000000000000000: s_rzeros <= 22;
       28'b?????10000000000000000000000: s_rzeros = 22;
       28'b????100000000000000000000000: s_rzeros <= 23;
       28'b????100000000000000000000000: s_rzeros = 23;
       28'b???1000000000000000000000000: s_rzeros <= 24;
       28'b???1000000000000000000000000: s_rzeros = 24;
       28'b??10000000000000000000000000: s_rzeros <= 25;
       28'b??10000000000000000000000000: s_rzeros = 25;
       28'b?100000000000000000000000000: s_rzeros <= 26;
       28'b?100000000000000000000000000: s_rzeros = 26;
       28'b1000000000000000000000000000: s_rzeros <= 27;
       28'b1000000000000000000000000000: s_rzeros = 27;
       28'b0000000000000000000000000000: s_rzeros <= 28;
       28'b0000000000000000000000000000: s_rzeros = 28;
     endcase // casex (s_fract_sm_28)
     endcase // casex (s_fract_sm_28)
 
 
   assign s_sticky = (s_exp_diff > s_rzeros) & (|s_fract_sm_28);
   assign s_sticky = (s_exp_diff > {2'b00,s_rzeros}) & (|s_fract_sm_28);
 
 
   assign s_fracta_28_o = s_expa_gt_expb ?
   assign s_fracta_28_o = s_expa_gt_expb ?
                          s_fracta_28 :
                          s_fracta_28 :
                          {s_fract_shr_28[27:1],(s_sticky|s_fract_shr_28[0])};
                          {s_fract_shr_28[27:1],(s_sticky|s_fract_shr_28[0])};
 
 
   assign s_fractb_28_o =  s_expa_gt_expb ?
   assign s_fractb_28_o =  s_expa_gt_expb ?
                           {s_fract_shr_28[27:1],(s_sticky|s_fract_shr_28[0])} :
                           {s_fract_shr_28[27:1],(s_sticky|s_fract_shr_28[0])} :
                           s_fractb_28;
                           s_fractb_28;
 
 
endmodule // or1200_fpu_pre_norm_addsub
endmodule // or1200_fpu_pre_norm_addsub
 
 
 
 
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.