Ignore:
Timestamp:
Jan 15, 2009, 6:19:08 PM (15 years ago)
Author:
rosiere
Message:

1) Add soc test
2) fix bug (Pc management, Decod and execute, Update prediction ...)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Execute_loop/Execute_loop/Multi_Execute_unit/Execute_unit/Functionnal_unit/Operation/src/Operation.cpp

    r100 r101  
    9090
    9191    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
    92     bool            carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
     92//  bool            carry_out = carry(param->_size_data,gpr1,gpr2,gpr3);
     93    // In ISA : l.sub don't change flag carry
     94    bool            carry_out  = get_flag(op->_data_rc,FLAG_CY);
    9395
    9496    // Result
    … …  
    104106
    105107#undef  FUNCTION
     108#define FUNCTION "Functionnal_unit::operation_l_mul"
     109  void operation_l_mul         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
     110  {
     111    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mul");
     112
     113    Tgeneral_data_t gpr1      = unsigned(param->_size_data,op->_data_ra);
     114    Tgeneral_data_t gpr2      = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
     115    Tgeneral_data_t gpr3      ;
     116    bool            overflow  ;
     117    bool            carry_out ;
     118
     119    if (param->_size_data == 32)
     120      {
     121        int64_t res = static_cast<int64_t>(gpr1) * static_cast<int64_t>(gpr2);
     122
     123        log_printf(TRACE,Functionnal_unit,FUNCTION,"  * res   : %llx",res);
     124
     125        gpr3      = param->_mask_data & static_cast<Tgeneral_data_t>(res);
     126        carry_out = res != gpr3;
     127        overflow  = carry_out;
     128      }
     129    else
     130      {
     131        throw ERRORMORPHEO(FUNCTION,_("64 bits multiplcation : not yet implemented\n"));
     132      }
     133
     134    // Result
     135    op->_timing       = param->_timing[op->_type][op->_operation];
     136    op->_data_rd      = gpr3;
     137    op->_data_re      = 0;
     138    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
     139    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
     140    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
     141    op->_no_sequence  = 0;
     142  //op->_address      = 0;
     143  };
     144
     145#undef  FUNCTION
     146#define FUNCTION "Functionnal_unit::operation_l_mulu"
     147  void operation_l_mulu        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
     148  {
     149    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_mulu");
     150
     151    Tgeneral_data_t gpr1      = unsigned(param->_size_data,op->_data_ra);
     152    Tgeneral_data_t gpr2      = unsigned(param->_size_data,op->_data_rb);
     153    Tgeneral_data_t gpr3      ;
     154    bool            overflow  ;
     155    bool            carry_out ;
     156
     157    if (param->_size_data == 32)
     158      {
     159        uint64_t res = static_cast<uint64_t>(gpr1) * static_cast<uint64_t>(gpr2);
     160
     161        log_printf(TRACE,Functionnal_unit,FUNCTION,"  * res   : %llx",res);
     162
     163        gpr3      = param->_mask_data & static_cast<Tgeneral_data_t>(res);
     164        carry_out = res != gpr3;
     165        overflow  = carry_out;
     166      }
     167    else
     168      {
     169        throw ERRORMORPHEO(FUNCTION,_("64 bits multiplcation : not yet implemented\n"));
     170      }
     171
     172    // Result
     173    op->_timing       = param->_timing[op->_type][op->_operation];
     174    op->_data_rd      = gpr3;
     175    op->_data_re      = 0;
     176    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
     177    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
     178    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
     179    op->_no_sequence  = 0;
     180  //op->_address      = 0;
     181  };
     182
     183#undef  FUNCTION
     184#define FUNCTION "Functionnal_unit::operation_l_div"
     185  void operation_l_div         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
     186  {
     187    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_div");
     188
     189    Tgeneral_data_t gpr1      = signed(param->_size_data,op->_data_ra);
     190    Tgeneral_data_t gpr2      = signed(param->_size_data,op->_data_rb);
     191    Tgeneral_data_t gpr3      = (gpr2!=0)?(gpr1/gpr2):0;
     192    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
     193    bool            carry_out = (gpr2==0);
     194
     195    // Result
     196    op->_timing       = param->_timing[op->_type][op->_operation];
     197    op->_data_rd      = gpr3;
     198    op->_data_re      = 0;
     199    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
     200    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
     201    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
     202    op->_no_sequence  = 0;
     203  //op->_address      = 0;
     204  };
     205
     206#undef  FUNCTION
     207#define FUNCTION "Functionnal_unit::operation_l_divu"
     208  void operation_l_divu        (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
     209  {
     210    log_printf(TRACE,Functionnal_unit,FUNCTION,"Operation : l_divu");
     211
     212    Tgeneral_data_t gpr1      = unsigned(param->_size_data,op->_data_ra);
     213    Tgeneral_data_t gpr2      = unsigned(param->_size_data,op->_data_rb);
     214    Tgeneral_data_t gpr3      = (gpr2!=0)?(gpr1/gpr2):0;
     215    bool            overflow  = ovf  (param->_size_data,gpr1,gpr2,gpr3);
     216    bool            carry_out = (gpr2==0);
     217
     218    // Result
     219    op->_timing       = param->_timing[op->_type][op->_operation];
     220    op->_data_rd      = gpr3;
     221    op->_data_re      = 0;
     222    op->_data_re      = set_flag(op->_data_re,FLAG_OV,overflow );
     223    op->_data_re      = set_flag(op->_data_re,FLAG_CY,carry_out);
     224    op->_exception    = (overflow==1)?EXCEPTION_ALU_RANGE:EXCEPTION_ALU_NONE;
     225    op->_no_sequence  = 0;
     226  //op->_address      = 0;
     227  };
     228
     229#undef  FUNCTION
    106230#define FUNCTION "Functionnal_unit::operation_l_and"
    107231  void operation_l_and         (execute_operation_t * op, execute_register_t * reg, execute_param_t * param)
    … …  
    465589    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
    466590
     591    // Tgeneral_data_t is unsigned
    467592    bool            f_out      = (gpr1 >= gpr2);
    468593
    … …  
    485610    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
    486611
     612    // Tgeneral_data_t is unsigned
    487613    bool            f_out      = (gpr1 >  gpr2);
    488614
    … …  
    505631    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
    506632
     633    // Tgeneral_data_t is unsigned
    507634    bool            f_out      = (gpr1 <= gpr2);
    508635
    … …  
    525652    Tgeneral_data_t gpr2       = unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb);
    526653
     654    // Tgeneral_data_t is unsigned
    527655    bool            f_out      = (gpr1 <  gpr2);
    528656
    … …  
    544672    Tgeneral_data_t gpr1       =   op->_data_ra;
    545673    Tgeneral_data_t gpr2       =   (op->_has_immediat==1)?op->_immediat:op->_data_rb;
    546    
    547     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ra  : %.8x",unsigned(param->_size_data,op->_data_ra));
    548     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_ras : %.8x",  signed(param->_size_data,op->_data_ra));
    549     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rb  : %.8x",unsigned(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
    550     log_printf(TRACE,Functionnal_unit,FUNCTION," * data_rbs : %.8x",  signed(param->_size_data,(op->_has_immediat==1)?op->_immediat:op->_data_rb));
    551    
     674       
    552675    bool            f_out;
    553676
    554     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
    555       {
    556       case 1 /*b01*/ : f_out = 1                               ; break;
    557       case 2 /*b10*/ : f_out = 0                               ; break;
    558       default        : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
    559       }
    560 
    561     log_printf(TRACE,Functionnal_unit,FUNCTION," * f_out    : %.8x",f_out);
     677    if (param->_size_data == 32)
     678      f_out = static_cast<int32_t>(gpr1) >= static_cast<int32_t>(gpr2);
     679    else
     680      f_out = static_cast<int64_t>(gpr1) >= static_cast<int64_t>(gpr2);
     681
     682//     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
     683//       {
     684//       case 1 /*b01*/ : f_out = 1                               ; break;
     685//       case 2 /*b10*/ : f_out = 0                               ; break;
     686//       default        : f_out = signed(param->_size_data,gpr1) >= signed(param->_size_data,gpr2); break;
     687//       }
    562688
    563689    // Result
    … …  
    581707    bool            f_out;
    582708
    583     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
    584       {
    585       case 1 /*b01*/ : f_out = 1; break;
    586       case 2 /*b10*/ : f_out = 0; break;
    587       default        : f_out = signed(param->_size_data,gpr1) >  signed(param->_size_data,gpr2); break;
    588       }
     709    if (param->_size_data == 32)
     710      f_out = static_cast<int32_t>(gpr1) >  static_cast<int32_t>(gpr2);
     711    else
     712      f_out = static_cast<int64_t>(gpr1) >  static_cast<int64_t>(gpr2);
     713
     714//     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
     715//       {
     716//       case 1 /*b01*/ : f_out = 1; break;
     717//       case 2 /*b10*/ : f_out = 0; break;
     718//       default        : f_out = signed(param->_size_data,gpr1) >  signed(param->_size_data,gpr2); break;
     719//       }
    589720
    590721    // Result
    … …  
    608739    bool            f_out;
    609740
    610     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
    611       {
    612       case 1 /*b01*/ : f_out = 0; break;
    613       case 2 /*b10*/ : f_out = 1; break;
    614       default        : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
    615       }
     741    if (param->_size_data == 32)
     742      f_out = static_cast<int32_t>(gpr1) <= static_cast<int32_t>(gpr2);
     743    else
     744      f_out = static_cast<int64_t>(gpr1) <= static_cast<int64_t>(gpr2);
     745
     746//     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
     747//       {
     748//       case 1 /*b01*/ : f_out = 0; break;
     749//       case 2 /*b10*/ : f_out = 1; break;
     750//       default        : f_out = signed(param->_size_data,gpr1) <= signed(param->_size_data,gpr2); break;
     751//       }
    616752   
    617753    // Result
    … …  
    635771    bool            f_out;
    636772
    637     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
    638       {
    639       case 1 /*b01*/ : f_out = 0; break;
    640       case 2 /*b10*/ : f_out = 1; break;
    641       default        : f_out = signed(param->_size_data,gpr1) <  signed(param->_size_data,gpr2); break;
    642       }
     773    if (param->_size_data == 32)
     774      f_out = static_cast<int32_t>(gpr1) <  static_cast<int32_t>(gpr2);
     775    else
     776      f_out = static_cast<int64_t>(gpr1) <  static_cast<int64_t>(gpr2);
     777
     778//     switch (concatenation_bool(sign(param->_size_data,gpr1),sign(param->_size_data,gpr2)))
     779//       {
     780//       case 1 /*b01*/ : f_out = 0; break;
     781//       case 2 /*b10*/ : f_out = 1; break;
     782//       default        : f_out = signed(param->_size_data,gpr1) <  signed(param->_size_data,gpr2); break;
     783//       }
    643784
    644785    // Result
Note: See TracChangeset for help on using the changeset viewer.