Ignore:
Timestamp:
Dec 10, 2008, 7:31:39 PM (16 years ago)
Author:
rosiere
Message:

Almost complete design
with Test and test platform

Location:
trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/include/Types.h

    r86 r88  
    3939    Ttype_t             _type              ;
    4040    Toperation_t        _operation         ;
     41    Tcontrol_t          _no_execute        ;
    4142    Tcontrol_t          _has_immediat      ;
    4243    Tgeneral_data_t     _immediat          ;
    … …  
    5253    Tspecial_address_t  _num_reg_re        ;
    5354    Texception_t        _exception_use     ;
     55    Texception_t        _exception         ;
    5456    Tbranch_condition_t _branch_condition  ;
    5557//     Tcontrol_t          _branch_stack_write;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/src/Instruction.cpp

    r86 r88  
    1414#include "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Instruction/include/Instruction.h"
    1515#include "Behavioural/include/Constants.h"
     16#include "Behavioural/include/Operation.h"
    1617
    1718namespace morpheo {
    … …  
    124125       
    125126    inst->_exception_use = EXCEPTION_USE_ILLEGAL_INSTRUCTION;
     127    inst->_exception     = EXCEPTION_ILLEGAL_INSTRUCTION;
    126128
    127129    if (inst->_is_delay_slot)
    … …  
    138140
    139141    uint32_t opcod = range<uint32_t>(inst->_instruction,31,26);
    140 
    141     inst->_type = TYPE_CUSTOM;
     142   
    142143    switch (opcod)
    143144      {
    144       case OPCOD_L_CUST1 : {inst->_operation = OPERATION_CUSTOM_L_1; break;}
    145       case OPCOD_L_CUST2 : {inst->_operation = OPERATION_CUSTOM_L_2; break;}
    146       case OPCOD_L_CUST3 : {inst->_operation = OPERATION_CUSTOM_L_3; break;}
    147       case OPCOD_L_CUST4 : {inst->_operation = OPERATION_CUSTOM_L_4; break;}
    148       case OPCOD_L_CUST5 : {inst->_operation = OPERATION_CUSTOM_L_5; break;}
    149       case OPCOD_L_CUST6 : {inst->_operation = OPERATION_CUSTOM_L_6; break;}
    150       case OPCOD_L_CUST7 : {inst->_operation = OPERATION_CUSTOM_L_7; break;}
    151       case OPCOD_L_CUST8 : {inst->_operation = OPERATION_CUSTOM_L_8; break;}
     145      case OPCOD_L_CUST1 : {inst->_type = instruction_information(INSTRUCTION_L_CUST1)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST1)._operation; break;}
     146      case OPCOD_L_CUST2 : {inst->_type = instruction_information(INSTRUCTION_L_CUST2)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST2)._operation; break;}
     147      case OPCOD_L_CUST3 : {inst->_type = instruction_information(INSTRUCTION_L_CUST3)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST3)._operation; break;}
     148      case OPCOD_L_CUST4 : {inst->_type = instruction_information(INSTRUCTION_L_CUST4)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST4)._operation; break;}
     149      case OPCOD_L_CUST5 : {inst->_type = instruction_information(INSTRUCTION_L_CUST5)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST5)._operation; break;}
     150      case OPCOD_L_CUST6 : {inst->_type = instruction_information(INSTRUCTION_L_CUST6)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST6)._operation; break;}
     151      case OPCOD_L_CUST7 : {inst->_type = instruction_information(INSTRUCTION_L_CUST7)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST7)._operation; break;}
     152      case OPCOD_L_CUST8 : {inst->_type = instruction_information(INSTRUCTION_L_CUST8)._type; inst->_operation = instruction_information(INSTRUCTION_L_CUST8)._operation; break;}
     153
    152154      default            : {throw ERRORMORPHEO("instruction_l_custom",_("Invalid Custom Opcod."));}
    153155      }
    … …  
    164166    uint32_t opcod = range<uint32_t>(inst->_instruction, 7, 0);
    165167
    166     inst->_type = TYPE_CUSTOM;
    167168    switch (opcod)
    168169      {
    169 //       case OPCOD_LF_CUST1_D : {inst->_operation = OPERATION_CUSTOM_LF_1_D; break;}
    170 //       case OPCOD_LF_CUST1_S : {inst->_operation = OPERATION_CUSTOM_LF_1_S; break;}
     170//       case OPCOD_LF_CUST1_D : {inst->_type = instruction_information(INSTRUCTION_LF_CUST1_D)._type; inst->_operation = instruction_information(INSTRUCTION_LF_CUST1_D)._operation; break;}
     171//       case OPCOD_LF_CUST1_S : {inst->_type = instruction_information(INSTRUCTION_LF_CUST1_S)._type; inst->_operation = instruction_information(INSTRUCTION_LF_CUST1_S)._operation; break;}
    171172      default               : {throw ERRORMORPHEO("instruction_lf_custom",_("Invalid Custom Opcod."));}
    172173      }
    … …  
    183184    uint32_t opcod = range<uint32_t>(inst->_instruction, 7, 0);
    184185
    185     inst->_type = TYPE_CUSTOM;
    186186    switch (opcod)
    187187      {
    188 //       case OPCOD_LV_CUST1 : {inst->_operation = OPERATION_CUSTOM_LV_1; break;}
    189 //       case OPCOD_LV_CUST2 : {inst->_operation = OPERATION_CUSTOM_LV_2; break;}
    190 //       case OPCOD_LV_CUST3 : {inst->_operation = OPERATION_CUSTOM_LV_3; break;}
    191 //       case OPCOD_LV_CUST4 : {inst->_operation = OPERATION_CUSTOM_LV_4; break;}
     188//       case OPCOD_LV_CUST1 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST1)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST1)._operation; break;}
     189//       case OPCOD_LV_CUST2 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST2)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST2)._operation; break;}
     190//       case OPCOD_LV_CUST3 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST3)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST3)._operation; break;}
     191//       case OPCOD_LV_CUST4 : {inst->_type = instruction_information(INSTRUCTION_LV_CUST4)._type; inst->_operation = instruction_information(INSTRUCTION_LV_CUST4)._operation; break;}
    192192      default             : {throw ERRORMORPHEO("instruction_lv_custom",_("Invalid Custom Opcod."));}
    193193      }
    … …  
    252252  {
    253253    log_printf(TRACE,Decod,"instruction_l_add","  * instruction   : l.add");
    254     inst->_type               = TYPE_ALU;
    255     inst->_operation          = OPERATION_ALU_L_ADD;
     254    inst->_type               = instruction_information(INSTRUCTION_L_ADD)._type     ; //TYPE_ALU;
     255    inst->_operation          = instruction_information(INSTRUCTION_L_ADD)._operation; //OPERATION_ALU_L_ADD;
    256256    inst->_has_immediat       = 0;
    257257//  inst->_immediat           = ;
    … …  
    267267    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    268268    inst->_exception_use      = EXCEPTION_USE_RANGE;
    269 //  inst->_branch_condition   = ;
    270 //  inst->_branch_stack_write = ;
    271 //  inst->_branch_direction   = ;
    272 //  inst->_address_next       = ;
     269    inst->_exception          = EXCEPTION_DECOD_NONE;
     270//  inst->_branch_condition   = ;
     271//  inst->_branch_stack_write = ;
     272//  inst->_branch_direction   = ;
     273//  inst->_address_next       = ;
     274    inst->_no_execute         = 0;
    273275    inst->_event_type         = EVENT_TYPE_NONE;
    274276  }
    … …  
    278280    log_printf(TRACE,Decod,"instruction_l_addc","  * instruction   : l.addc");
    279281
    280     inst->_type               = TYPE_ALU;
    281     inst->_operation          = OPERATION_ALU_L_ADD;
     282    inst->_type               = instruction_information(INSTRUCTION_L_ADDC)._type     ; //TYPE_ALU;
     283    inst->_operation          = instruction_information(INSTRUCTION_L_ADDC)._operation; //OPERATION_ALU_L_ADD;
    282284    inst->_has_immediat       = 0;
    283285//  inst->_immediat           = ;
    … …  
    293295    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    294296    inst->_exception_use      = EXCEPTION_USE_RANGE;
    295 //  inst->_branch_condition   = ;
    296 //  inst->_branch_stack_write = ;
    297 //  inst->_branch_direction   = ;
    298 //  inst->_address_next       = ;
     297    inst->_exception          = EXCEPTION_DECOD_NONE;
     298//  inst->_branch_condition   = ;
     299//  inst->_branch_stack_write = ;
     300//  inst->_branch_direction   = ;
     301//  inst->_address_next       = ;
     302    inst->_no_execute         = 0;
    299303    inst->_event_type         = EVENT_TYPE_NONE;
    300304  }
    … …  
    304308    log_printf(TRACE,Decod,"instruction_l_addi","  * instruction   : l.addi");
    305309
    306     inst->_type               = TYPE_ALU;
    307     inst->_operation          = OPERATION_ALU_L_ADD;
     310    inst->_type               = instruction_information(INSTRUCTION_L_ADDI)._type     ; //TYPE_ALU;
     311    inst->_operation          = instruction_information(INSTRUCTION_L_ADDI)._operation; //OPERATION_ALU_L_ADD;
    308312    inst->_has_immediat       = 1;
    309313    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    319323    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    320324    inst->_exception_use      = EXCEPTION_USE_RANGE;
    321 //  inst->_branch_condition   = ;
    322 //  inst->_branch_stack_write = ;
    323 //  inst->_branch_direction   = ;
    324 //  inst->_address_next       = ;
     325    inst->_exception          = EXCEPTION_DECOD_NONE;
     326//  inst->_branch_condition   = ;
     327//  inst->_branch_stack_write = ;
     328//  inst->_branch_direction   = ;
     329//  inst->_address_next       = ;
     330    inst->_no_execute         = 0;
    325331    inst->_event_type         = EVENT_TYPE_NONE;
    326332  }
    … …  
    330336    log_printf(TRACE,Decod,"instruction_l_addic","  * instruction   : l.addic");
    331337
    332     inst->_type               = TYPE_ALU;
    333     inst->_operation          = OPERATION_ALU_L_ADD;
     338    inst->_type               = instruction_information(INSTRUCTION_L_ADDIC)._type     ; //TYPE_ALU;
     339    inst->_operation          = instruction_information(INSTRUCTION_L_ADDIC)._operation; //OPERATION_ALU_L_ADD;
    334340    inst->_has_immediat       = 1;
    335341    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    345351    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    346352    inst->_exception_use      = EXCEPTION_USE_RANGE;
    347 //  inst->_branch_condition   = ;
    348 //  inst->_branch_stack_write = ;
    349 //  inst->_branch_direction   = ;
    350 //  inst->_address_next       = ;
     353    inst->_exception          = EXCEPTION_DECOD_NONE;
     354//  inst->_branch_condition   = ;
     355//  inst->_branch_stack_write = ;
     356//  inst->_branch_direction   = ;
     357//  inst->_address_next       = ;
     358    inst->_no_execute         = 0;
    351359    inst->_event_type         = EVENT_TYPE_NONE;
    352360  }
    … …  
    356364    log_printf(TRACE,Decod,"instruction_l_and","  * instruction   : l.and");
    357365
    358     inst->_type               = TYPE_ALU;
    359     inst->_operation          = OPERATION_ALU_L_AND;
    360     inst->_has_immediat       = 0;
    361 //  inst->_immediat           = ;
    362     inst->_read_ra            = 1;
    363     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    364     inst->_read_rb            = 1;
    365     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    366     inst->_read_rc            = 0;
    367 //  inst->_num_reg_rc         = ;
    368     inst->_write_rd           = 1;
    369     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    370     inst->_write_re           = 0;
    371 //  inst->_num_reg_re         = ;
    372     inst->_exception_use      = EXCEPTION_USE_NONE;
    373 //  inst->_branch_condition   = ;
    374 //  inst->_branch_stack_write = ;
    375 //  inst->_branch_direction   = ;
    376 //  inst->_address_next       = ;
     366    inst->_type               = instruction_information(INSTRUCTION_L_AND)._type     ; //TYPE_ALU;
     367    inst->_operation          = instruction_information(INSTRUCTION_L_AND)._operation; //OPERATION_ALU_L_AND;
     368    inst->_has_immediat       = 0;
     369//  inst->_immediat           = ;
     370    inst->_read_ra            = 1;
     371    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     372    inst->_read_rb            = 1;
     373    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     374    inst->_read_rc            = 0;
     375//  inst->_num_reg_rc         = ;
     376    inst->_write_rd           = 1;
     377    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     378    inst->_write_re           = 0;
     379//  inst->_num_reg_re         = ;
     380    inst->_exception_use      = EXCEPTION_USE_NONE;
     381    inst->_exception          = EXCEPTION_DECOD_NONE;
     382//  inst->_branch_condition   = ;
     383//  inst->_branch_stack_write = ;
     384//  inst->_branch_direction   = ;
     385//  inst->_address_next       = ;
     386    inst->_no_execute         = 0;
    377387    inst->_event_type         = EVENT_TYPE_NONE;
    378388  }
    … …  
    382392    log_printf(TRACE,Decod,"instruction_l_andi","  * instruction   : l.andi");
    383393
    384     inst->_type               = TYPE_ALU;
    385     inst->_operation          = OPERATION_ALU_L_AND;
     394    inst->_type               = instruction_information(INSTRUCTION_L_ANDI)._type     ; //TYPE_ALU;
     395    inst->_operation          = instruction_information(INSTRUCTION_L_ANDI)._operation; //OPERATION_ALU_L_AND;
    386396    inst->_has_immediat       = 1;
    387397    inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    397407//  inst->_num_reg_re         = ;
    398408    inst->_exception_use      = EXCEPTION_USE_NONE;
    399 //  inst->_branch_condition   = ;
    400 //  inst->_branch_stack_write = ;
    401 //  inst->_branch_direction   = ;
    402 //  inst->_address_next       = ;
     409    inst->_exception          = EXCEPTION_DECOD_NONE;
     410//  inst->_branch_condition   = ;
     411//  inst->_branch_stack_write = ;
     412//  inst->_branch_direction   = ;
     413//  inst->_address_next       = ;
     414    inst->_no_execute         = 0;
    403415    inst->_event_type         = EVENT_TYPE_NONE;
    404416  }
    … …  
    408420    log_printf(TRACE,Decod,"instruction_l_bf","  * instruction   : l.bf");
    409421
    410     Tgeneral_data_t address_next = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
    411 
    412     inst->_type               = TYPE_BRANCH;
    413     inst->_operation          = OPERATION_BRANCH_L_TEST_F;
     422    Tgeneral_data_t address_next = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
     423                                                   );
     424
     425    inst->_type               = instruction_information(INSTRUCTION_L_BF)._type     ; //TYPE_BRANCH;
     426    inst->_operation          = instruction_information(INSTRUCTION_L_BF)._operation; //OPERATION_BRANCH_L_TEST_F;
    414427    inst->_has_immediat       = 1;
    415428    inst->_immediat           = address_next;
    … …  
    425438//  inst->_num_reg_re         = ;
    426439    inst->_exception_use      = EXCEPTION_USE_NONE;
     440    inst->_exception          = EXCEPTION_DECOD_NONE;
    427441    inst->_branch_condition   = BRANCH_CONDITION_FLAG_SET;
    428442//  inst->_branch_stack_write = 0;
    … …  
    430444    inst->_branch_direction   = range<Tgeneral_data_t   >(inst->_instruction,25,25);
    431445    inst->_address_next       = address_next;
     446    inst->_no_execute         = 0;
    432447    inst->_event_type         = EVENT_TYPE_NONE;
    433448  }
    … …  
    437452    log_printf(TRACE,Decod,"instruction_l_bnf","  * instruction   : l.bnf");
    438453
    439     Tgeneral_data_t address_next = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
    440 
    441     inst->_type               = TYPE_BRANCH;
    442     inst->_operation          = OPERATION_BRANCH_L_TEST_NF;
     454    Tgeneral_data_t address_next = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
     455                                                   );
     456
     457    inst->_type               = instruction_information(INSTRUCTION_L_BNF)._type     ; //TYPE_BRANCH;
     458    inst->_operation          = instruction_information(INSTRUCTION_L_BNF)._operation; //OPERATION_BRANCH_L_TEST_NF;
    443459    inst->_has_immediat       = 1;
    444460    inst->_immediat           = address_next;
    … …  
    454470//  inst->_num_reg_re         = ;
    455471    inst->_exception_use      = EXCEPTION_USE_NONE;
     472    inst->_exception          = EXCEPTION_DECOD_NONE;
    456473    inst->_branch_condition   = BRANCH_CONDITION_FLAG_UNSET;
    457474//  inst->_branch_stack_write = 0;
    458475    inst->_branch_direction   = range<Tgeneral_data_t   >(inst->_instruction,25,25);
    459476    inst->_address_next       = address_next;
     477    inst->_no_execute         = 0;
    460478    inst->_event_type         = EVENT_TYPE_NONE;
    461479  }
    … …  
    465483    log_printf(TRACE,Decod,"instruction_l_cmov","  * instruction   : l.cmov");
    466484
    467     inst->_type               = TYPE_MOVE;
    468     inst->_operation          = OPERATION_MOVE_L_CMOV;
     485    inst->_type               = instruction_information(INSTRUCTION_L_CMOV)._type     ; //TYPE_MOVE;
     486    inst->_operation          = instruction_information(INSTRUCTION_L_CMOV)._operation; //OPERATION_MOVE_L_CMOV;
    469487    inst->_has_immediat       = 0;
    470488//  inst->_immediat           = ;
    … …  
    480498//  inst->_num_reg_re         = ;
    481499    inst->_exception_use      = EXCEPTION_USE_NONE;
    482 //  inst->_branch_condition   = ;
    483 //  inst->_branch_stack_write = ;
    484 //  inst->_branch_direction   = ;
    485 //  inst->_address_next       = ;
     500    inst->_exception          = EXCEPTION_DECOD_NONE;
     501//  inst->_branch_condition   = ;
     502//  inst->_branch_stack_write = ;
     503//  inst->_branch_direction   = ;
     504//  inst->_address_next       = ;
     505    inst->_no_execute         = 0;
    486506    inst->_event_type         = EVENT_TYPE_NONE;
    487507  }
    … …  
    497517    else
    498518      {
    499     inst->_type               = TYPE_SPECIAL;
    500     inst->_operation          = OPERATION_SPECIAL_L_CSYNC;
     519    inst->_type               = instruction_information(INSTRUCTION_L_CSYNC)._type     ; //TYPE_SPECIAL;
     520    inst->_operation          = instruction_information(INSTRUCTION_L_CSYNC)._operation; //OPERATION_SPECIAL_L_CSYNC;
    501521    inst->_has_immediat       = 0;
    502522//  inst->_immediat           = ;
    … …  
    512532//  inst->_num_reg_re         = ;
    513533    inst->_exception_use      = EXCEPTION_USE_NONE;
     534    inst->_exception          = EXCEPTION_DECOD_NONE;
    514535//  inst->_branch_condition   = ;
    515536//  inst->_branch_stack_write = ;
    516537//  inst->_branch_direction   = ;
    517538//  inst->_address_next       = ; // don't change
     539    inst->_no_execute         = 0;
    518540    inst->_event_type         = EVENT_TYPE_CSYNC;
    519541      }
    … …  
    533555    log_printf(TRACE,Decod,"instruction_l_div","  * instruction   : l.div");
    534556
    535     inst->_type               = TYPE_MUL_DIV;
    536     inst->_operation          = OPERATION_MUL_DIV_L_DIV;
     557    inst->_type               = instruction_information(INSTRUCTION_L_DIV)._type     ; //TYPE_DIV;
     558    inst->_operation          = instruction_information(INSTRUCTION_L_DIV)._operation; //OPERATION_DIV_L_DIV;
    537559    inst->_has_immediat       = 0;
    538560//  inst->_immediat           = ;
    … …  
    548570    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    549571    inst->_exception_use      = EXCEPTION_USE_RANGE;
    550 //  inst->_branch_condition   = ;
    551 //  inst->_branch_stack_write = ;
    552 //  inst->_branch_direction   = ;
    553 //  inst->_address_next       = ;
     572    inst->_exception          = EXCEPTION_DECOD_NONE;
     573//  inst->_branch_condition   = ;
     574//  inst->_branch_stack_write = ;
     575//  inst->_branch_direction   = ;
     576//  inst->_address_next       = ;
     577    inst->_no_execute         = 0;
    554578    inst->_event_type         = EVENT_TYPE_NONE;
    555579  }
    … …  
    559583    log_printf(TRACE,Decod,"instruction_l_divu","  * instruction   : l.divu");
    560584
    561     inst->_type               = TYPE_MUL_DIV;
    562     inst->_operation          = OPERATION_MUL_DIV_L_DIVU;
     585    inst->_type               = instruction_information(INSTRUCTION_L_DIVU)._type     ; //TYPE_DIV;
     586    inst->_operation          = instruction_information(INSTRUCTION_L_DIVU)._operation; //OPERATION_DIV_L_DIVU;
    563587    inst->_has_immediat       = 0;
    564588//  inst->_immediat           = ;
    … …  
    574598    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    575599    inst->_exception_use      = EXCEPTION_USE_RANGE;
    576 //  inst->_branch_condition   = ;
    577 //  inst->_branch_stack_write = ;
    578 //  inst->_branch_direction   = ;
    579 //  inst->_address_next       = ;
     600    inst->_exception          = EXCEPTION_DECOD_NONE;
     601//  inst->_branch_condition   = ;
     602//  inst->_branch_stack_write = ;
     603//  inst->_branch_direction   = ;
     604//  inst->_address_next       = ;
     605    inst->_no_execute         = 0;
    580606    inst->_event_type         = EVENT_TYPE_NONE;
    581607  }
    … …  
    585611    log_printf(TRACE,Decod,"instruction_l_extbs","  * instruction   : l.extbs");
    586612
    587     inst->_type               = TYPE_EXTEND;
    588     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
     613    inst->_type               = instruction_information(INSTRUCTION_L_EXTBS)._type     ; //TYPE_EXTEND;
     614    inst->_operation          = instruction_information(INSTRUCTION_L_EXTBS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
    589615    inst->_has_immediat       = 1;
    590616    inst->_immediat           = 8;
    … …  
    600626//  inst->_num_reg_re         = ;
    601627    inst->_exception_use      = EXCEPTION_USE_NONE;
    602 //  inst->_branch_condition   = ;
    603 //  inst->_branch_stack_write = ;
    604 //  inst->_branch_direction   = ;
    605 //  inst->_address_next       = ;
     628    inst->_exception          = EXCEPTION_DECOD_NONE;
     629//  inst->_branch_condition   = ;
     630//  inst->_branch_stack_write = ;
     631//  inst->_branch_direction   = ;
     632//  inst->_address_next       = ;
     633    inst->_no_execute         = 0;
    606634    inst->_event_type         = EVENT_TYPE_NONE;
    607635  }
    … …  
    611639    log_printf(TRACE,Decod,"instruction_l_extbz","  * instruction   : l.extbz");
    612640
    613     inst->_type               = TYPE_EXTEND;
    614     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
     641    inst->_type               = instruction_information(INSTRUCTION_L_EXTBZ)._type     ; //TYPE_EXTEND;
     642    inst->_operation          = instruction_information(INSTRUCTION_L_EXTBZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
    615643    inst->_has_immediat       = 1;
    616644    inst->_immediat           = 8;
    … …  
    626654//  inst->_num_reg_re         = ;
    627655    inst->_exception_use      = EXCEPTION_USE_NONE;
    628 //  inst->_branch_condition   = ;
    629 //  inst->_branch_stack_write = ;
    630 //  inst->_branch_direction   = ;
    631 //  inst->_address_next       = ;
     656    inst->_exception          = EXCEPTION_DECOD_NONE;
     657//  inst->_branch_condition   = ;
     658//  inst->_branch_stack_write = ;
     659//  inst->_branch_direction   = ;
     660//  inst->_address_next       = ;
     661    inst->_no_execute         = 0;
    632662    inst->_event_type         = EVENT_TYPE_NONE;
    633663  }
    … …  
    637667    log_printf(TRACE,Decod,"instruction_l_exths","  * instruction   : l.exths");
    638668
    639     inst->_type               = TYPE_EXTEND;
    640     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
     669    inst->_type               = instruction_information(INSTRUCTION_L_EXTHS)._type     ; //TYPE_EXTEND;
     670    inst->_operation          = instruction_information(INSTRUCTION_L_EXTHS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
    641671    inst->_has_immediat       = 1;
    642672    inst->_immediat           = 16;
    … …  
    652682//  inst->_num_reg_re         = ;
    653683    inst->_exception_use      = EXCEPTION_USE_NONE;
    654 //  inst->_branch_condition   = ;
    655 //  inst->_branch_stack_write = ;
    656 //  inst->_branch_direction   = ;
    657 //  inst->_address_next       = ;
     684    inst->_exception          = EXCEPTION_DECOD_NONE;
     685//  inst->_branch_condition   = ;
     686//  inst->_branch_stack_write = ;
     687//  inst->_branch_direction   = ;
     688//  inst->_address_next       = ;
     689    inst->_no_execute         = 0;
    658690    inst->_event_type         = EVENT_TYPE_NONE;
    659691  }
    … …  
    663695    log_printf(TRACE,Decod,"instruction_l_exthz","  * instruction   : l.exthz");
    664696
    665     inst->_type               = TYPE_EXTEND;
    666     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
     697    inst->_type               = instruction_information(INSTRUCTION_L_EXTHZ)._type     ; //TYPE_EXTEND;
     698    inst->_operation          = instruction_information(INSTRUCTION_L_EXTHZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
    667699    inst->_has_immediat       = 1;
    668700    inst->_immediat           = 16;
    … …  
    678710//  inst->_num_reg_re         = ;
    679711    inst->_exception_use      = EXCEPTION_USE_NONE;
    680 //  inst->_branch_condition   = ;
    681 //  inst->_branch_stack_write = ;
    682 //  inst->_branch_direction   = ;
    683 //  inst->_address_next       = ;
     712    inst->_exception          = EXCEPTION_DECOD_NONE;
     713//  inst->_branch_condition   = ;
     714//  inst->_branch_stack_write = ;
     715//  inst->_branch_direction   = ;
     716//  inst->_address_next       = ;
     717    inst->_no_execute         = 0;
    684718    inst->_event_type         = EVENT_TYPE_NONE;
    685719  }
    … …  
    689723    log_printf(TRACE,Decod,"instruction_l_extws","  * instruction   : l.extws");
    690724
    691     inst->_type               = TYPE_EXTEND;
    692     inst->_operation          = OPERATION_EXTEND_L_EXTEND_S;
     725    inst->_type               = instruction_information(INSTRUCTION_L_EXTWS)._type     ; //TYPE_EXTEND;
     726    inst->_operation          = instruction_information(INSTRUCTION_L_EXTWS)._operation; //OPERATION_EXTEND_L_EXTEND_S;
    693727    inst->_has_immediat       = 1;
    694728    inst->_immediat           = 32;
    … …  
    704738//  inst->_num_reg_re         = ;
    705739    inst->_exception_use      = EXCEPTION_USE_NONE;
    706 //  inst->_branch_condition   = ;
    707 //  inst->_branch_stack_write = ;
    708 //  inst->_branch_direction   = ;
    709 //  inst->_address_next       = ;
     740    inst->_exception          = EXCEPTION_DECOD_NONE;
     741//  inst->_branch_condition   = ;
     742//  inst->_branch_stack_write = ;
     743//  inst->_branch_direction   = ;
     744//  inst->_address_next       = ;
     745    inst->_no_execute         = 0;
    710746    inst->_event_type         = EVENT_TYPE_NONE;
    711747  }
    … …  
    715751    log_printf(TRACE,Decod,"instruction_l_extwz","  * instruction   : l.extwz");
    716752
    717     inst->_type               = TYPE_EXTEND;
    718     inst->_operation          = OPERATION_EXTEND_L_EXTEND_Z;
     753    inst->_type               = instruction_information(INSTRUCTION_L_EXTWZ)._type     ; //TYPE_EXTEND;
     754    inst->_operation          = instruction_information(INSTRUCTION_L_EXTWZ)._operation; //OPERATION_EXTEND_L_EXTEND_Z;
    719755    inst->_has_immediat       = 1;
    720756    inst->_immediat           = 32;
    … …  
    730766//  inst->_num_reg_re         = ;
    731767    inst->_exception_use      = EXCEPTION_USE_NONE;
    732 //  inst->_branch_condition   = ;
    733 //  inst->_branch_stack_write = ;
    734 //  inst->_branch_direction   = ;
    735 //  inst->_address_next       = ;
     768    inst->_exception          = EXCEPTION_DECOD_NONE;
     769//  inst->_branch_condition   = ;
     770//  inst->_branch_stack_write = ;
     771//  inst->_branch_direction   = ;
     772//  inst->_address_next       = ;
     773    inst->_no_execute         = 0;
    736774    inst->_event_type         = EVENT_TYPE_NONE;
    737775  }
    … …  
    741779    log_printf(TRACE,Decod,"instruction_l_ff1","  * instruction   : l.ff1");
    742780
    743     inst->_type               = TYPE_FIND;
    744     inst->_operation          = OPERATION_FIND_L_FF1;
    745     inst->_has_immediat       = 0;
    746 //  inst->_immediat           = ;
    747     inst->_read_ra            = 1;
    748     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    749     inst->_read_rb            = 0;
    750 //  inst->_num_reg_rb         = ;
    751     inst->_read_rc            = 0;
    752 //  inst->_num_reg_rc         = ;
    753     inst->_write_rd           = 1;
    754     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    755     inst->_write_re           = 0;
    756 //  inst->_num_reg_re         = ;
    757     inst->_exception_use      = EXCEPTION_USE_NONE;
    758 //  inst->_branch_condition   = ;
    759 //  inst->_branch_stack_write = ;
    760 //  inst->_branch_direction   = ;
    761 //  inst->_address_next       = ;
     781    inst->_type               = instruction_information(INSTRUCTION_L_FF1)._type     ; //TYPE_FIND;
     782    inst->_operation          = instruction_information(INSTRUCTION_L_FF1)._operation; //OPERATION_FIND_L_FF1;
     783    inst->_has_immediat       = 0;
     784//  inst->_immediat           = ;
     785    inst->_read_ra            = 1;
     786    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     787    inst->_read_rb            = 0;
     788//  inst->_num_reg_rb         = ;
     789    inst->_read_rc            = 0;
     790//  inst->_num_reg_rc         = ;
     791    inst->_write_rd           = 1;
     792    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     793    inst->_write_re           = 0;
     794//  inst->_num_reg_re         = ;
     795    inst->_exception_use      = EXCEPTION_USE_NONE;
     796    inst->_exception          = EXCEPTION_DECOD_NONE;
     797//  inst->_branch_condition   = ;
     798//  inst->_branch_stack_write = ;
     799//  inst->_branch_direction   = ;
     800//  inst->_address_next       = ;
     801    inst->_no_execute         = 0;
    762802    inst->_event_type         = EVENT_TYPE_NONE;
    763803  }
    … …  
    767807    log_printf(TRACE,Decod,"instruction_l_fl1","  * instruction   : l.fl1");
    768808
    769     inst->_type               = TYPE_FIND;
    770     inst->_operation          = OPERATION_FIND_L_FL1;
    771     inst->_has_immediat       = 0;
    772 //  inst->_immediat           = ;
    773     inst->_read_ra            = 1;
    774     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    775     inst->_read_rb            = 0;
    776 //  inst->_num_reg_rb         = ;
    777     inst->_read_rc            = 0;
    778 //  inst->_num_reg_rc         = ;
    779     inst->_write_rd           = 1;
    780     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    781     inst->_write_re           = 0;
    782 //  inst->_num_reg_re         = ;
    783     inst->_exception_use      = EXCEPTION_USE_NONE;
    784 //  inst->_branch_condition   = ;
    785 //  inst->_branch_stack_write = ;
    786 //  inst->_branch_direction   = ;
    787 //  inst->_address_next       = ;
     809    inst->_type               = instruction_information(INSTRUCTION_L_FL1)._type     ; //TYPE_FIND;
     810    inst->_operation          = instruction_information(INSTRUCTION_L_FL1)._operation; //OPERATION_FIND_L_FL1;
     811    inst->_has_immediat       = 0;
     812//  inst->_immediat           = ;
     813    inst->_read_ra            = 1;
     814    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     815    inst->_read_rb            = 0;
     816//  inst->_num_reg_rb         = ;
     817    inst->_read_rc            = 0;
     818//  inst->_num_reg_rc         = ;
     819    inst->_write_rd           = 1;
     820    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     821    inst->_write_re           = 0;
     822//  inst->_num_reg_re         = ;
     823    inst->_exception_use      = EXCEPTION_USE_NONE;
     824    inst->_exception          = EXCEPTION_DECOD_NONE;
     825//  inst->_branch_condition   = ;
     826//  inst->_branch_stack_write = ;
     827//  inst->_branch_direction   = ;
     828//  inst->_address_next       = ;
     829    inst->_no_execute         = 0;
    788830    inst->_event_type         = EVENT_TYPE_NONE;
    789831  }
    … …  
    793835    log_printf(TRACE,Decod,"instruction_l_j","  * instruction   : l.j");
    794836
    795     inst->_type               = TYPE_BRANCH;
    796     inst->_operation          = OPERATION_BRANCH_NONE;
     837    inst->_type               = instruction_information(INSTRUCTION_L_J)._type     ; //TYPE_BRANCH;
     838    inst->_operation          = instruction_information(INSTRUCTION_L_J)._operation; //OPERATION_BRANCH_NONE;
    797839    inst->_has_immediat       = 0;
    798840//  inst->_immediat           = ;
    … …  
    808850//  inst->_num_reg_re         = ;
    809851    inst->_exception_use      = EXCEPTION_USE_NONE;
     852    inst->_exception          = EXCEPTION_DECOD_NONE;
    810853    inst->_branch_condition   = BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK;
    811854//  inst->_branch_stack_write = 0;
    812855    inst->_branch_direction   = 1;
    813     inst->_address_next       = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
     856    inst->_address_next       = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
     857                                                               );
     858    inst->_no_execute         = 1;
    814859    inst->_event_type         = EVENT_TYPE_NONE;
    815860  }
    … …  
    819864    log_printf(TRACE,Decod,"instruction_l_jal","  * instruction   : l.jal");
    820865
    821     inst->_type               = TYPE_BRANCH;
    822     inst->_operation          = OPERATION_BRANCH_L_JALR;
     866    inst->_type               = instruction_information(INSTRUCTION_L_JAL)._type     ; //TYPE_BRANCH;
     867    inst->_operation          = instruction_information(INSTRUCTION_L_JAL)._operation; //OPERATION_BRANCH_L_JALR;
    823868    inst->_has_immediat       = 1;
    824869    inst->_immediat           = inst->_address_next+1;
    … …  
    834879//  inst->_num_reg_re         = ;
    835880    inst->_exception_use      = EXCEPTION_USE_NONE;
     881    inst->_exception          = EXCEPTION_DECOD_NONE;
    836882    inst->_branch_condition   = BRANCH_CONDITION_NONE_WITH_WRITE_STACK; // Always jump
    837883//  inst->_branch_stack_write = 1;
    838884    inst->_branch_direction   = 1;
    839     inst->_address_next       = inst->_address+(EXTENDS(inst->_instruction,26)<<2);
     885    inst->_address_next       = signed(param->_size_data,inst->_address+EXTENDS(inst->_instruction,26)// <<2
     886                                                );
     887    inst->_no_execute         = 0;
    840888    inst->_event_type         = EVENT_TYPE_NONE;
    841889  }
    … …  
    853901    else
    854902      {
    855     inst->_type               = TYPE_BRANCH;
    856     inst->_operation          = OPERATION_BRANCH_L_JALR;
     903    inst->_type               = instruction_information(INSTRUCTION_L_JALR)._type     ; //TYPE_BRANCH;
     904    inst->_operation          = instruction_information(INSTRUCTION_L_JALR)._operation; //OPERATION_BRANCH_L_JALR;
    857905    inst->_has_immediat       = 0;
    858906//  inst->_immediat           = ;
    … …  
    868916//  inst->_num_reg_re         = ;
    869917    inst->_exception_use      = EXCEPTION_USE_NONE;
     918    inst->_exception          = EXCEPTION_DECOD_NONE;
    870919//  inst->_branch_condition   = (inst->_num_reg_rb == 9)?BRANCH_CONDITION_READ_STACK:BRANCH_CONDITION_READ_REGISTER;
    871920    inst->_branch_condition   = BRANCH_CONDITION_READ_REGISTER_WITH_WRITE_STACK;
    … …  
    873922    inst->_branch_direction   = 1;
    874923//  inst->_address_next       = ;
     924    inst->_no_execute         = 0;
    875925    inst->_event_type         = EVENT_TYPE_NONE;
    876926      }
    … …  
    881931    log_printf(TRACE,Decod,"instruction_l_jr","  * instruction   : l.jr");
    882932
    883     inst->_type               = TYPE_BRANCH;
    884     inst->_operation          = OPERATION_BRANCH_L_JALR;
     933    inst->_type               = instruction_information(INSTRUCTION_L_JR)._type     ; //TYPE_BRANCH;
     934    inst->_operation          = instruction_information(INSTRUCTION_L_JR)._operation; //OPERATION_BRANCH_L_JALR;
    885935    inst->_has_immediat       = 0;
    886936//  inst->_immediat           = ;
    … …  
    896946//  inst->_num_reg_re         = ;
    897947    inst->_exception_use      = EXCEPTION_USE_NONE;
     948    inst->_exception          = EXCEPTION_DECOD_NONE;
    898949    inst->_branch_condition   = (inst->_num_reg_rb == 9)?BRANCH_CONDITION_READ_STACK:BRANCH_CONDITION_READ_REGISTER_WITHOUT_WRITE_STACK;
    899950//  inst->_branch_stack_write = 0;
    900951    inst->_branch_direction   = 1;
    901952//  inst->_address_next       = ;
     953    inst->_no_execute         = 0;
    902954    inst->_event_type         = EVENT_TYPE_NONE;
    903955  }
    … …  
    907959    log_printf(TRACE,Decod,"instruction_l_lbs","  * instruction   : l.lbs");
    908960
    909     inst->_type               = TYPE_MEMORY;
    910     inst->_operation          = OPERATION_MEMORY_LOAD_8_S;
     961    inst->_type               = instruction_information(INSTRUCTION_L_LBS)._type     ; //TYPE_MEMORY;
     962    inst->_operation          = instruction_information(INSTRUCTION_L_LBS)._operation; //OPERATION_MEMORY_LOAD_8_S;
    911963    inst->_has_immediat       = 1;
    912964    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    922974//  inst->_num_reg_re         = ;
    923975    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
    924 //  inst->_branch_condition   = ;
    925 //  inst->_branch_stack_write = ;
    926 //  inst->_branch_direction   = ;
    927 //  inst->_address_next       = ;
     976    inst->_exception          = EXCEPTION_DECOD_NONE;
     977//  inst->_branch_condition   = ;
     978//  inst->_branch_stack_write = ;
     979//  inst->_branch_direction   = ;
     980//  inst->_address_next       = ;
     981    inst->_no_execute         = 0;
    928982    inst->_event_type         = EVENT_TYPE_NONE;
    929983  }
    … …  
    933987    log_printf(TRACE,Decod,"instruction_l_lbz","  * instruction   : l.lbz");
    934988
    935     inst->_type               = TYPE_MEMORY;
    936     inst->_operation          = OPERATION_MEMORY_LOAD_8_Z;
     989    inst->_type               = instruction_information(INSTRUCTION_L_LBZ)._type     ; //TYPE_MEMORY;
     990    inst->_operation          = instruction_information(INSTRUCTION_L_LBZ)._operation; //OPERATION_MEMORY_LOAD_8_Z;
    937991    inst->_has_immediat       = 1;
    938992    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    9481002//  inst->_num_reg_re         = ;
    9491003    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
    950 //  inst->_branch_condition   = ;
    951 //  inst->_branch_stack_write = ;
    952 //  inst->_branch_direction   = ;
    953 //  inst->_address_next       = ;
     1004    inst->_exception          = EXCEPTION_DECOD_NONE;
     1005//  inst->_branch_condition   = ;
     1006//  inst->_branch_stack_write = ;
     1007//  inst->_branch_direction   = ;
     1008//  inst->_address_next       = ;
     1009    inst->_no_execute         = 0;
    9541010    inst->_event_type         = EVENT_TYPE_NONE;
    9551011  }
    … …  
    9591015    log_printf(TRACE,Decod,"instruction_l_ld","  * instruction   : l.ld");
    9601016
    961     inst->_type               = TYPE_MEMORY;
    962     inst->_operation          = OPERATION_MEMORY_LOAD_64_S;
     1017    inst->_type               = instruction_information(INSTRUCTION_L_LD)._type     ; //TYPE_MEMORY;
     1018    inst->_operation          = instruction_information(INSTRUCTION_L_LD)._operation; //OPERATION_MEMORY_LOAD_64_S;
    9631019    inst->_has_immediat       = 1;
    9641020    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    9741030//  inst->_num_reg_re         = ;
    9751031    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    976 //  inst->_branch_condition   = ;
    977 //  inst->_branch_stack_write = ;
    978 //  inst->_branch_direction   = ;
    979 //  inst->_address_next       = ;
     1032    inst->_exception          = EXCEPTION_DECOD_NONE;
     1033//  inst->_branch_condition   = ;
     1034//  inst->_branch_stack_write = ;
     1035//  inst->_branch_direction   = ;
     1036//  inst->_address_next       = ;
     1037    inst->_no_execute         = 0;
    9801038    inst->_event_type         = EVENT_TYPE_NONE;
    9811039  }
    … …  
    9851043    log_printf(TRACE,Decod,"instruction_l_lhs","  * instruction   : l.lhs");
    9861044
    987     inst->_type               = TYPE_MEMORY;
    988     inst->_operation          = OPERATION_MEMORY_LOAD_16_S;
     1045    inst->_type               = instruction_information(INSTRUCTION_L_LHS)._type     ; //TYPE_MEMORY;
     1046    inst->_operation          = instruction_information(INSTRUCTION_L_LHS)._operation; //OPERATION_MEMORY_LOAD_16_S;
    9891047    inst->_has_immediat       = 1;
    9901048    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    10001058//  inst->_num_reg_re         = ;
    10011059    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    1002 //  inst->_branch_condition   = ;
    1003 //  inst->_branch_stack_write = ;
    1004 //  inst->_branch_direction   = ;
    1005 //  inst->_address_next       = ;
     1060    inst->_exception          = EXCEPTION_DECOD_NONE;
     1061//  inst->_branch_condition   = ;
     1062//  inst->_branch_stack_write = ;
     1063//  inst->_branch_direction   = ;
     1064//  inst->_address_next       = ;
     1065    inst->_no_execute         = 0;
    10061066    inst->_event_type         = EVENT_TYPE_NONE;
    10071067  }
    … …  
    10111071    log_printf(TRACE,Decod,"instruction_l_lhz","  * instruction   : l.lhz");
    10121072
    1013     inst->_type               = TYPE_MEMORY;
    1014     inst->_operation          = OPERATION_MEMORY_LOAD_16_Z;
     1073    inst->_type               = instruction_information(INSTRUCTION_L_LHZ)._type     ; //TYPE_MEMORY;
     1074    inst->_operation          = instruction_information(INSTRUCTION_L_LHZ)._operation; //OPERATION_MEMORY_LOAD_16_Z;
    10151075    inst->_has_immediat       = 1;
    10161076    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    10261086//  inst->_num_reg_re         = ;
    10271087    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    1028 //  inst->_branch_condition   = ;
    1029 //  inst->_branch_stack_write = ;
    1030 //  inst->_branch_direction   = ;
    1031 //  inst->_address_next       = ;
     1088    inst->_exception          = EXCEPTION_DECOD_NONE;
     1089//  inst->_branch_condition   = ;
     1090//  inst->_branch_stack_write = ;
     1091//  inst->_branch_direction   = ;
     1092//  inst->_address_next       = ;
     1093    inst->_no_execute         = 0;
    10321094    inst->_event_type         = EVENT_TYPE_NONE;
    10331095  }
    … …  
    10371099    log_printf(TRACE,Decod,"instruction_l_lws","  * instruction   : l.lws");
    10381100
    1039     inst->_type               = TYPE_MEMORY;
    1040     inst->_operation          = OPERATION_MEMORY_LOAD_32_S;
     1101    inst->_type               = instruction_information(INSTRUCTION_L_LWS)._type     ; //TYPE_MEMORY;
     1102    inst->_operation          = instruction_information(INSTRUCTION_L_LWS)._operation; //OPERATION_MEMORY_LOAD_32_S;
    10411103    inst->_has_immediat       = 1;
    10421104    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    10521114//  inst->_num_reg_re         = ;
    10531115    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    1054 //  inst->_branch_condition   = ;
    1055 //  inst->_branch_stack_write = ;
    1056 //  inst->_branch_direction   = ;
    1057 //  inst->_address_next       = ;
     1116    inst->_exception          = EXCEPTION_DECOD_NONE;
     1117//  inst->_branch_condition   = ;
     1118//  inst->_branch_stack_write = ;
     1119//  inst->_branch_direction   = ;
     1120//  inst->_address_next       = ;
     1121    inst->_no_execute         = 0;
    10581122    inst->_event_type         = EVENT_TYPE_NONE;
    10591123  }
    … …  
    10631127    log_printf(TRACE,Decod,"instruction_l_lwz","  * instruction   : l.lwz");
    10641128
    1065     inst->_type               = TYPE_MEMORY;
    1066     inst->_operation          = OPERATION_MEMORY_LOAD_32_Z;
     1129    inst->_type               = instruction_information(INSTRUCTION_L_LWZ)._type     ; //TYPE_MEMORY;
     1130    inst->_operation          = instruction_information(INSTRUCTION_L_LWZ)._operation; //OPERATION_MEMORY_LOAD_32_Z;
    10671131    inst->_has_immediat       = 1;
    10681132    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    10781142//  inst->_num_reg_re         = ;
    10791143    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    1080 //  inst->_branch_condition   = ;
    1081 //  inst->_branch_stack_write = ;
    1082 //  inst->_branch_direction   = ;
    1083 //  inst->_address_next       = ;
     1144    inst->_exception          = EXCEPTION_DECOD_NONE;
     1145//  inst->_branch_condition   = ;
     1146//  inst->_branch_stack_write = ;
     1147//  inst->_branch_direction   = ;
     1148//  inst->_address_next       = ;
     1149    inst->_no_execute         = 0;
    10841150    inst->_event_type         = EVENT_TYPE_NONE;
    10851151  }
    … …  
    10891155    log_printf(TRACE,Decod,"instruction_l_mac","  * instruction   : l.mac");
    10901156
    1091     inst->_type               = TYPE_SPECIAL;
    1092     inst->_operation          = OPERATION_SPECIAL_L_MAC;
    1093     inst->_has_immediat       = 0;
    1094 //  inst->_immediat           = ;
    1095     inst->_read_ra            = 1;
    1096     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    1097     inst->_read_rb            = 1;
    1098     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    1099     inst->_read_rc            = 0;
    1100 //  inst->_num_reg_rc         = ;
    1101     inst->_write_rd           = 0;
    1102 //  inst->_num_reg_rd         = ;
    1103     inst->_write_re           = 0;
    1104 //  inst->_num_reg_re         = ;
    1105     inst->_exception_use      = EXCEPTION_USE_NONE;
     1157    inst->_type               = instruction_information(INSTRUCTION_L_MAC)._type     ; //TYPE_SPECIAL;
     1158    inst->_operation          = instruction_information(INSTRUCTION_L_MAC)._operation; //OPERATION_SPECIAL_L_MAC;
     1159    inst->_has_immediat       = 0;
     1160//  inst->_immediat           = ;
     1161    inst->_read_ra            = 1;
     1162    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     1163    inst->_read_rb            = 1;
     1164    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     1165    inst->_read_rc            = 0;
     1166//  inst->_num_reg_rc         = ;
     1167    inst->_write_rd           = 0;
     1168//  inst->_num_reg_rd         = ;
     1169    inst->_write_re           = 0;
     1170//  inst->_num_reg_re         = ;
     1171    inst->_exception_use      = EXCEPTION_USE_NONE;
     1172    inst->_exception          = EXCEPTION_DECOD_NONE;
    11061173//  inst->_branch_condition   = ;
    11071174//  inst->_branch_stack_write = ;
    11081175//  inst->_branch_direction   = ;
    11091176//  inst->_address_next       = ; // don't change
     1177    inst->_no_execute         = 0;
    11101178    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    11111179  }
    … …  
    11151183    log_printf(TRACE,Decod,"instruction_l_maci","  * instruction   : l.maci");
    11161184
    1117     inst->_type               = TYPE_SPECIAL;
    1118     inst->_operation          = OPERATION_SPECIAL_L_MAC;
     1185    inst->_type               = instruction_information(INSTRUCTION_L_MACI)._type     ; //TYPE_SPECIAL;
     1186    inst->_operation          = instruction_information(INSTRUCTION_L_MACI)._operation; //OPERATION_SPECIAL_L_MAC;
    11191187    inst->_has_immediat       = 1;
    11201188    inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    11311199//  inst->_num_reg_re         = ;
    11321200    inst->_exception_use      = EXCEPTION_USE_NONE;
     1201    inst->_exception          = EXCEPTION_DECOD_NONE;
    11331202//  inst->_branch_condition   = ;
    11341203//  inst->_branch_stack_write = ;
    11351204//  inst->_branch_direction   = ;
    11361205//  inst->_address_next       = ; // don't change
     1206    inst->_no_execute         = 0;
    11371207    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    11381208  }
    … …  
    11481218    else
    11491219      {
    1150     inst->_type               = TYPE_SPECIAL;
    1151     inst->_operation          = OPERATION_SPECIAL_L_MACRC;
     1220    inst->_type               = instruction_information(INSTRUCTION_L_MACRC)._type     ; //TYPE_SPECIAL;
     1221    inst->_operation          = instruction_information(INSTRUCTION_L_MACRC)._operation; //OPERATION_SPECIAL_L_MACRC;
    11521222    inst->_has_immediat       = 0;
    11531223//  inst->_immediat           = ;
    … …  
    11631233//  inst->_num_reg_re         = ;
    11641234    inst->_exception_use      = EXCEPTION_USE_NONE;
     1235    inst->_exception          = EXCEPTION_DECOD_NONE;
    11651236//  inst->_branch_condition   = ;
    11661237//  inst->_branch_stack_write = ;
    11671238//  inst->_branch_direction   = ;
    11681239//  inst->_address_next       = ; // don't change
     1240    inst->_no_execute         = 0;
    11691241    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    11701242      }
    … …  
    11751247    log_printf(TRACE,Decod,"instruction_l_mfspr","  * instruction   : l.mfspr");
    11761248
    1177     inst->_type               = TYPE_SPECIAL;
    1178     inst->_operation          = OPERATION_SPECIAL_L_MFSPR;
     1249    inst->_type               = instruction_information(INSTRUCTION_L_MFSPR)._type     ; //TYPE_SPECIAL;
     1250    inst->_operation          = instruction_information(INSTRUCTION_L_MFSPR)._operation; //OPERATION_SPECIAL_L_MFSPR;
    11791251    inst->_has_immediat       = 1;
    11801252    inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    11901262//  inst->_num_reg_re         = ;
    11911263    inst->_exception_use      = EXCEPTION_USE_NONE;
     1264    inst->_exception          = EXCEPTION_DECOD_NONE;
    11921265//  inst->_branch_condition   = ;
    11931266//  inst->_branch_stack_write = ;
    11941267//  inst->_branch_direction   = ;
    11951268//  inst->_address_next       = ; // don't change
     1269    inst->_no_execute         = 0;
    11961270    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    11971271  }
    … …  
    12011275    log_printf(TRACE,Decod,"instruction_l_movhi","  * instruction   : l.movhi");
    12021276
    1203     inst->_type               = TYPE_MOVE;
    1204     inst->_operation          = OPERATION_MOVE_L_MOVHI;
     1277    inst->_type               = instruction_information(INSTRUCTION_L_MOVHI)._type     ; //TYPE_MOVE;
     1278    inst->_operation          = instruction_information(INSTRUCTION_L_MOVHI)._operation; //OPERATION_MOVE_L_MOVHI;
    12051279    inst->_has_immediat       = 1;
    12061280    inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    12161290//  inst->_num_reg_re         = ;
    12171291    inst->_exception_use      = EXCEPTION_USE_NONE;
    1218 //  inst->_branch_condition   = ;
    1219 //  inst->_branch_stack_write = ;
    1220 //  inst->_branch_direction   = ;
    1221 //  inst->_address_next       = ;
     1292    inst->_exception          = EXCEPTION_DECOD_NONE;
     1293//  inst->_branch_condition   = ;
     1294//  inst->_branch_stack_write = ;
     1295//  inst->_branch_direction   = ;
     1296//  inst->_address_next       = ;
     1297    inst->_no_execute         = 0;
    12221298    inst->_event_type         = EVENT_TYPE_NONE;
    12231299  }
    … …  
    12271303    log_printf(TRACE,Decod,"instruction_l_msb","  * instruction   : l.msb");
    12281304
    1229     inst->_type               = TYPE_SPECIAL;
    1230     inst->_operation          = OPERATION_SPECIAL_L_MSB;
    1231     inst->_has_immediat       = 0;
    1232 //  inst->_immediat           = ;
    1233     inst->_read_ra            = 1;
    1234     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    1235     inst->_read_rb            = 1;
    1236     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    1237     inst->_read_rc            = 0;
    1238 //  inst->_num_reg_rc         = ;
    1239     inst->_write_rd           = 0;
    1240 //  inst->_num_reg_rd         = ;
    1241     inst->_write_re           = 0;
    1242 //  inst->_num_reg_re         = ;
    1243     inst->_exception_use      = EXCEPTION_USE_NONE;
     1305    inst->_type               = instruction_information(INSTRUCTION_L_MSB)._type     ; //TYPE_SPECIAL;
     1306    inst->_operation          = instruction_information(INSTRUCTION_L_MSB)._operation; //OPERATION_SPECIAL_L_MSB;
     1307    inst->_has_immediat       = 0;
     1308//  inst->_immediat           = ;
     1309    inst->_read_ra            = 1;
     1310    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     1311    inst->_read_rb            = 1;
     1312    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     1313    inst->_read_rc            = 0;
     1314//  inst->_num_reg_rc         = ;
     1315    inst->_write_rd           = 0;
     1316//  inst->_num_reg_rd         = ;
     1317    inst->_write_re           = 0;
     1318//  inst->_num_reg_re         = ;
     1319    inst->_exception_use      = EXCEPTION_USE_NONE;
     1320    inst->_exception          = EXCEPTION_DECOD_NONE;
    12441321//  inst->_branch_condition   = ;
    12451322//  inst->_branch_stack_write = ;
    12461323//  inst->_branch_direction   = ;
    12471324//  inst->_address_next       = ; // don't change
     1325    inst->_no_execute         = 0;
    12481326    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    12491327  }
    … …  
    12591337    else
    12601338      {
    1261     inst->_type               = TYPE_SPECIAL;
    1262     inst->_operation          = OPERATION_SPECIAL_L_MSYNC;
     1339    inst->_type               = instruction_information(INSTRUCTION_L_MSYNC)._type     ; //TYPE_SPECIAL;
     1340    inst->_operation          = instruction_information(INSTRUCTION_L_MSYNC)._operation; //OPERATION_SPECIAL_L_MSYNC;
    12631341    inst->_has_immediat       = 0;
    12641342//  inst->_immediat           = ;
    … …  
    12741352//  inst->_num_reg_re         = ;
    12751353    inst->_exception_use      = EXCEPTION_USE_NONE;
     1354    inst->_exception          = EXCEPTION_DECOD_NONE;
    12761355//  inst->_branch_condition   = ;
    12771356//  inst->_branch_stack_write = ;
    12781357//  inst->_branch_direction   = ;
    12791358//  inst->_address_next       = ; // don't change
     1359    inst->_no_execute         = 0;
    12801360    inst->_event_type         = EVENT_TYPE_MSYNC;
    12811361      }
    … …  
    12861366    log_printf(TRACE,Decod,"instruction_l_mtspr","  * instruction   : l.mtspr");
    12871367
    1288     inst->_type               = TYPE_SPECIAL;
    1289     inst->_operation          = OPERATION_SPECIAL_L_MTSPR;
     1368    inst->_type               = instruction_information(INSTRUCTION_L_MTSPR)._type     ; //TYPE_SPECIAL;
     1369    inst->_operation          = instruction_information(INSTRUCTION_L_MTSPR)._operation; //OPERATION_SPECIAL_L_MTSPR;
    12901370    inst->_has_immediat       = 1;
    12911371    inst->_immediat           = EXTENDZ(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    13021382//  inst->_num_reg_re         = ;
    13031383    inst->_exception_use      = EXCEPTION_USE_NONE;
     1384    inst->_exception          = EXCEPTION_DECOD_NONE;
    13041385//  inst->_branch_condition   = ;
    13051386//  inst->_branch_stack_write = ;
    13061387//  inst->_branch_direction   = ;
    13071388//  inst->_address_next       = ; // don't change
     1389    inst->_no_execute         = 0;
    13081390    inst->_event_type         = EVENT_TYPE_SPR_ACCESS;
    13091391  }
    … …  
    13131395    log_printf(TRACE,Decod,"instruction_l_mul","  * instruction   : l.mul");
    13141396
    1315     inst->_type               = TYPE_MUL_DIV;
    1316     inst->_operation          = OPERATION_MUL_DIV_L_MUL;
     1397    inst->_type               = instruction_information(INSTRUCTION_L_MUL)._type     ; //TYPE_MUL;
     1398    inst->_operation          = instruction_information(INSTRUCTION_L_MUL)._operation; //OPERATION_MUL_L_MUL;
    13171399    inst->_has_immediat       = 0;
    13181400//  inst->_immediat           = ;
    … …  
    13281410    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    13291411    inst->_exception_use      = EXCEPTION_USE_RANGE;
    1330 //  inst->_branch_condition   = ;
    1331 //  inst->_branch_stack_write = ;
    1332 //  inst->_branch_direction   = ;
    1333 //  inst->_address_next       = ;
     1412    inst->_exception          = EXCEPTION_DECOD_NONE;
     1413//  inst->_branch_condition   = ;
     1414//  inst->_branch_stack_write = ;
     1415//  inst->_branch_direction   = ;
     1416//  inst->_address_next       = ;
     1417    inst->_no_execute         = 0;
    13341418    inst->_event_type         = EVENT_TYPE_NONE;
    13351419  }
    … …  
    13391423    log_printf(TRACE,Decod,"instruction_l_muli","  * instruction   : l.muli");
    13401424
    1341     inst->_type               = TYPE_MUL_DIV;
    1342     inst->_operation          = OPERATION_MUL_DIV_L_MUL;
     1425    inst->_type               = instruction_information(INSTRUCTION_L_MULI)._type     ; //TYPE_MUL;
     1426    inst->_operation          = instruction_information(INSTRUCTION_L_MULI)._operation; //OPERATION_MUL_L_MUL;
    13431427    inst->_has_immediat       = 1;
    13441428    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    13541438    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    13551439    inst->_exception_use      = EXCEPTION_USE_RANGE;
    1356 //  inst->_branch_condition   = ;
    1357 //  inst->_branch_stack_write = ;
    1358 //  inst->_branch_direction   = ;
    1359 //  inst->_address_next       = ;
     1440    inst->_exception          = EXCEPTION_DECOD_NONE;
     1441//  inst->_branch_condition   = ;
     1442//  inst->_branch_stack_write = ;
     1443//  inst->_branch_direction   = ;
     1444//  inst->_address_next       = ;
     1445    inst->_no_execute         = 0;
    13601446    inst->_event_type         = EVENT_TYPE_NONE;
    13611447  }
    … …  
    13651451    log_printf(TRACE,Decod,"instruction_l_mulu","  * instruction   : l.mulu");
    13661452
    1367     inst->_type               = TYPE_MUL_DIV;
    1368     inst->_operation          = OPERATION_MUL_DIV_L_MULU;
     1453    inst->_type               = instruction_information(INSTRUCTION_L_MULU)._type     ; //TYPE_MUL;
     1454    inst->_operation          = instruction_information(INSTRUCTION_L_MULU)._operation; //OPERATION_MUL_L_MULU;
    13691455    inst->_has_immediat       = 0;
    13701456//  inst->_immediat           = ;
    … …  
    13801466    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    13811467    inst->_exception_use      = EXCEPTION_USE_RANGE;
    1382 //  inst->_branch_condition   = ;
    1383 //  inst->_branch_stack_write = ;
    1384 //  inst->_branch_direction   = ;
    1385 //  inst->_address_next       = ;
     1468    inst->_exception          = EXCEPTION_DECOD_NONE;
     1469//  inst->_branch_condition   = ;
     1470//  inst->_branch_stack_write = ;
     1471//  inst->_branch_direction   = ;
     1472//  inst->_address_next       = ;
     1473    inst->_no_execute         = 0;
    13861474    inst->_event_type         = EVENT_TYPE_NONE;
    13871475  }
    … …  
    13911479    log_printf(TRACE,Decod,"instruction_l_nop","  * instruction   : l.nop");
    13921480
    1393     inst->_type               = TYPE_SPECIAL;
    1394     inst->_operation          = OPERATION_SPECIAL_L_NOP;
     1481    inst->_type               = instruction_information(INSTRUCTION_L_NOP)._type     ; //TYPE_SPECIAL;
     1482    inst->_operation          = instruction_information(INSTRUCTION_L_NOP)._operation; //OPERATION_SPECIAL_L_NOP;
    13951483//  inst->_has_immediat       = 1;
    13961484//  inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    14081496//  inst->_num_reg_re         = ;
    14091497    inst->_exception_use      = EXCEPTION_USE_NONE;
    1410 //  inst->_branch_condition   = ;
    1411 //  inst->_branch_stack_write = ;
    1412 //  inst->_branch_direction   = ;
    1413 //  inst->_address_next       = ;
     1498    inst->_exception          = EXCEPTION_DECOD_NONE;
     1499//  inst->_branch_condition   = ;
     1500//  inst->_branch_stack_write = ;
     1501//  inst->_branch_direction   = ;
     1502//  inst->_address_next       = ;
     1503    inst->_no_execute         = 1;
    14141504    inst->_event_type         = EVENT_TYPE_NONE;
    14151505  }
    … …  
    14191509    log_printf(TRACE,Decod,"instruction_l_or","  * instruction   : l.or");
    14201510
    1421     inst->_type               = TYPE_ALU;
    1422     inst->_operation          = OPERATION_ALU_L_OR;
    1423     inst->_has_immediat       = 0;
    1424 //  inst->_immediat           = ;
    1425     inst->_read_ra            = 1;
    1426     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    1427     inst->_read_rb            = 1;
    1428     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    1429     inst->_read_rc            = 0;
    1430 //  inst->_num_reg_rc         = ;
    1431     inst->_write_rd           = 1;
    1432     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    1433     inst->_write_re           = 0;
    1434 //  inst->_num_reg_re         = ;
    1435     inst->_exception_use      = EXCEPTION_USE_NONE;
    1436 //  inst->_branch_condition   = ;
    1437 //  inst->_branch_stack_write = ;
    1438 //  inst->_branch_direction   = ;
    1439 //  inst->_address_next       = ;
     1511    inst->_type               = instruction_information(INSTRUCTION_L_OR)._type     ; //TYPE_ALU;
     1512    inst->_operation          = instruction_information(INSTRUCTION_L_OR)._operation; //OPERATION_ALU_L_OR;
     1513    inst->_has_immediat       = 0;
     1514//  inst->_immediat           = ;
     1515    inst->_read_ra            = 1;
     1516    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     1517    inst->_read_rb            = 1;
     1518    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     1519    inst->_read_rc            = 0;
     1520//  inst->_num_reg_rc         = ;
     1521    inst->_write_rd           = 1;
     1522    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     1523    inst->_write_re           = 0;
     1524//  inst->_num_reg_re         = ;
     1525    inst->_exception_use      = EXCEPTION_USE_NONE;
     1526    inst->_exception          = EXCEPTION_DECOD_NONE;
     1527//  inst->_branch_condition   = ;
     1528//  inst->_branch_stack_write = ;
     1529//  inst->_branch_direction   = ;
     1530//  inst->_address_next       = ;
     1531    inst->_no_execute         = 0;
    14401532    inst->_event_type         = EVENT_TYPE_NONE;
    14411533  }
    … …  
    14451537    log_printf(TRACE,Decod,"instruction_l_ori","  * instruction   : l.ori");
    14461538
    1447     inst->_type               = TYPE_ALU;
    1448     inst->_operation          = OPERATION_ALU_L_OR;
     1539    inst->_type               = instruction_information(INSTRUCTION_L_ORI)._type     ; //TYPE_ALU;
     1540    inst->_operation          = instruction_information(INSTRUCTION_L_ORI)._operation; //OPERATION_ALU_L_OR;
    14491541    inst->_has_immediat       = 1;
    14501542    inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    14601552//  inst->_num_reg_re         = ;
    14611553    inst->_exception_use      = EXCEPTION_USE_NONE;
    1462 //  inst->_branch_condition   = ;
    1463 //  inst->_branch_stack_write = ;
    1464 //  inst->_branch_direction   = ;
    1465 //  inst->_address_next       = ;
     1554    inst->_exception          = EXCEPTION_DECOD_NONE;
     1555//  inst->_branch_condition   = ;
     1556//  inst->_branch_stack_write = ;
     1557//  inst->_branch_direction   = ;
     1558//  inst->_address_next       = ;
     1559    inst->_no_execute         = 0;
    14661560    inst->_event_type         = EVENT_TYPE_NONE;
    14671561  }
    … …  
    14771571    else
    14781572      {
    1479     inst->_type               = TYPE_SPECIAL;
    1480     inst->_operation          = OPERATION_SPECIAL_L_PSYNC;
     1573    inst->_type               = instruction_information(INSTRUCTION_L_PSYNC)._type     ; //TYPE_SPECIAL;
     1574    inst->_operation          = instruction_information(INSTRUCTION_L_PSYNC)._operation; //OPERATION_SPECIAL_L_PSYNC;
    14811575    inst->_has_immediat       = 0;
    14821576//  inst->_immediat           = ;
    … …  
    14921586//  inst->_num_reg_re         = ;
    14931587    inst->_exception_use      = EXCEPTION_USE_NONE;
     1588    inst->_exception          = EXCEPTION_DECOD_NONE;
    14941589//  inst->_branch_condition   = ;
    14951590//  inst->_branch_stack_write = ;
    14961591//  inst->_branch_direction   = ;
    14971592//  inst->_address_next       = ; // don't change
     1593    inst->_no_execute         = 0;
    14981594    inst->_event_type         = EVENT_TYPE_PSYNC;
    14991595      }
    … …  
    15041600    log_printf(TRACE,Decod,"instruction_l_rfe","  * instruction   : l.rfe");
    15051601
    1506     inst->_type               = TYPE_SPECIAL;
    1507     inst->_operation          = OPERATION_SPECIAL_L_RFE;
     1602    inst->_type               = instruction_information(INSTRUCTION_L_RFE)._type     ; //TYPE_SPECIAL;
     1603    inst->_operation          = instruction_information(INSTRUCTION_L_RFE)._operation; //OPERATION_SPECIAL_L_RFE;
    15081604    inst->_has_immediat       = 0;
    15091605//  inst->_immediat           = ;
    … …  
    15191615//  inst->_num_reg_re         = ;
    15201616    inst->_exception_use      = EXCEPTION_USE_NONE;
     1617    inst->_exception          = EXCEPTION_DECOD_NONE;
    15211618//  inst->_branch_condition   = ;
    15221619//  inst->_branch_stack_write = ;
    15231620//  inst->_branch_direction   = ;
    15241621//  inst->_address_next       = ; // don't change
     1622    inst->_no_execute         = 1;
    15251623    inst->_event_type         = EVENT_TYPE_NONE; // can't anticip this instruction : must read EPCR in rename stage
    15261624  }
    … …  
    15301628    log_printf(TRACE,Decod,"instruction_l_ror","  * instruction   : l.ror");
    15311629
    1532     inst->_type               = TYPE_SHIFT;
    1533     inst->_operation          = OPERATION_SHIFT_L_ROR;
    1534     inst->_has_immediat       = 0;
    1535 //  inst->_immediat           = ;
    1536     inst->_read_ra            = 1;
    1537     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    1538     inst->_read_rb            = 1;
    1539     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    1540     inst->_read_rc            = 0;
    1541 //  inst->_num_reg_rc         = ;
    1542     inst->_write_rd           = 1;
    1543     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    1544     inst->_write_re           = 0;
    1545 //  inst->_num_reg_re         = ;
    1546     inst->_exception_use      = EXCEPTION_USE_NONE;
    1547 //  inst->_branch_condition   = ;
    1548 //  inst->_branch_stack_write = ;
    1549 //  inst->_branch_direction   = ;
    1550 //  inst->_address_next       = ;
     1630    inst->_type               = instruction_information(INSTRUCTION_L_ROR)._type     ; //TYPE_SHIFT;
     1631    inst->_operation          = instruction_information(INSTRUCTION_L_ROR)._operation; //OPERATION_SHIFT_L_ROR;
     1632    inst->_has_immediat       = 0;
     1633//  inst->_immediat           = ;
     1634    inst->_read_ra            = 1;
     1635    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     1636    inst->_read_rb            = 1;
     1637    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     1638    inst->_read_rc            = 0;
     1639//  inst->_num_reg_rc         = ;
     1640    inst->_write_rd           = 1;
     1641    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     1642    inst->_write_re           = 0;
     1643//  inst->_num_reg_re         = ;
     1644    inst->_exception_use      = EXCEPTION_USE_NONE;
     1645    inst->_exception          = EXCEPTION_DECOD_NONE;
     1646//  inst->_branch_condition   = ;
     1647//  inst->_branch_stack_write = ;
     1648//  inst->_branch_direction   = ;
     1649//  inst->_address_next       = ;
     1650    inst->_no_execute         = 0;
    15511651    inst->_event_type         = EVENT_TYPE_NONE;
    15521652  }
    … …  
    15561656    log_printf(TRACE,Decod,"instruction_l_rori","  * instruction   : l.rori");
    15571657
    1558     inst->_type               = TYPE_SHIFT;
    1559     inst->_operation          = OPERATION_SHIFT_L_ROR;
     1658    inst->_type               = instruction_information(INSTRUCTION_L_RORI)._type     ; //TYPE_SHIFT;
     1659    inst->_operation          = instruction_information(INSTRUCTION_L_RORI)._operation; //OPERATION_SHIFT_L_ROR;
    15601660    inst->_has_immediat       = 1;
    15611661    inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
    … …  
    15711671//  inst->_num_reg_re         = ;
    15721672    inst->_exception_use      = EXCEPTION_USE_NONE;
    1573 //  inst->_branch_condition   = ;
    1574 //  inst->_branch_stack_write = ;
    1575 //  inst->_branch_direction   = ;
    1576 //  inst->_address_next       = ;
     1673    inst->_exception          = EXCEPTION_DECOD_NONE;
     1674//  inst->_branch_condition   = ;
     1675//  inst->_branch_stack_write = ;
     1676//  inst->_branch_direction   = ;
     1677//  inst->_address_next       = ;
     1678    inst->_no_execute         = 0;
    15771679    inst->_event_type         = EVENT_TYPE_NONE;
    15781680  }
    … …  
    15821684    log_printf(TRACE,Decod,"instruction_l_sb","  * instruction   : l.sb");
    15831685
    1584     inst->_type               = TYPE_MEMORY;
    1585     inst->_operation          = OPERATION_MEMORY_STORE_8;
     1686    inst->_type               = instruction_information(INSTRUCTION_L_SB)._type     ; //TYPE_MEMORY;
     1687    inst->_operation          = instruction_information(INSTRUCTION_L_SB)._operation; //OPERATION_MEMORY_STORE_8;
    15861688    inst->_has_immediat       = 1;
    15871689    inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    15981700//  inst->_num_reg_re         = ;
    15991701    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITHOUT_ALIGNMENT;
    1600 //  inst->_branch_condition   = ;
    1601 //  inst->_branch_stack_write = ;
    1602 //  inst->_branch_direction   = ;
    1603 //  inst->_address_next       = ;
     1702    inst->_exception          = EXCEPTION_DECOD_NONE;
     1703//  inst->_branch_condition   = ;
     1704//  inst->_branch_stack_write = ;
     1705//  inst->_branch_direction   = ;
     1706//  inst->_address_next       = ;
     1707    inst->_no_execute         = 0;
    16041708    inst->_event_type         = EVENT_TYPE_NONE;
    16051709  }
    … …  
    16091713    log_printf(TRACE,Decod,"instruction_l_sb","  * instruction   : l.sb");
    16101714
    1611     inst->_type               = TYPE_MEMORY;
    1612     inst->_operation          = OPERATION_MEMORY_STORE_64;
     1715    inst->_type               = instruction_information(INSTRUCTION_L_SD)._type     ; //TYPE_MEMORY;
     1716    inst->_operation          = instruction_information(INSTRUCTION_L_SD)._operation; //OPERATION_MEMORY_STORE_64;
    16131717    inst->_has_immediat       = 1;
    16141718    inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    16251729//  inst->_num_reg_re         = ;
    16261730    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    1627 //  inst->_branch_condition   = ;
    1628 //  inst->_branch_stack_write = ;
    1629 //  inst->_branch_direction   = ;
    1630 //  inst->_address_next       = ;
     1731    inst->_exception          = EXCEPTION_DECOD_NONE;
     1732//  inst->_branch_condition   = ;
     1733//  inst->_branch_stack_write = ;
     1734//  inst->_branch_direction   = ;
     1735//  inst->_address_next       = ;
     1736    inst->_no_execute         = 0;
    16311737    inst->_event_type         = EVENT_TYPE_NONE;
    16321738  }
    … …  
    16361742    log_printf(TRACE,Decod,"instruction_l_sfeq","  * instruction   : l.sfeq");
    16371743
    1638     inst->_type               = TYPE_TEST;
    1639     inst->_operation          = OPERATION_TEST_L_SFEQ;
     1744    inst->_type               = instruction_information(INSTRUCTION_L_SFEQ)._type     ; //TYPE_TEST;
     1745    inst->_operation          = instruction_information(INSTRUCTION_L_SFEQ)._operation; //OPERATION_TEST_L_SFEQ;
    16401746    inst->_has_immediat       = 0;
    16411747//  inst->_immediat           = ;
    … …  
    16511757    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    16521758    inst->_exception_use      = EXCEPTION_USE_NONE;
    1653 //  inst->_branch_condition   = ;
    1654 //  inst->_branch_stack_write = ;
    1655 //  inst->_branch_direction   = ;
    1656 //  inst->_address_next       = ;
     1759    inst->_exception          = EXCEPTION_DECOD_NONE;
     1760//  inst->_branch_condition   = ;
     1761//  inst->_branch_stack_write = ;
     1762//  inst->_branch_direction   = ;
     1763//  inst->_address_next       = ;
     1764    inst->_no_execute         = 0;
    16571765    inst->_event_type         = EVENT_TYPE_NONE;
    16581766  }
    … …  
    16621770    log_printf(TRACE,Decod,"instruction_l_sfeqi","  * instruction   : l.sfeqi");
    16631771
    1664     inst->_type               = TYPE_TEST;
    1665     inst->_operation          = OPERATION_TEST_L_SFEQ;
     1772    inst->_type               = instruction_information(INSTRUCTION_L_SFEQI)._type     ; //TYPE_TEST;
     1773    inst->_operation          = instruction_information(INSTRUCTION_L_SFEQI)._operation; //OPERATION_TEST_L_SFEQ;
    16661774    inst->_has_immediat       = 1;
    16671775    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    16771785    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    16781786    inst->_exception_use      = EXCEPTION_USE_NONE;
    1679 //  inst->_branch_condition   = ;
    1680 //  inst->_branch_stack_write = ;
    1681 //  inst->_branch_direction   = ;
    1682 //  inst->_address_next       = ;
     1787    inst->_exception          = EXCEPTION_DECOD_NONE;
     1788//  inst->_branch_condition   = ;
     1789//  inst->_branch_stack_write = ;
     1790//  inst->_branch_direction   = ;
     1791//  inst->_address_next       = ;
     1792    inst->_no_execute         = 0;
    16831793    inst->_event_type         = EVENT_TYPE_NONE;
    16841794  }
    … …  
    16881798    log_printf(TRACE,Decod,"instruction_l_sfges","  * instruction   : l.sfges");
    16891799
    1690     inst->_type               = TYPE_TEST;
    1691     inst->_operation          = OPERATION_TEST_L_SFGES;
     1800    inst->_type               = instruction_information(INSTRUCTION_L_SFGES)._type     ; //TYPE_TEST;
     1801    inst->_operation          = instruction_information(INSTRUCTION_L_SFGES)._operation; //OPERATION_TEST_L_SFGES;
    16921802    inst->_has_immediat       = 0;
    16931803//  inst->_immediat           = ;
    … …  
    17031813    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    17041814    inst->_exception_use      = EXCEPTION_USE_NONE;
    1705 //  inst->_branch_condition   = ;
    1706 //  inst->_branch_stack_write = ;
    1707 //  inst->_branch_direction   = ;
    1708 //  inst->_address_next       = ;
     1815    inst->_exception          = EXCEPTION_DECOD_NONE;
     1816//  inst->_branch_condition   = ;
     1817//  inst->_branch_stack_write = ;
     1818//  inst->_branch_direction   = ;
     1819//  inst->_address_next       = ;
     1820    inst->_no_execute         = 0;
    17091821    inst->_event_type         = EVENT_TYPE_NONE;
    17101822  }
    … …  
    17141826    log_printf(TRACE,Decod,"instruction_l_sfgesi","  * instruction   : l.sfgesi");
    17151827
    1716     inst->_type               = TYPE_TEST;
    1717     inst->_operation          = OPERATION_TEST_L_SFGES;
     1828    inst->_type               = instruction_information(INSTRUCTION_L_SFGESI)._type     ; //TYPE_TEST;
     1829    inst->_operation          = instruction_information(INSTRUCTION_L_SFGESI)._operation; //OPERATION_TEST_L_SFGES;
    17181830    inst->_has_immediat       = 1;
    17191831    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    17291841    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    17301842    inst->_exception_use      = EXCEPTION_USE_NONE;
    1731 //  inst->_branch_condition   = ;
    1732 //  inst->_branch_stack_write = ;
    1733 //  inst->_branch_direction   = ;
    1734 //  inst->_address_next       = ;
     1843    inst->_exception          = EXCEPTION_DECOD_NONE;
     1844//  inst->_branch_condition   = ;
     1845//  inst->_branch_stack_write = ;
     1846//  inst->_branch_direction   = ;
     1847//  inst->_address_next       = ;
     1848    inst->_no_execute         = 0;
    17351849    inst->_event_type         = EVENT_TYPE_NONE;
    17361850  }
    … …  
    17401854    log_printf(TRACE,Decod,"instruction_l_sfgeu","  * instruction   : l.sfgeu");
    17411855
    1742     inst->_type               = TYPE_TEST;
    1743     inst->_operation          = OPERATION_TEST_L_SFGEU;
     1856    inst->_type               = instruction_information(INSTRUCTION_L_SFGEU)._type     ; //TYPE_TEST;
     1857    inst->_operation          = instruction_information(INSTRUCTION_L_SFGEU)._operation; //OPERATION_TEST_L_SFGEU;
    17441858    inst->_has_immediat       = 0;
    17451859//  inst->_immediat           = ;
    … …  
    17551869    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    17561870    inst->_exception_use      = EXCEPTION_USE_NONE;
    1757 //  inst->_branch_condition   = ;
    1758 //  inst->_branch_stack_write = ;
    1759 //  inst->_branch_direction   = ;
    1760 //  inst->_address_next       = ;
     1871    inst->_exception          = EXCEPTION_DECOD_NONE;
     1872//  inst->_branch_condition   = ;
     1873//  inst->_branch_stack_write = ;
     1874//  inst->_branch_direction   = ;
     1875//  inst->_address_next       = ;
     1876    inst->_no_execute         = 0;
    17611877    inst->_event_type         = EVENT_TYPE_NONE;
    17621878  }
    … …  
    17661882    log_printf(TRACE,Decod,"instruction_l_sfgeui","  * instruction   : l.sfgeui");
    17671883
    1768     inst->_type               = TYPE_TEST;
    1769     inst->_operation          = OPERATION_TEST_L_SFGEU;
     1884    inst->_type               = instruction_information(INSTRUCTION_L_SFGEUI)._type     ; //TYPE_TEST;
     1885    inst->_operation          = instruction_information(INSTRUCTION_L_SFGEUI)._operation; //OPERATION_TEST_L_SFGEU;
    17701886    inst->_has_immediat       = 1;
    17711887    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    17811897    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    17821898    inst->_exception_use      = EXCEPTION_USE_NONE;
    1783 //  inst->_branch_condition   = ;
    1784 //  inst->_branch_stack_write = ;
    1785 //  inst->_branch_direction   = ;
    1786 //  inst->_address_next       = ;
     1899    inst->_exception          = EXCEPTION_DECOD_NONE;
     1900//  inst->_branch_condition   = ;
     1901//  inst->_branch_stack_write = ;
     1902//  inst->_branch_direction   = ;
     1903//  inst->_address_next       = ;
     1904    inst->_no_execute         = 0;
    17871905    inst->_event_type         = EVENT_TYPE_NONE;
    17881906  }
    … …  
    17921910    log_printf(TRACE,Decod,"instruction_l_sfgts","  * instruction   : l.sfgts");
    17931911
    1794     inst->_type               = TYPE_TEST;
    1795     inst->_operation          = OPERATION_TEST_L_SFGTS;
     1912    inst->_type               = instruction_information(INSTRUCTION_L_SFGTS)._type     ; //TYPE_TEST;
     1913    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTS)._operation; //OPERATION_TEST_L_SFGTS;
    17961914    inst->_has_immediat       = 0;
    17971915//  inst->_immediat           = ;
    … …  
    18071925    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    18081926    inst->_exception_use      = EXCEPTION_USE_NONE;
    1809 //  inst->_branch_condition   = ;
    1810 //  inst->_branch_stack_write = ;
    1811 //  inst->_branch_direction   = ;
    1812 //  inst->_address_next       = ;
     1927    inst->_exception          = EXCEPTION_DECOD_NONE;
     1928//  inst->_branch_condition   = ;
     1929//  inst->_branch_stack_write = ;
     1930//  inst->_branch_direction   = ;
     1931//  inst->_address_next       = ;
     1932    inst->_no_execute         = 0;
    18131933    inst->_event_type         = EVENT_TYPE_NONE;
    18141934  }
    … …  
    18181938    log_printf(TRACE,Decod,"instruction_l_sfgtsi","  * instruction   : l.sfgtsi");
    18191939
    1820     inst->_type               = TYPE_TEST;
    1821     inst->_operation          = OPERATION_TEST_L_SFGTS;
     1940    inst->_type               = instruction_information(INSTRUCTION_L_SFGTSI)._type     ; //TYPE_TEST;
     1941    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTSI)._operation; //OPERATION_TEST_L_SFGTS;
    18221942    inst->_has_immediat       = 1;
    18231943    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    18331953    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    18341954    inst->_exception_use      = EXCEPTION_USE_NONE;
    1835 //  inst->_branch_condition   = ;
    1836 //  inst->_branch_stack_write = ;
    1837 //  inst->_branch_direction   = ;
    1838 //  inst->_address_next       = ;
     1955    inst->_exception          = EXCEPTION_DECOD_NONE;
     1956//  inst->_branch_condition   = ;
     1957//  inst->_branch_stack_write = ;
     1958//  inst->_branch_direction   = ;
     1959//  inst->_address_next       = ;
     1960    inst->_no_execute         = 0;
    18391961    inst->_event_type         = EVENT_TYPE_NONE;
    18401962  }
    … …  
    18441966    log_printf(TRACE,Decod,"instruction_l_sfgtu","  * instruction   : l.sfgtu");
    18451967
    1846     inst->_type               = TYPE_TEST;
    1847     inst->_operation          = OPERATION_TEST_L_SFGTU;
     1968    inst->_type               = instruction_information(INSTRUCTION_L_SFGTU)._type     ; //TYPE_TEST;
     1969    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTU)._operation; //OPERATION_TEST_L_SFGTU;
    18481970    inst->_has_immediat       = 0;
    18491971//  inst->_immediat           = ;
    … …  
    18591981    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    18601982    inst->_exception_use      = EXCEPTION_USE_NONE;
    1861 //  inst->_branch_condition   = ;
    1862 //  inst->_branch_stack_write = ;
    1863 //  inst->_branch_direction   = ;
    1864 //  inst->_address_next       = ;
     1983    inst->_exception          = EXCEPTION_DECOD_NONE;
     1984//  inst->_branch_condition   = ;
     1985//  inst->_branch_stack_write = ;
     1986//  inst->_branch_direction   = ;
     1987//  inst->_address_next       = ;
     1988    inst->_no_execute         = 0;
    18651989    inst->_event_type         = EVENT_TYPE_NONE;
    18661990  }
    … …  
    18701994    log_printf(TRACE,Decod,"instruction_l_sfgtui","  * instruction   : l.sfgtui");
    18711995
    1872     inst->_type               = TYPE_TEST;
    1873     inst->_operation          = OPERATION_TEST_L_SFGTU;
     1996    inst->_type               = instruction_information(INSTRUCTION_L_SFGTUI)._type     ; //TYPE_TEST;
     1997    inst->_operation          = instruction_information(INSTRUCTION_L_SFGTUI)._operation; //OPERATION_TEST_L_SFGTU;
    18741998    inst->_has_immediat       = 1;
    18751999    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    18852009    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    18862010    inst->_exception_use      = EXCEPTION_USE_NONE;
    1887 //  inst->_branch_condition   = ;
    1888 //  inst->_branch_stack_write = ;
    1889 //  inst->_branch_direction   = ;
    1890 //  inst->_address_next       = ;
     2011    inst->_exception          = EXCEPTION_DECOD_NONE;
     2012//  inst->_branch_condition   = ;
     2013//  inst->_branch_stack_write = ;
     2014//  inst->_branch_direction   = ;
     2015//  inst->_address_next       = ;
     2016    inst->_no_execute         = 0;
    18912017    inst->_event_type         = EVENT_TYPE_NONE;
    18922018  }
    … …  
    18962022    log_printf(TRACE,Decod,"instruction_l_sfles","  * instruction   : l.sfles");
    18972023
    1898     inst->_type               = TYPE_TEST;
    1899     inst->_operation          = OPERATION_TEST_L_SFLES;
     2024    inst->_type               = instruction_information(INSTRUCTION_L_SFLES)._type     ; //TYPE_TEST;
     2025    inst->_operation          = instruction_information(INSTRUCTION_L_SFLES)._operation; //OPERATION_TEST_L_SFLES;
    19002026    inst->_has_immediat       = 0;
    19012027//  inst->_immediat           = ;
    … …  
    19112037    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    19122038    inst->_exception_use      = EXCEPTION_USE_NONE;
    1913 //  inst->_branch_condition   = ;
    1914 //  inst->_branch_stack_write = ;
    1915 //  inst->_branch_direction   = ;
    1916 //  inst->_address_next       = ;
     2039    inst->_exception          = EXCEPTION_DECOD_NONE;
     2040//  inst->_branch_condition   = ;
     2041//  inst->_branch_stack_write = ;
     2042//  inst->_branch_direction   = ;
     2043//  inst->_address_next       = ;
     2044    inst->_no_execute         = 0;
    19172045    inst->_event_type         = EVENT_TYPE_NONE;
    19182046  }
    … …  
    19222050    log_printf(TRACE,Decod,"instruction_l_sflesi","  * instruction   : l.sflesi");
    19232051
    1924     inst->_type               = TYPE_TEST;
    1925     inst->_operation          = OPERATION_TEST_L_SFLES;
     2052    inst->_type               = instruction_information(INSTRUCTION_L_SFLESI)._type     ; //TYPE_TEST;
     2053    inst->_operation          = instruction_information(INSTRUCTION_L_SFLESI)._operation; //OPERATION_TEST_L_SFLES;
    19262054    inst->_has_immediat       = 1;
    19272055    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    19372065    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    19382066    inst->_exception_use      = EXCEPTION_USE_NONE;
    1939 //  inst->_branch_condition   = ;
    1940 //  inst->_branch_stack_write = ;
    1941 //  inst->_branch_direction   = ;
    1942 //  inst->_address_next       = ;
     2067    inst->_exception          = EXCEPTION_DECOD_NONE;
     2068//  inst->_branch_condition   = ;
     2069//  inst->_branch_stack_write = ;
     2070//  inst->_branch_direction   = ;
     2071//  inst->_address_next       = ;
     2072    inst->_no_execute         = 0;
    19432073    inst->_event_type         = EVENT_TYPE_NONE;
    19442074  }
    … …  
    19482078    log_printf(TRACE,Decod,"instruction_l_sfleu","  * instruction   : l.sfleu");
    19492079
    1950     inst->_type               = TYPE_TEST;
    1951     inst->_operation          = OPERATION_TEST_L_SFLEU;
     2080    inst->_type               = instruction_information(INSTRUCTION_L_SFLEU)._type     ; //TYPE_TEST;
     2081    inst->_operation          = instruction_information(INSTRUCTION_L_SFLEU)._operation; //OPERATION_TEST_L_SFLEU;
    19522082    inst->_has_immediat       = 0;
    19532083//  inst->_immediat           = ;
    … …  
    19632093    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    19642094    inst->_exception_use      = EXCEPTION_USE_NONE;
    1965 //  inst->_branch_condition   = ;
    1966 //  inst->_branch_stack_write = ;
    1967 //  inst->_branch_direction   = ;
    1968 //  inst->_address_next       = ;
     2095    inst->_exception          = EXCEPTION_DECOD_NONE;
     2096//  inst->_branch_condition   = ;
     2097//  inst->_branch_stack_write = ;
     2098//  inst->_branch_direction   = ;
     2099//  inst->_address_next       = ;
     2100    inst->_no_execute         = 0;
    19692101    inst->_event_type         = EVENT_TYPE_NONE;
    19702102  }
    … …  
    19742106    log_printf(TRACE,Decod,"instruction_l_sfleui","  * instruction   : l.sfleui");
    19752107
    1976     inst->_type               = TYPE_TEST;
    1977     inst->_operation          = OPERATION_TEST_L_SFLEU;
     2108    inst->_type               = instruction_information(INSTRUCTION_L_SFLEUI)._type     ; //TYPE_TEST;
     2109    inst->_operation          = instruction_information(INSTRUCTION_L_SFLEUI)._operation; //OPERATION_TEST_L_SFLEU;
    19782110    inst->_has_immediat       = 1;
    19792111    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    19892121    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    19902122    inst->_exception_use      = EXCEPTION_USE_NONE;
    1991 //  inst->_branch_condition   = ;
    1992 //  inst->_branch_stack_write = ;
    1993 //  inst->_branch_direction   = ;
    1994 //  inst->_address_next       = ;
     2123    inst->_exception          = EXCEPTION_DECOD_NONE;
     2124//  inst->_branch_condition   = ;
     2125//  inst->_branch_stack_write = ;
     2126//  inst->_branch_direction   = ;
     2127//  inst->_address_next       = ;
     2128    inst->_no_execute         = 0;
    19952129    inst->_event_type         = EVENT_TYPE_NONE;
    19962130  }
    … …  
    20002134    log_printf(TRACE,Decod,"instruction_l_sflts","  * instruction   : l.sflts");
    20012135
    2002     inst->_type               = TYPE_TEST;
    2003     inst->_operation          = OPERATION_TEST_L_SFLTS;
     2136    inst->_type               = instruction_information(INSTRUCTION_L_SFLTS)._type     ; //TYPE_TEST;
     2137    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTS)._operation; //OPERATION_TEST_L_SFLTS;
    20042138    inst->_has_immediat       = 0;
    20052139//  inst->_immediat           = ;
    … …  
    20152149    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    20162150    inst->_exception_use      = EXCEPTION_USE_NONE;
    2017 //  inst->_branch_condition   = ;
    2018 //  inst->_branch_stack_write = ;
    2019 //  inst->_branch_direction   = ;
    2020 //  inst->_address_next       = ;
     2151    inst->_exception          = EXCEPTION_DECOD_NONE;
     2152//  inst->_branch_condition   = ;
     2153//  inst->_branch_stack_write = ;
     2154//  inst->_branch_direction   = ;
     2155//  inst->_address_next       = ;
     2156    inst->_no_execute         = 0;
    20212157    inst->_event_type         = EVENT_TYPE_NONE;
    20222158  }
    … …  
    20262162    log_printf(TRACE,Decod,"instruction_l_sfltsi","  * instruction   : l.sfltsi");
    20272163
    2028     inst->_type               = TYPE_TEST;
    2029     inst->_operation          = OPERATION_TEST_L_SFLTS;
     2164    inst->_type               = instruction_information(INSTRUCTION_L_SFLTSI)._type     ; //TYPE_TEST;
     2165    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTSI)._operation; //OPERATION_TEST_L_SFLTS;
    20302166    inst->_has_immediat       = 1;
    20312167    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    20412177    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    20422178    inst->_exception_use      = EXCEPTION_USE_NONE;
    2043 //  inst->_branch_condition   = ;
    2044 //  inst->_branch_stack_write = ;
    2045 //  inst->_branch_direction   = ;
    2046 //  inst->_address_next       = ;
     2179    inst->_exception          = EXCEPTION_DECOD_NONE;
     2180//  inst->_branch_condition   = ;
     2181//  inst->_branch_stack_write = ;
     2182//  inst->_branch_direction   = ;
     2183//  inst->_address_next       = ;
     2184    inst->_no_execute         = 0;
    20472185    inst->_event_type         = EVENT_TYPE_NONE;
    20482186  }
    … …  
    20522190    log_printf(TRACE,Decod,"instruction_l_sfltu","  * instruction   : l.sfltu");
    20532191
    2054     inst->_type               = TYPE_TEST;
    2055     inst->_operation          = OPERATION_TEST_L_SFLTU;
     2192    inst->_type               = instruction_information(INSTRUCTION_L_SFLTU)._type     ; //TYPE_TEST;
     2193    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTU)._operation; //OPERATION_TEST_L_SFLTU;
    20562194    inst->_has_immediat       = 0;
    20572195//  inst->_immediat           = ;
    … …  
    20672205    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    20682206    inst->_exception_use      = EXCEPTION_USE_NONE;
    2069 //  inst->_branch_condition   = ;
    2070 //  inst->_branch_stack_write = ;
    2071 //  inst->_branch_direction   = ;
    2072 //  inst->_address_next       = ;
     2207    inst->_exception          = EXCEPTION_DECOD_NONE;
     2208//  inst->_branch_condition   = ;
     2209//  inst->_branch_stack_write = ;
     2210//  inst->_branch_direction   = ;
     2211//  inst->_address_next       = ;
     2212    inst->_no_execute         = 0;
    20732213    inst->_event_type         = EVENT_TYPE_NONE;
    20742214  }
    … …  
    20782218    log_printf(TRACE,Decod,"instruction_l_sfltui","  * instruction   : l.sfltui");
    20792219
    2080     inst->_type               = TYPE_TEST;
    2081     inst->_operation          = OPERATION_TEST_L_SFLTU;
     2220    inst->_type               = instruction_information(INSTRUCTION_L_SFLTUI)._type     ; //TYPE_TEST;
     2221    inst->_operation          = instruction_information(INSTRUCTION_L_SFLTUI)._operation; //OPERATION_TEST_L_SFLTU;
    20822222    inst->_has_immediat       = 1;
    20832223    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    20932233    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    20942234    inst->_exception_use      = EXCEPTION_USE_NONE;
    2095 //  inst->_branch_condition   = ;
    2096 //  inst->_branch_stack_write = ;
    2097 //  inst->_branch_direction   = ;
    2098 //  inst->_address_next       = ;
     2235    inst->_exception          = EXCEPTION_DECOD_NONE;
     2236//  inst->_branch_condition   = ;
     2237//  inst->_branch_stack_write = ;
     2238//  inst->_branch_direction   = ;
     2239//  inst->_address_next       = ;
     2240    inst->_no_execute         = 0;
    20992241    inst->_event_type         = EVENT_TYPE_NONE;
    21002242  }
    … …  
    21042246    log_printf(TRACE,Decod,"instruction_l_sfne","  * instruction   : l.sfne");
    21052247
    2106     inst->_type               = TYPE_TEST;
    2107     inst->_operation          = OPERATION_TEST_L_SFNE;
     2248    inst->_type               = instruction_information(INSTRUCTION_L_SFNE)._type     ; //TYPE_TEST;
     2249    inst->_operation          = instruction_information(INSTRUCTION_L_SFNE)._operation; //OPERATION_TEST_L_SFNE;
    21082250    inst->_has_immediat       = 0;
    21092251//  inst->_immediat           = ;
    … …  
    21192261    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    21202262    inst->_exception_use      = EXCEPTION_USE_NONE;
    2121 //  inst->_branch_condition   = ;
    2122 //  inst->_branch_stack_write = ;
    2123 //  inst->_branch_direction   = ;
    2124 //  inst->_address_next       = ;
     2263    inst->_exception          = EXCEPTION_DECOD_NONE;
     2264//  inst->_branch_condition   = ;
     2265//  inst->_branch_stack_write = ;
     2266//  inst->_branch_direction   = ;
     2267//  inst->_address_next       = ;
     2268    inst->_no_execute         = 0;
    21252269    inst->_event_type         = EVENT_TYPE_NONE;
    21262270  }
    … …  
    21302274    log_printf(TRACE,Decod,"instruction_l_sfnei","  * instruction   : l.sfnei");
    21312275
    2132     inst->_type               = TYPE_TEST;
    2133     inst->_operation          = OPERATION_TEST_L_SFNE;
     2276    inst->_type               = instruction_information(INSTRUCTION_L_SFNEI)._type     ; //TYPE_TEST;
     2277    inst->_operation          = instruction_information(INSTRUCTION_L_SFNEI)._operation; //OPERATION_TEST_L_SFNE;
    21342278    inst->_has_immediat       = 1;
    21352279    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    21452289    inst->_num_reg_re         = SPR_LOGIC_SR_F;
    21462290    inst->_exception_use      = EXCEPTION_USE_NONE;
    2147 //  inst->_branch_condition   = ;
    2148 //  inst->_branch_stack_write = ;
    2149 //  inst->_branch_direction   = ;
    2150 //  inst->_address_next       = ;
     2291    inst->_exception          = EXCEPTION_DECOD_NONE;
     2292//  inst->_branch_condition   = ;
     2293//  inst->_branch_stack_write = ;
     2294//  inst->_branch_direction   = ;
     2295//  inst->_address_next       = ;
     2296    inst->_no_execute         = 0;
    21512297    inst->_event_type         = EVENT_TYPE_NONE;
    21522298  }
    … …  
    21562302    log_printf(TRACE,Decod,"instruction_l_sh","  * instruction   : l.sh");
    21572303
    2158     inst->_type               = TYPE_MEMORY;
    2159     inst->_operation          = OPERATION_MEMORY_STORE_16;
     2304    inst->_type               = instruction_information(INSTRUCTION_L_SH)._type     ; //TYPE_MEMORY;
     2305    inst->_operation          = instruction_information(INSTRUCTION_L_SH)._operation; //OPERATION_MEMORY_STORE_16;
    21602306    inst->_has_immediat       = 1;
    21612307    inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    21722318//  inst->_num_reg_re         = ;
    21732319    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    2174 //  inst->_branch_condition   = ;
    2175 //  inst->_branch_stack_write = ;
    2176 //  inst->_branch_direction   = ;
    2177 //  inst->_address_next       = ;
     2320    inst->_exception          = EXCEPTION_DECOD_NONE;
     2321//  inst->_branch_condition   = ;
     2322//  inst->_branch_stack_write = ;
     2323//  inst->_branch_direction   = ;
     2324//  inst->_address_next       = ;
     2325    inst->_no_execute         = 0;
    21782326    inst->_event_type         = EVENT_TYPE_NONE;
    21792327  }
    … …  
    21832331    log_printf(TRACE,Decod,"instruction_l_sll","  * instruction   : l.sll");
    21842332
    2185     inst->_type               = TYPE_SHIFT;
    2186     inst->_operation          = OPERATION_SHIFT_L_SLL;
    2187     inst->_has_immediat       = 0;
    2188 //  inst->_immediat           = ;
    2189     inst->_read_ra            = 1;
    2190     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    2191     inst->_read_rb            = 1;
    2192     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    2193     inst->_read_rc            = 0;
    2194 //  inst->_num_reg_rc         = ;
    2195     inst->_write_rd           = 1;
    2196     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    2197     inst->_write_re           = 0;
    2198 //  inst->_num_reg_re         = ;
    2199     inst->_exception_use      = EXCEPTION_USE_NONE;
    2200 //  inst->_branch_condition   = ;
    2201 //  inst->_branch_stack_write = ;
    2202 //  inst->_branch_direction   = ;
    2203 //  inst->_address_next       = ;
     2333    inst->_type               = instruction_information(INSTRUCTION_L_SLL)._type     ; //TYPE_SHIFT;
     2334    inst->_operation          = instruction_information(INSTRUCTION_L_SLL)._operation; //OPERATION_SHIFT_L_SLL;
     2335    inst->_has_immediat       = 0;
     2336//  inst->_immediat           = ;
     2337    inst->_read_ra            = 1;
     2338    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     2339    inst->_read_rb            = 1;
     2340    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     2341    inst->_read_rc            = 0;
     2342//  inst->_num_reg_rc         = ;
     2343    inst->_write_rd           = 1;
     2344    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     2345    inst->_write_re           = 0;
     2346//  inst->_num_reg_re         = ;
     2347    inst->_exception_use      = EXCEPTION_USE_NONE;
     2348    inst->_exception          = EXCEPTION_DECOD_NONE;
     2349//  inst->_branch_condition   = ;
     2350//  inst->_branch_stack_write = ;
     2351//  inst->_branch_direction   = ;
     2352//  inst->_address_next       = ;
     2353    inst->_no_execute         = 0;
    22042354    inst->_event_type         = EVENT_TYPE_NONE;
    22052355  }
    … …  
    22092359    log_printf(TRACE,Decod,"instruction_l_slli","  * instruction   : l.slli");
    22102360
    2211     inst->_type               = TYPE_SHIFT;
    2212     inst->_operation          = OPERATION_SHIFT_L_SLL;
     2361    inst->_type               = instruction_information(INSTRUCTION_L_SLLI)._type     ; //TYPE_SHIFT;
     2362    inst->_operation          = instruction_information(INSTRUCTION_L_SLLI)._operation; //OPERATION_SHIFT_L_SLL;
    22132363    inst->_has_immediat       = 1;
    22142364    inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
    … …  
    22242374//  inst->_num_reg_re         = ;
    22252375    inst->_exception_use      = EXCEPTION_USE_NONE;
    2226 //  inst->_branch_condition   = ;
    2227 //  inst->_branch_stack_write = ;
    2228 //  inst->_branch_direction   = ;
    2229 //  inst->_address_next       = ;
     2376    inst->_exception          = EXCEPTION_DECOD_NONE;
     2377//  inst->_branch_condition   = ;
     2378//  inst->_branch_stack_write = ;
     2379//  inst->_branch_direction   = ;
     2380//  inst->_address_next       = ;
     2381    inst->_no_execute         = 0;
    22302382    inst->_event_type         = EVENT_TYPE_NONE;
    22312383  }
    … …  
    22352387    log_printf(TRACE,Decod,"instruction_l_sra","  * instruction   : l.sra");
    22362388
    2237     inst->_type               = TYPE_SHIFT;
    2238     inst->_operation          = OPERATION_SHIFT_L_SRA;
    2239     inst->_has_immediat       = 0;
    2240 //  inst->_immediat           = ;
    2241     inst->_read_ra            = 1;
    2242     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    2243     inst->_read_rb            = 1;
    2244     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    2245     inst->_read_rc            = 0;
    2246 //  inst->_num_reg_rc         = ;
    2247     inst->_write_rd           = 1;
    2248     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    2249     inst->_write_re           = 0;
    2250 //  inst->_num_reg_re         = ;
    2251     inst->_exception_use      = EXCEPTION_USE_NONE;
    2252 //  inst->_branch_condition   = ;
    2253 //  inst->_branch_stack_write = ;
    2254 //  inst->_branch_direction   = ;
    2255 //  inst->_address_next       = ;
     2389    inst->_type               = instruction_information(INSTRUCTION_L_SRA)._type     ; //TYPE_SHIFT;
     2390    inst->_operation          = instruction_information(INSTRUCTION_L_SRA)._operation; //OPERATION_SHIFT_L_SRA;
     2391    inst->_has_immediat       = 0;
     2392//  inst->_immediat           = ;
     2393    inst->_read_ra            = 1;
     2394    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     2395    inst->_read_rb            = 1;
     2396    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     2397    inst->_read_rc            = 0;
     2398//  inst->_num_reg_rc         = ;
     2399    inst->_write_rd           = 1;
     2400    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     2401    inst->_write_re           = 0;
     2402//  inst->_num_reg_re         = ;
     2403    inst->_exception_use      = EXCEPTION_USE_NONE;
     2404    inst->_exception          = EXCEPTION_DECOD_NONE;
     2405//  inst->_branch_condition   = ;
     2406//  inst->_branch_stack_write = ;
     2407//  inst->_branch_direction   = ;
     2408//  inst->_address_next       = ;
     2409    inst->_no_execute         = 0;
    22562410    inst->_event_type         = EVENT_TYPE_NONE;
    22572411  }
    … …  
    22612415    log_printf(TRACE,Decod,"instruction_l_srai","  * instruction   : l.srai");
    22622416
    2263     inst->_type               = TYPE_SHIFT;
    2264     inst->_operation          = OPERATION_SHIFT_L_SRA;
     2417    inst->_type               = instruction_information(INSTRUCTION_L_SRAI)._type     ; //TYPE_SHIFT;
     2418    inst->_operation          = instruction_information(INSTRUCTION_L_SRAI)._operation; //OPERATION_SHIFT_L_SRA;
    22652419    inst->_has_immediat       = 1;
    22662420    inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
    … …  
    22762430//  inst->_num_reg_re         = ;
    22772431    inst->_exception_use      = EXCEPTION_USE_NONE;
    2278 //  inst->_branch_condition   = ;
    2279 //  inst->_branch_stack_write = ;
    2280 //  inst->_branch_direction   = ;
    2281 //  inst->_address_next       = ;
     2432    inst->_exception          = EXCEPTION_DECOD_NONE;
     2433//  inst->_branch_condition   = ;
     2434//  inst->_branch_stack_write = ;
     2435//  inst->_branch_direction   = ;
     2436//  inst->_address_next       = ;
     2437    inst->_no_execute         = 0;
    22822438    inst->_event_type         = EVENT_TYPE_NONE;
    22832439  }
    … …  
    22872443    log_printf(TRACE,Decod,"instruction_l_srl","  * instruction   : l.srl");
    22882444
    2289     inst->_type               = TYPE_SHIFT;
    2290     inst->_operation          = OPERATION_SHIFT_L_SRL;
    2291     inst->_has_immediat       = 0;
    2292 //  inst->_immediat           = ;
    2293     inst->_read_ra            = 1;
    2294     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    2295     inst->_read_rb            = 1;
    2296     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    2297     inst->_read_rc            = 0;
    2298 //  inst->_num_reg_rc         = ;
    2299     inst->_write_rd           = 1;
    2300     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    2301     inst->_write_re           = 0;
    2302 //  inst->_num_reg_re         = ;
    2303     inst->_exception_use      = EXCEPTION_USE_NONE;
    2304 //  inst->_branch_condition   = ;
    2305 //  inst->_branch_stack_write = ;
    2306 //  inst->_branch_direction   = ;
    2307 //  inst->_address_next       = ;
     2445    inst->_type               = instruction_information(INSTRUCTION_L_SRL)._type     ; //TYPE_SHIFT;
     2446    inst->_operation          = instruction_information(INSTRUCTION_L_SRL)._operation; //OPERATION_SHIFT_L_SRL;
     2447    inst->_has_immediat       = 0;
     2448//  inst->_immediat           = ;
     2449    inst->_read_ra            = 1;
     2450    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     2451    inst->_read_rb            = 1;
     2452    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     2453    inst->_read_rc            = 0;
     2454//  inst->_num_reg_rc         = ;
     2455    inst->_write_rd           = 1;
     2456    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     2457    inst->_write_re           = 0;
     2458//  inst->_num_reg_re         = ;
     2459    inst->_exception_use      = EXCEPTION_USE_NONE;
     2460    inst->_exception          = EXCEPTION_DECOD_NONE;
     2461//  inst->_branch_condition   = ;
     2462//  inst->_branch_stack_write = ;
     2463//  inst->_branch_direction   = ;
     2464//  inst->_address_next       = ;
     2465    inst->_no_execute         = 0;
    23082466    inst->_event_type         = EVENT_TYPE_NONE;
    23092467  }
    … …  
    23132471    log_printf(TRACE,Decod,"instruction_l_srli","  * instruction   : l.srli");
    23142472
    2315     inst->_type               = TYPE_SHIFT;
    2316     inst->_operation          = OPERATION_SHIFT_L_SRL;
     2473    inst->_type               = instruction_information(INSTRUCTION_L_SRLI)._type     ; //TYPE_SHIFT;
     2474    inst->_operation          = instruction_information(INSTRUCTION_L_SRLI)._operation; //OPERATION_SHIFT_L_SRL;
    23172475    inst->_has_immediat       = 1;
    23182476    inst->_immediat           = range<Tgeneral_data_t   >(inst->_instruction, 5, 0);
    … …  
    23282486//  inst->_num_reg_re         = ;
    23292487    inst->_exception_use      = EXCEPTION_USE_NONE;
    2330 //  inst->_branch_condition   = ;
    2331 //  inst->_branch_stack_write = ;
    2332 //  inst->_branch_direction   = ;
    2333 //  inst->_address_next       = ;
     2488    inst->_exception          = EXCEPTION_DECOD_NONE;
     2489//  inst->_branch_condition   = ;
     2490//  inst->_branch_stack_write = ;
     2491//  inst->_branch_direction   = ;
     2492//  inst->_address_next       = ;
     2493    inst->_no_execute         = 0;
    23342494    inst->_event_type         = EVENT_TYPE_NONE;
    23352495  }
    … …  
    23392499    log_printf(TRACE,Decod,"instruction_l_sub","  * instruction   : l.sub");
    23402500
    2341     inst->_type               = TYPE_ALU;
    2342     inst->_operation          = OPERATION_ALU_L_SUB;
     2501    inst->_type               = instruction_information(INSTRUCTION_L_SUB)._type     ; //TYPE_ALU;
     2502    inst->_operation          = instruction_information(INSTRUCTION_L_SUB)._operation; //OPERATION_ALU_L_SUB;
    23432503    inst->_has_immediat       = 0;
    23442504//  inst->_immediat           = ;
    … …  
    23542514    inst->_num_reg_re         = SPR_LOGIC_SR_CY_OV;
    23552515    inst->_exception_use      = EXCEPTION_USE_RANGE;
    2356 //  inst->_branch_condition   = ;
    2357 //  inst->_branch_stack_write = ;
    2358 //  inst->_branch_direction   = ;
    2359 //  inst->_address_next       = ;
     2516    inst->_exception          = EXCEPTION_DECOD_NONE;
     2517//  inst->_branch_condition   = ;
     2518//  inst->_branch_stack_write = ;
     2519//  inst->_branch_direction   = ;
     2520//  inst->_address_next       = ;
     2521    inst->_no_execute         = 0;
    23602522    inst->_event_type         = EVENT_TYPE_NONE;
    23612523  }
    … …  
    23652527    log_printf(TRACE,Decod,"instruction_l_sw","  * instruction   : l.sw");
    23662528
    2367     inst->_type               = TYPE_MEMORY;
    2368     inst->_operation          = OPERATION_MEMORY_STORE_32;
     2529    inst->_type               = instruction_information(INSTRUCTION_L_SW)._type     ; //TYPE_MEMORY;
     2530    inst->_operation          = instruction_information(INSTRUCTION_L_SW)._operation; //OPERATION_MEMORY_STORE_32;
    23692531    inst->_has_immediat       = 1;
    23702532    inst->_immediat           = EXTENDS(((range<Tgeneral_data_t   >(inst->_instruction,25,21)<<11)|
    … …  
    23812543//  inst->_num_reg_re         = ;
    23822544    inst->_exception_use      = EXCEPTION_USE_MEMORY_WITH_ALIGNMENT;
    2383 //  inst->_branch_condition   = ;
    2384 //  inst->_branch_stack_write = ;
    2385 //  inst->_branch_direction   = ;
    2386 //  inst->_address_next       = ;
     2545    inst->_exception          = EXCEPTION_DECOD_NONE;
     2546//  inst->_branch_condition   = ;
     2547//  inst->_branch_stack_write = ;
     2548//  inst->_branch_direction   = ;
     2549//  inst->_address_next       = ;
     2550    inst->_no_execute         = 0;
    23872551    inst->_event_type         = EVENT_TYPE_NONE;
    23882552  }
    … …  
    23982562    else
    23992563      {
    2400     inst->_type               = TYPE_SPECIAL;
    2401     inst->_operation          = OPERATION_SPECIAL_L_SYS;
     2564    inst->_type               = instruction_information(INSTRUCTION_L_SYS)._type     ; //TYPE_SPECIAL;
     2565    inst->_operation          = instruction_information(INSTRUCTION_L_SYS)._operation; //OPERATION_SPECIAL_L_SYS;
    24022566//  inst->_has_immediat       = 1;
    24032567//  inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    24152579//  inst->_num_reg_re         = ;
    24162580    inst->_exception_use      = EXCEPTION_USE_SYSCALL;
     2581    inst->_exception          = EXCEPTION_SYSCALL;
    24172582//  inst->_branch_condition   = ;
    24182583//  inst->_branch_stack_write = ;
    … …  
    24262591
    24272592//  inst->_address_next       = ; // don't change
     2593    inst->_no_execute         = 1;
    24282594    inst->_event_type         = EVENT_TYPE_EXCEPTION;
    24292595      }
    … …  
    24402606    else
    24412607      {
    2442     inst->_type               = TYPE_SPECIAL;
    2443     inst->_operation          = OPERATION_SPECIAL_L_TRAP;
     2608    inst->_type               = instruction_information(INSTRUCTION_L_TRAP)._type     ; //TYPE_SPECIAL;
     2609    inst->_operation          = instruction_information(INSTRUCTION_L_TRAP)._operation; //OPERATION_SPECIAL_L_TRAP;
    24442610    inst->_has_immediat       = 1;
    24452611    inst->_immediat           = EXTENDZ(inst->_instruction,16);
    … …  
    24552621//  inst->_num_reg_re         = ;
    24562622    inst->_exception_use      = EXCEPTION_USE_TRAP;
    2457 //  inst->_branch_condition   = ;
    2458 //  inst->_branch_stack_write = ;
    2459 //  inst->_branch_direction   = ;
    2460 //  inst->_address_next       = ;
     2623    inst->_exception          = EXCEPTION_DECOD_NONE;
     2624//  inst->_branch_condition   = ;
     2625//  inst->_branch_stack_write = ;
     2626//  inst->_branch_direction   = ;
     2627//  inst->_address_next       = ;
     2628    inst->_no_execute         = 1;
    24612629    inst->_event_type         = EVENT_TYPE_NONE;
    24622630      }
    … …  
    24672635    log_printf(TRACE,Decod,"instruction_l_xor","  * instruction   : l.xor");
    24682636
    2469     inst->_type               = TYPE_ALU;
    2470     inst->_operation          = OPERATION_ALU_L_XOR;
    2471     inst->_has_immediat       = 0;
    2472 //  inst->_immediat           = ;
    2473     inst->_read_ra            = 1;
    2474     inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
    2475     inst->_read_rb            = 1;
    2476     inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
    2477     inst->_read_rc            = 0;
    2478 //  inst->_num_reg_rc         = ;
    2479     inst->_write_rd           = 1;
    2480     inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
    2481     inst->_write_re           = 0;
    2482 //  inst->_num_reg_re         = ;
    2483     inst->_exception_use      = EXCEPTION_USE_NONE;
    2484 //  inst->_branch_condition   = ;
    2485 //  inst->_branch_stack_write = ;
    2486 //  inst->_branch_direction   = ;
    2487 //  inst->_address_next       = ;
     2637    inst->_type               = instruction_information(INSTRUCTION_L_XOR)._type     ; //TYPE_ALU;
     2638    inst->_operation          = instruction_information(INSTRUCTION_L_XOR)._operation; //OPERATION_ALU_L_XOR;
     2639    inst->_has_immediat       = 0;
     2640//  inst->_immediat           = ;
     2641    inst->_read_ra            = 1;
     2642    inst->_num_reg_ra         = range<Tgeneral_address_t>(inst->_instruction,20,16);
     2643    inst->_read_rb            = 1;
     2644    inst->_num_reg_rb         = range<Tgeneral_address_t>(inst->_instruction,15,11);
     2645    inst->_read_rc            = 0;
     2646//  inst->_num_reg_rc         = ;
     2647    inst->_write_rd           = 1;
     2648    inst->_num_reg_rd         = range<Tgeneral_address_t>(inst->_instruction,25,21);
     2649    inst->_write_re           = 0;
     2650//  inst->_num_reg_re         = ;
     2651    inst->_exception_use      = EXCEPTION_USE_NONE;
     2652    inst->_exception          = EXCEPTION_DECOD_NONE;
     2653//  inst->_branch_condition   = ;
     2654//  inst->_branch_stack_write = ;
     2655//  inst->_branch_direction   = ;
     2656//  inst->_address_next       = ;
     2657    inst->_no_execute         = 0;
    24882658    inst->_event_type         = EVENT_TYPE_NONE;
    24892659  }
    … …  
    24932663    log_printf(TRACE,Decod,"instruction_l_xori","  * instruction   : l.xori");
    24942664
    2495     inst->_type               = TYPE_ALU;
    2496     inst->_operation          = OPERATION_ALU_L_XOR;
     2665    inst->_type               = instruction_information(INSTRUCTION_L_XORI)._type     ; //TYPE_ALU;
     2666    inst->_operation          = instruction_information(INSTRUCTION_L_XORI)._operation; //OPERATION_ALU_L_XOR;
    24972667    inst->_has_immediat       = 1;
    24982668    inst->_immediat           = EXTENDS(inst->_instruction,16);
    … …  
    25082678//  inst->_num_reg_re         = ;
    25092679    inst->_exception_use      = EXCEPTION_USE_NONE;
    2510 //  inst->_branch_condition   = ;
    2511 //  inst->_branch_stack_write = ;
    2512 //  inst->_branch_direction   = ;
    2513 //  inst->_address_next       = ;
     2680    inst->_exception          = EXCEPTION_DECOD_NONE;
     2681//  inst->_branch_condition   = ;
     2682//  inst->_branch_stack_write = ;
     2683//  inst->_branch_direction   = ;
     2684//  inst->_address_next       = ;
     2685    inst->_no_execute         = 0;
    25142686    inst->_event_type         = EVENT_TYPE_NONE;
    25152687  }

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/Makefile.deps

    r81 r88  
    1313include                         $(DIR_MORPHEO)/Behavioural/Makefile.deps
    1414endif
     15ifndef Priority
     16include                         $(DIR_MORPHEO)/Behavioural/Generic/Priority/Makefile.deps
     17endif
    1518ifndef Custom
    1619include                         $(DIR_MORPHEO)/Behavioural/Custom/Makefile.deps
    … …  
    2528Decod_LIBRARY                   =       -lDecod \
    2629                                        $(Custom_LIBRARY)               \
     30                                        $(Priority_LIBRARY)             \
    2731                                        $(Behavioural_LIBRARY) 
    2832
    29 Decod_DIR_LIBRARY               =       -L$(Decod_DIR)/lib      \
     33Decod_DIR_LIBRARY               =       -L$(Decod_DIR)/lib              \
    3034                                        $(Custom_DIR_LIBRARY)           \
     35                                        $(Priority_DIR_LIBRARY)         \
    3136                                        $(Behavioural_DIR_LIBRARY)
    3237
    … …  
    3641                                @\
    3742                                $(MAKE) Behavioural_library;            \
     43                                $(MAKE) Priority_library;               \
    3844                                $(MAKE) Custom_library;                 \
    3945                                $(MAKE) --directory=$(Decod_DIR) --makefile=Makefile;
    … …  
    4248                                @\
    4349                                $(MAKE) Behavioural_library_clean;      \
     50                                $(MAKE) Priority_library_clean;         \
    4451                                $(MAKE) Custom_library_clean;           \
    4552                                $(MAKE) --directory=$(Decod_DIR) --makefile=Makefile clean;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/Makefile

    r81 r88  
    2424library_clean                   : Decod_library_clean
    2525
     26local_clean                     :
     27
    2628include                         $(DIR_COMPONENT)/Makefile.deps
    2729include                         $(DIR_MORPHEO)/Behavioural/Makefile.flags

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_min.cfg

    r87 r88  
    11Decod
    221       1       *4      # nb_context           
    3 1       1       *4      # nb_inst_fetch        [0] [nb_context]
     31       1       *4      # nb_inst_fetch                 [0] [nb_context]
    441       1       *4      # nb_inst_decod       
    5 1       1       *2      # nb_branch_speculated
    6 0       0       +1      # size_branch_update_prediction
     51       1       *2      # nb_branch_speculated          [0] [nb_context]
    761       1       *2      # nb_context_select   
    8732      32      *2      # size_general_data   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_mono_context.cfg

    r87 r88  
    11Decod
    221       1       *4      # nb_context           
    3 4       16      *4      # nb_inst_fetch        [0] [nb_context]
    4 1       4       *4      # nb_inst_decod       
    5 1       1       *2      # nb_branch_speculated
    6 0       2       +1      # size_branch_update_prediction
     34       16      *4      # nb_inst_fetch                 [0] [nb_context]
     41       4       *4      # nb_inst_decod         
     51       1       *2      # nb_branch_speculated          [0] [nb_context]
    761       1       *2      # nb_context_select   
    8732      32      *2      # size_general_data   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/config_multi_context.cfg

    r87 r88  
    11Decod
    224       4       *4      # nb_context           
    3 1       1       *4      # nb_inst_fetch        [0] [nb_context]
    4 2       2       *4      # nb_inst_fetch        [1] [nb_context]
    5 4       4       *4      # nb_inst_fetch        [2] [nb_context]
    6 8       8       *4      # nb_inst_fetch        [3] [nb_context]
     31       1       *4      # nb_inst_fetch                 [0] [nb_context]
     42       2       *4      # nb_inst_fetch                 [1] [nb_context]
     54       4       *4      # nb_inst_fetch                 [2] [nb_context]
     68       8       *4      # nb_inst_fetch                 [3] [nb_context]
    771       8       *2      # nb_inst_decod       
    8 1       1       *2      # nb_branch_speculated
    9 2       2       *2      # size_branch_update_prediction
     81       1       *2      # nb_branch_speculated          [0] [nb_context]
     90       0       *2      # nb_branch_speculated          [1] [nb_context]
     101       1       *2      # nb_branch_speculated          [2] [nb_context]
     112       2       *2      # nb_branch_speculated          [3] [nb_context]
    10121       4       *2      # nb_context_select   
    111332      32      *2      # size_general_data   

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/include/Decod_request.h

    r87 r88  
    3232  public : Ttype_t             _type                       ;
    3333  public : Toperation_t        _operation                  ;
     34  public : Tcontrol_t          _no_execute                 ;
    3435  public : Tcontrol_t          _is_delay_slot              ;
    3536  public : Tcontrol_t          _has_immediat               ;
    … …  
    4647  public : Tspecial_address_t  _num_reg_re                 ;
    4748  public : Texception_t        _exception_use              ;
     49  public : Texception_t        _exception_ifetch           ;
     50  public : Texception_t        _exception_decod            ;
    4851  public : Tevent_type_t       _context_event_type         ;
    4952
    … …  
    6467                    Ttype_t             type                       ,
    6568                    Toperation_t        operation                  ,
     69//                  Tcontrol_t          no_execute                 ,
    6670                    Tcontrol_t          is_delay_slot              ,
    6771                    Tcontrol_t          has_immediat               ,
    … …  
    7882                    Tspecial_address_t  num_reg_re                 ,
    7983                    Texception_t        exception_use              ,
     84//                     Texception_t        exception_ifetch           ,
     85//                     Texception_t        exception_decod            ,
    8086                    Tevent_type_t       context_event_type         )
    8187    {
    … …  
    110116      _exception_use               = exception_use              ;
    111117      _context_event_type          = context_event_type         ;
     118
     119      _no_execute                  = 0                          ;
     120      _exception_ifetch            = EXCEPTION_IFETCH_NONE      ;
     121      _exception_decod             = EXCEPTION_DECOD_NONE       ;
    112122    }
    113123  };
    … …  
    246256    0xe3caa309,x,y,z,
    247257    BRANCH_STATE_NONE,0,BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK,0, 0x0,
    248     0,TYPE_MUL_DIV,OPERATION_MUL_DIV_L_DIV,false,
     258    0,TYPE_DIV,OPERATION_DIV_L_DIV,false,
    249259    0,0x0,1,10,1,20,0,0                 ,1,30,1,SPR_LOGIC_SR_CY_OV,
    250260    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
    … …  
    265275    0xe3caa30a,x,y,z,
    266276    BRANCH_STATE_NONE,0,BRANCH_CONDITION_NONE_WITHOUT_WRITE_STACK,0, 0x0,
    267     0,TYPE_MUL_DIV,OPERATION_MUL_DIV_L_DIVU,true,
     277    0,TYPE_DIV,OPERATION_DIV_L_DIVU,true,
    268278    0,0x0,1,10,1,20,0,0                 ,1,30,1,SPR_LOGIC_SR_CY_OV,
    269279    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
    … …  
    622632    0xe3caa306,x,y,z,
    623633    0,0,0,0,0,0,
    624     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
     634    TYPE_MUL,OPERATION_MUL_L_MUL,false,
    625635    0,0, 1,10, 1,20, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
    626636    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
    … …  
    631641    0xb3ca03fa,x,y,z,
    632642    0,0,0,0,0,0,
    633     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
     643    TYPE_MUL,OPERATION_MUL_L_MUL,false,
    634644    1,0x3fa, 1,10, 0,0, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
    635645    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
    … …  
    640650    0xb3cafc06,x,y,z,
    641651    0,0,0,0,0,0,
    642     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MUL,false,
     652    TYPE_MUL,OPERATION_MUL_L_MUL,false,
    643653    1,0xfffffc06, 1,10, 0,0, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
    644654    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));
    … …  
    649659    0xe3caa30b,x,y,z,
    650660    0,0,0,0,0,0,
    651     TYPE_MUL_DIV,OPERATION_MUL_DIV_L_MULU,false,
     661    TYPE_MUL,OPERATION_MUL_L_MULU,false,
    652662    0,0, 1,10, 1,20, 0,0, 1,30, 1,SPR_LOGIC_SR_CY_OV,
    653663    EXCEPTION_USE_RANGE,EVENT_TYPE_NONE));

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/src/main.cpp

    r87 r88  
    99#include "Behavioural/Custom/include/Custom_example.h"
    1010
    11 #define NB_PARAMS 8
     11#define NB_PARAMS 6
    1212
    1313void usage (int argc, char * argv[])
    … …  
    1515  err (_("<Usage> %s name_instance list_params.\n"),argv[0]);
    1616  err (_("list_params is :\n"));
    17   err (_(" * nb_context                                (uint32_t         )\n"));
    18   err (_(" * nb_inst_fetch                [nb_context] (uint32_t         )\n"));
    19   err (_(" * nb_inst_decod                             (uint32_t         )\n"));
    20   err (_(" * nb_branch_speculated                      (uint32_t         )\n"));
    21   err (_(" * size_branch_update_prediction             (uint32_t         )\n"));
    22   err (_(" * nb_context_select                         (uint32_t         )\n"));
    23   err (_(" * size_general_data                         (uint32_t         )\n"));
    24   err (_(" * priority                                  (Tpriority_t      )\n"));
    25   err (_(" * load_balancing                            (Tload_balancing_t)\n"));
     17  err (_(" * nb_context                                 (uint32_t         )\n"));
     18  err (_(" * nb_inst_fetch                 [nb_context] (uint32_t         )\n"));
     19  err (_(" * nb_inst_decod                              (uint32_t         )\n"));
     20  err (_(" * nb_branch_speculated          [nb_context] (uint32_t         )\n"));
     21  err (_(" * nb_context_select                          (uint32_t         )\n"));
     22  err (_(" * size_general_data                          (uint32_t         )\n"));
     23  err (_(" * priority                                   (Tpriority_t      )\n"));
     24  err (_(" * load_balancing                             (Tload_balancing_t)\n"));
    2625
    2726  exit (1);
    … …  
    4241  uint32_t            _nb_context           = fromString<uint32_t         >(argv[x++]);
    4342
    44   if (argc != static_cast<int>(2+NB_PARAMS+_nb_context))
     43  if (argc != static_cast<int>(2+NB_PARAMS+2*_nb_context))
    4544    usage (argc, argv);
    4645 
    47   uint32_t          * _nb_inst_fetch        = new uint32_t [_nb_context];
     46  uint32_t          * _nb_inst_fetch                = new uint32_t [_nb_context];
    4847  for (uint32_t i=0;i<_nb_context; i++)
    4948    _nb_inst_fetch [i] = fromString<uint32_t>(argv[x++]);
    5049
    5150  uint32_t            _nb_inst_decod                = fromString<uint32_t         >(argv[x++]);
    52   uint32_t            _nb_branch_speculated         = fromString<uint32_t         >(argv[x++]);
    53   uint32_t            _size_branch_update_prediction= fromString<uint32_t         >(argv[x++]);
     51
     52  uint32_t          * _nb_branch_speculated         = new uint32_t [_nb_context];
     53  for (uint32_t i=0;i<_nb_context; i++)
     54    _nb_branch_speculated [i] = fromString<uint32_t>(argv[x++]);
     55
     56//   uint32_t          * _size_branch_update_prediction= new uint32_t [_nb_context];
     57//   for (uint32_t i=0;i<_nb_context; i++)
     58//     _size_branch_update_prediction[i] = fromString<uint32_t>(argv[x++]);
     59
    5460  uint32_t            _nb_context_select            = fromString<uint32_t         >(argv[x++]);
    5561  uint32_t            _size_general_data            = fromString<uint32_t         >(argv[x++]);
    … …  
    6369     
    6470      for (uint32_t j=0; j<NB_INSTRUCTION; j++)
    65         _instruction_implemeted [i][j] = true;
     71        _instruction_implemeted [i][j] = true;
    6672    }
    6773
    … …  
    7076    {
    7177      morpheo::behavioural::core::multi_front_end::front_end::decod_unit::decod::Parameters * param = new morpheo::behavioural::core::multi_front_end::front_end::decod_unit::decod::Parameters
    72         (_nb_context                   ,
    73          _nb_inst_fetch                ,
    74          _nb_inst_decod                ,
    75          _nb_branch_speculated         ,
    76          _size_branch_update_prediction,
    77          _nb_context_select            ,
    78          _size_general_data            ,
    79          _priority                     ,
    80          _load_balancing               ,
    81          _instruction_implemeted       ,
    82          &(morpheo::behavioural::custom::example_get_custom_information)
    83          );
     78        (_nb_context                   ,
     79         _nb_inst_fetch                ,
     80         _nb_inst_decod                ,
     81         _nb_branch_speculated         ,
     82//          _size_branch_update_prediction,
     83         _nb_context_select            ,
     84         _size_general_data            ,
     85         _priority                     ,
     86         _load_balancing               ,
     87         _instruction_implemeted       ,
     88         &(morpheo::behavioural::custom::example_get_custom_information),
     89         true // is_toplevel
     90         );
    8491     
    8592      msg(_("%s"),param->print(1).c_str());
    … …  
    100107  delete _nb_inst_fetch;
    101108  delete _instruction_implemeted;
     109  delete _nb_branch_speculated;
     110//   delete _size_branch_update_prediction;
     111
    102112  return (_return);
    103113}

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/SelfTest/src/test.cpp

    r87 r88  
    2222
    2323#ifdef STATISTICS
    24   morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,50);
     24  morpheo::behavioural::Parameters_Statistics * _parameters_statistics = new morpheo::behavioural::Parameters_Statistics (5,0);
    2525#endif
     26
     27  Tusage_t _usage = USE_ALL;
     28
     29//   _usage = usage_unset(_usage,USE_SYSTEMC              );
     30//   _usage = usage_unset(_usage,USE_VHDL                 );
     31//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH       );
     32//   _usage = usage_unset(_usage,USE_VHDL_TESTBENCH_ASSERT);
     33//   _usage = usage_unset(_usage,USE_POSITION             );
     34//   _usage = usage_unset(_usage,USE_STATISTICS           );
     35//   _usage = usage_unset(_usage,USE_INFORMATION          );
    2636
    2737  Decod * _Decod = new Decod
    … …  
    3141#endif
    3242     _param,
    33      USE_ALL);
     43     _usage);
    3444 
    3545#ifdef SYSTEMC
    … …  
    4252  sc_signal<Tcontrol_t> *  in_NRESET = new sc_signal<Tcontrol_t> ("NRESET");
    4353
    44   ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
    45   ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
    46   ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
     54  ALLOC2_SC_SIGNAL( in_IFETCH_VAL                         ," in_IFETCH_VAL                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
     55  ALLOC2_SC_SIGNAL(out_IFETCH_ACK                         ,"out_IFETCH_ACK                         ",Tcontrol_t         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
     56  ALLOC2_SC_SIGNAL( in_IFETCH_INSTRUCTION                 ," in_IFETCH_INSTRUCTION                 ",Tinstruction_t     ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
    4757  ALLOC1_SC_SIGNAL( in_IFETCH_CONTEXT_ID                  ," in_IFETCH_CONTEXT_ID                  ",Tcontext_t         ,_param->_nb_context);
    4858  ALLOC1_SC_SIGNAL( in_IFETCH_ADDRESS                     ," in_IFETCH_ADDRESS                     ",Tgeneral_address_t ,_param->_nb_context);
    … …  
    5161  ALLOC1_SC_SIGNAL( in_IFETCH_BRANCH_STATE                ," in_IFETCH_BRANCH_STATE                ",Tbranch_state_t    ,_param->_nb_context);
    5262  ALLOC1_SC_SIGNAL( in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ," in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ",Tprediction_ptr_t  ,_param->_nb_context);
     63  ALLOC1_SC_SIGNAL( in_IFETCH_EXCEPTION                   ," in_IFETCH_EXCEPTION                   ",Texception_t       ,_param->_nb_context);
     64
    5365  ALLOC1_SC_SIGNAL(out_DECOD_VAL                          ,"out_DECOD_VAL                          ",Tcontrol_t         ,_param->_nb_inst_decod);
    5466  ALLOC1_SC_SIGNAL( in_DECOD_ACK                          ," in_DECOD_ACK                          ",Tcontrol_t         ,_param->_nb_inst_decod);
    … …  
    5769  ALLOC1_SC_SIGNAL(out_DECOD_TYPE                         ,"out_DECOD_TYPE                         ",Ttype_t            ,_param->_nb_inst_decod);
    5870  ALLOC1_SC_SIGNAL(out_DECOD_OPERATION                    ,"out_DECOD_OPERATION                    ",Toperation_t       ,_param->_nb_inst_decod);
     71  ALLOC1_SC_SIGNAL(out_DECOD_NO_EXECUTE                   ,"out_DECOD_NO_EXECUTE                   ",Tcontrol_t         ,_param->_nb_inst_decod);
    5972  ALLOC1_SC_SIGNAL(out_DECOD_IS_DELAY_SLOT                ,"out_DECOD_IS_DELAY_SLOT                ",Tcontrol_t         ,_param->_nb_inst_decod);
    6073  ALLOC1_SC_SIGNAL(out_DECOD_ADDRESS                      ,"out_DECOD_ADDRESS                      ",Tgeneral_data_t    ,_param->_nb_inst_decod);
    … …  
    7285  ALLOC1_SC_SIGNAL(out_DECOD_NUM_REG_RE                   ,"out_DECOD_NUM_REG_RE                   ",Tspecial_address_t ,_param->_nb_inst_decod);
    7386  ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION_USE                ,"out_DECOD_EXCEPTION_USE                ",Texception_t       ,_param->_nb_inst_decod);
     87  ALLOC1_SC_SIGNAL(out_DECOD_EXCEPTION                    ,"out_DECOD_EXCEPTION                    ",Texception_t       ,_param->_nb_inst_decod);
    7488  ALLOC1_SC_SIGNAL(out_PREDICT_VAL                        ,"out_PREDICT_VAL                        ",Tcontrol_t         ,_param->_nb_inst_decod);
    7589  ALLOC1_SC_SIGNAL( in_PREDICT_ACK                        ," in_PREDICT_ACK                        ",Tcontrol_t         ,_param->_nb_inst_decod);
    … …  
    89103  ALLOC_SC_SIGNAL ( in_CONTEXT_EVENT_ACK                  ," in_CONTEXT_EVENT_ACK                  ",Tcontrol_t         );
    90104  ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_CONTEXT_ID           ,"out_CONTEXT_EVENT_CONTEXT_ID           ",Tcontext_t         );
     105  ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_DEPTH                ,"out_CONTEXT_EVENT_DEPTH                ",Tdepth_t           );
    91106  ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_TYPE                 ,"out_CONTEXT_EVENT_TYPE                 ",Tevent_type_t      );
    92107  ALLOC_SC_SIGNAL (out_CONTEXT_EVENT_IS_DELAY_SLOT        ,"out_CONTEXT_EVENT_IS_DELAY_SLOT        ",Tcontrol_t         );
    … …  
    103118  (*(_Decod->in_NRESET))       (*(in_NRESET));
    104119
    105   INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_VAL                         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
    106   INSTANCE2_SC_SIGNAL(_Decod,out_IFETCH_ACK                         ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
    107   INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_INSTRUCTION                 ,_param->_nb_context,_param->_nb_inst_fetch[alloc_signal_it1]);
     120  INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_VAL                         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
     121  INSTANCE2_SC_SIGNAL(_Decod,out_IFETCH_ACK                         ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
     122  INSTANCE2_SC_SIGNAL(_Decod, in_IFETCH_INSTRUCTION                 ,_param->_nb_context,_param->_nb_inst_fetch[it1]);
    108123  if (_param->_have_port_context_id)
    109124  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_CONTEXT_ID                  ,_param->_nb_context);
    110125  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_ADDRESS                     ,_param->_nb_context);
    111126//   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_ADDRESS_NEXT                ,_param->_nb_context);
    112   if (_param->_have_port_inst_ifetch_ptr)
    113   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_INST_IFETCH_PTR             ,_param->_nb_context);
    114127  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_STATE                ,_param->_nb_context);
    115   if (_param->_have_port_branch_update_prediction_id)
    116   INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ,_param->_nb_context);
     128  INSTANCE1_SC_SIGNAL(_Decod, in_IFETCH_EXCEPTION                   ,_param->_nb_context);
     129
     130  for (uint32_t i=0; i<_param->_nb_context; i++)
     131    {
     132      if (_param->_have_port_inst_ifetch_ptr)
     133        INSTANCE_SC_SIGNAL(_Decod, in_IFETCH_INST_IFETCH_PTR [i]);
     134//       if (_param->_have_port_branch_update_prediction_id)
     135      if (_param->_have_port_depth)
     136        INSTANCE_SC_SIGNAL(_Decod, in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]);
     137    }
     138
    117139  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_VAL                          ,_param->_nb_inst_decod);
    118140  INSTANCE1_SC_SIGNAL(_Decod, in_DECOD_ACK                          ,_param->_nb_inst_decod);
    … …  
    123145  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_TYPE                         ,_param->_nb_inst_decod);
    124146  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_OPERATION                    ,_param->_nb_inst_decod);
     147  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_NO_EXECUTE                   ,_param->_nb_inst_decod);
    125148  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_IS_DELAY_SLOT                ,_param->_nb_inst_decod);
    126149  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_ADDRESS                      ,_param->_nb_inst_decod);
    … …  
    138161  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_NUM_REG_RE                   ,_param->_nb_inst_decod);
    139162  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_EXCEPTION_USE                ,_param->_nb_inst_decod);
     163  INSTANCE1_SC_SIGNAL(_Decod,out_DECOD_EXCEPTION                    ,_param->_nb_inst_decod);
    140164  INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_VAL                        ,_param->_nb_inst_decod);
    141165  INSTANCE1_SC_SIGNAL(_Decod, in_PREDICT_ACK                        ,_param->_nb_inst_decod);
    … …  
    144168  INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod);
    145169  INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod);
    146   if (_param->_have_port_branch_update_prediction_id)
     170//   if (_param->_have_port_branch_update_prediction_id)
     171  if (_param->_have_port_depth)
    147172  INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod);
    148173  INSTANCE1_SC_SIGNAL(_Decod,out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod);
    … …  
    153178//   INSTANCE1_SC_SIGNAL(_Decod, in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod);
    154179  INSTANCE1_SC_SIGNAL(_Decod, in_CONTEXT_DECOD_ENABLE               ,_param->_nb_context);
    155   if (_param->_have_port_depth)
    156   INSTANCE1_SC_SIGNAL(_Decod, in_CONTEXT_DEPTH                      ,_param->_nb_context);
     180  for (uint32_t i=0; i<_param->_nb_context; i++)
     181    if (_param->_have_port_depth)
     182      INSTANCE_SC_SIGNAL(_Decod, in_CONTEXT_DEPTH [i]);
    157183  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_VAL                  );
    158184  INSTANCE_SC_SIGNAL (_Decod, in_CONTEXT_EVENT_ACK                  );
    159185  if (_param->_have_port_context_id)
    160186  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_CONTEXT_ID           );
     187  if (_param->_have_port_depth)
     188  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_DEPTH                );
    161189  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_TYPE                 );
    162190  INSTANCE_SC_SIGNAL (_Decod,out_CONTEXT_EVENT_IS_DELAY_SLOT        );
    … …  
    236264                      if (_param->_have_port_inst_ifetch_ptr)
    237265                      in_IFETCH_INST_IFETCH_PTR [i]->write(0);
     266                      in_IFETCH_EXCEPTION       [i]->write(EXCEPTION_IFETCH_NONE);
    238267
    239268                      // Alignement
    … …  
    336365                    TEST(Tcontrol_t         , out_PREDICT_MATCH_INST_IFETCH_PTR       [i]->read(),((request [context].front()._address)%_param->_nb_inst_fetch[context]) == 0);
    337366                    TEST(Tbranch_state_t    , out_PREDICT_BRANCH_STATE                [i]->read(), request [context].front()._branch_state               );
    338                     if (_param->_have_port_branch_update_prediction_id)
     367//                  if (_param->_have_port_branch_update_prediction_id)
     368                    if (_param->_have_port_depth)
    339369                    TEST(Tprediction_ptr_t  , out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i]->read(), request [context].front()._branch_update_prediction_id);
    340370                    TEST(Tbranch_condition_t, out_PREDICT_BRANCH_CONDITION            [i]->read(), request [context].front()._branch_condition           );
    … …  
    358388                    if (_param->_have_port_context_id)
    359389                    TEST(Tcontext_t     ,out_CONTEXT_EVENT_CONTEXT_ID   ->read(), context);
     390                    if (_param->_have_port_depth )
     391                    TEST(Tcontext_t     ,out_CONTEXT_EVENT_DEPTH        ->read(), request [context].front()._depth        );
    360392                    TEST(Tevent_type_t  ,out_CONTEXT_EVENT_TYPE         ->read(), request [context].front()._context_event_type);
    361393                    TEST(Tcontrol_t     ,out_CONTEXT_EVENT_IS_DELAY_SLOT->read(), request [context].front()._is_delay_slot);
    … …  
    403435  delete []  in_IFETCH_BRANCH_STATE                ;
    404436  delete []  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;
     437  delete []  in_IFETCH_EXCEPTION                   ;
    405438 
    406439  delete [] out_DECOD_VAL                          ;
    … …  
    410443  delete [] out_DECOD_TYPE                         ;
    411444  delete [] out_DECOD_OPERATION                    ;
     445  delete [] out_DECOD_NO_EXECUTE                   ;
    412446  delete [] out_DECOD_IS_DELAY_SLOT                ;
    413447  delete [] out_DECOD_ADDRESS                      ;
    … …  
    425459  delete [] out_DECOD_NUM_REG_RE                   ;
    426460  delete [] out_DECOD_EXCEPTION_USE                ;
     461  delete [] out_DECOD_EXCEPTION                    ;
    427462 
    428463  delete [] out_PREDICT_VAL                        ;
    … …  
    445480  delete     in_CONTEXT_EVENT_ACK                  ;
    446481  delete    out_CONTEXT_EVENT_CONTEXT_ID           ;
     482  delete    out_CONTEXT_EVENT_DEPTH                ;
    447483  delete    out_CONTEXT_EVENT_TYPE                 ;
    448484  delete    out_CONTEXT_EVENT_IS_DELAY_SLOT        ;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Decod.h

    r86 r88  
    1313#endif
    1414
    15 #include <iostream>
    16 #include <list>
    1715#include "Common/include/ToString.h"
    1816#include "Common/include/Debug.h"
    … …  
    2927#endif
    3028#include "Behavioural/include/Usage.h"
     29
     30#include "Behavioural/Generic/Priority/include/Priority.h"
     31
     32#include <iostream>
     33#include <list>
    3134
    3235namespace morpheo {
    … …  
    7578  public    : SC_IN (Tbranch_state_t    )  **  in_IFETCH_BRANCH_STATE                ;//[nb_context]
    7679  public    : SC_IN (Tprediction_ptr_t  )  **  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;//[nb_context]
    77                                                                                      
     80  public    : SC_IN (Texception_t       )  **  in_IFETCH_EXCEPTION                   ;//[nb_context]                                                                                 
    7881    // ~~~~~[ Interface : "decod" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~           
    7982  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_VAL                          ;//[nb_inst_decod]
    … …  
    8386  public    : SC_OUT(Ttype_t            )  ** out_DECOD_TYPE                         ;//[nb_inst_decod]
    8487  public    : SC_OUT(Toperation_t       )  ** out_DECOD_OPERATION                    ;//[nb_inst_decod]
     88  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_NO_EXECUTE                   ;//[nb_inst_decod]
    8589  public    : SC_OUT(Tcontrol_t         )  ** out_DECOD_IS_DELAY_SLOT                ;//[nb_inst_decod]
    8690  public    : SC_OUT(Tgeneral_data_t    )  ** out_DECOD_ADDRESS                      ;//[nb_inst_decod]
    … …  
    98102  public    : SC_OUT(Tspecial_address_t )  ** out_DECOD_NUM_REG_RE                   ;//[nb_inst_decod]
    99103  public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION_USE                ;//[nb_inst_decod]
     104  public    : SC_OUT(Texception_t       )  ** out_DECOD_EXCEPTION                    ;//[nb_inst_decod]
    100105
    101106    // ~~~~~[ Interface : "predict" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    … …  
    121126  public    : SC_IN (Tcontrol_t         )   *  in_CONTEXT_EVENT_ACK                  ;
    122127  public    : SC_OUT(Tcontext_t         )   * out_CONTEXT_EVENT_CONTEXT_ID           ;
     128  public    : SC_OUT(Tdepth_t           )   * out_CONTEXT_EVENT_DEPTH                ;
    123129  public    : SC_OUT(Tevent_type_t      )   * out_CONTEXT_EVENT_TYPE                 ;
    124130  public    : SC_OUT(Tcontrol_t         )   * out_CONTEXT_EVENT_IS_DELAY_SLOT        ;
    … …  
    127133
    128134    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     135  private   : generic::priority::Priority   * _priority;
    129136
    130137    // ~~~~~[ Register ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    131   private   : uint32_t                        reg_CONTEXT_PRIORITY;
    132138  private   : Tgeneral_data_t               * reg_CONTEXT_ADDRESS_PREVIOUS     ; //[nb_context]
    133139  private   : Tcontrol_t                    * reg_CONTEXT_IS_DELAY_SLOT        ; //[nb_context]
    … …  
    136142  private   : Tcontrol_t                    * internal_CONTEXT_IS_DELAY_SLOT   ; //[nb_context]
    137143
     144  private   : Tcontrol_t                    * internal_DECOD_VAL               ; //[nb_inst_decod]
    138145    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    139146  private   : decod_instruction_t           * _decod_instruction;
    … …  
    141148  private   : function_decod_t           **** _function_decod   ; //[nb_context][type][opcod]
    142149  private   : function_decod_t           **** _function_custom  ; //[nb_context][type][opcod]
    143   private   : std::list<select_t>             select;
    144150#endif
    145151

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Parameters.h

    r86 r88  
    2929  public : uint32_t          * _nb_inst_fetch                ; //[nb_context]
    3030  public : uint32_t            _nb_inst_decod                ;
    31   public : uint32_t            _size_general_data            ;
    32   public : uint32_t            _nb_branch_speculated         ;
    33   public : uint32_t            _size_branch_update_prediction;
     31//public : uint32_t            _size_general_data            ;
     32  public : uint32_t          * _nb_branch_speculated         ; //[nb_context]
     33//public : uint32_t          * _size_branch_update_prediction; //[nb_context]
    3434  public : uint32_t            _nb_context_select            ;
    3535  public : Tpriority_t         _priority                     ;
    3636  public : Tload_balancing_t   _load_balancing               ;
    3737  public : bool             ** _instruction_implemeted       ; //[nb_context][nb_instruction]
    38   public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (uint32_t);
     38  public : morpheo::behavioural::custom::custom_information_t (*_get_custom_information) (void);
    3939   
    40   public : uint32_t            _max_nb_inst_fetch     ;
    41 
    42   public : uint32_t            _size_address_inst     ;
    43   public : uint32_t            _size_context_id       ;
    44   public : uint32_t            _size_depth            ;
    45   public : uint32_t            _size_inst_ifetch_ptr  ;
    46                                                      
    47   public : bool                _have_port_context_id                 ;
    48   public : bool                _have_port_depth                      ;
    49   public : bool                _have_port_branch_update_prediction_id;
    50   public : bool                _have_port_inst_ifetch_ptr            ;
     40  public : uint32_t            _max_nb_inst_fetch;
     41//public : uint32_t            _size_address_inst;
    5142
    5243    //-----[ methods ]-----------------------------------------------------------
    … …  
    5546                        uint32_t          * nb_inst_fetch                ,
    5647                        uint32_t            nb_inst_decod                ,
     48                        uint32_t          * nb_branch_speculated         ,
     49//                      uint32_t          * size_branch_update_prediction,
     50                        uint32_t            nb_context_select            ,
    5751                        uint32_t            size_general_data            ,
    58                         uint32_t            nb_branch_speculated         ,
    59                         uint32_t            size_branch_update_prediction,
    60                         uint32_t            nb_context_select            ,
    6152                        Tpriority_t         priority                     ,
    6253                        Tload_balancing_t   load_balancing               ,
    6354                        bool             ** instruction_implemeted       ,
    64                         morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t));
     55                        morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
     56                        bool                is_toplevel=false
     57                        );
    6558
    6659//   public : Parameters  (Parameters & param) ;
    6760  public : ~Parameters () ;
     61
     62  public :        void            copy       (void);
    6863
    6964  public :        Parameters_test msg_error  (void);

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Types.h

    r81 r88  
    1919namespace decod {
    2020
    21   class select_t
    22   {
    23   public : uint32_t _context ;
    24   public : uint32_t _inst_fetch;
    25    
    26   public : select_t (uint32_t context,
    27                      uint32_t inst_fetch)
    28     {
    29       _context    = context ;
    30       _inst_fetch = inst_fetch;
    31     }
    32   };
    33 
    3421
    3522}; // end namespace decod

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod.cpp

    r81 r88  
    3838    log_printf(FUNC,Decod,FUNCTION,"Begin");
    3939
     40#if DEBUG_Decod == true
     41    log_printf(INFO,Decod,FUNCTION,_("<%s> Parameters"),_name.c_str());
     42
     43    std::cout << *param << std::endl;
     44#endif   
     45
    4046    log_printf(INFO,Decod,FUNCTION,"Allocation");
    4147
    … …  
    4753
    4854#ifdef STATISTICS
    49     if (_usage & USE_STATISTICS)
     55    if (usage_is_set(_usage,USE_STATISTICS))
    5056      {
    5157        log_printf(INFO,Decod,FUNCTION,"Allocation of statistics");
    … …  
    5662
    5763#ifdef VHDL
    58     if (_usage & USE_VHDL)
     64    if (usage_is_set(_usage,USE_VHDL))
    5965      {
    6066        // generate the vhdl
    … …  
    6672
    6773#ifdef SYSTEMC
    68     if (_usage & USE_SYSTEMC)
     74    if (usage_is_set(_usage,USE_SYSTEMC))
    6975      {
    7076        log_printf(INFO,Decod,FUNCTION,"Method - transition");
    … …  
    95101            if (_param->_have_port_context_id)
    96102            sensitive << (*(in_IFETCH_CONTEXT_ID                  [i]));
    97             if (_param->_have_port_branch_update_prediction_id)
     103            if (_param->_have_port_depth)
    98104            sensitive << (*(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [i]));
    99105            if (_param->_have_port_depth)
    … …  
    110116
    111117# ifdef SYSTEMCASS_SPECIFIC
     118        /*
    112119        // List dependency information
    113120
    … …  
    162169              }
    163170
    164             if (_param->_have_port_depth)
    165               {
    166             for (uint32_t x=0; x<_param->_nb_context; x++)
    167               {
     171            for (uint32_t x=0; x<_param->_nb_context; x++)
     172              {
     173            if (_param->_have_port_depth[i])
     174              {
     175
    168176                (*(out_DECOD_DEPTH [i])) (*(in_CONTEXT_DECOD_ENABLE [x]));
    169177                (*(out_DECOD_DEPTH [i])) (*(in_CONTEXT_DEPTH        [x]));
    … …  
    402410                if (_param->_have_port_context_id)
    403411                (*(out_PREDICT_MATCH_INST_IFETCH_PTR [i])) (*(in_IFETCH_CONTEXT_ID      [x]));
    404                 if (_param->_have_port_inst_ifetch_ptr)
     412                if (_param->_have_port_inst_ifetch_ptr[i])
    405413                (*(out_PREDICT_MATCH_INST_IFETCH_PTR [i])) (*(in_IFETCH_INST_IFETCH_PTR [x]));
    406414                for (uint32_t y=0; y<_param->_nb_inst_fetch [x]; y++)
    … …  
    601609              }
    602610          }
    603        
     611        */
    604612# endif   
    605613       
    … …  
    617625
    618626#ifdef STATISTICS
    619     if (_usage & USE_STATISTICS)
     627    if (usage_is_set(_usage,USE_STATISTICS))
    620628      {
    621629        statistics_deallocation();

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_allocation.cpp

    r86 r88  
    11/*
    2  * $Id$
     2 * $id: Decod_allocation.cpp 86 2008-05-14 17:08:56Z rosiere $
    33 *
    44 * [ Description ]
    … …  
    5858    // ~~~~~[ Interface : "ifetch" ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    5959    {
    60       ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[alloc_interface_it1]);
     60      ALLOC2_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context, _param->_nb_inst_fetch[it1]);
    6161
    6262     
    63       _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
    64       _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
    65       _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[alloc_signal_it1]);
     63      _ALLOC2_VALACK_IN ( in_IFETCH_VAL        ,VAL, _param->_nb_context, _param->_nb_inst_fetch[it1]);
     64      _ALLOC2_VALACK_OUT(out_IFETCH_ACK        ,ACK, _param->_nb_context, _param->_nb_inst_fetch[it1]);
     65      _ALLOC2_SIGNAL_IN ( in_IFETCH_INSTRUCTION,"instruction", Tinstruction_t, _param->_size_instruction,_param->_nb_context, _param->_nb_inst_fetch[it1]);
    6666    }
    6767    {
    6868      ALLOC1_INTERFACE("ifetch", IN, WEST, "Instruction's bundle", _param->_nb_context);
    6969     
    70       ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
    71       ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_address_inst            );
    72 //    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_address_inst            );
    73       ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr         );
    74       ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
    75       ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
     70      ALLOC1_SIGNAL_IN (in_IFETCH_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
     71      ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS                    ,"address"                    ,Tgeneral_address_t ,_param->_size_instruction_address    );
     72//    ALLOC1_SIGNAL_IN (in_IFETCH_ADDRESS_NEXT               ,"address_next"               ,Tgeneral_address_t ,_param->_size_instruction_address    );
     73      ALLOC1_SIGNAL_IN (in_IFETCH_INST_IFETCH_PTR            ,"inst_ifetch_ptr"            ,Tinst_ifetch_ptr_t ,_param->_size_inst_ifetch_ptr );
     74      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
     75      ALLOC1_SIGNAL_IN (in_IFETCH_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
     76      ALLOC1_SIGNAL_IN (in_IFETCH_EXCEPTION                  ,"exception"                  ,Texception_t       ,_param->_size_exception_ifetch);
    7677    }
    7778
    … …  
    8687      ALLOC1_SIGNAL_OUT(out_DECOD_TYPE         ,"type"         ,Ttype_t           ,_param->_size_type                  );
    8788      ALLOC1_SIGNAL_OUT(out_DECOD_OPERATION    ,"operation"    ,Toperation_t      ,_param->_size_operation             );
     89      ALLOC1_SIGNAL_OUT(out_DECOD_NO_EXECUTE   ,"no_execute"   ,Tcontrol_t        ,1                                   );
    8890      ALLOC1_SIGNAL_OUT(out_DECOD_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t        ,1                                   );
    89       ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_address_inst          );
     91      ALLOC1_SIGNAL_OUT(out_DECOD_ADDRESS      ,"address"      ,Tgeneral_data_t   ,_param->_size_instruction_address          );
    9092      ALLOC1_SIGNAL_OUT(out_DECOD_HAS_IMMEDIAT ,"has_immediat" ,Tcontrol_t        ,1                                   );
    9193      ALLOC1_SIGNAL_OUT(out_DECOD_IMMEDIAT     ,"immediat"     ,Tgeneral_data_t   ,_param->_size_general_data          );
    … …  
    101103      ALLOC1_SIGNAL_OUT(out_DECOD_NUM_REG_RE   ,"num_reg_re"   ,Tspecial_address_t,_param->_size_special_register_logic);
    102104      ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION_USE,"exception_use",Texception_t      ,_param->_size_exception_use         );
     105      ALLOC1_SIGNAL_OUT(out_DECOD_EXCEPTION    ,"exception"    ,Texception_t      ,_param->_size_exception_decod       );
    103106    }
    104107
    … …  
    109112      ALLOC1_VALACK_OUT(out_PREDICT_VAL                        ,VAL);
    110113      ALLOC1_VALACK_IN ( in_PREDICT_ACK                        ,ACK);
    111       ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id              );
    112       ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                                     );
    113       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state            );
    114       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_branch_update_prediction);
    115       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition        );
    116 //    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                                     );
    117       ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                                     );
    118       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_address_inst            );
    119       ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_address_inst            );
    120 //    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                                     );
     114      ALLOC1_SIGNAL_OUT(out_PREDICT_CONTEXT_ID                 ,"context_id"                 ,Tcontext_t         ,_param->_size_context_id      );
     115      ALLOC1_SIGNAL_OUT(out_PREDICT_MATCH_INST_IFETCH_PTR      ,"match_inst_ifetch_ptr"      ,Tcontrol_t         ,1                             );
     116      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STATE               ,"branch_state"               ,Tbranch_state_t    ,_param->_size_branch_state    );
     117      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,"branch_update_prediction_id",Tprediction_ptr_t  ,_param->_size_depth           );
     118      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_CONDITION           ,"branch_condition"           ,Tbranch_condition_t,_param->_size_branch_condition);
     119//    ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_STACK_WRITE         ,"branch_stack_write"         ,Tcontrol_t         ,1                             );
     120      ALLOC1_SIGNAL_OUT(out_PREDICT_BRANCH_DIRECTION           ,"branch_direction"           ,Tcontrol_t         ,1                             );
     121      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_SRC                ,"address_src"                ,Tgeneral_data_t    ,_param->_size_instruction_address    );
     122      ALLOC1_SIGNAL_OUT(out_PREDICT_ADDRESS_DEST               ,"address_dest"               ,Tgeneral_data_t    ,_param->_size_instruction_address    );
     123//    ALLOC1_SIGNAL_IN ( in_PREDICT_CAN_CONTINUE               ,"can_continue"               ,Tcontrol_t         ,1                             );
    121124    }
    122125   
    … …  
    136139      ALLOC_VALACK_IN ( in_CONTEXT_EVENT_ACK          ,ACK);
    137140      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_CONTEXT_ID   ,"context_id"   ,Tcontext_t     ,_param->_size_context_id  );
     141      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_DEPTH        ,"depth"        ,Tdepth_t       ,_param->_size_depth       );
    138142      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_TYPE         ,"type"         ,Tevent_type_t  ,_param->_size_event_type  );
    139143      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_IS_DELAY_SLOT,"is_delay_slot",Tcontrol_t     ,1                         );
    140       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_address_inst);
    141       ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_address_inst);
    142     }
    143 
    144     // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    145 
     144      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS      ,"address"      ,Tgeneral_data_t,_param->_size_instruction_address);
     145      ALLOC_SIGNAL_OUT(out_CONTEXT_EVENT_ADDRESS_EPCR ,"address_epcr" ,Tgeneral_data_t,_param->_size_instruction_address);
     146    }
     147
     148
     149    // ~~~~~[ Internal ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     150    if (usage_is_set(_usage,USE_SYSTEMC))
     151      {
    146152    reg_CONTEXT_ADDRESS_PREVIOUS      = new Tgeneral_data_t [_param->_nb_context];
    147153    reg_CONTEXT_IS_DELAY_SLOT         = new Tcontrol_t      [_param->_nb_context];
    … …  
    150156    internal_CONTEXT_ADDRESS_PREVIOUS = new Tgeneral_data_t [_param->_nb_context];
    151157    internal_CONTEXT_IS_DELAY_SLOT    = new Tcontrol_t      [_param->_nb_context];
     158
     159#ifdef STATISTICS
     160    internal_DECOD_VAL                = new Tcontrol_t      [_param->_nb_inst_decod];
     161#endif
     162      }
     163
     164    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
     165    _priority = new generic::priority::Priority (_name+"_priority"      ,
     166                                                 _param->_priority      ,
     167                                                 _param->_load_balancing,
     168                                                 _param->_nb_context    ,
     169                                                 _param->_nb_inst_fetch ,
     170                                                 _param->_nb_context_select);
    152171
    153172    const uint32_t nb_opcod_type = 14;
    … …  
    415434//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_decod [i][ 2][OPCOD_LV_CUST4   ] = &(instruction_lv_custom);
    416435
    417         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST1    ]) _function_custom[i][ 0][OPCOD_L_CUST1    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_1   );
    418         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST2    ]) _function_custom[i][ 0][OPCOD_L_CUST2    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_2   );
    419         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST3    ]) _function_custom[i][ 0][OPCOD_L_CUST3    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_3   );
    420         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST4    ]) _function_custom[i][ 0][OPCOD_L_CUST4    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_4   );
    421         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST5    ]) _function_custom[i][ 0][OPCOD_L_CUST5    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_5   );
    422         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST6    ]) _function_custom[i][ 0][OPCOD_L_CUST6    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_6   );
    423         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST7    ]) _function_custom[i][ 0][OPCOD_L_CUST7    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_7   );
    424         if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST8    ]) _function_custom[i][ 0][OPCOD_L_CUST8    ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_L_8   );
    425 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_D ]) _function_custom[i][ 1][OPCOD_LF_CUST1_D ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LF_1_D);
    426 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_S ]) _function_custom[i][ 1][OPCOD_LF_CUST1_S ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LF_1_S);
    427 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST1   ]) _function_custom[i][ 2][OPCOD_LV_CUST1   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_1  );
    428 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST2   ]) _function_custom[i][ 2][OPCOD_LV_CUST2   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_2  );
    429 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST3   ]) _function_custom[i][ 2][OPCOD_LV_CUST3   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_3  );
    430 //      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_custom[i][ 2][OPCOD_LV_CUST4   ] = _param->_get_custom_information(i)._get_custom_decod(OPERATION_CUSTOM_LV_4  );
     436        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST1    ]) _function_custom[i][ 0][OPCOD_L_CUST1    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_1   );
     437        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST2    ]) _function_custom[i][ 0][OPCOD_L_CUST2    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_2   );
     438        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST3    ]) _function_custom[i][ 0][OPCOD_L_CUST3    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_3   );
     439        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST4    ]) _function_custom[i][ 0][OPCOD_L_CUST4    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_4   );
     440        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST5    ]) _function_custom[i][ 0][OPCOD_L_CUST5    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_5   );
     441        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST6    ]) _function_custom[i][ 0][OPCOD_L_CUST6    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_6   );
     442        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST7    ]) _function_custom[i][ 0][OPCOD_L_CUST7    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_7   );
     443        if (_param->_instruction_implemeted[i][INSTRUCTION_L_CUST8    ]) _function_custom[i][ 0][OPCOD_L_CUST8    ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_L_8   );
     444//      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_D ]) _function_custom[i][ 1][OPCOD_LF_CUST1_D ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LF_1_D);
     445//      if (_param->_instruction_implemeted[i][INSTRUCTION_LF_CUST1_S ]) _function_custom[i][ 1][OPCOD_LF_CUST1_S ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LF_1_S);
     446//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST1   ]) _function_custom[i][ 2][OPCOD_LV_CUST1   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_1  );
     447//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST2   ]) _function_custom[i][ 2][OPCOD_LV_CUST2   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_2  );
     448//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST3   ]) _function_custom[i][ 2][OPCOD_LV_CUST3   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_3  );
     449//      if (_param->_instruction_implemeted[i][INSTRUCTION_LV_CUST4   ]) _function_custom[i][ 2][OPCOD_LV_CUST4   ] = _param->_get_custom_information()._get_custom_decod(OPERATION_CUSTOM_LV_4  );
    431450      }
    432451
    … …  
    440459
    441460#ifdef POSITION
    442     _component->generate_file();
     461    if (usage_is_set(_usage,USE_POSITION))
     462      _component->generate_file();
    443463#endif
    444464

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_deallocation.cpp

    r86 r88  
    77
    88#include "Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/include/Decod.h"
     9#include "Behavioural/include/Allocation.h"
    910
    1011namespace morpheo                    {
    … …  
    2728        delete    in_CLOCK ;
    2829        delete    in_NRESET;
     30     
     31        DELETE2_SIGNAL( in_IFETCH_VAL        , _param->_nb_context, _param->_nb_inst_fetch[it1],1);
     32        DELETE2_SIGNAL(out_IFETCH_ACK        , _param->_nb_context, _param->_nb_inst_fetch[it1],1);
     33        DELETE2_SIGNAL( in_IFETCH_INSTRUCTION, _param->_nb_context, _param->_nb_inst_fetch[it1],_param->_size_instruction);
     34     
     35        DELETE1_SIGNAL(in_IFETCH_CONTEXT_ID                 , _param->_nb_context,_param->_size_context_id      );
     36        DELETE1_SIGNAL(in_IFETCH_ADDRESS                    , _param->_nb_context,_param->_size_instruction_address    );
     37//      DELETE1_SIGNAL(in_IFETCH_ADDRESS_NEXT               , _param->_nb_context,_param->_size_instruction_address    );
     38        DELETE1_SIGNAL(in_IFETCH_INST_IFETCH_PTR            , _param->_nb_context,_param->_size_inst_ifetch_ptr );
     39        DELETE1_SIGNAL(in_IFETCH_BRANCH_STATE               , _param->_nb_context,_param->_size_branch_state    );
     40        DELETE1_SIGNAL(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID, _param->_nb_context,_param->_size_depth           );
     41        DELETE1_SIGNAL(in_IFETCH_EXCEPTION                  , _param->_nb_context,_param->_size_exception_ifetch);
    2942
    30         delete []  in_IFETCH_VAL                         ;
    31         delete [] out_IFETCH_ACK                         ;
    32         delete []  in_IFETCH_INSTRUCTION                 ;
    33         if (_param->_have_port_context_id)
    34         delete []  in_IFETCH_CONTEXT_ID                  ;
    35         delete []  in_IFETCH_ADDRESS                     ;
    36 //      delete []  in_IFETCH_ADDRESS_NEXT                ;
    37         if (_param->_have_port_inst_ifetch_ptr)
    38         delete []  in_IFETCH_INST_IFETCH_PTR             ;
    39         delete []  in_IFETCH_BRANCH_STATE                ;
    40         if (_param->_have_port_branch_update_prediction_id)
    41         delete []  in_IFETCH_BRANCH_UPDATE_PREDICTION_ID ;
     43        DELETE1_SIGNAL(out_DECOD_VAL          ,_param->_nb_inst_decod,1);
     44        DELETE1_SIGNAL( in_DECOD_ACK          ,_param->_nb_inst_decod,1);
     45        DELETE1_SIGNAL(out_DECOD_CONTEXT_ID   ,_param->_nb_inst_decod,_param->_size_context_id            );
     46        DELETE1_SIGNAL(out_DECOD_DEPTH        ,_param->_nb_inst_decod,_param->_size_depth                 );
     47        DELETE1_SIGNAL(out_DECOD_TYPE         ,_param->_nb_inst_decod,_param->_size_type                  );
     48        DELETE1_SIGNAL(out_DECOD_OPERATION    ,_param->_nb_inst_decod,_param->_size_operation             );
     49        DELETE1_SIGNAL(out_DECOD_NO_EXECUTE   ,_param->_nb_inst_decod,1                                   );
     50        DELETE1_SIGNAL(out_DECOD_IS_DELAY_SLOT,_param->_nb_inst_decod,1                                   );
     51        DELETE1_SIGNAL(out_DECOD_ADDRESS      ,_param->_nb_inst_decod,_param->_size_instruction_address          );
     52        DELETE1_SIGNAL(out_DECOD_HAS_IMMEDIAT ,_param->_nb_inst_decod,1                                   );
     53        DELETE1_SIGNAL(out_DECOD_IMMEDIAT     ,_param->_nb_inst_decod,_param->_size_general_data          );
     54        DELETE1_SIGNAL(out_DECOD_READ_RA      ,_param->_nb_inst_decod,1                                   );
     55        DELETE1_SIGNAL(out_DECOD_NUM_REG_RA   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
     56        DELETE1_SIGNAL(out_DECOD_READ_RB      ,_param->_nb_inst_decod,1                                   );
     57        DELETE1_SIGNAL(out_DECOD_NUM_REG_RB   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
     58        DELETE1_SIGNAL(out_DECOD_READ_RC      ,_param->_nb_inst_decod,1                                   );
     59        DELETE1_SIGNAL(out_DECOD_NUM_REG_RC   ,_param->_nb_inst_decod,_param->_size_special_register_logic);
     60        DELETE1_SIGNAL(out_DECOD_WRITE_RD     ,_param->_nb_inst_decod,1                                   );
     61        DELETE1_SIGNAL(out_DECOD_NUM_REG_RD   ,_param->_nb_inst_decod,_param->_size_general_register_logic);
     62        DELETE1_SIGNAL(out_DECOD_WRITE_RE     ,_param->_nb_inst_decod,1                                   );
     63        DELETE1_SIGNAL(out_DECOD_NUM_REG_RE   ,_param->_nb_inst_decod,_param->_size_special_register_logic);
     64        DELETE1_SIGNAL(out_DECOD_EXCEPTION_USE,_param->_nb_inst_decod,_param->_size_exception_use         );
     65        DELETE1_SIGNAL(out_DECOD_EXCEPTION    ,_param->_nb_inst_decod,_param->_size_exception_decod       );
    4266
    43         delete [] out_DECOD_VAL                          ;
    44         delete []  in_DECOD_ACK                          ;
    45         if (_param->_have_port_context_id)
    46         delete [] out_DECOD_CONTEXT_ID                   ;
    47         if (_param->_have_port_depth)
    48         delete [] out_DECOD_DEPTH                        ;
    49         delete [] out_DECOD_TYPE                         ;
    50         delete [] out_DECOD_OPERATION                    ;
    51         delete [] out_DECOD_IS_DELAY_SLOT                ;
    52         delete [] out_DECOD_ADDRESS                      ;
    53         delete [] out_DECOD_HAS_IMMEDIAT                 ;
    54         delete [] out_DECOD_IMMEDIAT                     ;
    55         delete [] out_DECOD_READ_RA                      ;
    56         delete [] out_DECOD_NUM_REG_RA                   ;
    57         delete [] out_DECOD_READ_RB                      ;
    58         delete [] out_DECOD_NUM_REG_RB                   ;
    59         delete [] out_DECOD_READ_RC                      ;
    60         delete [] out_DECOD_NUM_REG_RC                   ;
    61         delete [] out_DECOD_WRITE_RD                     ;
    62         delete [] out_DECOD_NUM_REG_RD                   ;
    63         delete [] out_DECOD_WRITE_RE                     ;
    64         delete [] out_DECOD_NUM_REG_RE                   ;
    65         delete [] out_DECOD_EXCEPTION_USE                ;
     67        DELETE1_SIGNAL(out_PREDICT_VAL                        ,_param->_nb_inst_decod,1);
     68        DELETE1_SIGNAL( in_PREDICT_ACK                        ,_param->_nb_inst_decod,1);
     69        DELETE1_SIGNAL(out_PREDICT_CONTEXT_ID                 ,_param->_nb_inst_decod,_param->_size_context_id      );
     70        DELETE1_SIGNAL(out_PREDICT_MATCH_INST_IFETCH_PTR      ,_param->_nb_inst_decod,1                             );
     71        DELETE1_SIGNAL(out_PREDICT_BRANCH_STATE               ,_param->_nb_inst_decod,_param->_size_branch_state    );
     72        DELETE1_SIGNAL(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID,_param->_nb_inst_decod,_param->_size_depth           );
     73        DELETE1_SIGNAL(out_PREDICT_BRANCH_CONDITION           ,_param->_nb_inst_decod,_param->_size_branch_condition);
     74//      DELETE1_SIGNAL(out_PREDICT_BRANCH_STACK_WRITE         ,_param->_nb_inst_decod,1                             );
     75        DELETE1_SIGNAL(out_PREDICT_BRANCH_DIRECTION           ,_param->_nb_inst_decod,1                             );
     76        DELETE1_SIGNAL(out_PREDICT_ADDRESS_SRC                ,_param->_nb_inst_decod,_param->_size_instruction_address    );
     77        DELETE1_SIGNAL(out_PREDICT_ADDRESS_DEST               ,_param->_nb_inst_decod,_param->_size_instruction_address    );
     78//      DELETE1_SIGNAL( in_PREDICT_CAN_CONTINUE               ,_param->_nb_inst_decod,1                             );
    6679
    67         delete [] out_PREDICT_VAL                        ;
    68         delete []  in_PREDICT_ACK                        ;
    69         if (_param->_have_port_context_id)
    70         delete [] out_PREDICT_CONTEXT_ID                 ;
    71         delete [] out_PREDICT_BRANCH_STATE               ;
    72         delete [] out_PREDICT_MATCH_INST_IFETCH_PTR      ;
    73         if (_param->_have_port_branch_update_prediction_id)
    74         delete [] out_PREDICT_BRANCH_UPDATE_PREDICTION_ID;
    75         delete [] out_PREDICT_BRANCH_CONDITION           ;
    76 //      delete [] out_PREDICT_BRANCH_STACK_WRITE         ;
    77         delete [] out_PREDICT_BRANCH_DIRECTION           ;
    78         delete [] out_PREDICT_ADDRESS_SRC                ;
    79         delete [] out_PREDICT_ADDRESS_DEST               ;
    80 //      delete []  in_PREDICT_CAN_CONTINUE               ;
     80        DELETE1_SIGNAL(in_CONTEXT_DECOD_ENABLE, _param->_nb_context,1);
     81        DELETE1_SIGNAL(in_CONTEXT_DEPTH       , _param->_nb_context,_param->_size_depth);
    8182
    82         delete []  in_CONTEXT_DECOD_ENABLE               ;
    83         if (_param->_have_port_depth)
    84         delete []  in_CONTEXT_DEPTH                      ;
     83        DELETE_SIGNAL (out_CONTEXT_EVENT_VAL          ,1);
     84        DELETE_SIGNAL ( in_CONTEXT_EVENT_ACK          ,1);
     85        DELETE_SIGNAL (out_CONTEXT_EVENT_CONTEXT_ID   ,_param->_size_context_id  );
     86        DELETE_SIGNAL (out_CONTEXT_EVENT_DEPTH        ,_param->_size_depth       );
     87        DELETE_SIGNAL (out_CONTEXT_EVENT_TYPE         ,_param->_size_event_type  );
     88        DELETE_SIGNAL (out_CONTEXT_EVENT_IS_DELAY_SLOT,1                         );
     89        DELETE_SIGNAL (out_CONTEXT_EVENT_ADDRESS      ,_param->_size_instruction_address);
     90        DELETE_SIGNAL (out_CONTEXT_EVENT_ADDRESS_EPCR ,_param->_size_instruction_address);
    8591
    86         delete    out_CONTEXT_EVENT_VAL                  ;
    87         delete     in_CONTEXT_EVENT_ACK                  ;
    88         if (_param->_have_port_context_id)
    89         delete    out_CONTEXT_EVENT_CONTEXT_ID           ;
    90         delete    out_CONTEXT_EVENT_TYPE                 ;
    91         delete    out_CONTEXT_EVENT_IS_DELAY_SLOT        ;
    92         delete    out_CONTEXT_EVENT_ADDRESS              ;
    93         delete    out_CONTEXT_EVENT_ADDRESS_EPCR         ;
     92
     93   
     94        delete    reg_CONTEXT_ADDRESS_PREVIOUS      ;
     95        delete [] reg_CONTEXT_IS_DELAY_SLOT         ;
     96       
     97        delete [] internal_CONTEXT_HAVE_TRANSACTION ;
     98        delete [] internal_CONTEXT_ADDRESS_PREVIOUS ;
     99        delete [] internal_CONTEXT_IS_DELAY_SLOT    ;
     100       
     101#ifdef STATISTICS
     102        delete [] internal_DECOD_VAL;
     103#endif
    94104      }
    95105
    96106    // ~~~~~[ Component ]~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
    97     delete    reg_CONTEXT_ADDRESS_PREVIOUS      ;
    98     delete    reg_CONTEXT_IS_DELAY_SLOT         ;
     107    delete    _priority;
    99108
    100     delete    internal_CONTEXT_HAVE_TRANSACTION ;
    101     delete    internal_CONTEXT_ADDRESS_PREVIOUS ;
    102     delete    internal_CONTEXT_IS_DELAY_SLOT    ;
    103109
    104110    const uint32_t nb_opcod_type = 14;

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_end_cycle.cpp

    r81 r88  
    2525
    2626#ifdef STATISTICS
    27     _stat->end_cycle();
     27    if (usage_is_set(_usage,USE_STATISTICS))
     28      _stat->end_cycle();
    2829#endif   
    2930
    … …  
    3132    // Evaluation before read the ouput signal
    3233//  sc_start(0);
    33     _interfaces->testbench();
     34    if (usage_is_set(_usage,VHDL_TESTBENCH))
     35      _interfaces->testbench();
    3436#endif
    3537

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_genMealy.cpp

    r87 r88  
    2222  void Decod::genMealy (void)
    2323  {
    24     log_printf(TRACE,Decod,FUNCTION,"Begin");
     24    log_begin(Decod,FUNCTION);
     25    log_function(Decod,FUNCTION,_name.c_str());
    2526
    2627    //-----------------------------------
    … …  
    3839      {
    3940        decod_val   [i] = false;
     41        predict_val [i] = false;
    4042      }
    4143
    … …  
    5759    //-----------------------------------
    5860    // scan all decod "slot_out"
    59     log_printf(TRACE,Decod,FUNCTION,"KANE LIVE");   
    60     std::list<select_t>::iterator it=select.begin();
     61    std::list<generic::priority::select_t> * select = _priority->select();
     62    std::list<generic::priority::select_t>::iterator it=select->begin();
    6163    for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
    6264      {
    63         while ((it != select.end())     and  // have a no scanned "slot_in" ?
     65        while ((it != select->end())    and  // have a no scanned "slot_in" ?
    6466               (decod_val [i] == false) and  // have not a previous selected entry?
    6567               (context_event_val == false)) // Have not a context_event (spr_access, exception, ...)
    6668          {
    67             log_printf(TRACE,Decod,FUNCTION,"loop");   
    68 
    6969            predict_val [i] = false;
    7070
    71             Tcontext_t x = it->_context ;
    72             uint32_t   y = it->_inst_fetch;
     71            Tcontext_t x = it->grp;
     72            uint32_t   y = it->elt;
    7373
    7474            // Test if this instruction is valid
    … …  
    7676                (can_continue [x]                == 1))    // context can decod instruction (have not a previous event)
    7777              {
    78                 can_continue      [x] = can_continue_next [x];
     78                log_printf(TRACE,Decod,FUNCTION,"  * IFETCH [%d][%d]",x,y);   
     79
     80                can_continue [x] = can_continue_next [x];
    7981
    8082                decod_val  [i]    = true;                        // fetch_val and decod_enable
    … …  
    9092                _decod_instruction->_is_delay_slot    = internal_CONTEXT_IS_DELAY_SLOT [x];
    9193
    92                 // Decod !
    93                 log_printf(TRACE,Decod,FUNCTION,"DECOD [%d]",i);
    94                 log_printf(TRACE,Decod,FUNCTION,"  * context       : %d",x);
    95                 log_printf(TRACE,Decod,FUNCTION,"  * fetch         : %d",y);
    96                 log_printf(TRACE,Decod,FUNCTION,"  * address       : %.8x",addr);
    97                 log_printf(TRACE,Decod,FUNCTION,"  * is_delay_slot : %d",internal_CONTEXT_IS_DELAY_SLOT [x]);
    98 
    99                 instruction_decod (_decod_instruction, _decod_param[x]);
    100 
    101                 Ttype_t type = _decod_instruction->_type;
     94                // Test IFetch exception
     95                Texception_t ifetch_exception = PORT_READ(in_IFETCH_EXCEPTION [x]);
     96
     97                if (ifetch_exception == EXCEPTION_IFETCH_NONE)
     98                  {
     99                    // Decod !
     100                    log_printf(TRACE,Decod,FUNCTION,"  * DECOD [%d]",i);
     101                    log_printf(TRACE,Decod,FUNCTION,"    * context       : %d",x);
     102                    log_printf(TRACE,Decod,FUNCTION,"    * fetch         : %d",y);
     103                    log_printf(TRACE,Decod,FUNCTION,"    * address       : %.8x (%.8x)",addr,(addr<<2));
     104                    log_printf(TRACE,Decod,FUNCTION,"    * is_delay_slot : %d",internal_CONTEXT_IS_DELAY_SLOT [x]);
     105                   
     106                    instruction_decod (_decod_instruction, _decod_param[x]);
     107                  }
     108                else
     109                  {
     110                    // No decod : nop
     111                    instruction_l_nop (_decod_instruction, _decod_param[x]);
     112
     113                    _decod_instruction->_exception_use = EXCEPTION_USE_NONE;
     114                    _decod_instruction->_exception     = exception_ifetch_to_exception_decod(ifetch_exception);
     115                   
     116                    // INSTRUCTION_TLB 
     117                    // INSTRUCTION_PAGE
     118                    // BUS_ERROR       
     119                    if (_decod_instruction->_is_delay_slot)
     120                      _decod_instruction->_address_next       = _decod_instruction->_address_previous;
     121                    else
     122                      _decod_instruction->_address_next       = _decod_instruction->_address;
     123                   
     124                    _decod_instruction->_event_type         = EVENT_TYPE_EXCEPTION;
     125                  }
     126
     127                Ttype_t  type  = _decod_instruction->_type;
     128                Tdepth_t depth = (_param->_have_port_depth)?PORT_READ(in_CONTEXT_DEPTH [x]):0; // DEPTH_CURRENT
    102129
    103130                if (_param->_have_port_context_id)
    104131                PORT_WRITE(out_DECOD_CONTEXT_ID    [i], x);
    105132                if (_param->_have_port_depth)
    106                 PORT_WRITE(out_DECOD_DEPTH         [i], PORT_READ(in_CONTEXT_DEPTH [x]));
     133                PORT_WRITE(out_DECOD_DEPTH         [i], depth);
    107134                PORT_WRITE(out_DECOD_TYPE          [i], type);
    108135                PORT_WRITE(out_DECOD_OPERATION     [i], _decod_instruction->_operation     );
     136                PORT_WRITE(out_DECOD_NO_EXECUTE    [i], _decod_instruction->_no_execute    );
    109137                PORT_WRITE(out_DECOD_IS_DELAY_SLOT [i], _decod_instruction->_is_delay_slot );
    110138                PORT_WRITE(out_DECOD_ADDRESS       [i], addr);
    … …  
    122150                PORT_WRITE(out_DECOD_NUM_REG_RE    [i], _decod_instruction->_num_reg_re    );
    123151                PORT_WRITE(out_DECOD_EXCEPTION_USE [i], _decod_instruction->_exception_use );
     152//              PORT_WRITE(out_DECOD_EXCEPTION     [i], _decod_instruction->_exception     );
    124153
    125154                if (type == TYPE_BRANCH)
    126155                  {
    127                     log_printf(TRACE,Decod,FUNCTION,"  * type is branch");
     156                    log_printf(TRACE,Decod,FUNCTION,"    * type is branch");
     157                    log_printf(TRACE,Decod,FUNCTION,"      * address src  : %.8x (%.8x)",_decod_instruction->_address     ,_decod_instruction->_address     <<2);
     158                    log_printf(TRACE,Decod,FUNCTION,"      * address dest : %.8x (%.8x)",_decod_instruction->_address_next,_decod_instruction->_address_next<<2);
    128159
    129160                    predict_val [i]     = ifetch_ack  [x][y] // and decod_val [i]
    … …  
    136167                    PORT_WRITE(out_PREDICT_MATCH_INST_IFETCH_PTR       [i],y == ((_param->_have_port_inst_ifetch_ptr)?PORT_READ(in_IFETCH_INST_IFETCH_PTR [x]):0));
    137168                    PORT_WRITE(out_PREDICT_BRANCH_STATE                [i],PORT_READ(in_IFETCH_BRANCH_STATE                [x]));
    138                     if (_param->_have_port_branch_update_prediction_id)
    139                     PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i],PORT_READ(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [x]));
     169                    if (_param->_have_port_depth)
     170                    PORT_WRITE(out_PREDICT_BRANCH_UPDATE_PREDICTION_ID [i],PORT_READ(in_IFETCH_BRANCH_UPDATE_PREDICTION_ID [x]));
    140171                    PORT_WRITE(out_PREDICT_BRANCH_CONDITION            [i],_decod_instruction->_branch_condition  );
    141172//                  PORT_WRITE(out_PREDICT_BRANCH_STACK_WRITE          [i],_decod_instruction->_branch_stack_write);
    … …  
    145176               
    146177                    //can_continue_next [x] = PORT_READ(in_PREDICT_CAN_CONTINUE [i]); // can continue is set if direction is "not take" (also, continue is sequential order)
    147                     can_continue_next [x] = false; // one branch per context
     178                    can_continue_next [x] = false; // one branch per context, the DS don't execute
    148179                  }
    149180
    … …  
    160191                    if (_param->_have_port_context_id)
    161192                    PORT_WRITE(out_CONTEXT_EVENT_CONTEXT_ID   , x);
     193                    if (_param->_have_port_depth)
     194                    PORT_WRITE(out_CONTEXT_EVENT_DEPTH        , depth);
    162195                    PORT_WRITE(out_CONTEXT_EVENT_TYPE         , _decod_instruction->_event_type    );
    163196                    PORT_WRITE(out_CONTEXT_EVENT_IS_DELAY_SLOT, _decod_instruction->_is_delay_slot );
    … …  
    184217              }
    185218
    186             log_printf(TRACE,Decod,FUNCTION,"  - num_(decod, context, fetch) : %d %d %d",i, x, y);
    187             log_printf(TRACE,Decod,FUNCTION,"    - ifetch_ack        : %d",ifetch_ack  [x][y]);
    188             log_printf(TRACE,Decod,FUNCTION,"    - context_event_val : %d",context_event_val );
    189             log_printf(TRACE,Decod,FUNCTION,"    - predict_val       : %d",predict_val [i]   );
    190             log_printf(TRACE,Decod,FUNCTION,"    - decod_val         : %d",decod_val   [i]   );
     219            log_printf(TRACE,Decod,FUNCTION,"    - num_(decod, context, fetch) : %d %d %d",i, x, y);
     220            log_printf(TRACE,Decod,FUNCTION,"      - ifetch_ack        : %d",ifetch_ack  [x][y]);
     221            log_printf(TRACE,Decod,FUNCTION,"      - context_event_val : %d",context_event_val );
     222            log_printf(TRACE,Decod,FUNCTION,"      - predict_val       : %d",predict_val [i]   );
     223            log_printf(TRACE,Decod,FUNCTION,"      - decod_val         : %d",decod_val   [i]   );
    191224           
    192225            it ++;
    … …  
    207240        PORT_WRITE(out_PREDICT_VAL [i], predict_val [i]);
    208241        PORT_WRITE(out_DECOD_VAL   [i], decod_val   [i]);
    209       }
    210 
    211     log_printf(FUNC,Decod,FUNCTION,"End");
     242       
     243#ifdef STATISTICS
     244        internal_DECOD_VAL [i] = decod_val [i];
     245#endif
     246      }
     247
     248    log_end(Decod,FUNCTION);
    212249  };
    213250

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_statistics_allocation.cpp

    r81 r88  
    2727                      "Decod",
    2828                      param_statistics);
    29    
    30     _stat_sum_inst_decod = _stat->create_variable ("sum_inst_decod" // ,"", "Sum of decod instruction"
    31                                                    );
    3229
     30    _stat_sum_inst_decod = _stat->create_variable("sum_inst_decod");
     31   
     32   
     33    _stat->create_expr_average_by_cycle ("average_nb_inst_decod","sum_inst_decod","","Average of decod instruction by cycle");
     34    _stat->create_expr_percent          ("percent_nb_inst_decod","average_nb_inst_decod", toString(_param->_nb_inst_decod), "Percent of decod instruction by cycle");
     35 
    3336
    34     _stat->create_expr_average_by_cycle ("average_sum_inst_decod","sum_inst_decod","","Average of decod instruction by cycle");
    35     _stat->create_expr_percent          ("percent_sum_inst_decod","average_sum_inst_decod", toString(_param->_nb_inst_decod), "Percent of decod instruction by cycle");
    3637 
    3738    log_printf(FUNC,Decod,FUNCTION,"End");

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Decod_transition.cpp

    r87 r88  
    2222  void Decod::transition (void)
    2323  {
    24     log_printf(FUNC,Decod,FUNCTION,"Begin");
     24    log_begin(Decod,FUNCTION);
    2525
    2626    if (PORT_READ(in_NRESET) == 0)
    2727      {
    28         reg_CONTEXT_PRIORITY = 0;
     28        _priority->reset();
    2929
    3030        for (uint32_t i=0; i<_param->_nb_context; i++)
    … …  
    3636    else
    3737      {
    38         switch (_param->_priority)
    39           {
    40 //        case PRIORITY_STATIC :
    41 //          {
    42 //            reg_CONTEXT_PRIORITY = (reg_CONTEXT_PRIORITY+_param->_nb_context_select)%_param->_nb_context;
    43 //            break;
    44 //          }
    45           case PRIORITY_ROUND_ROBIN :
    46             {
    47               reg_CONTEXT_PRIORITY = (reg_CONTEXT_PRIORITY+1                         )%_param->_nb_context;
    48               break;
    49             }
    50           default:
    51             {
    52               break;
    53             }
    54           }
    55 
    56         // flush list
    57         select.clear();
    58        
    59         // Compute next scan order !!!
    60         switch (_param->_load_balancing)
    61           {
    62 //        case LOAD_BALANCING_BALANCE :
    63 //          {
    64 //            for (uint32_t j=0; j<_param->_max_nb_inst_fetch; j++)
    65 //              for (uint32_t i=0; i<_param->_nb_context_select; i++)
    66 //                {
    67 //                  uint32_t x=(reg_CONTEXT_PRIORITY+i)%_param->_nb_context;
    68                    
    69 //                  // Test valid inst_fetch
    70 //                  if (j < _param->_nb_inst_fetch[x])
    71 //                    select.push_back(select_t(x,j));
    72 //                }
    73                  
    74 //            break;
    75 //          }
    76           case LOAD_BALANCING_MAXIMUM_FOR_PRIORITY :
    77             {
    78 
    79               for (uint32_t i=0; i<_param->_nb_context_select; i++)
    80                 {
    81                   uint32_t x=(reg_CONTEXT_PRIORITY+i)%_param->_nb_context;
    82                  
    83                   for (uint32_t j=0; j<_param->_nb_inst_fetch[x]; j++)
    84                     select.push_back(select_t(x,j));
    85                 }
    86 
    87               break;
    88             }
    89           default :
    90             {
    91               break;
    92             }
    93           }
     38        _priority->transition();
    9439
    9540        // Compute "next previous" address
    … …  
    9742          if (internal_CONTEXT_HAVE_TRANSACTION[i])
    9843            {
    99 #ifdef STATISTICS
    100               (*_stat_sum_inst_decod) ++;
    101 #endif
    102 
    10344              reg_CONTEXT_ADDRESS_PREVIOUS [i] = internal_CONTEXT_ADDRESS_PREVIOUS [i];
    10445              reg_CONTEXT_IS_DELAY_SLOT    [i] = internal_CONTEXT_IS_DELAY_SLOT    [i];
    … …  
    10748//      for (uint32_t i=0; i<_param->_nb_context; i++)
    10849//        log_printf(TRACE,Decod,FUNCTION,"[%d] %.8x %d",i,reg_CONTEXT_ADDRESS_PREVIOUS [i], reg_CONTEXT_IS_DELAY_SLOT [i]);
     50
     51#ifdef STATISTICS
     52        if (usage_is_set(_usage,USE_STATISTICS))
     53          for (uint32_t i=0; i<_param->_nb_inst_decod; i++)
     54            if (internal_DECOD_VAL [i] and PORT_READ(in_DECOD_ACK[i]))
     55              (*_stat_sum_inst_decod) ++;
     56#endif
    10957      }
    11058
    … …  
    11361#endif
    11462
    115     log_printf(FUNC,Decod,FUNCTION,"End");
     63    log_end(Decod,FUNCTION);
    11664  };
    11765

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters.cpp

    r87 r88  
    11/*
    2 
    32 * $Id$
    43 *
    … …  
    2423                          uint32_t          * nb_inst_fetch                ,
    2524                          uint32_t            nb_inst_decod                ,
    26                           uint32_t            nb_branch_speculated         ,
    27                           uint32_t            size_branch_update_prediction,
     25                          uint32_t          * nb_branch_speculated         ,
     26//                        uint32_t          * size_branch_update_prediction,
    2827                          uint32_t            nb_context_select            ,
    2928                          uint32_t            size_general_data            ,
    … …  
    3130                          Tload_balancing_t   load_balancing               ,
    3231                          bool             ** instruction_implemeted       ,
    33                           morpheo::behavioural::custom::custom_information_t (*get_custom_information) (uint32_t))
     32                          morpheo::behavioural::custom::custom_information_t (*get_custom_information) (void),
     33                          bool                is_toplevel
     34                          )
    3435  {
    3536    log_printf(FUNC,Decod,FUNCTION,"Begin");
    … …  
    4041    _nb_branch_speculated          = nb_branch_speculated         ;
    4142    _nb_context_select             = nb_context_select            ;
    42     _size_branch_update_prediction = size_branch_update_prediction;
    43     _size_general_data             = size_general_data            ;
     43//  _size_branch_update_prediction = size_branch_update_prediction;
     44//  _size_general_data             = size_general_data            ;
    4445    _priority                      = priority                     ;
    4546    _load_balancing                = load_balancing               ;
    … …  
    5253
    5354   
    54     _max_nb_inst_fetch                     = max<uint32_t>(nb_inst_fetch,nb_context);
     55    _max_nb_inst_fetch                        = max<uint32_t>(nb_inst_fetch,nb_context);
     56                                             
     57//  _size_address_inst                        = size_general_data-2;
    5558
    56     _size_address_inst                     = size_general_data-2;
    57     _size_context_id                       = log2(nb_context          );
    58     _size_depth                            = log2(nb_branch_speculated);
    59     _size_inst_ifetch_ptr                  = log2(_max_nb_inst_fetch  );
     59    test();
    6060
    61     _have_port_context_id                  = _size_context_id > 0;
    62     _have_port_depth                       = _size_depth      > 0;
    63     _have_port_branch_update_prediction_id = _size_branch_update_prediction > 0;
    64     _have_port_inst_ifetch_ptr             = _size_inst_ifetch_ptr > 0;
    65    
    66     test();
     61    if (is_toplevel)
     62      {
     63        _size_context_id                      = log2(nb_context          );
     64        _size_depth                           = log2(max<uint32_t>(_nb_branch_speculated,_nb_context));
     65//      _size_branch_update_prediction_id     = max<uint32_t>(_size_branch_update_prediction,_nb_context);
     66        _size_inst_ifetch_ptr                 = log2(_max_nb_inst_fetch  );
     67        _size_instruction_address             = size_general_data-2;
     68        _size_general_data                    = size_general_data;
     69
     70        _have_port_context_id                 = _size_context_id > 0;
     71        _have_port_depth                      = _size_depth                       > 0;
     72//      _have_port_branch_update_prediction_id= _size_branch_update_prediction_id > 0;
     73        _have_port_inst_ifetch_ptr            = _size_inst_ifetch_ptr             > 0;
     74
     75        copy ();
     76      }
     77
    6778    log_printf(FUNC,Decod,FUNCTION,"End");
    6879  };
    … …  
    8293  {
    8394    log_printf(FUNC,Decod,FUNCTION,"Begin");
     95
     96    log_printf(FUNC,Decod,FUNCTION,"End");
     97  };
     98
     99#undef  FUNCTION
     100#define FUNCTION "Decod::copy"
     101  void Parameters::copy (void)
     102  {
     103    log_printf(FUNC,Decod,FUNCTION,"Begin");
     104
    84105    log_printf(FUNC,Decod,FUNCTION,"End");
    85106  };

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters_msg_error.cpp

    r87 r88  
    3131      test.error(_("nb_inst_decod must be > 0.\n"));
    3232
    33     if ((_size_general_data != 32) and
    34         (_size_general_data != 64))
    35       test.error(_("size_general_data must be equal at 32 or 64 bits.\n"));
     33//  if ((_size_general_data != 32) and
     34//      (_size_general_data != 64))
     35//    test.error(_("size_general_data must be equal at 32 or 64 bits.\n"));
    3636
    37     if ((_nb_branch_speculated == 0) or
    38         (_nb_branch_speculated > _nb_context))
    39       test.error(_("nb_branch_speculated must be in [1:nb_context].\n"));
     37//     if ((_nb_branch_speculated == 0) or
     38//      (_nb_branch_speculated > _nb_context))
     39//       test.error(_("nb_branch_speculated must be in [1:nb_context].\n"));
    4040
    4141    if ((_nb_context_select == 0) or
    … …  
    4848
    4949    if (sum_inst_fetch < _nb_inst_decod)
    50       test.error(_("The sum of the _nb_context_select most nb_inst_fetch must be greater that _nb_inst_decod"));
     50      test.error(_("The sum of the _nb_context_select most nb_inst_fetch must be greater that _nb_inst_decod\n"));
    5151
    5252    if ((_priority != PRIORITY_ROUND_ROBIN))

  • trunk/IPs/systemC/processor/Morpheo/Behavioural/Core/Multi_Front_end/Front_end/Decod_unit/Decod/src/Parameters_print.cpp

    r81 r88  
    3030    xml.singleton_begin("nb_inst_decod                "); xml.attribut("value",toString(_nb_inst_decod                )); xml.singleton_end();
    3131    xml.singleton_begin("nb_branch_speculated         "); xml.attribut("value",toString(_nb_branch_speculated         )); xml.singleton_end();
    32     xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
     32//  xml.singleton_begin("size_branch_update_prediction"); xml.attribut("value",toString(_size_branch_update_prediction)); xml.singleton_end();
    3333    xml.singleton_begin("nb_context_select            "); xml.attribut("value",toString(_nb_context_select            )); xml.singleton_end();
    3434    xml.singleton_begin("size_general_data            "); xml.attribut("value",toString(_size_general_data            )); xml.singleton_end();
Note: See TracChangeset for help on using the changeset viewer.