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

Almost complete design
with Test and test platform

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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  }
Note: See TracChangeset for help on using the changeset viewer.