sid/component/cgen-cpu/sh/sh2-decode.cxx

   1 /* Simulator instruction decoder for sh2.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 2000-2009 Red Hat, Inc.
   6
   7 This file is part of the Red Hat simulators.
   8
   9
  10 */
  11
  12
  13 #if HAVE_CONFIG_H
  14 #include "config.h"
  15 #endif
  16 #include "sh2.h"
  17
  18 using namespace sh2; // FIXME: namespace organization still wip
  19
  20
  21 // The instruction descriptor array.
  22
  23 sh2_idesc sh2_idesc::idesc_table[SH2_INSN_XTRCT_COMPACT + 1] =
  24 {
  25   { sh2_sem_x_invalid, "X_INVALID", SH2_INSN_X_INVALID, { 0|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_NONE, SH4A_GROUP_NONE } },
  26   { sh2_sem_add_compact, "ADD_COMPACT", SH2_INSN_ADD_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  27   { sh2_sem_addi_compact, "ADDI_COMPACT", SH2_INSN_ADDI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_NONE } },
  28   { sh2_sem_addc_compact, "ADDC_COMPACT", SH2_INSN_ADDC_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  29   { sh2_sem_addv_compact, "ADDV_COMPACT", SH2_INSN_ADDV_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  30   { sh2_sem_and_compact, "AND_COMPACT", SH2_INSN_AND_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  31   { sh2_sem_andi_compact, "ANDI_COMPACT", SH2_INSN_ANDI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  32   { sh2_sem_andb_compact, "ANDB_COMPACT", SH2_INSN_ANDB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
  33   { sh2_sem_bf_compact, "BF_COMPACT", SH2_INSN_BF_COMPACT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  34   { sh2_sem_bfs_compact, "BFS_COMPACT", SH2_INSN_BFS_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_COND_CTI), (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  35   { sh2_sem_bra_compact, "BRA_COMPACT", SH2_INSN_BRA_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  36   { sh2_sem_braf_compact, "BRAF_COMPACT", SH2_INSN_BRAF_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_BR } },
  37   { sh2_sem_bsr_compact, "BSR_COMPACT", SH2_INSN_BSR_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  38   { sh2_sem_bsrf_compact, "BSRF_COMPACT", SH2_INSN_BSRF_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_BR } },
  39   { sh2_sem_bt_compact, "BT_COMPACT", SH2_INSN_BT_COMPACT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  40   { sh2_sem_bts_compact, "BTS_COMPACT", SH2_INSN_BTS_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_COND_CTI), (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_BR, SH4A_GROUP_BR } },
  41   { sh2_sem_clrmac_compact, "CLRMAC_COMPACT", SH2_INSN_CLRMAC_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
  42   { sh2_sem_clrt_compact, "CLRT_COMPACT", SH2_INSN_CLRT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  43   { sh2_sem_cmpeq_compact, "CMPEQ_COMPACT", SH2_INSN_CMPEQ_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  44   { sh2_sem_cmpeqi_compact, "CMPEQI_COMPACT", SH2_INSN_CMPEQI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  45   { sh2_sem_cmpge_compact, "CMPGE_COMPACT", SH2_INSN_CMPGE_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  46   { sh2_sem_cmpgt_compact, "CMPGT_COMPACT", SH2_INSN_CMPGT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  47   { sh2_sem_cmphi_compact, "CMPHI_COMPACT", SH2_INSN_CMPHI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  48   { sh2_sem_cmphs_compact, "CMPHS_COMPACT", SH2_INSN_CMPHS_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  49   { sh2_sem_cmppl_compact, "CMPPL_COMPACT", SH2_INSN_CMPPL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  50   { sh2_sem_cmppz_compact, "CMPPZ_COMPACT", SH2_INSN_CMPPZ_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  51   { sh2_sem_cmpstr_compact, "CMPSTR_COMPACT", SH2_INSN_CMPSTR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
  52   { sh2_sem_div0s_compact, "DIV0S_COMPACT", SH2_INSN_DIV0S_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  53   { sh2_sem_div0u_compact, "DIV0U_COMPACT", SH2_INSN_DIV0U_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  54   { sh2_sem_div1_compact, "DIV1_COMPACT", SH2_INSN_DIV1_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  55   { sh2_sem_dmulsl_compact, "DMULSL_COMPACT", SH2_INSN_DMULSL_COMPACT, { 0, (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
  56   { sh2_sem_dmulul_compact, "DMULUL_COMPACT", SH2_INSN_DMULUL_COMPACT, { 0, (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
  57   { sh2_sem_dt_compact, "DT_COMPACT", SH2_INSN_DT_COMPACT, { 0, (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  58   { sh2_sem_extsb_compact, "EXTSB_COMPACT", SH2_INSN_EXTSB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  59   { sh2_sem_extsw_compact, "EXTSW_COMPACT", SH2_INSN_EXTSW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  60   { sh2_sem_extub_compact, "EXTUB_COMPACT", SH2_INSN_EXTUB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  61   { sh2_sem_extuw_compact, "EXTUW_COMPACT", SH2_INSN_EXTUW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
  62   { sh2_sem_frchg_compact, "FRCHG_COMPACT", SH2_INSN_FRCHG_COMPACT, { 0|(1<<CGEN_INSN_FP_INSN), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_FE, SH4A_GROUP_FE } },
  63   { sh2_sem_fschg_compact, "FSCHG_COMPACT", SH2_INSN_FSCHG_COMPACT, { 0|(1<<CGEN_INSN_FP_INSN), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_FE, SH4A_GROUP_FE } },
  64   { sh2_sem_jmp_compact, "JMP_COMPACT", SH2_INSN_JMP_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_BR } },
  65   { sh2_sem_jsr_compact, "JSR_COMPACT", SH2_INSN_JSR_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_BR } },
  66   { sh2_sem_ldc_gbr_compact, "LDC_GBR_COMPACT", SH2_INSN_LDC_GBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  67   { sh2_sem_ldc_vbr_compact, "LDC_VBR_COMPACT", SH2_INSN_LDC_VBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  68   { sh2_sem_ldc_sr_compact, "LDC_SR_COMPACT", SH2_INSN_LDC_SR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
  69   { sh2_sem_ldcl_gbr_compact, "LDCL_GBR_COMPACT", SH2_INSN_LDCL_GBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  70   { sh2_sem_ldcl_vbr_compact, "LDCL_VBR_COMPACT", SH2_INSN_LDCL_VBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  71   { sh2_sem_lds_mach_compact, "LDS_MACH_COMPACT", SH2_INSN_LDS_MACH_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  72   { sh2_sem_ldsl_mach_compact, "LDSL_MACH_COMPACT", SH2_INSN_LDSL_MACH_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  73   { sh2_sem_lds_macl_compact, "LDS_MACL_COMPACT", SH2_INSN_LDS_MACL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  74   { sh2_sem_ldsl_macl_compact, "LDSL_MACL_COMPACT", SH2_INSN_LDSL_MACL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  75   { sh2_sem_lds_pr_compact, "LDS_PR_COMPACT", SH2_INSN_LDS_PR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  76   { sh2_sem_ldsl_pr_compact, "LDSL_PR_COMPACT", SH2_INSN_LDSL_PR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
  77   { sh2_sem_macl_compact, "MACL_COMPACT", SH2_INSN_MACL_COMPACT, { 0, (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
  78   { sh2_sem_macw_compact, "MACW_COMPACT", SH2_INSN_MACW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
  79   { sh2_sem_mov_compact, "MOV_COMPACT", SH2_INSN_MOV_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_MT } },
  80   { sh2_sem_movi_compact, "MOVI_COMPACT", SH2_INSN_MOVI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_MT } },
  81   { sh2_sem_movb1_compact, "MOVB1_COMPACT", SH2_INSN_MOVB1_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  82   { sh2_sem_movb2_compact, "MOVB2_COMPACT", SH2_INSN_MOVB2_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  83   { sh2_sem_movb3_compact, "MOVB3_COMPACT", SH2_INSN_MOVB3_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  84   { sh2_sem_movb4_compact, "MOVB4_COMPACT", SH2_INSN_MOVB4_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  85   { sh2_sem_movb5_compact, "MOVB5_COMPACT", SH2_INSN_MOVB5_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  86   { sh2_sem_movb6_compact, "MOVB6_COMPACT", SH2_INSN_MOVB6_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  87   { sh2_sem_movb7_compact, "MOVB7_COMPACT", SH2_INSN_MOVB7_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  88   { sh2_sem_movb8_compact, "MOVB8_COMPACT", SH2_INSN_MOVB8_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  89   { sh2_sem_movb9_compact, "MOVB9_COMPACT", SH2_INSN_MOVB9_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  90   { sh2_sem_movb10_compact, "MOVB10_COMPACT", SH2_INSN_MOVB10_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  91   { sh2_sem_movl1_compact, "MOVL1_COMPACT", SH2_INSN_MOVL1_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  92   { sh2_sem_movl2_compact, "MOVL2_COMPACT", SH2_INSN_MOVL2_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  93   { sh2_sem_movl3_compact, "MOVL3_COMPACT", SH2_INSN_MOVL3_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  94   { sh2_sem_movl4_compact, "MOVL4_COMPACT", SH2_INSN_MOVL4_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  95   { sh2_sem_movl5_compact, "MOVL5_COMPACT", SH2_INSN_MOVL5_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  96   { sh2_sem_movl6_compact, "MOVL6_COMPACT", SH2_INSN_MOVL6_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  97   { sh2_sem_movl7_compact, "MOVL7_COMPACT", SH2_INSN_MOVL7_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  98   { sh2_sem_movl8_compact, "MOVL8_COMPACT", SH2_INSN_MOVL8_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
  99   { sh2_sem_movl9_compact, "MOVL9_COMPACT", SH2_INSN_MOVL9_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 100   { sh2_sem_movl10_compact, "MOVL10_COMPACT", SH2_INSN_MOVL10_COMPACT, { 0|(1<<CGEN_INSN_ILLSLOT), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 101   { sh2_sem_movl11_compact, "MOVL11_COMPACT", SH2_INSN_MOVL11_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 102   { sh2_sem_movw1_compact, "MOVW1_COMPACT", SH2_INSN_MOVW1_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 103   { sh2_sem_movw2_compact, "MOVW2_COMPACT", SH2_INSN_MOVW2_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 104   { sh2_sem_movw3_compact, "MOVW3_COMPACT", SH2_INSN_MOVW3_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 105   { sh2_sem_movw4_compact, "MOVW4_COMPACT", SH2_INSN_MOVW4_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 106   { sh2_sem_movw5_compact, "MOVW5_COMPACT", SH2_INSN_MOVW5_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 107   { sh2_sem_movw6_compact, "MOVW6_COMPACT", SH2_INSN_MOVW6_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 108   { sh2_sem_movw7_compact, "MOVW7_COMPACT", SH2_INSN_MOVW7_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 109   { sh2_sem_movw8_compact, "MOVW8_COMPACT", SH2_INSN_MOVW8_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 110   { sh2_sem_movw9_compact, "MOVW9_COMPACT", SH2_INSN_MOVW9_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 111   { sh2_sem_movw10_compact, "MOVW10_COMPACT", SH2_INSN_MOVW10_COMPACT, { 0|(1<<CGEN_INSN_ILLSLOT), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 112   { sh2_sem_movw11_compact, "MOVW11_COMPACT", SH2_INSN_MOVW11_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_LS, SH4A_GROUP_LS } },
 113   { sh2_sem_mova_compact, "MOVA_COMPACT", SH2_INSN_MOVA_COMPACT, { 0|(1<<CGEN_INSN_ILLSLOT), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_LS } },
 114   { sh2_sem_movt_compact, "MOVT_COMPACT", SH2_INSN_MOVT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 115   { sh2_sem_mull_compact, "MULL_COMPACT", SH2_INSN_MULL_COMPACT, { 0, (1<<MACH_SH2)|(1<<MACH_SH2E)|(1<<MACH_SH2A_FPU)|(1<<MACH_SH2A_NOFPU)|(1<<MACH_SH3)|(1<<MACH_SH3E)|(1<<MACH_SH4_NOFPU)|(1<<MACH_SH4)|(1<<MACH_SH4A_NOFPU)|(1<<MACH_SH4A)|(1<<MACH_SH4AL)|(1<<MACH_SH5), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
 116   { sh2_sem_mulsw_compact, "MULSW_COMPACT", SH2_INSN_MULSW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
 117   { sh2_sem_muluw_compact, "MULUW_COMPACT", SH2_INSN_MULUW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_EX } },
 118   { sh2_sem_neg_compact, "NEG_COMPACT", SH2_INSN_NEG_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 119   { sh2_sem_negc_compact, "NEGC_COMPACT", SH2_INSN_NEGC_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 120   { sh2_sem_nop_compact, "NOP_COMPACT", SH2_INSN_NOP_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_MT } },
 121   { sh2_sem_not_compact, "NOT_COMPACT", SH2_INSN_NOT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 122   { sh2_sem_or_compact, "OR_COMPACT", SH2_INSN_OR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 123   { sh2_sem_ori_compact, "ORI_COMPACT", SH2_INSN_ORI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 124   { sh2_sem_orb_compact, "ORB_COMPACT", SH2_INSN_ORB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
 125   { sh2_sem_rotcl_compact, "ROTCL_COMPACT", SH2_INSN_ROTCL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 126   { sh2_sem_rotcr_compact, "ROTCR_COMPACT", SH2_INSN_ROTCR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 127   { sh2_sem_rotl_compact, "ROTL_COMPACT", SH2_INSN_ROTL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 128   { sh2_sem_rotr_compact, "ROTR_COMPACT", SH2_INSN_ROTR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 129   { sh2_sem_rts_compact, "RTS_COMPACT", SH2_INSN_RTS_COMPACT, { 0|(1<<CGEN_INSN_DELAY_SLOT)|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_BR } },
 130   { sh2_sem_sett_compact, "SETT_COMPACT", SH2_INSN_SETT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
 131   { sh2_sem_shal_compact, "SHAL_COMPACT", SH2_INSN_SHAL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 132   { sh2_sem_shar_compact, "SHAR_COMPACT", SH2_INSN_SHAR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 133   { sh2_sem_shll_compact, "SHLL_COMPACT", SH2_INSN_SHLL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 134   { sh2_sem_shll2_compact, "SHLL2_COMPACT", SH2_INSN_SHLL2_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 135   { sh2_sem_shll8_compact, "SHLL8_COMPACT", SH2_INSN_SHLL8_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 136   { sh2_sem_shll16_compact, "SHLL16_COMPACT", SH2_INSN_SHLL16_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 137   { sh2_sem_shlr_compact, "SHLR_COMPACT", SH2_INSN_SHLR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 138   { sh2_sem_shlr2_compact, "SHLR2_COMPACT", SH2_INSN_SHLR2_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 139   { sh2_sem_shlr8_compact, "SHLR8_COMPACT", SH2_INSN_SHLR8_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 140   { sh2_sem_shlr16_compact, "SHLR16_COMPACT", SH2_INSN_SHLR16_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 141   { sh2_sem_stc_gbr_compact, "STC_GBR_COMPACT", SH2_INSN_STC_GBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_NONE } },
 142   { sh2_sem_stc_vbr_compact, "STC_VBR_COMPACT", SH2_INSN_STC_VBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_NONE } },
 143   { sh2_sem_stcl_gbr_compact, "STCL_GBR_COMPACT", SH2_INSN_STCL_GBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_NONE } },
 144   { sh2_sem_stcl_vbr_compact, "STCL_VBR_COMPACT", SH2_INSN_STCL_VBR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_NONE } },
 145   { sh2_sem_sts_mach_compact, "STS_MACH_COMPACT", SH2_INSN_STS_MACH_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 146   { sh2_sem_stsl_mach_compact, "STSL_MACH_COMPACT", SH2_INSN_STSL_MACH_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 147   { sh2_sem_sts_macl_compact, "STS_MACL_COMPACT", SH2_INSN_STS_MACL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 148   { sh2_sem_stsl_macl_compact, "STSL_MACL_COMPACT", SH2_INSN_STSL_MACL_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 149   { sh2_sem_sts_pr_compact, "STS_PR_COMPACT", SH2_INSN_STS_PR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 150   { sh2_sem_stsl_pr_compact, "STSL_PR_COMPACT", SH2_INSN_STSL_PR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_LS } },
 151   { sh2_sem_sub_compact, "SUB_COMPACT", SH2_INSN_SUB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 152   { sh2_sem_subc_compact, "SUBC_COMPACT", SH2_INSN_SUBC_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 153   { sh2_sem_subv_compact, "SUBV_COMPACT", SH2_INSN_SUBV_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 154   { sh2_sem_swapb_compact, "SWAPB_COMPACT", SH2_INSN_SWAPB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 155   { sh2_sem_swapw_compact, "SWAPW_COMPACT", SH2_INSN_SWAPW_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 156   { sh2_sem_tasb_compact, "TASB_COMPACT", SH2_INSN_TASB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
 157   { sh2_sem_trapa_compact, "TRAPA_COMPACT", SH2_INSN_TRAPA_COMPACT, { 0|(1<<CGEN_INSN_ILLSLOT), (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
 158   { sh2_sem_tst_compact, "TST_COMPACT", SH2_INSN_TST_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
 159   { sh2_sem_tsti_compact, "TSTI_COMPACT", SH2_INSN_TSTI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_MT, SH4A_GROUP_EX } },
 160   { sh2_sem_tstb_compact, "TSTB_COMPACT", SH2_INSN_TSTB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
 161   { sh2_sem_xor_compact, "XOR_COMPACT", SH2_INSN_XOR_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 162   { sh2_sem_xori_compact, "XORI_COMPACT", SH2_INSN_XORI_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 163   { sh2_sem_xorb_compact, "XORB_COMPACT", SH2_INSN_XORB_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_CO, SH4A_GROUP_CO } },
 164   { sh2_sem_xtrct_compact, "XTRCT_COMPACT", SH2_INSN_XTRCT_COMPACT, { 0, (1<<MACH_BASE), { 1, "\x80" }, SH4_GROUP_EX, SH4A_GROUP_EX } },
 165
 166 };
 167
 168 // Given a canonical virtual insn id, return the target specific one.
 169
 170 sh2_insn_type
 171 sh2_idesc::lookup_virtual (virtual_insn_type vit)
 172 {
 173   switch (vit)
 174     {
 175       case VIRTUAL_INSN_INVALID: return SH2_INSN_X_INVALID;
 176       case VIRTUAL_INSN_COND: return SH2_INSN_X_INVALID;
 177     }
 178   abort ();
 179 }
 180
 181
 182 // Declare extractor functions
 183
 184 static void
 185 sh2_extract_sfmt_empty (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 186 static void
 187 sh2_extract_sfmt_add_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 188 static void
 189 sh2_extract_sfmt_addi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 190 static void
 191 sh2_extract_sfmt_addc_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 192 static void
 193 sh2_extract_sfmt_addv_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 194 static void
 195 sh2_extract_sfmt_and_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 196 static void
 197 sh2_extract_sfmt_andi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 198 static void
 199 sh2_extract_sfmt_andb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 200 static void
 201 sh2_extract_sfmt_bf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 202 static void
 203 sh2_extract_sfmt_bfs_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 204 static void
 205 sh2_extract_sfmt_bra_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 206 static void
 207 sh2_extract_sfmt_braf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 208 static void
 209 sh2_extract_sfmt_bsr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 210 static void
 211 sh2_extract_sfmt_bsrf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 212 static void
 213 sh2_extract_sfmt_clrmac_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 214 static void
 215 sh2_extract_sfmt_clrt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 216 static void
 217 sh2_extract_sfmt_cmpeq_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 218 static void
 219 sh2_extract_sfmt_cmpeqi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 220 static void
 221 sh2_extract_sfmt_cmppl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 222 static void
 223 sh2_extract_sfmt_div0s_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 224 static void
 225 sh2_extract_sfmt_div0u_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 226 static void
 227 sh2_extract_sfmt_div1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 228 static void
 229 sh2_extract_sfmt_dmulsl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 230 static void
 231 sh2_extract_sfmt_dt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 232 static void
 233 sh2_extract_sfmt_extsb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 234 static void
 235 sh2_extract_sfmt_frchg_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 236 static void
 237 sh2_extract_sfmt_fschg_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 238 static void
 239 sh2_extract_sfmt_ldc_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 240 static void
 241 sh2_extract_sfmt_ldc_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 242 static void
 243 sh2_extract_sfmt_ldc_sr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 244 static void
 245 sh2_extract_sfmt_ldcl_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 246 static void
 247 sh2_extract_sfmt_ldcl_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 248 static void
 249 sh2_extract_sfmt_lds_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 250 static void
 251 sh2_extract_sfmt_ldsl_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 252 static void
 253 sh2_extract_sfmt_lds_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 254 static void
 255 sh2_extract_sfmt_ldsl_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 256 static void
 257 sh2_extract_sfmt_lds_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 258 static void
 259 sh2_extract_sfmt_ldsl_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 260 static void
 261 sh2_extract_sfmt_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 262 static void
 263 sh2_extract_sfmt_macw_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 264 static void
 265 sh2_extract_sfmt_mov_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 266 static void
 267 sh2_extract_sfmt_movi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 268 static void
 269 sh2_extract_sfmt_movb1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 270 static void
 271 sh2_extract_sfmt_movb2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 272 static void
 273 sh2_extract_sfmt_movb3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 274 static void
 275 sh2_extract_sfmt_movb4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 276 static void
 277 sh2_extract_sfmt_movb5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 278 static void
 279 sh2_extract_sfmt_movb6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 280 static void
 281 sh2_extract_sfmt_movb7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 282 static void
 283 sh2_extract_sfmt_movb8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 284 static void
 285 sh2_extract_sfmt_movb9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 286 static void
 287 sh2_extract_sfmt_movb10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 288 static void
 289 sh2_extract_sfmt_movl1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 290 static void
 291 sh2_extract_sfmt_movl2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 292 static void
 293 sh2_extract_sfmt_movl3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 294 static void
 295 sh2_extract_sfmt_movl4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 296 static void
 297 sh2_extract_sfmt_movl5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 298 static void
 299 sh2_extract_sfmt_movl6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 300 static void
 301 sh2_extract_sfmt_movl7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 302 static void
 303 sh2_extract_sfmt_movl8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 304 static void
 305 sh2_extract_sfmt_movl9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 306 static void
 307 sh2_extract_sfmt_movl10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 308 static void
 309 sh2_extract_sfmt_movl11_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 310 static void
 311 sh2_extract_sfmt_movw1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 312 static void
 313 sh2_extract_sfmt_movw2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 314 static void
 315 sh2_extract_sfmt_movw3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 316 static void
 317 sh2_extract_sfmt_movw4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 318 static void
 319 sh2_extract_sfmt_movw5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 320 static void
 321 sh2_extract_sfmt_movw6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 322 static void
 323 sh2_extract_sfmt_movw7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 324 static void
 325 sh2_extract_sfmt_movw8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 326 static void
 327 sh2_extract_sfmt_movw9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 328 static void
 329 sh2_extract_sfmt_movw10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 330 static void
 331 sh2_extract_sfmt_movw11_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 332 static void
 333 sh2_extract_sfmt_mova_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 334 static void
 335 sh2_extract_sfmt_movt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 336 static void
 337 sh2_extract_sfmt_mull_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 338 static void
 339 sh2_extract_sfmt_negc_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 340 static void
 341 sh2_extract_sfmt_nop_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 342 static void
 343 sh2_extract_sfmt_rotcl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 344 static void
 345 sh2_extract_sfmt_rts_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 346 static void
 347 sh2_extract_sfmt_shll2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 348 static void
 349 sh2_extract_sfmt_stc_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 350 static void
 351 sh2_extract_sfmt_stc_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 352 static void
 353 sh2_extract_sfmt_stcl_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 354 static void
 355 sh2_extract_sfmt_stcl_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 356 static void
 357 sh2_extract_sfmt_sts_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 358 static void
 359 sh2_extract_sfmt_stsl_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 360 static void
 361 sh2_extract_sfmt_sts_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 362 static void
 363 sh2_extract_sfmt_stsl_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 364 static void
 365 sh2_extract_sfmt_sts_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 366 static void
 367 sh2_extract_sfmt_stsl_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 368 static void
 369 sh2_extract_sfmt_tasb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 370 static void
 371 sh2_extract_sfmt_trapa_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 372 static void
 373 sh2_extract_sfmt_tsti_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 374 static void
 375 sh2_extract_sfmt_tstb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn);
 376
 377 // Fetch & decode instruction
 378 void
 379 sh2_scache::decode (sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn)
 380 {
 381   /* Result of decoder.  */
 382   SH2_INSN_TYPE itype;
 383
 384   {
 385     sh2_insn_word insn = base_insn;
 386
 387     {
 388       unsigned int val = (((insn >> 22) & (15 << 6)) | ((insn >> 16) & (63 << 0)));
 389       switch (val)
 390       {
 391       case 3 :
 392         entire_insn = entire_insn >> 16;
 393         if ((entire_insn & 0xf0ff) == 0x3)
 394           { itype = SH2_INSN_BSRF_COMPACT; sh2_extract_sfmt_bsrf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 395         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 396       case 4 : /* fall through */
 397       case 20 : /* fall through */
 398       case 36 : /* fall through */
 399       case 52 :
 400         entire_insn = entire_insn >> 16;
 401         itype = SH2_INSN_MOVB3_COMPACT; sh2_extract_sfmt_movb3_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 402       case 5 : /* fall through */
 403       case 21 : /* fall through */
 404       case 37 : /* fall through */
 405       case 53 :
 406         entire_insn = entire_insn >> 16;
 407         itype = SH2_INSN_MOVW3_COMPACT; sh2_extract_sfmt_movw3_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 408       case 6 : /* fall through */
 409       case 22 : /* fall through */
 410       case 38 : /* fall through */
 411       case 54 :
 412         entire_insn = entire_insn >> 16;
 413         itype = SH2_INSN_MOVL3_COMPACT; sh2_extract_sfmt_movl3_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 414       case 7 : /* fall through */
 415       case 23 : /* fall through */
 416       case 39 : /* fall through */
 417       case 55 :
 418         entire_insn = entire_insn >> 16;
 419         itype = SH2_INSN_MULL_COMPACT; sh2_extract_sfmt_mull_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 420       case 8 :
 421         entire_insn = entire_insn >> 16;
 422         if ((entire_insn & 0xffff) == 0x8)
 423           { itype = SH2_INSN_CLRT_COMPACT; sh2_extract_sfmt_clrt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 424         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 425       case 9 :
 426         entire_insn = entire_insn >> 16;
 427         if ((entire_insn & 0xffff) == 0x9)
 428           { itype = SH2_INSN_NOP_COMPACT; sh2_extract_sfmt_nop_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 429         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 430       case 10 :
 431         entire_insn = entire_insn >> 16;
 432         if ((entire_insn & 0xf0ff) == 0xa)
 433           { itype = SH2_INSN_STS_MACH_COMPACT; sh2_extract_sfmt_sts_mach_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 434         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 435       case 11 :
 436         entire_insn = entire_insn >> 16;
 437         if ((entire_insn & 0xffff) == 0xb)
 438           { itype = SH2_INSN_RTS_COMPACT; sh2_extract_sfmt_rts_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 439         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 440       case 12 : /* fall through */
 441       case 28 : /* fall through */
 442       case 44 : /* fall through */
 443       case 60 :
 444         entire_insn = entire_insn >> 16;
 445         itype = SH2_INSN_MOVB8_COMPACT; sh2_extract_sfmt_movb8_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 446       case 13 : /* fall through */
 447       case 29 : /* fall through */
 448       case 45 : /* fall through */
 449       case 61 :
 450         entire_insn = entire_insn >> 16;
 451         itype = SH2_INSN_MOVW8_COMPACT; sh2_extract_sfmt_movw8_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 452       case 14 : /* fall through */
 453       case 30 : /* fall through */
 454       case 46 : /* fall through */
 455       case 62 :
 456         entire_insn = entire_insn >> 16;
 457         itype = SH2_INSN_MOVL8_COMPACT; sh2_extract_sfmt_movl8_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 458       case 15 : /* fall through */
 459       case 31 : /* fall through */
 460       case 47 : /* fall through */
 461       case 63 :
 462         entire_insn = entire_insn >> 16;
 463         itype = SH2_INSN_MACL_COMPACT; sh2_extract_sfmt_macl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 464       case 18 :
 465         entire_insn = entire_insn >> 16;
 466         if ((entire_insn & 0xf0ff) == 0x12)
 467           { itype = SH2_INSN_STC_GBR_COMPACT; sh2_extract_sfmt_stc_gbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 468         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 469       case 24 :
 470         entire_insn = entire_insn >> 16;
 471         if ((entire_insn & 0xffff) == 0x18)
 472           { itype = SH2_INSN_SETT_COMPACT; sh2_extract_sfmt_clrt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 473         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 474       case 25 :
 475         entire_insn = entire_insn >> 16;
 476         if ((entire_insn & 0xffff) == 0x19)
 477           { itype = SH2_INSN_DIV0U_COMPACT; sh2_extract_sfmt_div0u_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 478         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 479       case 26 :
 480         entire_insn = entire_insn >> 16;
 481         if ((entire_insn & 0xf0ff) == 0x1a)
 482           { itype = SH2_INSN_STS_MACL_COMPACT; sh2_extract_sfmt_sts_macl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 483         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 484       case 34 :
 485         entire_insn = entire_insn >> 16;
 486         if ((entire_insn & 0xf0ff) == 0x22)
 487           { itype = SH2_INSN_STC_VBR_COMPACT; sh2_extract_sfmt_stc_vbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 488         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 489       case 35 :
 490         entire_insn = entire_insn >> 16;
 491         if ((entire_insn & 0xf0ff) == 0x23)
 492           { itype = SH2_INSN_BRAF_COMPACT; sh2_extract_sfmt_braf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 493         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 494       case 40 :
 495         entire_insn = entire_insn >> 16;
 496         if ((entire_insn & 0xffff) == 0x28)
 497           { itype = SH2_INSN_CLRMAC_COMPACT; sh2_extract_sfmt_clrmac_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 498         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 499       case 41 :
 500         entire_insn = entire_insn >> 16;
 501         if ((entire_insn & 0xf0ff) == 0x29)
 502           { itype = SH2_INSN_MOVT_COMPACT; sh2_extract_sfmt_movt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 503         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 504       case 42 :
 505         entire_insn = entire_insn >> 16;
 506         if ((entire_insn & 0xf0ff) == 0x2a)
 507           { itype = SH2_INSN_STS_PR_COMPACT; sh2_extract_sfmt_sts_pr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 508         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 509       case 64 : /* fall through */
 510       case 65 : /* fall through */
 511       case 66 : /* fall through */
 512       case 67 : /* fall through */
 513       case 68 : /* fall through */
 514       case 69 : /* fall through */
 515       case 70 : /* fall through */
 516       case 71 : /* fall through */
 517       case 72 : /* fall through */
 518       case 73 : /* fall through */
 519       case 74 : /* fall through */
 520       case 75 : /* fall through */
 521       case 76 : /* fall through */
 522       case 77 : /* fall through */
 523       case 78 : /* fall through */
 524       case 79 : /* fall through */
 525       case 80 : /* fall through */
 526       case 81 : /* fall through */
 527       case 82 : /* fall through */
 528       case 83 : /* fall through */
 529       case 84 : /* fall through */
 530       case 85 : /* fall through */
 531       case 86 : /* fall through */
 532       case 87 : /* fall through */
 533       case 88 : /* fall through */
 534       case 89 : /* fall through */
 535       case 90 : /* fall through */
 536       case 91 : /* fall through */
 537       case 92 : /* fall through */
 538       case 93 : /* fall through */
 539       case 94 : /* fall through */
 540       case 95 : /* fall through */
 541       case 96 : /* fall through */
 542       case 97 : /* fall through */
 543       case 98 : /* fall through */
 544       case 99 : /* fall through */
 545       case 100 : /* fall through */
 546       case 101 : /* fall through */
 547       case 102 : /* fall through */
 548       case 103 : /* fall through */
 549       case 104 : /* fall through */
 550       case 105 : /* fall through */
 551       case 106 : /* fall through */
 552       case 107 : /* fall through */
 553       case 108 : /* fall through */
 554       case 109 : /* fall through */
 555       case 110 : /* fall through */
 556       case 111 : /* fall through */
 557       case 112 : /* fall through */
 558       case 113 : /* fall through */
 559       case 114 : /* fall through */
 560       case 115 : /* fall through */
 561       case 116 : /* fall through */
 562       case 117 : /* fall through */
 563       case 118 : /* fall through */
 564       case 119 : /* fall through */
 565       case 120 : /* fall through */
 566       case 121 : /* fall through */
 567       case 122 : /* fall through */
 568       case 123 : /* fall through */
 569       case 124 : /* fall through */
 570       case 125 : /* fall through */
 571       case 126 : /* fall through */
 572       case 127 :
 573         entire_insn = entire_insn >> 16;
 574         itype = SH2_INSN_MOVL5_COMPACT; sh2_extract_sfmt_movl5_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 575       case 128 : /* fall through */
 576       case 144 : /* fall through */
 577       case 160 : /* fall through */
 578       case 176 :
 579         entire_insn = entire_insn >> 16;
 580         itype = SH2_INSN_MOVB1_COMPACT; sh2_extract_sfmt_movb1_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 581       case 129 : /* fall through */
 582       case 145 : /* fall through */
 583       case 161 : /* fall through */
 584       case 177 :
 585         entire_insn = entire_insn >> 16;
 586         itype = SH2_INSN_MOVW1_COMPACT; sh2_extract_sfmt_movw1_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 587       case 130 : /* fall through */
 588       case 146 : /* fall through */
 589       case 162 : /* fall through */
 590       case 178 :
 591         entire_insn = entire_insn >> 16;
 592         itype = SH2_INSN_MOVL1_COMPACT; sh2_extract_sfmt_movl1_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 593       case 132 : /* fall through */
 594       case 148 : /* fall through */
 595       case 164 : /* fall through */
 596       case 180 :
 597         entire_insn = entire_insn >> 16;
 598         itype = SH2_INSN_MOVB2_COMPACT; sh2_extract_sfmt_movb2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 599       case 133 : /* fall through */
 600       case 149 : /* fall through */
 601       case 165 : /* fall through */
 602       case 181 :
 603         entire_insn = entire_insn >> 16;
 604         itype = SH2_INSN_MOVW2_COMPACT; sh2_extract_sfmt_movw2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 605       case 134 : /* fall through */
 606       case 150 : /* fall through */
 607       case 166 : /* fall through */
 608       case 182 :
 609         entire_insn = entire_insn >> 16;
 610         itype = SH2_INSN_MOVL2_COMPACT; sh2_extract_sfmt_movl2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 611       case 135 : /* fall through */
 612       case 151 : /* fall through */
 613       case 167 : /* fall through */
 614       case 183 :
 615         entire_insn = entire_insn >> 16;
 616         itype = SH2_INSN_DIV0S_COMPACT; sh2_extract_sfmt_div0s_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 617       case 136 : /* fall through */
 618       case 152 : /* fall through */
 619       case 168 : /* fall through */
 620       case 184 :
 621         entire_insn = entire_insn >> 16;
 622         itype = SH2_INSN_TST_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 623       case 137 : /* fall through */
 624       case 153 : /* fall through */
 625       case 169 : /* fall through */
 626       case 185 :
 627         entire_insn = entire_insn >> 16;
 628         itype = SH2_INSN_AND_COMPACT; sh2_extract_sfmt_and_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 629       case 138 : /* fall through */
 630       case 154 : /* fall through */
 631       case 170 : /* fall through */
 632       case 186 :
 633         entire_insn = entire_insn >> 16;
 634         itype = SH2_INSN_XOR_COMPACT; sh2_extract_sfmt_and_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 635       case 139 : /* fall through */
 636       case 155 : /* fall through */
 637       case 171 : /* fall through */
 638       case 187 :
 639         entire_insn = entire_insn >> 16;
 640         itype = SH2_INSN_OR_COMPACT; sh2_extract_sfmt_and_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 641       case 140 : /* fall through */
 642       case 156 : /* fall through */
 643       case 172 : /* fall through */
 644       case 188 :
 645         entire_insn = entire_insn >> 16;
 646         itype = SH2_INSN_CMPSTR_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 647       case 141 : /* fall through */
 648       case 157 : /* fall through */
 649       case 173 : /* fall through */
 650       case 189 :
 651         entire_insn = entire_insn >> 16;
 652         itype = SH2_INSN_XTRCT_COMPACT; sh2_extract_sfmt_add_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 653       case 142 : /* fall through */
 654       case 158 : /* fall through */
 655       case 174 : /* fall through */
 656       case 190 :
 657         entire_insn = entire_insn >> 16;
 658         itype = SH2_INSN_MULUW_COMPACT; sh2_extract_sfmt_mull_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 659       case 143 : /* fall through */
 660       case 159 : /* fall through */
 661       case 175 : /* fall through */
 662       case 191 :
 663         entire_insn = entire_insn >> 16;
 664         itype = SH2_INSN_MULSW_COMPACT; sh2_extract_sfmt_mull_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 665       case 192 : /* fall through */
 666       case 208 : /* fall through */
 667       case 224 : /* fall through */
 668       case 240 :
 669         entire_insn = entire_insn >> 16;
 670         itype = SH2_INSN_CMPEQ_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 671       case 194 : /* fall through */
 672       case 210 : /* fall through */
 673       case 226 : /* fall through */
 674       case 242 :
 675         entire_insn = entire_insn >> 16;
 676         itype = SH2_INSN_CMPHS_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 677       case 195 : /* fall through */
 678       case 211 : /* fall through */
 679       case 227 : /* fall through */
 680       case 243 :
 681         entire_insn = entire_insn >> 16;
 682         itype = SH2_INSN_CMPGE_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 683       case 196 : /* fall through */
 684       case 212 : /* fall through */
 685       case 228 : /* fall through */
 686       case 244 :
 687         entire_insn = entire_insn >> 16;
 688         itype = SH2_INSN_DIV1_COMPACT; sh2_extract_sfmt_div1_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 689       case 197 : /* fall through */
 690       case 213 : /* fall through */
 691       case 229 : /* fall through */
 692       case 245 :
 693         entire_insn = entire_insn >> 16;
 694         itype = SH2_INSN_DMULUL_COMPACT; sh2_extract_sfmt_dmulsl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 695       case 198 : /* fall through */
 696       case 214 : /* fall through */
 697       case 230 : /* fall through */
 698       case 246 :
 699         entire_insn = entire_insn >> 16;
 700         itype = SH2_INSN_CMPHI_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 701       case 199 : /* fall through */
 702       case 215 : /* fall through */
 703       case 231 : /* fall through */
 704       case 247 :
 705         entire_insn = entire_insn >> 16;
 706         itype = SH2_INSN_CMPGT_COMPACT; sh2_extract_sfmt_cmpeq_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 707       case 200 : /* fall through */
 708       case 216 : /* fall through */
 709       case 232 : /* fall through */
 710       case 248 :
 711         entire_insn = entire_insn >> 16;
 712         itype = SH2_INSN_SUB_COMPACT; sh2_extract_sfmt_add_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 713       case 202 : /* fall through */
 714       case 218 : /* fall through */
 715       case 234 : /* fall through */
 716       case 250 :
 717         entire_insn = entire_insn >> 16;
 718         itype = SH2_INSN_SUBC_COMPACT; sh2_extract_sfmt_addc_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 719       case 203 : /* fall through */
 720       case 219 : /* fall through */
 721       case 235 : /* fall through */
 722       case 251 :
 723         entire_insn = entire_insn >> 16;
 724         itype = SH2_INSN_SUBV_COMPACT; sh2_extract_sfmt_addv_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 725       case 204 : /* fall through */
 726       case 220 : /* fall through */
 727       case 236 : /* fall through */
 728       case 252 :
 729         entire_insn = entire_insn >> 16;
 730         itype = SH2_INSN_ADD_COMPACT; sh2_extract_sfmt_add_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 731       case 205 : /* fall through */
 732       case 221 : /* fall through */
 733       case 237 : /* fall through */
 734       case 253 :
 735         entire_insn = entire_insn >> 16;
 736         itype = SH2_INSN_DMULSL_COMPACT; sh2_extract_sfmt_dmulsl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 737       case 206 : /* fall through */
 738       case 222 : /* fall through */
 739       case 238 : /* fall through */
 740       case 254 :
 741         entire_insn = entire_insn >> 16;
 742         itype = SH2_INSN_ADDC_COMPACT; sh2_extract_sfmt_addc_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 743       case 207 : /* fall through */
 744       case 223 : /* fall through */
 745       case 239 : /* fall through */
 746       case 255 :
 747         entire_insn = entire_insn >> 16;
 748         itype = SH2_INSN_ADDV_COMPACT; sh2_extract_sfmt_addv_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 749       case 256 :
 750         entire_insn = entire_insn >> 16;
 751         if ((entire_insn & 0xf0ff) == 0x4000)
 752           { itype = SH2_INSN_SHLL_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 753         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 754       case 257 :
 755         entire_insn = entire_insn >> 16;
 756         if ((entire_insn & 0xf0ff) == 0x4001)
 757           { itype = SH2_INSN_SHLR_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 758         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 759       case 258 :
 760         entire_insn = entire_insn >> 16;
 761         if ((entire_insn & 0xf0ff) == 0x4002)
 762           { itype = SH2_INSN_STSL_MACH_COMPACT; sh2_extract_sfmt_stsl_mach_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 763         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 764       case 260 :
 765         entire_insn = entire_insn >> 16;
 766         if ((entire_insn & 0xf0ff) == 0x4004)
 767           { itype = SH2_INSN_ROTL_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 768         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 769       case 261 :
 770         entire_insn = entire_insn >> 16;
 771         if ((entire_insn & 0xf0ff) == 0x4005)
 772           { itype = SH2_INSN_ROTR_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 773         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 774       case 262 :
 775         entire_insn = entire_insn >> 16;
 776         if ((entire_insn & 0xf0ff) == 0x4006)
 777           { itype = SH2_INSN_LDSL_MACH_COMPACT; sh2_extract_sfmt_ldsl_mach_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 778         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 779       case 264 :
 780         entire_insn = entire_insn >> 16;
 781         if ((entire_insn & 0xf0ff) == 0x4008)
 782           { itype = SH2_INSN_SHLL2_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 783         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 784       case 265 :
 785         entire_insn = entire_insn >> 16;
 786         if ((entire_insn & 0xf0ff) == 0x4009)
 787           { itype = SH2_INSN_SHLR2_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 788         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 789       case 266 :
 790         entire_insn = entire_insn >> 16;
 791         if ((entire_insn & 0xf0ff) == 0x400a)
 792           { itype = SH2_INSN_LDS_MACH_COMPACT; sh2_extract_sfmt_lds_mach_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 793         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 794       case 267 :
 795         entire_insn = entire_insn >> 16;
 796         if ((entire_insn & 0xf0ff) == 0x400b)
 797           { itype = SH2_INSN_JSR_COMPACT; sh2_extract_sfmt_bsrf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 798         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 799       case 270 :
 800         entire_insn = entire_insn >> 16;
 801         if ((entire_insn & 0xf0ff) == 0x400e)
 802           { itype = SH2_INSN_LDC_SR_COMPACT; sh2_extract_sfmt_ldc_sr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 803         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 804       case 271 : /* fall through */
 805       case 287 : /* fall through */
 806       case 303 : /* fall through */
 807       case 319 :
 808         entire_insn = entire_insn >> 16;
 809         itype = SH2_INSN_MACW_COMPACT; sh2_extract_sfmt_macw_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
 810       case 272 :
 811         entire_insn = entire_insn >> 16;
 812         if ((entire_insn & 0xf0ff) == 0x4010)
 813           { itype = SH2_INSN_DT_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 814         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 815       case 273 :
 816         entire_insn = entire_insn >> 16;
 817         if ((entire_insn & 0xf0ff) == 0x4011)
 818           { itype = SH2_INSN_CMPPZ_COMPACT; sh2_extract_sfmt_cmppl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 819         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 820       case 274 :
 821         entire_insn = entire_insn >> 16;
 822         if ((entire_insn & 0xf0ff) == 0x4012)
 823           { itype = SH2_INSN_STSL_MACL_COMPACT; sh2_extract_sfmt_stsl_macl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 824         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 825       case 275 :
 826         entire_insn = entire_insn >> 16;
 827         if ((entire_insn & 0xf0ff) == 0x4013)
 828           { itype = SH2_INSN_STCL_GBR_COMPACT; sh2_extract_sfmt_stcl_gbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 829         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 830       case 277 :
 831         entire_insn = entire_insn >> 16;
 832         if ((entire_insn & 0xf0ff) == 0x4015)
 833           { itype = SH2_INSN_CMPPL_COMPACT; sh2_extract_sfmt_cmppl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 834         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 835       case 278 :
 836         entire_insn = entire_insn >> 16;
 837         if ((entire_insn & 0xf0ff) == 0x4016)
 838           { itype = SH2_INSN_LDSL_MACL_COMPACT; sh2_extract_sfmt_ldsl_macl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 839         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 840       case 279 :
 841         entire_insn = entire_insn >> 16;
 842         if ((entire_insn & 0xf0ff) == 0x4017)
 843           { itype = SH2_INSN_LDCL_GBR_COMPACT; sh2_extract_sfmt_ldcl_gbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 844         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 845       case 280 :
 846         entire_insn = entire_insn >> 16;
 847         if ((entire_insn & 0xf0ff) == 0x4018)
 848           { itype = SH2_INSN_SHLL8_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 849         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 850       case 281 :
 851         entire_insn = entire_insn >> 16;
 852         if ((entire_insn & 0xf0ff) == 0x4019)
 853           { itype = SH2_INSN_SHLR8_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 854         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 855       case 282 :
 856         entire_insn = entire_insn >> 16;
 857         if ((entire_insn & 0xf0ff) == 0x401a)
 858           { itype = SH2_INSN_LDS_MACL_COMPACT; sh2_extract_sfmt_lds_macl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 859         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 860       case 283 :
 861         entire_insn = entire_insn >> 16;
 862         if ((entire_insn & 0xf0ff) == 0x401b)
 863           { itype = SH2_INSN_TASB_COMPACT; sh2_extract_sfmt_tasb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 864         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 865       case 286 :
 866         entire_insn = entire_insn >> 16;
 867         if ((entire_insn & 0xf0ff) == 0x401e)
 868           { itype = SH2_INSN_LDC_GBR_COMPACT; sh2_extract_sfmt_ldc_gbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 869         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 870       case 288 :
 871         entire_insn = entire_insn >> 16;
 872         if ((entire_insn & 0xf0ff) == 0x4020)
 873           { itype = SH2_INSN_SHAL_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 874         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 875       case 289 :
 876         entire_insn = entire_insn >> 16;
 877         if ((entire_insn & 0xf0ff) == 0x4021)
 878           { itype = SH2_INSN_SHAR_COMPACT; sh2_extract_sfmt_dt_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 879         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 880       case 290 :
 881         entire_insn = entire_insn >> 16;
 882         if ((entire_insn & 0xf0ff) == 0x4022)
 883           { itype = SH2_INSN_STSL_PR_COMPACT; sh2_extract_sfmt_stsl_pr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 884         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 885       case 291 :
 886         entire_insn = entire_insn >> 16;
 887         if ((entire_insn & 0xf0ff) == 0x4023)
 888           { itype = SH2_INSN_STCL_VBR_COMPACT; sh2_extract_sfmt_stcl_vbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 889         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 890       case 292 :
 891         entire_insn = entire_insn >> 16;
 892         if ((entire_insn & 0xf0ff) == 0x4024)
 893           { itype = SH2_INSN_ROTCL_COMPACT; sh2_extract_sfmt_rotcl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 894         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 895       case 293 :
 896         entire_insn = entire_insn >> 16;
 897         if ((entire_insn & 0xf0ff) == 0x4025)
 898           { itype = SH2_INSN_ROTCR_COMPACT; sh2_extract_sfmt_rotcl_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 899         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 900       case 294 :
 901         entire_insn = entire_insn >> 16;
 902         if ((entire_insn & 0xf0ff) == 0x4026)
 903           { itype = SH2_INSN_LDSL_PR_COMPACT; sh2_extract_sfmt_ldsl_pr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 904         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 905       case 295 :
 906         entire_insn = entire_insn >> 16;
 907         if ((entire_insn & 0xf0ff) == 0x4027)
 908           { itype = SH2_INSN_LDCL_VBR_COMPACT; sh2_extract_sfmt_ldcl_vbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 909         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 910       case 296 :
 911         entire_insn = entire_insn >> 16;
 912         if ((entire_insn & 0xf0ff) == 0x4028)
 913           { itype = SH2_INSN_SHLL16_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 914         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 915       case 297 :
 916         entire_insn = entire_insn >> 16;
 917         if ((entire_insn & 0xf0ff) == 0x4029)
 918           { itype = SH2_INSN_SHLR16_COMPACT; sh2_extract_sfmt_shll2_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 919         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 920       case 298 :
 921         entire_insn = entire_insn >> 16;
 922         if ((entire_insn & 0xf0ff) == 0x402a)
 923           { itype = SH2_INSN_LDS_PR_COMPACT; sh2_extract_sfmt_lds_pr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 924         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 925       case 299 :
 926         entire_insn = entire_insn >> 16;
 927         if ((entire_insn & 0xf0ff) == 0x402b)
 928           { itype = SH2_INSN_JMP_COMPACT; sh2_extract_sfmt_braf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 929         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 930       case 302 :
 931         entire_insn = entire_insn >> 16;
 932         if ((entire_insn & 0xf0ff) == 0x402e)
 933           { itype = SH2_INSN_LDC_VBR_COMPACT; sh2_extract_sfmt_ldc_vbr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 934         itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 935       case 320 : /* fall through */
 936       case 321 : /* fall through */
 937       case 322 : /* fall through */
 938       case 323 : /* fall through */
 939       case 324 : /* fall through */
 940       case 325 : /* fall through */
 941       case 326 : /* fall through */
 942       case 327 : /* fall through */
 943       case 328 : /* fall through */
 944       case 329 : /* fall through */
 945       case 330 : /* fall through */
 946       case 331 : /* fall through */
 947       case 332 : /* fall through */
 948       case 333 : /* fall through */
 949       case 334 : /* fall through */
 950       case 335 : /* fall through */
 951       case 336 : /* fall through */
 952       case 337 : /* fall through */
 953       case 338 : /* fall through */
 954       case 339 : /* fall through */
 955       case 340 : /* fall through */
 956       case 341 : /* fall through */
 957       case 342 : /* fall through */
 958       case 343 : /* fall through */
 959       case 344 : /* fall through */
 960       case 345 : /* fall through */
 961       case 346 : /* fall through */
 962       case 347 : /* fall through */
 963       case 348 : /* fall through */
 964       case 349 : /* fall through */
 965       case 350 : /* fall through */
 966       case 351 : /* fall through */
 967       case 352 : /* fall through */
 968       case 353 : /* fall through */
 969       case 354 : /* fall through */
 970       case 355 : /* fall through */
 971       case 356 : /* fall through */
 972       case 357 : /* fall through */
 973       case 358 : /* fall through */
 974       case 359 : /* fall through */
 975       case 360 : /* fall through */
 976       case 361 : /* fall through */
 977       case 362 : /* fall through */
 978       case 363 : /* fall through */
 979       case 364 : /* fall through */
 980       case 365 : /* fall through */
 981       case 366 : /* fall through */
 982       case 367 : /* fall through */
 983       case 368 : /* fall through */
 984       case 369 : /* fall through */
 985       case 370 : /* fall through */
 986       case 371 : /* fall through */
 987       case 372 : /* fall through */
 988       case 373 : /* fall through */
 989       case 374 : /* fall through */
 990       case 375 : /* fall through */
 991       case 376 : /* fall through */
 992       case 377 : /* fall through */
 993       case 378 : /* fall through */
 994       case 379 : /* fall through */
 995       case 380 : /* fall through */
 996       case 381 : /* fall through */
 997       case 382 : /* fall through */
 998       case 383 :
 999         entire_insn = entire_insn >> 16;
1000         itype = SH2_INSN_MOVL11_COMPACT; sh2_extract_sfmt_movl11_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1001       case 384 : /* fall through */
1002       case 400 : /* fall through */
1003       case 416 : /* fall through */
1004       case 432 :
1005         entire_insn = entire_insn >> 16;
1006         itype = SH2_INSN_MOVB6_COMPACT; sh2_extract_sfmt_movb6_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1007       case 385 : /* fall through */
1008       case 401 : /* fall through */
1009       case 417 : /* fall through */
1010       case 433 :
1011         entire_insn = entire_insn >> 16;
1012         itype = SH2_INSN_MOVW6_COMPACT; sh2_extract_sfmt_movw6_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1013       case 386 : /* fall through */
1014       case 402 : /* fall through */
1015       case 418 : /* fall through */
1016       case 434 :
1017         entire_insn = entire_insn >> 16;
1018         itype = SH2_INSN_MOVL6_COMPACT; sh2_extract_sfmt_movl6_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1019       case 387 : /* fall through */
1020       case 403 : /* fall through */
1021       case 419 : /* fall through */
1022       case 435 :
1023         entire_insn = entire_insn >> 16;
1024         itype = SH2_INSN_MOV_COMPACT; sh2_extract_sfmt_mov_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1025       case 388 : /* fall through */
1026       case 404 : /* fall through */
1027       case 420 : /* fall through */
1028       case 436 :
1029         entire_insn = entire_insn >> 16;
1030         itype = SH2_INSN_MOVB7_COMPACT; sh2_extract_sfmt_movb7_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1031       case 389 : /* fall through */
1032       case 405 : /* fall through */
1033       case 421 : /* fall through */
1034       case 437 :
1035         entire_insn = entire_insn >> 16;
1036         itype = SH2_INSN_MOVW7_COMPACT; sh2_extract_sfmt_movw7_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1037       case 390 : /* fall through */
1038       case 406 : /* fall through */
1039       case 422 : /* fall through */
1040       case 438 :
1041         entire_insn = entire_insn >> 16;
1042         itype = SH2_INSN_MOVL7_COMPACT; sh2_extract_sfmt_movl7_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1043       case 391 : /* fall through */
1044       case 407 : /* fall through */
1045       case 423 : /* fall through */
1046       case 439 :
1047         entire_insn = entire_insn >> 16;
1048         itype = SH2_INSN_NOT_COMPACT; sh2_extract_sfmt_mov_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1049       case 392 : /* fall through */
1050       case 408 : /* fall through */
1051       case 424 : /* fall through */
1052       case 440 :
1053         entire_insn = entire_insn >> 16;
1054         itype = SH2_INSN_SWAPB_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1055       case 393 : /* fall through */
1056       case 409 : /* fall through */
1057       case 425 : /* fall through */
1058       case 441 :
1059         entire_insn = entire_insn >> 16;
1060         itype = SH2_INSN_SWAPW_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1061       case 394 : /* fall through */
1062       case 410 : /* fall through */
1063       case 426 : /* fall through */
1064       case 442 :
1065         entire_insn = entire_insn >> 16;
1066         itype = SH2_INSN_NEGC_COMPACT; sh2_extract_sfmt_negc_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1067       case 395 : /* fall through */
1068       case 411 : /* fall through */
1069       case 427 : /* fall through */
1070       case 443 :
1071         entire_insn = entire_insn >> 16;
1072         itype = SH2_INSN_NEG_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1073       case 396 : /* fall through */
1074       case 412 : /* fall through */
1075       case 428 : /* fall through */
1076       case 444 :
1077         entire_insn = entire_insn >> 16;
1078         itype = SH2_INSN_EXTUB_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1079       case 397 : /* fall through */
1080       case 413 : /* fall through */
1081       case 429 : /* fall through */
1082       case 445 :
1083         entire_insn = entire_insn >> 16;
1084         itype = SH2_INSN_EXTUW_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1085       case 398 : /* fall through */
1086       case 414 : /* fall through */
1087       case 430 : /* fall through */
1088       case 446 :
1089         entire_insn = entire_insn >> 16;
1090         itype = SH2_INSN_EXTSB_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1091       case 399 : /* fall through */
1092       case 415 : /* fall through */
1093       case 431 : /* fall through */
1094       case 447 :
1095         entire_insn = entire_insn >> 16;
1096         itype = SH2_INSN_EXTSW_COMPACT; sh2_extract_sfmt_extsb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1097       case 448 : /* fall through */
1098       case 449 : /* fall through */
1099       case 450 : /* fall through */
1100       case 451 : /* fall through */
1101       case 452 : /* fall through */
1102       case 453 : /* fall through */
1103       case 454 : /* fall through */
1104       case 455 : /* fall through */
1105       case 456 : /* fall through */
1106       case 457 : /* fall through */
1107       case 458 : /* fall through */
1108       case 459 : /* fall through */
1109       case 460 : /* fall through */
1110       case 461 : /* fall through */
1111       case 462 : /* fall through */
1112       case 463 : /* fall through */
1113       case 464 : /* fall through */
1114       case 465 : /* fall through */
1115       case 466 : /* fall through */
1116       case 467 : /* fall through */
1117       case 468 : /* fall through */
1118       case 469 : /* fall through */
1119       case 470 : /* fall through */
1120       case 471 : /* fall through */
1121       case 472 : /* fall through */
1122       case 473 : /* fall through */
1123       case 474 : /* fall through */
1124       case 475 : /* fall through */
1125       case 476 : /* fall through */
1126       case 477 : /* fall through */
1127       case 478 : /* fall through */
1128       case 479 : /* fall through */
1129       case 480 : /* fall through */
1130       case 481 : /* fall through */
1131       case 482 : /* fall through */
1132       case 483 : /* fall through */
1133       case 484 : /* fall through */
1134       case 485 : /* fall through */
1135       case 486 : /* fall through */
1136       case 487 : /* fall through */
1137       case 488 : /* fall through */
1138       case 489 : /* fall through */
1139       case 490 : /* fall through */
1140       case 491 : /* fall through */
1141       case 492 : /* fall through */
1142       case 493 : /* fall through */
1143       case 494 : /* fall through */
1144       case 495 : /* fall through */
1145       case 496 : /* fall through */
1146       case 497 : /* fall through */
1147       case 498 : /* fall through */
1148       case 499 : /* fall through */
1149       case 500 : /* fall through */
1150       case 501 : /* fall through */
1151       case 502 : /* fall through */
1152       case 503 : /* fall through */
1153       case 504 : /* fall through */
1154       case 505 : /* fall through */
1155       case 506 : /* fall through */
1156       case 507 : /* fall through */
1157       case 508 : /* fall through */
1158       case 509 : /* fall through */
1159       case 510 : /* fall through */
1160       case 511 :
1161         entire_insn = entire_insn >> 16;
1162         itype = SH2_INSN_ADDI_COMPACT; sh2_extract_sfmt_addi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1163       case 512 : /* fall through */
1164       case 513 : /* fall through */
1165       case 514 : /* fall through */
1166       case 515 : /* fall through */
1167       case 516 : /* fall through */
1168       case 517 : /* fall through */
1169       case 518 : /* fall through */
1170       case 519 : /* fall through */
1171       case 520 : /* fall through */
1172       case 521 : /* fall through */
1173       case 522 : /* fall through */
1174       case 523 : /* fall through */
1175       case 524 : /* fall through */
1176       case 525 : /* fall through */
1177       case 526 : /* fall through */
1178       case 527 : /* fall through */
1179       case 528 : /* fall through */
1180       case 529 : /* fall through */
1181       case 530 : /* fall through */
1182       case 531 : /* fall through */
1183       case 532 : /* fall through */
1184       case 533 : /* fall through */
1185       case 534 : /* fall through */
1186       case 535 : /* fall through */
1187       case 536 : /* fall through */
1188       case 537 : /* fall through */
1189       case 538 : /* fall through */
1190       case 539 : /* fall through */
1191       case 540 : /* fall through */
1192       case 541 : /* fall through */
1193       case 542 : /* fall through */
1194       case 543 : /* fall through */
1195       case 544 : /* fall through */
1196       case 545 : /* fall through */
1197       case 546 : /* fall through */
1198       case 547 : /* fall through */
1199       case 548 : /* fall through */
1200       case 549 : /* fall through */
1201       case 550 : /* fall through */
1202       case 551 : /* fall through */
1203       case 552 : /* fall through */
1204       case 553 : /* fall through */
1205       case 554 : /* fall through */
1206       case 555 : /* fall through */
1207       case 556 : /* fall through */
1208       case 557 : /* fall through */
1209       case 558 : /* fall through */
1210       case 559 : /* fall through */
1211       case 560 : /* fall through */
1212       case 561 : /* fall through */
1213       case 562 : /* fall through */
1214       case 563 : /* fall through */
1215       case 564 : /* fall through */
1216       case 565 : /* fall through */
1217       case 566 : /* fall through */
1218       case 567 : /* fall through */
1219       case 568 : /* fall through */
1220       case 569 : /* fall through */
1221       case 570 : /* fall through */
1222       case 571 : /* fall through */
1223       case 572 : /* fall through */
1224       case 573 : /* fall through */
1225       case 574 : /* fall through */
1226       case 575 :
1227         {
1228           unsigned int val = (((insn >> 24) & (15 << 0)));
1229           switch (val)
1230           {
1231           case 0 :
1232             entire_insn = entire_insn >> 16;
1233             itype = SH2_INSN_MOVB5_COMPACT; sh2_extract_sfmt_movb5_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1234           case 1 :
1235             entire_insn = entire_insn >> 16;
1236             itype = SH2_INSN_MOVW5_COMPACT; sh2_extract_sfmt_movw5_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1237           case 4 :
1238             entire_insn = entire_insn >> 16;
1239             itype = SH2_INSN_MOVB10_COMPACT; sh2_extract_sfmt_movb10_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1240           case 5 :
1241             entire_insn = entire_insn >> 16;
1242             itype = SH2_INSN_MOVW11_COMPACT; sh2_extract_sfmt_movw11_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1243           case 8 :
1244             entire_insn = entire_insn >> 16;
1245             itype = SH2_INSN_CMPEQI_COMPACT; sh2_extract_sfmt_cmpeqi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1246           case 9 :
1247             entire_insn = entire_insn >> 16;
1248             itype = SH2_INSN_BT_COMPACT; sh2_extract_sfmt_bf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1249           case 11 :
1250             entire_insn = entire_insn >> 16;
1251             itype = SH2_INSN_BF_COMPACT; sh2_extract_sfmt_bf_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1252           case 13 :
1253             entire_insn = entire_insn >> 16;
1254             itype = SH2_INSN_BTS_COMPACT; sh2_extract_sfmt_bfs_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1255           case 15 :
1256             entire_insn = entire_insn >> 16;
1257             itype = SH2_INSN_BFS_COMPACT; sh2_extract_sfmt_bfs_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1258           default : itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1259           }
1260         }
1261       case 576 : /* fall through */
1262       case 577 : /* fall through */
1263       case 578 : /* fall through */
1264       case 579 : /* fall through */
1265       case 580 : /* fall through */
1266       case 581 : /* fall through */
1267       case 582 : /* fall through */
1268       case 583 : /* fall through */
1269       case 584 : /* fall through */
1270       case 585 : /* fall through */
1271       case 586 : /* fall through */
1272       case 587 : /* fall through */
1273       case 588 : /* fall through */
1274       case 589 : /* fall through */
1275       case 590 : /* fall through */
1276       case 591 : /* fall through */
1277       case 592 : /* fall through */
1278       case 593 : /* fall through */
1279       case 594 : /* fall through */
1280       case 595 : /* fall through */
1281       case 596 : /* fall through */
1282       case 597 : /* fall through */
1283       case 598 : /* fall through */
1284       case 599 : /* fall through */
1285       case 600 : /* fall through */
1286       case 601 : /* fall through */
1287       case 602 : /* fall through */
1288       case 603 : /* fall through */
1289       case 604 : /* fall through */
1290       case 605 : /* fall through */
1291       case 606 : /* fall through */
1292       case 607 : /* fall through */
1293       case 608 : /* fall through */
1294       case 609 : /* fall through */
1295       case 610 : /* fall through */
1296       case 611 : /* fall through */
1297       case 612 : /* fall through */
1298       case 613 : /* fall through */
1299       case 614 : /* fall through */
1300       case 615 : /* fall through */
1301       case 616 : /* fall through */
1302       case 617 : /* fall through */
1303       case 618 : /* fall through */
1304       case 619 : /* fall through */
1305       case 620 : /* fall through */
1306       case 621 : /* fall through */
1307       case 622 : /* fall through */
1308       case 623 : /* fall through */
1309       case 624 : /* fall through */
1310       case 625 : /* fall through */
1311       case 626 : /* fall through */
1312       case 627 : /* fall through */
1313       case 628 : /* fall through */
1314       case 629 : /* fall through */
1315       case 630 : /* fall through */
1316       case 631 : /* fall through */
1317       case 632 : /* fall through */
1318       case 633 : /* fall through */
1319       case 634 : /* fall through */
1320       case 635 : /* fall through */
1321       case 636 : /* fall through */
1322       case 637 : /* fall through */
1323       case 638 : /* fall through */
1324       case 639 :
1325         entire_insn = entire_insn >> 16;
1326         itype = SH2_INSN_MOVW10_COMPACT; sh2_extract_sfmt_movw10_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1327       case 640 : /* fall through */
1328       case 641 : /* fall through */
1329       case 642 : /* fall through */
1330       case 643 : /* fall through */
1331       case 644 : /* fall through */
1332       case 645 : /* fall through */
1333       case 646 : /* fall through */
1334       case 647 : /* fall through */
1335       case 648 : /* fall through */
1336       case 649 : /* fall through */
1337       case 650 : /* fall through */
1338       case 651 : /* fall through */
1339       case 652 : /* fall through */
1340       case 653 : /* fall through */
1341       case 654 : /* fall through */
1342       case 655 : /* fall through */
1343       case 656 : /* fall through */
1344       case 657 : /* fall through */
1345       case 658 : /* fall through */
1346       case 659 : /* fall through */
1347       case 660 : /* fall through */
1348       case 661 : /* fall through */
1349       case 662 : /* fall through */
1350       case 663 : /* fall through */
1351       case 664 : /* fall through */
1352       case 665 : /* fall through */
1353       case 666 : /* fall through */
1354       case 667 : /* fall through */
1355       case 668 : /* fall through */
1356       case 669 : /* fall through */
1357       case 670 : /* fall through */
1358       case 671 : /* fall through */
1359       case 672 : /* fall through */
1360       case 673 : /* fall through */
1361       case 674 : /* fall through */
1362       case 675 : /* fall through */
1363       case 676 : /* fall through */
1364       case 677 : /* fall through */
1365       case 678 : /* fall through */
1366       case 679 : /* fall through */
1367       case 680 : /* fall through */
1368       case 681 : /* fall through */
1369       case 682 : /* fall through */
1370       case 683 : /* fall through */
1371       case 684 : /* fall through */
1372       case 685 : /* fall through */
1373       case 686 : /* fall through */
1374       case 687 : /* fall through */
1375       case 688 : /* fall through */
1376       case 689 : /* fall through */
1377       case 690 : /* fall through */
1378       case 691 : /* fall through */
1379       case 692 : /* fall through */
1380       case 693 : /* fall through */
1381       case 694 : /* fall through */
1382       case 695 : /* fall through */
1383       case 696 : /* fall through */
1384       case 697 : /* fall through */
1385       case 698 : /* fall through */
1386       case 699 : /* fall through */
1387       case 700 : /* fall through */
1388       case 701 : /* fall through */
1389       case 702 : /* fall through */
1390       case 703 :
1391         entire_insn = entire_insn >> 16;
1392         itype = SH2_INSN_BRA_COMPACT; sh2_extract_sfmt_bra_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1393       case 704 : /* fall through */
1394       case 705 : /* fall through */
1395       case 706 : /* fall through */
1396       case 707 : /* fall through */
1397       case 708 : /* fall through */
1398       case 709 : /* fall through */
1399       case 710 : /* fall through */
1400       case 711 : /* fall through */
1401       case 712 : /* fall through */
1402       case 713 : /* fall through */
1403       case 714 : /* fall through */
1404       case 715 : /* fall through */
1405       case 716 : /* fall through */
1406       case 717 : /* fall through */
1407       case 718 : /* fall through */
1408       case 719 : /* fall through */
1409       case 720 : /* fall through */
1410       case 721 : /* fall through */
1411       case 722 : /* fall through */
1412       case 723 : /* fall through */
1413       case 724 : /* fall through */
1414       case 725 : /* fall through */
1415       case 726 : /* fall through */
1416       case 727 : /* fall through */
1417       case 728 : /* fall through */
1418       case 729 : /* fall through */
1419       case 730 : /* fall through */
1420       case 731 : /* fall through */
1421       case 732 : /* fall through */
1422       case 733 : /* fall through */
1423       case 734 : /* fall through */
1424       case 735 : /* fall through */
1425       case 736 : /* fall through */
1426       case 737 : /* fall through */
1427       case 738 : /* fall through */
1428       case 739 : /* fall through */
1429       case 740 : /* fall through */
1430       case 741 : /* fall through */
1431       case 742 : /* fall through */
1432       case 743 : /* fall through */
1433       case 744 : /* fall through */
1434       case 745 : /* fall through */
1435       case 746 : /* fall through */
1436       case 747 : /* fall through */
1437       case 748 : /* fall through */
1438       case 749 : /* fall through */
1439       case 750 : /* fall through */
1440       case 751 : /* fall through */
1441       case 752 : /* fall through */
1442       case 753 : /* fall through */
1443       case 754 : /* fall through */
1444       case 755 : /* fall through */
1445       case 756 : /* fall through */
1446       case 757 : /* fall through */
1447       case 758 : /* fall through */
1448       case 759 : /* fall through */
1449       case 760 : /* fall through */
1450       case 761 : /* fall through */
1451       case 762 : /* fall through */
1452       case 763 : /* fall through */
1453       case 764 : /* fall through */
1454       case 765 : /* fall through */
1455       case 766 : /* fall through */
1456       case 767 :
1457         entire_insn = entire_insn >> 16;
1458         itype = SH2_INSN_BSR_COMPACT; sh2_extract_sfmt_bsr_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1459       case 768 : /* fall through */
1460       case 769 : /* fall through */
1461       case 770 : /* fall through */
1462       case 771 : /* fall through */
1463       case 772 : /* fall through */
1464       case 773 : /* fall through */
1465       case 774 : /* fall through */
1466       case 775 : /* fall through */
1467       case 776 : /* fall through */
1468       case 777 : /* fall through */
1469       case 778 : /* fall through */
1470       case 779 : /* fall through */
1471       case 780 : /* fall through */
1472       case 781 : /* fall through */
1473       case 782 : /* fall through */
1474       case 783 : /* fall through */
1475       case 784 : /* fall through */
1476       case 785 : /* fall through */
1477       case 786 : /* fall through */
1478       case 787 : /* fall through */
1479       case 788 : /* fall through */
1480       case 789 : /* fall through */
1481       case 790 : /* fall through */
1482       case 791 : /* fall through */
1483       case 792 : /* fall through */
1484       case 793 : /* fall through */
1485       case 794 : /* fall through */
1486       case 795 : /* fall through */
1487       case 796 : /* fall through */
1488       case 797 : /* fall through */
1489       case 798 : /* fall through */
1490       case 799 : /* fall through */
1491       case 800 : /* fall through */
1492       case 801 : /* fall through */
1493       case 802 : /* fall through */
1494       case 803 : /* fall through */
1495       case 804 : /* fall through */
1496       case 805 : /* fall through */
1497       case 806 : /* fall through */
1498       case 807 : /* fall through */
1499       case 808 : /* fall through */
1500       case 809 : /* fall through */
1501       case 810 : /* fall through */
1502       case 811 : /* fall through */
1503       case 812 : /* fall through */
1504       case 813 : /* fall through */
1505       case 814 : /* fall through */
1506       case 815 : /* fall through */
1507       case 816 : /* fall through */
1508       case 817 : /* fall through */
1509       case 818 : /* fall through */
1510       case 819 : /* fall through */
1511       case 820 : /* fall through */
1512       case 821 : /* fall through */
1513       case 822 : /* fall through */
1514       case 823 : /* fall through */
1515       case 824 : /* fall through */
1516       case 825 : /* fall through */
1517       case 826 : /* fall through */
1518       case 827 : /* fall through */
1519       case 828 : /* fall through */
1520       case 829 : /* fall through */
1521       case 830 : /* fall through */
1522       case 831 :
1523         {
1524           unsigned int val = (((insn >> 24) & (15 << 0)));
1525           switch (val)
1526           {
1527           case 0 :
1528             entire_insn = entire_insn >> 16;
1529             itype = SH2_INSN_MOVB4_COMPACT; sh2_extract_sfmt_movb4_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1530           case 1 :
1531             entire_insn = entire_insn >> 16;
1532             itype = SH2_INSN_MOVW4_COMPACT; sh2_extract_sfmt_movw4_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1533           case 2 :
1534             entire_insn = entire_insn >> 16;
1535             itype = SH2_INSN_MOVL4_COMPACT; sh2_extract_sfmt_movl4_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1536           case 3 :
1537             entire_insn = entire_insn >> 16;
1538             itype = SH2_INSN_TRAPA_COMPACT; sh2_extract_sfmt_trapa_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1539           case 4 :
1540             entire_insn = entire_insn >> 16;
1541             itype = SH2_INSN_MOVB9_COMPACT; sh2_extract_sfmt_movb9_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1542           case 5 :
1543             entire_insn = entire_insn >> 16;
1544             itype = SH2_INSN_MOVW9_COMPACT; sh2_extract_sfmt_movw9_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1545           case 6 :
1546             entire_insn = entire_insn >> 16;
1547             itype = SH2_INSN_MOVL9_COMPACT; sh2_extract_sfmt_movl9_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1548           case 7 :
1549             entire_insn = entire_insn >> 16;
1550             itype = SH2_INSN_MOVA_COMPACT; sh2_extract_sfmt_mova_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1551           case 8 :
1552             entire_insn = entire_insn >> 16;
1553             itype = SH2_INSN_TSTI_COMPACT; sh2_extract_sfmt_tsti_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1554           case 9 :
1555             entire_insn = entire_insn >> 16;
1556             itype = SH2_INSN_ANDI_COMPACT; sh2_extract_sfmt_andi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1557           case 10 :
1558             entire_insn = entire_insn >> 16;
1559             itype = SH2_INSN_XORI_COMPACT; sh2_extract_sfmt_andi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1560           case 11 :
1561             entire_insn = entire_insn >> 16;
1562             itype = SH2_INSN_ORI_COMPACT; sh2_extract_sfmt_andi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1563           case 12 :
1564             entire_insn = entire_insn >> 16;
1565             itype = SH2_INSN_TSTB_COMPACT; sh2_extract_sfmt_tstb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1566           case 13 :
1567             entire_insn = entire_insn >> 16;
1568             itype = SH2_INSN_ANDB_COMPACT; sh2_extract_sfmt_andb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1569           case 14 :
1570             entire_insn = entire_insn >> 16;
1571             itype = SH2_INSN_XORB_COMPACT; sh2_extract_sfmt_andb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1572           case 15 :
1573             entire_insn = entire_insn >> 16;
1574             itype = SH2_INSN_ORB_COMPACT; sh2_extract_sfmt_andb_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1575           default : itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1576           }
1577         }
1578       case 832 : /* fall through */
1579       case 833 : /* fall through */
1580       case 834 : /* fall through */
1581       case 835 : /* fall through */
1582       case 836 : /* fall through */
1583       case 837 : /* fall through */
1584       case 838 : /* fall through */
1585       case 839 : /* fall through */
1586       case 840 : /* fall through */
1587       case 841 : /* fall through */
1588       case 842 : /* fall through */
1589       case 843 : /* fall through */
1590       case 844 : /* fall through */
1591       case 845 : /* fall through */
1592       case 846 : /* fall through */
1593       case 847 : /* fall through */
1594       case 848 : /* fall through */
1595       case 849 : /* fall through */
1596       case 850 : /* fall through */
1597       case 851 : /* fall through */
1598       case 852 : /* fall through */
1599       case 853 : /* fall through */
1600       case 854 : /* fall through */
1601       case 855 : /* fall through */
1602       case 856 : /* fall through */
1603       case 857 : /* fall through */
1604       case 858 : /* fall through */
1605       case 859 : /* fall through */
1606       case 860 : /* fall through */
1607       case 861 : /* fall through */
1608       case 862 : /* fall through */
1609       case 863 : /* fall through */
1610       case 864 : /* fall through */
1611       case 865 : /* fall through */
1612       case 866 : /* fall through */
1613       case 867 : /* fall through */
1614       case 868 : /* fall through */
1615       case 869 : /* fall through */
1616       case 870 : /* fall through */
1617       case 871 : /* fall through */
1618       case 872 : /* fall through */
1619       case 873 : /* fall through */
1620       case 874 : /* fall through */
1621       case 875 : /* fall through */
1622       case 876 : /* fall through */
1623       case 877 : /* fall through */
1624       case 878 : /* fall through */
1625       case 879 : /* fall through */
1626       case 880 : /* fall through */
1627       case 881 : /* fall through */
1628       case 882 : /* fall through */
1629       case 883 : /* fall through */
1630       case 884 : /* fall through */
1631       case 885 : /* fall through */
1632       case 886 : /* fall through */
1633       case 887 : /* fall through */
1634       case 888 : /* fall through */
1635       case 889 : /* fall through */
1636       case 890 : /* fall through */
1637       case 891 : /* fall through */
1638       case 892 : /* fall through */
1639       case 893 : /* fall through */
1640       case 894 : /* fall through */
1641       case 895 :
1642         entire_insn = entire_insn >> 16;
1643         itype = SH2_INSN_MOVL10_COMPACT; sh2_extract_sfmt_movl10_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1644       case 896 : /* fall through */
1645       case 897 : /* fall through */
1646       case 898 : /* fall through */
1647       case 899 : /* fall through */
1648       case 900 : /* fall through */
1649       case 901 : /* fall through */
1650       case 902 : /* fall through */
1651       case 903 : /* fall through */
1652       case 904 : /* fall through */
1653       case 905 : /* fall through */
1654       case 906 : /* fall through */
1655       case 907 : /* fall through */
1656       case 908 : /* fall through */
1657       case 909 : /* fall through */
1658       case 910 : /* fall through */
1659       case 911 : /* fall through */
1660       case 912 : /* fall through */
1661       case 913 : /* fall through */
1662       case 914 : /* fall through */
1663       case 915 : /* fall through */
1664       case 916 : /* fall through */
1665       case 917 : /* fall through */
1666       case 918 : /* fall through */
1667       case 919 : /* fall through */
1668       case 920 : /* fall through */
1669       case 921 : /* fall through */
1670       case 922 : /* fall through */
1671       case 923 : /* fall through */
1672       case 924 : /* fall through */
1673       case 925 : /* fall through */
1674       case 926 : /* fall through */
1675       case 927 : /* fall through */
1676       case 928 : /* fall through */
1677       case 929 : /* fall through */
1678       case 930 : /* fall through */
1679       case 931 : /* fall through */
1680       case 932 : /* fall through */
1681       case 933 : /* fall through */
1682       case 934 : /* fall through */
1683       case 935 : /* fall through */
1684       case 936 : /* fall through */
1685       case 937 : /* fall through */
1686       case 938 : /* fall through */
1687       case 939 : /* fall through */
1688       case 940 : /* fall through */
1689       case 941 : /* fall through */
1690       case 942 : /* fall through */
1691       case 943 : /* fall through */
1692       case 944 : /* fall through */
1693       case 945 : /* fall through */
1694       case 946 : /* fall through */
1695       case 947 : /* fall through */
1696       case 948 : /* fall through */
1697       case 949 : /* fall through */
1698       case 950 : /* fall through */
1699       case 951 : /* fall through */
1700       case 952 : /* fall through */
1701       case 953 : /* fall through */
1702       case 954 : /* fall through */
1703       case 955 : /* fall through */
1704       case 956 : /* fall through */
1705       case 957 : /* fall through */
1706       case 958 : /* fall through */
1707       case 959 :
1708         entire_insn = entire_insn >> 16;
1709         itype = SH2_INSN_MOVI_COMPACT; sh2_extract_sfmt_movi_compact (this, current_cpu, pc, base_insn, entire_insn); goto done;
1710       case 1021 :
1711         {
1712           unsigned int val = (((insn >> 27) & (1 << 0)));
1713           switch (val)
1714           {
1715           case 0 :
1716             entire_insn = entire_insn >> 16;
1717             if ((entire_insn & 0xffff) == 0xf3fd)
1718               { itype = SH2_INSN_FSCHG_COMPACT; sh2_extract_sfmt_fschg_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1719             itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1720           case 1 :
1721             entire_insn = entire_insn >> 16;
1722             if ((entire_insn & 0xffff) == 0xfbfd)
1723               { itype = SH2_INSN_FRCHG_COMPACT; sh2_extract_sfmt_frchg_compact (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1724             itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1725           default : itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1726           }
1727         }
1728       default : itype = SH2_INSN_X_INVALID; sh2_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1729       }
1730     }
1731
1732   }
1733
1734   /* The instruction has been decoded and fields extracted.  */
1735   done:
1736
1737   this->addr = pc;
1738   // FIXME: To be redone (to handle ISA variants).
1739   this->idesc = & sh2_idesc::idesc_table[itype];
1740   // ??? record semantic handler?
1741   assert(this->idesc->sem_index == itype);
1742 }
1743
1744 void
1745 sh2_extract_sfmt_empty (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1746     sh2_insn_word insn = entire_insn;
1747 #define FLD(f) abuf->fields.fmt_empty.f
1748
1749
1750   /* Record the fields for the semantic handler.  */
1751   if (UNLIKELY(current_cpu->trace_extract_p))
1752     {
1753       current_cpu->trace_stream
1754         << "0x" << hex << pc << dec << " (sfmt_empty)\t"
1755         << endl;
1756     }
1757
1758 #undef FLD
1759 }
1760
1761 void
1762 sh2_extract_sfmt_add_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1763     sh2_insn_word insn = entire_insn;
1764 #define FLD(f) abuf->fields.sfmt_macl_compact.f
1765     UINT f_rn;
1766     UINT f_rm;
1767
1768     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1769     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
1770
1771   /* Record the fields for the semantic handler.  */
1772   FLD (f_rm) = f_rm;
1773   FLD (f_rn) = f_rn;
1774   if (UNLIKELY(current_cpu->trace_extract_p))
1775     {
1776       current_cpu->trace_stream
1777         << "0x" << hex << pc << dec << " (sfmt_add_compact)\t"
1778         << " f_rm:0x" << hex << f_rm << dec
1779         << " f_rn:0x" << hex << f_rn << dec
1780         << endl;
1781     }
1782
1783   /* Record the fields for profiling.  */
1784   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1785     {
1786       FLD (in_rm) = f_rm;
1787       FLD (in_rn) = f_rn;
1788       FLD (out_rn) = f_rn;
1789     }
1790 #undef FLD
1791 }
1792
1793 void
1794 sh2_extract_sfmt_addi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1795     sh2_insn_word insn = entire_insn;
1796 #define FLD(f) abuf->fields.sfmt_addi_compact.f
1797     UINT f_rn;
1798     UINT f_imm8;
1799
1800     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1801     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
1802
1803   /* Record the fields for the semantic handler.  */
1804   FLD (f_imm8) = f_imm8;
1805   FLD (f_rn) = f_rn;
1806   if (UNLIKELY(current_cpu->trace_extract_p))
1807     {
1808       current_cpu->trace_stream
1809         << "0x" << hex << pc << dec << " (sfmt_addi_compact)\t"
1810         << " f_imm8:0x" << hex << f_imm8 << dec
1811         << " f_rn:0x" << hex << f_rn << dec
1812         << endl;
1813     }
1814
1815   /* Record the fields for profiling.  */
1816   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1817     {
1818       FLD (in_rn) = f_rn;
1819       FLD (out_rn) = f_rn;
1820     }
1821 #undef FLD
1822 }
1823
1824 void
1825 sh2_extract_sfmt_addc_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1826     sh2_insn_word insn = entire_insn;
1827 #define FLD(f) abuf->fields.sfmt_macl_compact.f
1828     UINT f_rn;
1829     UINT f_rm;
1830
1831     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1832     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
1833
1834   /* Record the fields for the semantic handler.  */
1835   FLD (f_rm) = f_rm;
1836   FLD (f_rn) = f_rn;
1837   if (UNLIKELY(current_cpu->trace_extract_p))
1838     {
1839       current_cpu->trace_stream
1840         << "0x" << hex << pc << dec << " (sfmt_addc_compact)\t"
1841         << " f_rm:0x" << hex << f_rm << dec
1842         << " f_rn:0x" << hex << f_rn << dec
1843         << endl;
1844     }
1845
1846   /* Record the fields for profiling.  */
1847   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1848     {
1849       FLD (in_rm) = f_rm;
1850       FLD (in_rn) = f_rn;
1851       FLD (out_rn) = f_rn;
1852     }
1853 #undef FLD
1854 }
1855
1856 void
1857 sh2_extract_sfmt_addv_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1858     sh2_insn_word insn = entire_insn;
1859 #define FLD(f) abuf->fields.sfmt_macl_compact.f
1860     UINT f_rn;
1861     UINT f_rm;
1862
1863     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1864     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
1865
1866   /* Record the fields for the semantic handler.  */
1867   FLD (f_rm) = f_rm;
1868   FLD (f_rn) = f_rn;
1869   if (UNLIKELY(current_cpu->trace_extract_p))
1870     {
1871       current_cpu->trace_stream
1872         << "0x" << hex << pc << dec << " (sfmt_addv_compact)\t"
1873         << " f_rm:0x" << hex << f_rm << dec
1874         << " f_rn:0x" << hex << f_rn << dec
1875         << endl;
1876     }
1877
1878   /* Record the fields for profiling.  */
1879   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1880     {
1881       FLD (in_rm) = f_rm;
1882       FLD (in_rn) = f_rn;
1883       FLD (out_rn) = f_rn;
1884     }
1885 #undef FLD
1886 }
1887
1888 void
1889 sh2_extract_sfmt_and_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1890     sh2_insn_word insn = entire_insn;
1891 #define FLD(f) abuf->fields.sfmt_and_compact.f
1892     UINT f_rn;
1893     UINT f_rm;
1894
1895     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1896     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
1897
1898   /* Record the fields for the semantic handler.  */
1899   FLD (f_rm) = f_rm;
1900   FLD (f_rn) = f_rn;
1901   if (UNLIKELY(current_cpu->trace_extract_p))
1902     {
1903       current_cpu->trace_stream
1904         << "0x" << hex << pc << dec << " (sfmt_and_compact)\t"
1905         << " f_rm:0x" << hex << f_rm << dec
1906         << " f_rn:0x" << hex << f_rn << dec
1907         << endl;
1908     }
1909
1910   /* Record the fields for profiling.  */
1911   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1912     {
1913       FLD (in_rm64) = f_rm;
1914       FLD (in_rn64) = f_rn;
1915       FLD (out_rn64) = f_rn;
1916     }
1917 #undef FLD
1918 }
1919
1920 void
1921 sh2_extract_sfmt_andi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1922     sh2_insn_word insn = entire_insn;
1923 #define FLD(f) abuf->fields.sfmt_andi_compact.f
1924     UINT f_imm8;
1925
1926     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
1927
1928   /* Record the fields for the semantic handler.  */
1929   FLD (f_imm8) = f_imm8;
1930   if (UNLIKELY(current_cpu->trace_extract_p))
1931     {
1932       current_cpu->trace_stream
1933         << "0x" << hex << pc << dec << " (sfmt_andi_compact)\t"
1934         << " f_imm8:0x" << hex << f_imm8 << dec
1935         << endl;
1936     }
1937
1938   /* Record the fields for profiling.  */
1939   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1940     {
1941       FLD (in_r0) = 0;
1942       FLD (out_r0) = 0;
1943     }
1944 #undef FLD
1945 }
1946
1947 void
1948 sh2_extract_sfmt_andb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1949     sh2_insn_word insn = entire_insn;
1950 #define FLD(f) abuf->fields.sfmt_andi_compact.f
1951     UINT f_imm8;
1952
1953     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
1954
1955   /* Record the fields for the semantic handler.  */
1956   FLD (f_imm8) = f_imm8;
1957   if (UNLIKELY(current_cpu->trace_extract_p))
1958     {
1959       current_cpu->trace_stream
1960         << "0x" << hex << pc << dec << " (sfmt_andb_compact)\t"
1961         << " f_imm8:0x" << hex << f_imm8 << dec
1962         << endl;
1963     }
1964
1965   /* Record the fields for profiling.  */
1966   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1967     {
1968       FLD (in_r0) = 0;
1969     }
1970 #undef FLD
1971 }
1972
1973 void
1974 sh2_extract_sfmt_bf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1975     sh2_insn_word insn = entire_insn;
1976 #define FLD(f) abuf->fields.sfmt_bf_compact.f
1977     SI f_disp8;
1978
1979     f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) << (1))) + (((pc) + (4))));
1980
1981   /* Record the fields for the semantic handler.  */
1982   FLD (i_disp8) = f_disp8;
1983   if (UNLIKELY(current_cpu->trace_extract_p))
1984     {
1985       current_cpu->trace_stream
1986         << "0x" << hex << pc << dec << " (sfmt_bf_compact)\t"
1987         << endl;
1988     }
1989
1990   /* Record the fields for profiling.  */
1991   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1992     {
1993     }
1994 #undef FLD
1995 }
1996
1997 void
1998 sh2_extract_sfmt_bfs_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
1999     sh2_insn_word insn = entire_insn;
2000 #define FLD(f) abuf->fields.sfmt_bf_compact.f
2001     SI f_disp8;
2002
2003     f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) << (1))) + (((pc) + (4))));
2004
2005   /* Record the fields for the semantic handler.  */
2006   FLD (i_disp8) = f_disp8;
2007   if (UNLIKELY(current_cpu->trace_extract_p))
2008     {
2009       current_cpu->trace_stream
2010         << "0x" << hex << pc << dec << " (sfmt_bfs_compact)\t"
2011         << endl;
2012     }
2013
2014   /* Record the fields for profiling.  */
2015   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2016     {
2017     }
2018 #undef FLD
2019 }
2020
2021 void
2022 sh2_extract_sfmt_bra_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2023     sh2_insn_word insn = entire_insn;
2024 #define FLD(f) abuf->fields.sfmt_bra_compact.f
2025     SI f_disp12;
2026
2027     f_disp12 = ((((EXTRACT_MSB0_SINT (insn, 16, 4, 12)) << (1))) + (((pc) + (4))));
2028
2029   /* Record the fields for the semantic handler.  */
2030   FLD (i_disp12) = f_disp12;
2031   if (UNLIKELY(current_cpu->trace_extract_p))
2032     {
2033       current_cpu->trace_stream
2034         << "0x" << hex << pc << dec << " (sfmt_bra_compact)\t"
2035         << endl;
2036     }
2037
2038   /* Record the fields for profiling.  */
2039   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2040     {
2041     }
2042 #undef FLD
2043 }
2044
2045 void
2046 sh2_extract_sfmt_braf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2047     sh2_insn_word insn = entire_insn;
2048 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2049     UINT f_rn;
2050
2051     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2052
2053   /* Record the fields for the semantic handler.  */
2054   FLD (f_rn) = f_rn;
2055   if (UNLIKELY(current_cpu->trace_extract_p))
2056     {
2057       current_cpu->trace_stream
2058         << "0x" << hex << pc << dec << " (sfmt_braf_compact)\t"
2059         << " f_rn:0x" << hex << f_rn << dec
2060         << endl;
2061     }
2062
2063   /* Record the fields for profiling.  */
2064   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2065     {
2066       FLD (in_rn) = f_rn;
2067     }
2068 #undef FLD
2069 }
2070
2071 void
2072 sh2_extract_sfmt_bsr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2073     sh2_insn_word insn = entire_insn;
2074 #define FLD(f) abuf->fields.sfmt_bra_compact.f
2075     SI f_disp12;
2076
2077     f_disp12 = ((((EXTRACT_MSB0_SINT (insn, 16, 4, 12)) << (1))) + (((pc) + (4))));
2078
2079   /* Record the fields for the semantic handler.  */
2080   FLD (i_disp12) = f_disp12;
2081   if (UNLIKELY(current_cpu->trace_extract_p))
2082     {
2083       current_cpu->trace_stream
2084         << "0x" << hex << pc << dec << " (sfmt_bsr_compact)\t"
2085         << endl;
2086     }
2087
2088   /* Record the fields for profiling.  */
2089   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2090     {
2091     }
2092 #undef FLD
2093 }
2094
2095 void
2096 sh2_extract_sfmt_bsrf_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2097     sh2_insn_word insn = entire_insn;
2098 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2099     UINT f_rn;
2100
2101     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2102
2103   /* Record the fields for the semantic handler.  */
2104   FLD (f_rn) = f_rn;
2105   if (UNLIKELY(current_cpu->trace_extract_p))
2106     {
2107       current_cpu->trace_stream
2108         << "0x" << hex << pc << dec << " (sfmt_bsrf_compact)\t"
2109         << " f_rn:0x" << hex << f_rn << dec
2110         << endl;
2111     }
2112
2113   /* Record the fields for profiling.  */
2114   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2115     {
2116       FLD (in_rn) = f_rn;
2117     }
2118 #undef FLD
2119 }
2120
2121 void
2122 sh2_extract_sfmt_clrmac_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2123     sh2_insn_word insn = entire_insn;
2124 #define FLD(f) abuf->fields.fmt_empty.f
2125
2126
2127   /* Record the fields for the semantic handler.  */
2128   if (UNLIKELY(current_cpu->trace_extract_p))
2129     {
2130       current_cpu->trace_stream
2131         << "0x" << hex << pc << dec << " (sfmt_clrmac_compact)\t"
2132         << endl;
2133     }
2134
2135 #undef FLD
2136 }
2137
2138 void
2139 sh2_extract_sfmt_clrt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2140     sh2_insn_word insn = entire_insn;
2141 #define FLD(f) abuf->fields.fmt_empty.f
2142
2143
2144   /* Record the fields for the semantic handler.  */
2145   if (UNLIKELY(current_cpu->trace_extract_p))
2146     {
2147       current_cpu->trace_stream
2148         << "0x" << hex << pc << dec << " (sfmt_clrt_compact)\t"
2149         << endl;
2150     }
2151
2152 #undef FLD
2153 }
2154
2155 void
2156 sh2_extract_sfmt_cmpeq_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2157     sh2_insn_word insn = entire_insn;
2158 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
2159     UINT f_rn;
2160     UINT f_rm;
2161
2162     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2163     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2164
2165   /* Record the fields for the semantic handler.  */
2166   FLD (f_rm) = f_rm;
2167   FLD (f_rn) = f_rn;
2168   if (UNLIKELY(current_cpu->trace_extract_p))
2169     {
2170       current_cpu->trace_stream
2171         << "0x" << hex << pc << dec << " (sfmt_cmpeq_compact)\t"
2172         << " f_rm:0x" << hex << f_rm << dec
2173         << " f_rn:0x" << hex << f_rn << dec
2174         << endl;
2175     }
2176
2177   /* Record the fields for profiling.  */
2178   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2179     {
2180       FLD (in_rm) = f_rm;
2181       FLD (in_rn) = f_rn;
2182     }
2183 #undef FLD
2184 }
2185
2186 void
2187 sh2_extract_sfmt_cmpeqi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2188     sh2_insn_word insn = entire_insn;
2189 #define FLD(f) abuf->fields.sfmt_andi_compact.f
2190     UINT f_imm8;
2191
2192     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
2193
2194   /* Record the fields for the semantic handler.  */
2195   FLD (f_imm8) = f_imm8;
2196   if (UNLIKELY(current_cpu->trace_extract_p))
2197     {
2198       current_cpu->trace_stream
2199         << "0x" << hex << pc << dec << " (sfmt_cmpeqi_compact)\t"
2200         << " f_imm8:0x" << hex << f_imm8 << dec
2201         << endl;
2202     }
2203
2204   /* Record the fields for profiling.  */
2205   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2206     {
2207       FLD (in_r0) = 0;
2208     }
2209 #undef FLD
2210 }
2211
2212 void
2213 sh2_extract_sfmt_cmppl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2214     sh2_insn_word insn = entire_insn;
2215 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2216     UINT f_rn;
2217
2218     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2219
2220   /* Record the fields for the semantic handler.  */
2221   FLD (f_rn) = f_rn;
2222   if (UNLIKELY(current_cpu->trace_extract_p))
2223     {
2224       current_cpu->trace_stream
2225         << "0x" << hex << pc << dec << " (sfmt_cmppl_compact)\t"
2226         << " f_rn:0x" << hex << f_rn << dec
2227         << endl;
2228     }
2229
2230   /* Record the fields for profiling.  */
2231   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2232     {
2233       FLD (in_rn) = f_rn;
2234     }
2235 #undef FLD
2236 }
2237
2238 void
2239 sh2_extract_sfmt_div0s_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2240     sh2_insn_word insn = entire_insn;
2241 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
2242     UINT f_rn;
2243     UINT f_rm;
2244
2245     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2246     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2247
2248   /* Record the fields for the semantic handler.  */
2249   FLD (f_rm) = f_rm;
2250   FLD (f_rn) = f_rn;
2251   if (UNLIKELY(current_cpu->trace_extract_p))
2252     {
2253       current_cpu->trace_stream
2254         << "0x" << hex << pc << dec << " (sfmt_div0s_compact)\t"
2255         << " f_rm:0x" << hex << f_rm << dec
2256         << " f_rn:0x" << hex << f_rn << dec
2257         << endl;
2258     }
2259
2260   /* Record the fields for profiling.  */
2261   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2262     {
2263       FLD (in_rm) = f_rm;
2264       FLD (in_rn) = f_rn;
2265     }
2266 #undef FLD
2267 }
2268
2269 void
2270 sh2_extract_sfmt_div0u_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2271     sh2_insn_word insn = entire_insn;
2272 #define FLD(f) abuf->fields.fmt_empty.f
2273
2274
2275   /* Record the fields for the semantic handler.  */
2276   if (UNLIKELY(current_cpu->trace_extract_p))
2277     {
2278       current_cpu->trace_stream
2279         << "0x" << hex << pc << dec << " (sfmt_div0u_compact)\t"
2280         << endl;
2281     }
2282
2283 #undef FLD
2284 }
2285
2286 void
2287 sh2_extract_sfmt_div1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2288     sh2_insn_word insn = entire_insn;
2289 #define FLD(f) abuf->fields.sfmt_macl_compact.f
2290     UINT f_rn;
2291     UINT f_rm;
2292
2293     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2294     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2295
2296   /* Record the fields for the semantic handler.  */
2297   FLD (f_rm) = f_rm;
2298   FLD (f_rn) = f_rn;
2299   if (UNLIKELY(current_cpu->trace_extract_p))
2300     {
2301       current_cpu->trace_stream
2302         << "0x" << hex << pc << dec << " (sfmt_div1_compact)\t"
2303         << " f_rm:0x" << hex << f_rm << dec
2304         << " f_rn:0x" << hex << f_rn << dec
2305         << endl;
2306     }
2307
2308   /* Record the fields for profiling.  */
2309   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2310     {
2311       FLD (in_rm) = f_rm;
2312       FLD (in_rn) = f_rn;
2313       FLD (out_rn) = f_rn;
2314     }
2315 #undef FLD
2316 }
2317
2318 void
2319 sh2_extract_sfmt_dmulsl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2320     sh2_insn_word insn = entire_insn;
2321 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
2322     UINT f_rn;
2323     UINT f_rm;
2324
2325     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2326     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2327
2328   /* Record the fields for the semantic handler.  */
2329   FLD (f_rm) = f_rm;
2330   FLD (f_rn) = f_rn;
2331   if (UNLIKELY(current_cpu->trace_extract_p))
2332     {
2333       current_cpu->trace_stream
2334         << "0x" << hex << pc << dec << " (sfmt_dmulsl_compact)\t"
2335         << " f_rm:0x" << hex << f_rm << dec
2336         << " f_rn:0x" << hex << f_rn << dec
2337         << endl;
2338     }
2339
2340   /* Record the fields for profiling.  */
2341   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2342     {
2343       FLD (in_rm) = f_rm;
2344       FLD (in_rn) = f_rn;
2345     }
2346 #undef FLD
2347 }
2348
2349 void
2350 sh2_extract_sfmt_dt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2351     sh2_insn_word insn = entire_insn;
2352 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2353     UINT f_rn;
2354
2355     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2356
2357   /* Record the fields for the semantic handler.  */
2358   FLD (f_rn) = f_rn;
2359   if (UNLIKELY(current_cpu->trace_extract_p))
2360     {
2361       current_cpu->trace_stream
2362         << "0x" << hex << pc << dec << " (sfmt_dt_compact)\t"
2363         << " f_rn:0x" << hex << f_rn << dec
2364         << endl;
2365     }
2366
2367   /* Record the fields for profiling.  */
2368   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2369     {
2370       FLD (in_rn) = f_rn;
2371       FLD (out_rn) = f_rn;
2372     }
2373 #undef FLD
2374 }
2375
2376 void
2377 sh2_extract_sfmt_extsb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2378     sh2_insn_word insn = entire_insn;
2379 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
2380     UINT f_rn;
2381     UINT f_rm;
2382
2383     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2384     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2385
2386   /* Record the fields for the semantic handler.  */
2387   FLD (f_rm) = f_rm;
2388   FLD (f_rn) = f_rn;
2389   if (UNLIKELY(current_cpu->trace_extract_p))
2390     {
2391       current_cpu->trace_stream
2392         << "0x" << hex << pc << dec << " (sfmt_extsb_compact)\t"
2393         << " f_rm:0x" << hex << f_rm << dec
2394         << " f_rn:0x" << hex << f_rn << dec
2395         << endl;
2396     }
2397
2398   /* Record the fields for profiling.  */
2399   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2400     {
2401       FLD (in_rm) = f_rm;
2402       FLD (out_rn) = f_rn;
2403     }
2404 #undef FLD
2405 }
2406
2407 void
2408 sh2_extract_sfmt_frchg_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2409     sh2_insn_word insn = entire_insn;
2410 #define FLD(f) abuf->fields.fmt_empty.f
2411
2412
2413   /* Record the fields for the semantic handler.  */
2414   if (UNLIKELY(current_cpu->trace_extract_p))
2415     {
2416       current_cpu->trace_stream
2417         << "0x" << hex << pc << dec << " (sfmt_frchg_compact)\t"
2418         << endl;
2419     }
2420
2421 #undef FLD
2422 }
2423
2424 void
2425 sh2_extract_sfmt_fschg_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2426     sh2_insn_word insn = entire_insn;
2427 #define FLD(f) abuf->fields.fmt_empty.f
2428
2429
2430   /* Record the fields for the semantic handler.  */
2431   if (UNLIKELY(current_cpu->trace_extract_p))
2432     {
2433       current_cpu->trace_stream
2434         << "0x" << hex << pc << dec << " (sfmt_fschg_compact)\t"
2435         << endl;
2436     }
2437
2438 #undef FLD
2439 }
2440
2441 void
2442 sh2_extract_sfmt_ldc_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2443     sh2_insn_word insn = entire_insn;
2444 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2445     UINT f_rn;
2446
2447     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2448
2449   /* Record the fields for the semantic handler.  */
2450   FLD (f_rn) = f_rn;
2451   if (UNLIKELY(current_cpu->trace_extract_p))
2452     {
2453       current_cpu->trace_stream
2454         << "0x" << hex << pc << dec << " (sfmt_ldc_gbr_compact)\t"
2455         << " f_rn:0x" << hex << f_rn << dec
2456         << endl;
2457     }
2458
2459   /* Record the fields for profiling.  */
2460   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2461     {
2462       FLD (in_rn) = f_rn;
2463     }
2464 #undef FLD
2465 }
2466
2467 void
2468 sh2_extract_sfmt_ldc_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2469     sh2_insn_word insn = entire_insn;
2470 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2471     UINT f_rn;
2472
2473     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2474
2475   /* Record the fields for the semantic handler.  */
2476   FLD (f_rn) = f_rn;
2477   if (UNLIKELY(current_cpu->trace_extract_p))
2478     {
2479       current_cpu->trace_stream
2480         << "0x" << hex << pc << dec << " (sfmt_ldc_vbr_compact)\t"
2481         << " f_rn:0x" << hex << f_rn << dec
2482         << endl;
2483     }
2484
2485   /* Record the fields for profiling.  */
2486   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2487     {
2488       FLD (in_rn) = f_rn;
2489     }
2490 #undef FLD
2491 }
2492
2493 void
2494 sh2_extract_sfmt_ldc_sr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2495     sh2_insn_word insn = entire_insn;
2496 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2497     UINT f_rn;
2498
2499     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2500
2501   /* Record the fields for the semantic handler.  */
2502   FLD (f_rn) = f_rn;
2503   if (UNLIKELY(current_cpu->trace_extract_p))
2504     {
2505       current_cpu->trace_stream
2506         << "0x" << hex << pc << dec << " (sfmt_ldc_sr_compact)\t"
2507         << " f_rn:0x" << hex << f_rn << dec
2508         << endl;
2509     }
2510
2511   /* Record the fields for profiling.  */
2512   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2513     {
2514       FLD (in_rn) = f_rn;
2515     }
2516 #undef FLD
2517 }
2518
2519 void
2520 sh2_extract_sfmt_ldcl_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2521     sh2_insn_word insn = entire_insn;
2522 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2523     UINT f_rn;
2524
2525     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2526
2527   /* Record the fields for the semantic handler.  */
2528   FLD (f_rn) = f_rn;
2529   if (UNLIKELY(current_cpu->trace_extract_p))
2530     {
2531       current_cpu->trace_stream
2532         << "0x" << hex << pc << dec << " (sfmt_ldcl_gbr_compact)\t"
2533         << " f_rn:0x" << hex << f_rn << dec
2534         << endl;
2535     }
2536
2537   /* Record the fields for profiling.  */
2538   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2539     {
2540       FLD (in_rn) = f_rn;
2541       FLD (out_rn) = f_rn;
2542     }
2543 #undef FLD
2544 }
2545
2546 void
2547 sh2_extract_sfmt_ldcl_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2548     sh2_insn_word insn = entire_insn;
2549 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2550     UINT f_rn;
2551
2552     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2553
2554   /* Record the fields for the semantic handler.  */
2555   FLD (f_rn) = f_rn;
2556   if (UNLIKELY(current_cpu->trace_extract_p))
2557     {
2558       current_cpu->trace_stream
2559         << "0x" << hex << pc << dec << " (sfmt_ldcl_vbr_compact)\t"
2560         << " f_rn:0x" << hex << f_rn << dec
2561         << endl;
2562     }
2563
2564   /* Record the fields for profiling.  */
2565   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2566     {
2567       FLD (in_rn) = f_rn;
2568       FLD (out_rn) = f_rn;
2569     }
2570 #undef FLD
2571 }
2572
2573 void
2574 sh2_extract_sfmt_lds_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2575     sh2_insn_word insn = entire_insn;
2576 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2577     UINT f_rn;
2578
2579     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2580
2581   /* Record the fields for the semantic handler.  */
2582   FLD (f_rn) = f_rn;
2583   if (UNLIKELY(current_cpu->trace_extract_p))
2584     {
2585       current_cpu->trace_stream
2586         << "0x" << hex << pc << dec << " (sfmt_lds_mach_compact)\t"
2587         << " f_rn:0x" << hex << f_rn << dec
2588         << endl;
2589     }
2590
2591   /* Record the fields for profiling.  */
2592   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2593     {
2594       FLD (in_rn) = f_rn;
2595     }
2596 #undef FLD
2597 }
2598
2599 void
2600 sh2_extract_sfmt_ldsl_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2601     sh2_insn_word insn = entire_insn;
2602 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2603     UINT f_rn;
2604
2605     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2606
2607   /* Record the fields for the semantic handler.  */
2608   FLD (f_rn) = f_rn;
2609   if (UNLIKELY(current_cpu->trace_extract_p))
2610     {
2611       current_cpu->trace_stream
2612         << "0x" << hex << pc << dec << " (sfmt_ldsl_mach_compact)\t"
2613         << " f_rn:0x" << hex << f_rn << dec
2614         << endl;
2615     }
2616
2617   /* Record the fields for profiling.  */
2618   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2619     {
2620       FLD (in_rn) = f_rn;
2621       FLD (out_rn) = f_rn;
2622     }
2623 #undef FLD
2624 }
2625
2626 void
2627 sh2_extract_sfmt_lds_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2628     sh2_insn_word insn = entire_insn;
2629 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2630     UINT f_rn;
2631
2632     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2633
2634   /* Record the fields for the semantic handler.  */
2635   FLD (f_rn) = f_rn;
2636   if (UNLIKELY(current_cpu->trace_extract_p))
2637     {
2638       current_cpu->trace_stream
2639         << "0x" << hex << pc << dec << " (sfmt_lds_macl_compact)\t"
2640         << " f_rn:0x" << hex << f_rn << dec
2641         << endl;
2642     }
2643
2644   /* Record the fields for profiling.  */
2645   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2646     {
2647       FLD (in_rn) = f_rn;
2648     }
2649 #undef FLD
2650 }
2651
2652 void
2653 sh2_extract_sfmt_ldsl_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2654     sh2_insn_word insn = entire_insn;
2655 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2656     UINT f_rn;
2657
2658     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2659
2660   /* Record the fields for the semantic handler.  */
2661   FLD (f_rn) = f_rn;
2662   if (UNLIKELY(current_cpu->trace_extract_p))
2663     {
2664       current_cpu->trace_stream
2665         << "0x" << hex << pc << dec << " (sfmt_ldsl_macl_compact)\t"
2666         << " f_rn:0x" << hex << f_rn << dec
2667         << endl;
2668     }
2669
2670   /* Record the fields for profiling.  */
2671   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2672     {
2673       FLD (in_rn) = f_rn;
2674       FLD (out_rn) = f_rn;
2675     }
2676 #undef FLD
2677 }
2678
2679 void
2680 sh2_extract_sfmt_lds_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2681     sh2_insn_word insn = entire_insn;
2682 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2683     UINT f_rn;
2684
2685     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2686
2687   /* Record the fields for the semantic handler.  */
2688   FLD (f_rn) = f_rn;
2689   if (UNLIKELY(current_cpu->trace_extract_p))
2690     {
2691       current_cpu->trace_stream
2692         << "0x" << hex << pc << dec << " (sfmt_lds_pr_compact)\t"
2693         << " f_rn:0x" << hex << f_rn << dec
2694         << endl;
2695     }
2696
2697   /* Record the fields for profiling.  */
2698   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2699     {
2700       FLD (in_rn) = f_rn;
2701     }
2702 #undef FLD
2703 }
2704
2705 void
2706 sh2_extract_sfmt_ldsl_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2707     sh2_insn_word insn = entire_insn;
2708 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2709     UINT f_rn;
2710
2711     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2712
2713   /* Record the fields for the semantic handler.  */
2714   FLD (f_rn) = f_rn;
2715   if (UNLIKELY(current_cpu->trace_extract_p))
2716     {
2717       current_cpu->trace_stream
2718         << "0x" << hex << pc << dec << " (sfmt_ldsl_pr_compact)\t"
2719         << " f_rn:0x" << hex << f_rn << dec
2720         << endl;
2721     }
2722
2723   /* Record the fields for profiling.  */
2724   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2725     {
2726       FLD (in_rn) = f_rn;
2727       FLD (out_rn) = f_rn;
2728     }
2729 #undef FLD
2730 }
2731
2732 void
2733 sh2_extract_sfmt_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2734     sh2_insn_word insn = entire_insn;
2735 #define FLD(f) abuf->fields.sfmt_macl_compact.f
2736     UINT f_rn;
2737     UINT f_rm;
2738
2739     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2740     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2741
2742   /* Record the fields for the semantic handler.  */
2743   FLD (f_rm) = f_rm;
2744   FLD (f_rn) = f_rn;
2745   if (UNLIKELY(current_cpu->trace_extract_p))
2746     {
2747       current_cpu->trace_stream
2748         << "0x" << hex << pc << dec << " (sfmt_macl_compact)\t"
2749         << " f_rm:0x" << hex << f_rm << dec
2750         << " f_rn:0x" << hex << f_rn << dec
2751         << endl;
2752     }
2753
2754   /* Record the fields for profiling.  */
2755   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2756     {
2757       FLD (in_rm) = f_rm;
2758       FLD (in_rn) = f_rn;
2759       FLD (out_rm) = f_rm;
2760       FLD (out_rn) = f_rn;
2761     }
2762 #undef FLD
2763 }
2764
2765 void
2766 sh2_extract_sfmt_macw_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2767     sh2_insn_word insn = entire_insn;
2768 #define FLD(f) abuf->fields.sfmt_macl_compact.f
2769     UINT f_rn;
2770     UINT f_rm;
2771
2772     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2773     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2774
2775   /* Record the fields for the semantic handler.  */
2776   FLD (f_rm) = f_rm;
2777   FLD (f_rn) = f_rn;
2778   if (UNLIKELY(current_cpu->trace_extract_p))
2779     {
2780       current_cpu->trace_stream
2781         << "0x" << hex << pc << dec << " (sfmt_macw_compact)\t"
2782         << " f_rm:0x" << hex << f_rm << dec
2783         << " f_rn:0x" << hex << f_rn << dec
2784         << endl;
2785     }
2786
2787   /* Record the fields for profiling.  */
2788   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2789     {
2790       FLD (in_rm) = f_rm;
2791       FLD (in_rn) = f_rn;
2792       FLD (out_rm) = f_rm;
2793       FLD (out_rn) = f_rn;
2794     }
2795 #undef FLD
2796 }
2797
2798 void
2799 sh2_extract_sfmt_mov_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2800     sh2_insn_word insn = entire_insn;
2801 #define FLD(f) abuf->fields.sfmt_and_compact.f
2802     UINT f_rn;
2803     UINT f_rm;
2804
2805     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2806     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2807
2808   /* Record the fields for the semantic handler.  */
2809   FLD (f_rm) = f_rm;
2810   FLD (f_rn) = f_rn;
2811   if (UNLIKELY(current_cpu->trace_extract_p))
2812     {
2813       current_cpu->trace_stream
2814         << "0x" << hex << pc << dec << " (sfmt_mov_compact)\t"
2815         << " f_rm:0x" << hex << f_rm << dec
2816         << " f_rn:0x" << hex << f_rn << dec
2817         << endl;
2818     }
2819
2820   /* Record the fields for profiling.  */
2821   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2822     {
2823       FLD (in_rm64) = f_rm;
2824       FLD (out_rn64) = f_rn;
2825     }
2826 #undef FLD
2827 }
2828
2829 void
2830 sh2_extract_sfmt_movi_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2831     sh2_insn_word insn = entire_insn;
2832 #define FLD(f) abuf->fields.sfmt_addi_compact.f
2833     UINT f_rn;
2834     UINT f_imm8;
2835
2836     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2837     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
2838
2839   /* Record the fields for the semantic handler.  */
2840   FLD (f_imm8) = f_imm8;
2841   FLD (f_rn) = f_rn;
2842   if (UNLIKELY(current_cpu->trace_extract_p))
2843     {
2844       current_cpu->trace_stream
2845         << "0x" << hex << pc << dec << " (sfmt_movi_compact)\t"
2846         << " f_imm8:0x" << hex << f_imm8 << dec
2847         << " f_rn:0x" << hex << f_rn << dec
2848         << endl;
2849     }
2850
2851   /* Record the fields for profiling.  */
2852   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2853     {
2854       FLD (out_rn) = f_rn;
2855     }
2856 #undef FLD
2857 }
2858
2859 void
2860 sh2_extract_sfmt_movb1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2861     sh2_insn_word insn = entire_insn;
2862 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
2863     UINT f_rn;
2864     UINT f_rm;
2865
2866     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2867     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2868
2869   /* Record the fields for the semantic handler.  */
2870   FLD (f_rm) = f_rm;
2871   FLD (f_rn) = f_rn;
2872   if (UNLIKELY(current_cpu->trace_extract_p))
2873     {
2874       current_cpu->trace_stream
2875         << "0x" << hex << pc << dec << " (sfmt_movb1_compact)\t"
2876         << " f_rm:0x" << hex << f_rm << dec
2877         << " f_rn:0x" << hex << f_rn << dec
2878         << endl;
2879     }
2880
2881   /* Record the fields for profiling.  */
2882   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2883     {
2884       FLD (in_rm) = f_rm;
2885       FLD (in_rn) = f_rn;
2886     }
2887 #undef FLD
2888 }
2889
2890 void
2891 sh2_extract_sfmt_movb2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2892     sh2_insn_word insn = entire_insn;
2893 #define FLD(f) abuf->fields.sfmt_macl_compact.f
2894     UINT f_rn;
2895     UINT f_rm;
2896
2897     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2898     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2899
2900   /* Record the fields for the semantic handler.  */
2901   FLD (f_rm) = f_rm;
2902   FLD (f_rn) = f_rn;
2903   if (UNLIKELY(current_cpu->trace_extract_p))
2904     {
2905       current_cpu->trace_stream
2906         << "0x" << hex << pc << dec << " (sfmt_movb2_compact)\t"
2907         << " f_rm:0x" << hex << f_rm << dec
2908         << " f_rn:0x" << hex << f_rn << dec
2909         << endl;
2910     }
2911
2912   /* Record the fields for profiling.  */
2913   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2914     {
2915       FLD (in_rm) = f_rm;
2916       FLD (in_rn) = f_rn;
2917       FLD (out_rn) = f_rn;
2918     }
2919 #undef FLD
2920 }
2921
2922 void
2923 sh2_extract_sfmt_movb3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2924     sh2_insn_word insn = entire_insn;
2925 #define FLD(f) abuf->fields.sfmt_movb3_compact.f
2926     UINT f_rn;
2927     UINT f_rm;
2928
2929     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2930     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2931
2932   /* Record the fields for the semantic handler.  */
2933   FLD (f_rm) = f_rm;
2934   FLD (f_rn) = f_rn;
2935   if (UNLIKELY(current_cpu->trace_extract_p))
2936     {
2937       current_cpu->trace_stream
2938         << "0x" << hex << pc << dec << " (sfmt_movb3_compact)\t"
2939         << " f_rm:0x" << hex << f_rm << dec
2940         << " f_rn:0x" << hex << f_rn << dec
2941         << endl;
2942     }
2943
2944   /* Record the fields for profiling.  */
2945   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2946     {
2947       FLD (in_r0) = 0;
2948       FLD (in_rm) = f_rm;
2949       FLD (in_rn) = f_rn;
2950     }
2951 #undef FLD
2952 }
2953
2954 void
2955 sh2_extract_sfmt_movb4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2956     sh2_insn_word insn = entire_insn;
2957 #define FLD(f) abuf->fields.sfmt_andi_compact.f
2958     UINT f_imm8;
2959
2960     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
2961
2962   /* Record the fields for the semantic handler.  */
2963   FLD (f_imm8) = f_imm8;
2964   if (UNLIKELY(current_cpu->trace_extract_p))
2965     {
2966       current_cpu->trace_stream
2967         << "0x" << hex << pc << dec << " (sfmt_movb4_compact)\t"
2968         << " f_imm8:0x" << hex << f_imm8 << dec
2969         << endl;
2970     }
2971
2972   /* Record the fields for profiling.  */
2973   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2974     {
2975       FLD (in_r0) = 0;
2976     }
2977 #undef FLD
2978 }
2979
2980 void
2981 sh2_extract_sfmt_movb5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
2982     sh2_insn_word insn = entire_insn;
2983 #define FLD(f) abuf->fields.sfmt_movb5_compact.f
2984     UINT f_rm;
2985     UINT f_imm4;
2986
2987     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
2988     f_imm4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2989
2990   /* Record the fields for the semantic handler.  */
2991   FLD (f_imm4) = f_imm4;
2992   FLD (f_rm) = f_rm;
2993   if (UNLIKELY(current_cpu->trace_extract_p))
2994     {
2995       current_cpu->trace_stream
2996         << "0x" << hex << pc << dec << " (sfmt_movb5_compact)\t"
2997         << " f_imm4:0x" << hex << f_imm4 << dec
2998         << " f_rm:0x" << hex << f_rm << dec
2999         << endl;
3000     }
3001
3002   /* Record the fields for profiling.  */
3003   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3004     {
3005       FLD (in_r0) = 0;
3006       FLD (in_rm) = f_rm;
3007     }
3008 #undef FLD
3009 }
3010
3011 void
3012 sh2_extract_sfmt_movb6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3013     sh2_insn_word insn = entire_insn;
3014 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
3015     UINT f_rn;
3016     UINT f_rm;
3017
3018     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3019     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3020
3021   /* Record the fields for the semantic handler.  */
3022   FLD (f_rm) = f_rm;
3023   FLD (f_rn) = f_rn;
3024   if (UNLIKELY(current_cpu->trace_extract_p))
3025     {
3026       current_cpu->trace_stream
3027         << "0x" << hex << pc << dec << " (sfmt_movb6_compact)\t"
3028         << " f_rm:0x" << hex << f_rm << dec
3029         << " f_rn:0x" << hex << f_rn << dec
3030         << endl;
3031     }
3032
3033   /* Record the fields for profiling.  */
3034   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3035     {
3036       FLD (in_rm) = f_rm;
3037       FLD (out_rn) = f_rn;
3038     }
3039 #undef FLD
3040 }
3041
3042 void
3043 sh2_extract_sfmt_movb7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3044     sh2_insn_word insn = entire_insn;
3045 #define FLD(f) abuf->fields.sfmt_macl_compact.f
3046     UINT f_rn;
3047     UINT f_rm;
3048
3049     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3050     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3051
3052   /* Record the fields for the semantic handler.  */
3053   FLD (f_rm) = f_rm;
3054   FLD (f_rn) = f_rn;
3055   if (UNLIKELY(current_cpu->trace_extract_p))
3056     {
3057       current_cpu->trace_stream
3058         << "0x" << hex << pc << dec << " (sfmt_movb7_compact)\t"
3059         << " f_rm:0x" << hex << f_rm << dec
3060         << " f_rn:0x" << hex << f_rn << dec
3061         << endl;
3062     }
3063
3064   /* Record the fields for profiling.  */
3065   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3066     {
3067       FLD (in_rm) = f_rm;
3068       FLD (out_rm) = f_rm;
3069       FLD (out_rn) = f_rn;
3070     }
3071 #undef FLD
3072 }
3073
3074 void
3075 sh2_extract_sfmt_movb8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3076     sh2_insn_word insn = entire_insn;
3077 #define FLD(f) abuf->fields.sfmt_movb8_compact.f
3078     UINT f_rn;
3079     UINT f_rm;
3080
3081     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3082     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3083
3084   /* Record the fields for the semantic handler.  */
3085   FLD (f_rm) = f_rm;
3086   FLD (f_rn) = f_rn;
3087   if (UNLIKELY(current_cpu->trace_extract_p))
3088     {
3089       current_cpu->trace_stream
3090         << "0x" << hex << pc << dec << " (sfmt_movb8_compact)\t"
3091         << " f_rm:0x" << hex << f_rm << dec
3092         << " f_rn:0x" << hex << f_rn << dec
3093         << endl;
3094     }
3095
3096   /* Record the fields for profiling.  */
3097   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3098     {
3099       FLD (in_r0) = 0;
3100       FLD (in_rm) = f_rm;
3101       FLD (out_rn) = f_rn;
3102     }
3103 #undef FLD
3104 }
3105
3106 void
3107 sh2_extract_sfmt_movb9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3108     sh2_insn_word insn = entire_insn;
3109 #define FLD(f) abuf->fields.sfmt_andi_compact.f
3110     UINT f_imm8;
3111
3112     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
3113
3114   /* Record the fields for the semantic handler.  */
3115   FLD (f_imm8) = f_imm8;
3116   if (UNLIKELY(current_cpu->trace_extract_p))
3117     {
3118       current_cpu->trace_stream
3119         << "0x" << hex << pc << dec << " (sfmt_movb9_compact)\t"
3120         << " f_imm8:0x" << hex << f_imm8 << dec
3121         << endl;
3122     }
3123
3124   /* Record the fields for profiling.  */
3125   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3126     {
3127       FLD (out_r0) = 0;
3128     }
3129 #undef FLD
3130 }
3131
3132 void
3133 sh2_extract_sfmt_movb10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3134     sh2_insn_word insn = entire_insn;
3135 #define FLD(f) abuf->fields.sfmt_movb10_compact.f
3136     UINT f_rm;
3137     UINT f_imm4;
3138
3139     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3140     f_imm4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
3141
3142   /* Record the fields for the semantic handler.  */
3143   FLD (f_imm4) = f_imm4;
3144   FLD (f_rm) = f_rm;
3145   if (UNLIKELY(current_cpu->trace_extract_p))
3146     {
3147       current_cpu->trace_stream
3148         << "0x" << hex << pc << dec << " (sfmt_movb10_compact)\t"
3149         << " f_imm4:0x" << hex << f_imm4 << dec
3150         << " f_rm:0x" << hex << f_rm << dec
3151         << endl;
3152     }
3153
3154   /* Record the fields for profiling.  */
3155   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3156     {
3157       FLD (in_rm) = f_rm;
3158       FLD (out_r0) = 0;
3159     }
3160 #undef FLD
3161 }
3162
3163 void
3164 sh2_extract_sfmt_movl1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3165     sh2_insn_word insn = entire_insn;
3166 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
3167     UINT f_rn;
3168     UINT f_rm;
3169
3170     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3171     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3172
3173   /* Record the fields for the semantic handler.  */
3174   FLD (f_rm) = f_rm;
3175   FLD (f_rn) = f_rn;
3176   if (UNLIKELY(current_cpu->trace_extract_p))
3177     {
3178       current_cpu->trace_stream
3179         << "0x" << hex << pc << dec << " (sfmt_movl1_compact)\t"
3180         << " f_rm:0x" << hex << f_rm << dec
3181         << " f_rn:0x" << hex << f_rn << dec
3182         << endl;
3183     }
3184
3185   /* Record the fields for profiling.  */
3186   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3187     {
3188       FLD (in_rm) = f_rm;
3189       FLD (in_rn) = f_rn;
3190     }
3191 #undef FLD
3192 }
3193
3194 void
3195 sh2_extract_sfmt_movl2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3196     sh2_insn_word insn = entire_insn;
3197 #define FLD(f) abuf->fields.sfmt_macl_compact.f
3198     UINT f_rn;
3199     UINT f_rm;
3200
3201     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3202     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3203
3204   /* Record the fields for the semantic handler.  */
3205   FLD (f_rm) = f_rm;
3206   FLD (f_rn) = f_rn;
3207   if (UNLIKELY(current_cpu->trace_extract_p))
3208     {
3209       current_cpu->trace_stream
3210         << "0x" << hex << pc << dec << " (sfmt_movl2_compact)\t"
3211         << " f_rm:0x" << hex << f_rm << dec
3212         << " f_rn:0x" << hex << f_rn << dec
3213         << endl;
3214     }
3215
3216   /* Record the fields for profiling.  */
3217   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3218     {
3219       FLD (in_rm) = f_rm;
3220       FLD (in_rn) = f_rn;
3221       FLD (out_rn) = f_rn;
3222     }
3223 #undef FLD
3224 }
3225
3226 void
3227 sh2_extract_sfmt_movl3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3228     sh2_insn_word insn = entire_insn;
3229 #define FLD(f) abuf->fields.sfmt_movb3_compact.f
3230     UINT f_rn;
3231     UINT f_rm;
3232
3233     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3234     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3235
3236   /* Record the fields for the semantic handler.  */
3237   FLD (f_rm) = f_rm;
3238   FLD (f_rn) = f_rn;
3239   if (UNLIKELY(current_cpu->trace_extract_p))
3240     {
3241       current_cpu->trace_stream
3242         << "0x" << hex << pc << dec << " (sfmt_movl3_compact)\t"
3243         << " f_rm:0x" << hex << f_rm << dec
3244         << " f_rn:0x" << hex << f_rn << dec
3245         << endl;
3246     }
3247
3248   /* Record the fields for profiling.  */
3249   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3250     {
3251       FLD (in_r0) = 0;
3252       FLD (in_rm) = f_rm;
3253       FLD (in_rn) = f_rn;
3254     }
3255 #undef FLD
3256 }
3257
3258 void
3259 sh2_extract_sfmt_movl4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3260     sh2_insn_word insn = entire_insn;
3261 #define FLD(f) abuf->fields.sfmt_movl4_compact.f
3262     SI f_imm8x4;
3263
3264     f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2));
3265
3266   /* Record the fields for the semantic handler.  */
3267   FLD (f_imm8x4) = f_imm8x4;
3268   if (UNLIKELY(current_cpu->trace_extract_p))
3269     {
3270       current_cpu->trace_stream
3271         << "0x" << hex << pc << dec << " (sfmt_movl4_compact)\t"
3272         << " f_imm8x4:0x" << hex << f_imm8x4 << dec
3273         << endl;
3274     }
3275
3276   /* Record the fields for profiling.  */
3277   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3278     {
3279       FLD (in_r0) = 0;
3280     }
3281 #undef FLD
3282 }
3283
3284 void
3285 sh2_extract_sfmt_movl5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3286     sh2_insn_word insn = entire_insn;
3287 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
3288     UINT f_rn;
3289     UINT f_rm;
3290     SI f_imm4x4;
3291
3292     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3293     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3294     f_imm4x4 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (2));
3295
3296   /* Record the fields for the semantic handler.  */
3297   FLD (f_imm4x4) = f_imm4x4;
3298   FLD (f_rm) = f_rm;
3299   FLD (f_rn) = f_rn;
3300   if (UNLIKELY(current_cpu->trace_extract_p))
3301     {
3302       current_cpu->trace_stream
3303         << "0x" << hex << pc << dec << " (sfmt_movl5_compact)\t"
3304         << " f_imm4x4:0x" << hex << f_imm4x4 << dec
3305         << " f_rm:0x" << hex << f_rm << dec
3306         << " f_rn:0x" << hex << f_rn << dec
3307         << endl;
3308     }
3309
3310   /* Record the fields for profiling.  */
3311   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3312     {
3313       FLD (in_rm) = f_rm;
3314       FLD (in_rn) = f_rn;
3315     }
3316 #undef FLD
3317 }
3318
3319 void
3320 sh2_extract_sfmt_movl6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3321     sh2_insn_word insn = entire_insn;
3322 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
3323     UINT f_rn;
3324     UINT f_rm;
3325
3326     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3327     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3328
3329   /* Record the fields for the semantic handler.  */
3330   FLD (f_rm) = f_rm;
3331   FLD (f_rn) = f_rn;
3332   if (UNLIKELY(current_cpu->trace_extract_p))
3333     {
3334       current_cpu->trace_stream
3335         << "0x" << hex << pc << dec << " (sfmt_movl6_compact)\t"
3336         << " f_rm:0x" << hex << f_rm << dec
3337         << " f_rn:0x" << hex << f_rn << dec
3338         << endl;
3339     }
3340
3341   /* Record the fields for profiling.  */
3342   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3343     {
3344       FLD (in_rm) = f_rm;
3345       FLD (out_rn) = f_rn;
3346     }
3347 #undef FLD
3348 }
3349
3350 void
3351 sh2_extract_sfmt_movl7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3352     sh2_insn_word insn = entire_insn;
3353 #define FLD(f) abuf->fields.sfmt_macl_compact.f
3354     UINT f_rn;
3355     UINT f_rm;
3356
3357     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3358     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3359
3360   /* Record the fields for the semantic handler.  */
3361   FLD (f_rm) = f_rm;
3362   FLD (f_rn) = f_rn;
3363   if (UNLIKELY(current_cpu->trace_extract_p))
3364     {
3365       current_cpu->trace_stream
3366         << "0x" << hex << pc << dec << " (sfmt_movl7_compact)\t"
3367         << " f_rm:0x" << hex << f_rm << dec
3368         << " f_rn:0x" << hex << f_rn << dec
3369         << endl;
3370     }
3371
3372   /* Record the fields for profiling.  */
3373   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3374     {
3375       FLD (in_rm) = f_rm;
3376       FLD (in_rn) = f_rn;
3377       FLD (out_rm) = f_rm;
3378       FLD (out_rn) = f_rn;
3379     }
3380 #undef FLD
3381 }
3382
3383 void
3384 sh2_extract_sfmt_movl8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3385     sh2_insn_word insn = entire_insn;
3386 #define FLD(f) abuf->fields.sfmt_movb8_compact.f
3387     UINT f_rn;
3388     UINT f_rm;
3389
3390     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3391     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3392
3393   /* Record the fields for the semantic handler.  */
3394   FLD (f_rm) = f_rm;
3395   FLD (f_rn) = f_rn;
3396   if (UNLIKELY(current_cpu->trace_extract_p))
3397     {
3398       current_cpu->trace_stream
3399         << "0x" << hex << pc << dec << " (sfmt_movl8_compact)\t"
3400         << " f_rm:0x" << hex << f_rm << dec
3401         << " f_rn:0x" << hex << f_rn << dec
3402         << endl;
3403     }
3404
3405   /* Record the fields for profiling.  */
3406   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3407     {
3408       FLD (in_r0) = 0;
3409       FLD (in_rm) = f_rm;
3410       FLD (out_rn) = f_rn;
3411     }
3412 #undef FLD
3413 }
3414
3415 void
3416 sh2_extract_sfmt_movl9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3417     sh2_insn_word insn = entire_insn;
3418 #define FLD(f) abuf->fields.sfmt_movl9_compact.f
3419     SI f_imm8x4;
3420
3421     f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2));
3422
3423   /* Record the fields for the semantic handler.  */
3424   FLD (f_imm8x4) = f_imm8x4;
3425   if (UNLIKELY(current_cpu->trace_extract_p))
3426     {
3427       current_cpu->trace_stream
3428         << "0x" << hex << pc << dec << " (sfmt_movl9_compact)\t"
3429         << " f_imm8x4:0x" << hex << f_imm8x4 << dec
3430         << endl;
3431     }
3432
3433   /* Record the fields for profiling.  */
3434   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3435     {
3436       FLD (out_r0) = 0;
3437     }
3438 #undef FLD
3439 }
3440
3441 void
3442 sh2_extract_sfmt_movl10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3443     sh2_insn_word insn = entire_insn;
3444 #define FLD(f) abuf->fields.sfmt_movl10_compact.f
3445     UINT f_rn;
3446     SI f_imm8x4;
3447
3448     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3449     f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2));
3450
3451   /* Record the fields for the semantic handler.  */
3452   FLD (f_imm8x4) = f_imm8x4;
3453   FLD (f_rn) = f_rn;
3454   if (UNLIKELY(current_cpu->trace_extract_p))
3455     {
3456       current_cpu->trace_stream
3457         << "0x" << hex << pc << dec << " (sfmt_movl10_compact)\t"
3458         << " f_imm8x4:0x" << hex << f_imm8x4 << dec
3459         << " f_rn:0x" << hex << f_rn << dec
3460         << endl;
3461     }
3462
3463   /* Record the fields for profiling.  */
3464   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3465     {
3466       FLD (out_rn) = f_rn;
3467     }
3468 #undef FLD
3469 }
3470
3471 void
3472 sh2_extract_sfmt_movl11_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3473     sh2_insn_word insn = entire_insn;
3474 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
3475     UINT f_rn;
3476     UINT f_rm;
3477     SI f_imm4x4;
3478
3479     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3480     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3481     f_imm4x4 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (2));
3482
3483   /* Record the fields for the semantic handler.  */
3484   FLD (f_imm4x4) = f_imm4x4;
3485   FLD (f_rm) = f_rm;
3486   FLD (f_rn) = f_rn;
3487   if (UNLIKELY(current_cpu->trace_extract_p))
3488     {
3489       current_cpu->trace_stream
3490         << "0x" << hex << pc << dec << " (sfmt_movl11_compact)\t"
3491         << " f_imm4x4:0x" << hex << f_imm4x4 << dec
3492         << " f_rm:0x" << hex << f_rm << dec
3493         << " f_rn:0x" << hex << f_rn << dec
3494         << endl;
3495     }
3496
3497   /* Record the fields for profiling.  */
3498   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3499     {
3500       FLD (in_rm) = f_rm;
3501       FLD (out_rn) = f_rn;
3502     }
3503 #undef FLD
3504 }
3505
3506 void
3507 sh2_extract_sfmt_movw1_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3508     sh2_insn_word insn = entire_insn;
3509 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
3510     UINT f_rn;
3511     UINT f_rm;
3512
3513     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3514     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3515
3516   /* Record the fields for the semantic handler.  */
3517   FLD (f_rm) = f_rm;
3518   FLD (f_rn) = f_rn;
3519   if (UNLIKELY(current_cpu->trace_extract_p))
3520     {
3521       current_cpu->trace_stream
3522         << "0x" << hex << pc << dec << " (sfmt_movw1_compact)\t"
3523         << " f_rm:0x" << hex << f_rm << dec
3524         << " f_rn:0x" << hex << f_rn << dec
3525         << endl;
3526     }
3527
3528   /* Record the fields for profiling.  */
3529   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3530     {
3531       FLD (in_rm) = f_rm;
3532       FLD (in_rn) = f_rn;
3533     }
3534 #undef FLD
3535 }
3536
3537 void
3538 sh2_extract_sfmt_movw2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3539     sh2_insn_word insn = entire_insn;
3540 #define FLD(f) abuf->fields.sfmt_macl_compact.f
3541     UINT f_rn;
3542     UINT f_rm;
3543
3544     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3545     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3546
3547   /* Record the fields for the semantic handler.  */
3548   FLD (f_rm) = f_rm;
3549   FLD (f_rn) = f_rn;
3550   if (UNLIKELY(current_cpu->trace_extract_p))
3551     {
3552       current_cpu->trace_stream
3553         << "0x" << hex << pc << dec << " (sfmt_movw2_compact)\t"
3554         << " f_rm:0x" << hex << f_rm << dec
3555         << " f_rn:0x" << hex << f_rn << dec
3556         << endl;
3557     }
3558
3559   /* Record the fields for profiling.  */
3560   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3561     {
3562       FLD (in_rm) = f_rm;
3563       FLD (in_rn) = f_rn;
3564       FLD (out_rn) = f_rn;
3565     }
3566 #undef FLD
3567 }
3568
3569 void
3570 sh2_extract_sfmt_movw3_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3571     sh2_insn_word insn = entire_insn;
3572 #define FLD(f) abuf->fields.sfmt_movb3_compact.f
3573     UINT f_rn;
3574     UINT f_rm;
3575
3576     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3577     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3578
3579   /* Record the fields for the semantic handler.  */
3580   FLD (f_rm) = f_rm;
3581   FLD (f_rn) = f_rn;
3582   if (UNLIKELY(current_cpu->trace_extract_p))
3583     {
3584       current_cpu->trace_stream
3585         << "0x" << hex << pc << dec << " (sfmt_movw3_compact)\t"
3586         << " f_rm:0x" << hex << f_rm << dec
3587         << " f_rn:0x" << hex << f_rn << dec
3588         << endl;
3589     }
3590
3591   /* Record the fields for profiling.  */
3592   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3593     {
3594       FLD (in_r0) = 0;
3595       FLD (in_rm) = f_rm;
3596       FLD (in_rn) = f_rn;
3597     }
3598 #undef FLD
3599 }
3600
3601 void
3602 sh2_extract_sfmt_movw4_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3603     sh2_insn_word insn = entire_insn;
3604 #define FLD(f) abuf->fields.sfmt_movw4_compact.f
3605     SI f_imm8x2;
3606
3607     f_imm8x2 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (1));
3608
3609   /* Record the fields for the semantic handler.  */
3610   FLD (f_imm8x2) = f_imm8x2;
3611   if (UNLIKELY(current_cpu->trace_extract_p))
3612     {
3613       current_cpu->trace_stream
3614         << "0x" << hex << pc << dec << " (sfmt_movw4_compact)\t"
3615         << " f_imm8x2:0x" << hex << f_imm8x2 << dec
3616         << endl;
3617     }
3618
3619   /* Record the fields for profiling.  */
3620   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3621     {
3622       FLD (in_r0) = 0;
3623     }
3624 #undef FLD
3625 }
3626
3627 void
3628 sh2_extract_sfmt_movw5_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3629     sh2_insn_word insn = entire_insn;
3630 #define FLD(f) abuf->fields.sfmt_movw5_compact.f
3631     UINT f_rm;
3632     SI f_imm4x2;
3633
3634     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3635     f_imm4x2 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (1));
3636
3637   /* Record the fields for the semantic handler.  */
3638   FLD (f_imm4x2) = f_imm4x2;
3639   FLD (f_rm) = f_rm;
3640   if (UNLIKELY(current_cpu->trace_extract_p))
3641     {
3642       current_cpu->trace_stream
3643         << "0x" << hex << pc << dec << " (sfmt_movw5_compact)\t"
3644         << " f_imm4x2:0x" << hex << f_imm4x2 << dec
3645         << " f_rm:0x" << hex << f_rm << dec
3646         << endl;
3647     }
3648
3649   /* Record the fields for profiling.  */
3650   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3651     {
3652       FLD (in_r0) = 0;
3653       FLD (in_rm) = f_rm;
3654     }
3655 #undef FLD
3656 }
3657
3658 void
3659 sh2_extract_sfmt_movw6_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3660     sh2_insn_word insn = entire_insn;
3661 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
3662     UINT f_rn;
3663     UINT f_rm;
3664
3665     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3666     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3667
3668   /* Record the fields for the semantic handler.  */
3669   FLD (f_rm) = f_rm;
3670   FLD (f_rn) = f_rn;
3671   if (UNLIKELY(current_cpu->trace_extract_p))
3672     {
3673       current_cpu->trace_stream
3674         << "0x" << hex << pc << dec << " (sfmt_movw6_compact)\t"
3675         << " f_rm:0x" << hex << f_rm << dec
3676         << " f_rn:0x" << hex << f_rn << dec
3677         << endl;
3678     }
3679
3680   /* Record the fields for profiling.  */
3681   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3682     {
3683       FLD (in_rm) = f_rm;
3684       FLD (out_rn) = f_rn;
3685     }
3686 #undef FLD
3687 }
3688
3689 void
3690 sh2_extract_sfmt_movw7_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3691     sh2_insn_word insn = entire_insn;
3692 #define FLD(f) abuf->fields.sfmt_macl_compact.f
3693     UINT f_rn;
3694     UINT f_rm;
3695
3696     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3697     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3698
3699   /* Record the fields for the semantic handler.  */
3700   FLD (f_rm) = f_rm;
3701   FLD (f_rn) = f_rn;
3702   if (UNLIKELY(current_cpu->trace_extract_p))
3703     {
3704       current_cpu->trace_stream
3705         << "0x" << hex << pc << dec << " (sfmt_movw7_compact)\t"
3706         << " f_rm:0x" << hex << f_rm << dec
3707         << " f_rn:0x" << hex << f_rn << dec
3708         << endl;
3709     }
3710
3711   /* Record the fields for profiling.  */
3712   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3713     {
3714       FLD (in_rm) = f_rm;
3715       FLD (out_rm) = f_rm;
3716       FLD (out_rn) = f_rn;
3717     }
3718 #undef FLD
3719 }
3720
3721 void
3722 sh2_extract_sfmt_movw8_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3723     sh2_insn_word insn = entire_insn;
3724 #define FLD(f) abuf->fields.sfmt_movb8_compact.f
3725     UINT f_rn;
3726     UINT f_rm;
3727
3728     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3729     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3730
3731   /* Record the fields for the semantic handler.  */
3732   FLD (f_rm) = f_rm;
3733   FLD (f_rn) = f_rn;
3734   if (UNLIKELY(current_cpu->trace_extract_p))
3735     {
3736       current_cpu->trace_stream
3737         << "0x" << hex << pc << dec << " (sfmt_movw8_compact)\t"
3738         << " f_rm:0x" << hex << f_rm << dec
3739         << " f_rn:0x" << hex << f_rn << dec
3740         << endl;
3741     }
3742
3743   /* Record the fields for profiling.  */
3744   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3745     {
3746       FLD (in_r0) = 0;
3747       FLD (in_rm) = f_rm;
3748       FLD (out_rn) = f_rn;
3749     }
3750 #undef FLD
3751 }
3752
3753 void
3754 sh2_extract_sfmt_movw9_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3755     sh2_insn_word insn = entire_insn;
3756 #define FLD(f) abuf->fields.sfmt_movw9_compact.f
3757     SI f_imm8x2;
3758
3759     f_imm8x2 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (1));
3760
3761   /* Record the fields for the semantic handler.  */
3762   FLD (f_imm8x2) = f_imm8x2;
3763   if (UNLIKELY(current_cpu->trace_extract_p))
3764     {
3765       current_cpu->trace_stream
3766         << "0x" << hex << pc << dec << " (sfmt_movw9_compact)\t"
3767         << " f_imm8x2:0x" << hex << f_imm8x2 << dec
3768         << endl;
3769     }
3770
3771   /* Record the fields for profiling.  */
3772   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3773     {
3774       FLD (out_r0) = 0;
3775     }
3776 #undef FLD
3777 }
3778
3779 void
3780 sh2_extract_sfmt_movw10_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3781     sh2_insn_word insn = entire_insn;
3782 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
3783     UINT f_rn;
3784     SI f_imm8x2;
3785
3786     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3787     f_imm8x2 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (1));
3788
3789   /* Record the fields for the semantic handler.  */
3790   FLD (f_imm8x2) = f_imm8x2;
3791   FLD (f_rn) = f_rn;
3792   if (UNLIKELY(current_cpu->trace_extract_p))
3793     {
3794       current_cpu->trace_stream
3795         << "0x" << hex << pc << dec << " (sfmt_movw10_compact)\t"
3796         << " f_imm8x2:0x" << hex << f_imm8x2 << dec
3797         << " f_rn:0x" << hex << f_rn << dec
3798         << endl;
3799     }
3800
3801   /* Record the fields for profiling.  */
3802   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3803     {
3804       FLD (out_rn) = f_rn;
3805     }
3806 #undef FLD
3807 }
3808
3809 void
3810 sh2_extract_sfmt_movw11_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3811     sh2_insn_word insn = entire_insn;
3812 #define FLD(f) abuf->fields.sfmt_movw11_compact.f
3813     UINT f_rm;
3814     SI f_imm4x2;
3815
3816     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3817     f_imm4x2 = ((EXTRACT_MSB0_UINT (insn, 16, 12, 4)) << (1));
3818
3819   /* Record the fields for the semantic handler.  */
3820   FLD (f_imm4x2) = f_imm4x2;
3821   FLD (f_rm) = f_rm;
3822   if (UNLIKELY(current_cpu->trace_extract_p))
3823     {
3824       current_cpu->trace_stream
3825         << "0x" << hex << pc << dec << " (sfmt_movw11_compact)\t"
3826         << " f_imm4x2:0x" << hex << f_imm4x2 << dec
3827         << " f_rm:0x" << hex << f_rm << dec
3828         << endl;
3829     }
3830
3831   /* Record the fields for profiling.  */
3832   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3833     {
3834       FLD (in_rm) = f_rm;
3835       FLD (out_r0) = 0;
3836     }
3837 #undef FLD
3838 }
3839
3840 void
3841 sh2_extract_sfmt_mova_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3842     sh2_insn_word insn = entire_insn;
3843 #define FLD(f) abuf->fields.sfmt_movl9_compact.f
3844     SI f_imm8x4;
3845
3846     f_imm8x4 = ((EXTRACT_MSB0_UINT (insn, 16, 8, 8)) << (2));
3847
3848   /* Record the fields for the semantic handler.  */
3849   FLD (f_imm8x4) = f_imm8x4;
3850   if (UNLIKELY(current_cpu->trace_extract_p))
3851     {
3852       current_cpu->trace_stream
3853         << "0x" << hex << pc << dec << " (sfmt_mova_compact)\t"
3854         << " f_imm8x4:0x" << hex << f_imm8x4 << dec
3855         << endl;
3856     }
3857
3858   /* Record the fields for profiling.  */
3859   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3860     {
3861       FLD (out_r0) = 0;
3862     }
3863 #undef FLD
3864 }
3865
3866 void
3867 sh2_extract_sfmt_movt_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3868     sh2_insn_word insn = entire_insn;
3869 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
3870     UINT f_rn;
3871
3872     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3873
3874   /* Record the fields for the semantic handler.  */
3875   FLD (f_rn) = f_rn;
3876   if (UNLIKELY(current_cpu->trace_extract_p))
3877     {
3878       current_cpu->trace_stream
3879         << "0x" << hex << pc << dec << " (sfmt_movt_compact)\t"
3880         << " f_rn:0x" << hex << f_rn << dec
3881         << endl;
3882     }
3883
3884   /* Record the fields for profiling.  */
3885   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3886     {
3887       FLD (out_rn) = f_rn;
3888     }
3889 #undef FLD
3890 }
3891
3892 void
3893 sh2_extract_sfmt_mull_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3894     sh2_insn_word insn = entire_insn;
3895 #define FLD(f) abuf->fields.sfmt_movl5_compact.f
3896     UINT f_rn;
3897     UINT f_rm;
3898
3899     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3900     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3901
3902   /* Record the fields for the semantic handler.  */
3903   FLD (f_rm) = f_rm;
3904   FLD (f_rn) = f_rn;
3905   if (UNLIKELY(current_cpu->trace_extract_p))
3906     {
3907       current_cpu->trace_stream
3908         << "0x" << hex << pc << dec << " (sfmt_mull_compact)\t"
3909         << " f_rm:0x" << hex << f_rm << dec
3910         << " f_rn:0x" << hex << f_rn << dec
3911         << endl;
3912     }
3913
3914   /* Record the fields for profiling.  */
3915   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3916     {
3917       FLD (in_rm) = f_rm;
3918       FLD (in_rn) = f_rn;
3919     }
3920 #undef FLD
3921 }
3922
3923 void
3924 sh2_extract_sfmt_negc_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3925     sh2_insn_word insn = entire_insn;
3926 #define FLD(f) abuf->fields.sfmt_movl11_compact.f
3927     UINT f_rn;
3928     UINT f_rm;
3929
3930     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3931     f_rm = EXTRACT_MSB0_UINT (insn, 16, 8, 4);
3932
3933   /* Record the fields for the semantic handler.  */
3934   FLD (f_rm) = f_rm;
3935   FLD (f_rn) = f_rn;
3936   if (UNLIKELY(current_cpu->trace_extract_p))
3937     {
3938       current_cpu->trace_stream
3939         << "0x" << hex << pc << dec << " (sfmt_negc_compact)\t"
3940         << " f_rm:0x" << hex << f_rm << dec
3941         << " f_rn:0x" << hex << f_rn << dec
3942         << endl;
3943     }
3944
3945   /* Record the fields for profiling.  */
3946   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3947     {
3948       FLD (in_rm) = f_rm;
3949       FLD (out_rn) = f_rn;
3950     }
3951 #undef FLD
3952 }
3953
3954 void
3955 sh2_extract_sfmt_nop_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3956     sh2_insn_word insn = entire_insn;
3957 #define FLD(f) abuf->fields.fmt_empty.f
3958
3959
3960   /* Record the fields for the semantic handler.  */
3961   if (UNLIKELY(current_cpu->trace_extract_p))
3962     {
3963       current_cpu->trace_stream
3964         << "0x" << hex << pc << dec << " (sfmt_nop_compact)\t"
3965         << endl;
3966     }
3967
3968 #undef FLD
3969 }
3970
3971 void
3972 sh2_extract_sfmt_rotcl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
3973     sh2_insn_word insn = entire_insn;
3974 #define FLD(f) abuf->fields.sfmt_addi_compact.f
3975     UINT f_rn;
3976
3977     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
3978
3979   /* Record the fields for the semantic handler.  */
3980   FLD (f_rn) = f_rn;
3981   if (UNLIKELY(current_cpu->trace_extract_p))
3982     {
3983       current_cpu->trace_stream
3984         << "0x" << hex << pc << dec << " (sfmt_rotcl_compact)\t"
3985         << " f_rn:0x" << hex << f_rn << dec
3986         << endl;
3987     }
3988
3989   /* Record the fields for profiling.  */
3990   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3991     {
3992       FLD (in_rn) = f_rn;
3993       FLD (out_rn) = f_rn;
3994     }
3995 #undef FLD
3996 }
3997
3998 void
3999 sh2_extract_sfmt_rts_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4000     sh2_insn_word insn = entire_insn;
4001 #define FLD(f) abuf->fields.fmt_empty.f
4002
4003
4004   /* Record the fields for the semantic handler.  */
4005   if (UNLIKELY(current_cpu->trace_extract_p))
4006     {
4007       current_cpu->trace_stream
4008         << "0x" << hex << pc << dec << " (sfmt_rts_compact)\t"
4009         << endl;
4010     }
4011
4012   /* Record the fields for profiling.  */
4013   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4014     {
4015     }
4016 #undef FLD
4017 }
4018
4019 void
4020 sh2_extract_sfmt_shll2_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4021     sh2_insn_word insn = entire_insn;
4022 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4023     UINT f_rn;
4024
4025     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4026
4027   /* Record the fields for the semantic handler.  */
4028   FLD (f_rn) = f_rn;
4029   if (UNLIKELY(current_cpu->trace_extract_p))
4030     {
4031       current_cpu->trace_stream
4032         << "0x" << hex << pc << dec << " (sfmt_shll2_compact)\t"
4033         << " f_rn:0x" << hex << f_rn << dec
4034         << endl;
4035     }
4036
4037   /* Record the fields for profiling.  */
4038   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4039     {
4040       FLD (in_rn) = f_rn;
4041       FLD (out_rn) = f_rn;
4042     }
4043 #undef FLD
4044 }
4045
4046 void
4047 sh2_extract_sfmt_stc_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4048     sh2_insn_word insn = entire_insn;
4049 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
4050     UINT f_rn;
4051
4052     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4053
4054   /* Record the fields for the semantic handler.  */
4055   FLD (f_rn) = f_rn;
4056   if (UNLIKELY(current_cpu->trace_extract_p))
4057     {
4058       current_cpu->trace_stream
4059         << "0x" << hex << pc << dec << " (sfmt_stc_gbr_compact)\t"
4060         << " f_rn:0x" << hex << f_rn << dec
4061         << endl;
4062     }
4063
4064   /* Record the fields for profiling.  */
4065   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4066     {
4067       FLD (out_rn) = f_rn;
4068     }
4069 #undef FLD
4070 }
4071
4072 void
4073 sh2_extract_sfmt_stc_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4074     sh2_insn_word insn = entire_insn;
4075 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
4076     UINT f_rn;
4077
4078     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4079
4080   /* Record the fields for the semantic handler.  */
4081   FLD (f_rn) = f_rn;
4082   if (UNLIKELY(current_cpu->trace_extract_p))
4083     {
4084       current_cpu->trace_stream
4085         << "0x" << hex << pc << dec << " (sfmt_stc_vbr_compact)\t"
4086         << " f_rn:0x" << hex << f_rn << dec
4087         << endl;
4088     }
4089
4090   /* Record the fields for profiling.  */
4091   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4092     {
4093       FLD (out_rn) = f_rn;
4094     }
4095 #undef FLD
4096 }
4097
4098 void
4099 sh2_extract_sfmt_stcl_gbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4100     sh2_insn_word insn = entire_insn;
4101 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4102     UINT f_rn;
4103
4104     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4105
4106   /* Record the fields for the semantic handler.  */
4107   FLD (f_rn) = f_rn;
4108   if (UNLIKELY(current_cpu->trace_extract_p))
4109     {
4110       current_cpu->trace_stream
4111         << "0x" << hex << pc << dec << " (sfmt_stcl_gbr_compact)\t"
4112         << " f_rn:0x" << hex << f_rn << dec
4113         << endl;
4114     }
4115
4116   /* Record the fields for profiling.  */
4117   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4118     {
4119       FLD (in_rn) = f_rn;
4120       FLD (out_rn) = f_rn;
4121     }
4122 #undef FLD
4123 }
4124
4125 void
4126 sh2_extract_sfmt_stcl_vbr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4127     sh2_insn_word insn = entire_insn;
4128 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4129     UINT f_rn;
4130
4131     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4132
4133   /* Record the fields for the semantic handler.  */
4134   FLD (f_rn) = f_rn;
4135   if (UNLIKELY(current_cpu->trace_extract_p))
4136     {
4137       current_cpu->trace_stream
4138         << "0x" << hex << pc << dec << " (sfmt_stcl_vbr_compact)\t"
4139         << " f_rn:0x" << hex << f_rn << dec
4140         << endl;
4141     }
4142
4143   /* Record the fields for profiling.  */
4144   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4145     {
4146       FLD (in_rn) = f_rn;
4147       FLD (out_rn) = f_rn;
4148     }
4149 #undef FLD
4150 }
4151
4152 void
4153 sh2_extract_sfmt_sts_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4154     sh2_insn_word insn = entire_insn;
4155 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
4156     UINT f_rn;
4157
4158     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4159
4160   /* Record the fields for the semantic handler.  */
4161   FLD (f_rn) = f_rn;
4162   if (UNLIKELY(current_cpu->trace_extract_p))
4163     {
4164       current_cpu->trace_stream
4165         << "0x" << hex << pc << dec << " (sfmt_sts_mach_compact)\t"
4166         << " f_rn:0x" << hex << f_rn << dec
4167         << endl;
4168     }
4169
4170   /* Record the fields for profiling.  */
4171   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4172     {
4173       FLD (out_rn) = f_rn;
4174     }
4175 #undef FLD
4176 }
4177
4178 void
4179 sh2_extract_sfmt_stsl_mach_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4180     sh2_insn_word insn = entire_insn;
4181 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4182     UINT f_rn;
4183
4184     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4185
4186   /* Record the fields for the semantic handler.  */
4187   FLD (f_rn) = f_rn;
4188   if (UNLIKELY(current_cpu->trace_extract_p))
4189     {
4190       current_cpu->trace_stream
4191         << "0x" << hex << pc << dec << " (sfmt_stsl_mach_compact)\t"
4192         << " f_rn:0x" << hex << f_rn << dec
4193         << endl;
4194     }
4195
4196   /* Record the fields for profiling.  */
4197   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4198     {
4199       FLD (in_rn) = f_rn;
4200       FLD (out_rn) = f_rn;
4201     }
4202 #undef FLD
4203 }
4204
4205 void
4206 sh2_extract_sfmt_sts_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4207     sh2_insn_word insn = entire_insn;
4208 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
4209     UINT f_rn;
4210
4211     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4212
4213   /* Record the fields for the semantic handler.  */
4214   FLD (f_rn) = f_rn;
4215   if (UNLIKELY(current_cpu->trace_extract_p))
4216     {
4217       current_cpu->trace_stream
4218         << "0x" << hex << pc << dec << " (sfmt_sts_macl_compact)\t"
4219         << " f_rn:0x" << hex << f_rn << dec
4220         << endl;
4221     }
4222
4223   /* Record the fields for profiling.  */
4224   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4225     {
4226       FLD (out_rn) = f_rn;
4227     }
4228 #undef FLD
4229 }
4230
4231 void
4232 sh2_extract_sfmt_stsl_macl_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4233     sh2_insn_word insn = entire_insn;
4234 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4235     UINT f_rn;
4236
4237     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4238
4239   /* Record the fields for the semantic handler.  */
4240   FLD (f_rn) = f_rn;
4241   if (UNLIKELY(current_cpu->trace_extract_p))
4242     {
4243       current_cpu->trace_stream
4244         << "0x" << hex << pc << dec << " (sfmt_stsl_macl_compact)\t"
4245         << " f_rn:0x" << hex << f_rn << dec
4246         << endl;
4247     }
4248
4249   /* Record the fields for profiling.  */
4250   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4251     {
4252       FLD (in_rn) = f_rn;
4253       FLD (out_rn) = f_rn;
4254     }
4255 #undef FLD
4256 }
4257
4258 void
4259 sh2_extract_sfmt_sts_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4260     sh2_insn_word insn = entire_insn;
4261 #define FLD(f) abuf->fields.sfmt_movw10_compact.f
4262     UINT f_rn;
4263
4264     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4265
4266   /* Record the fields for the semantic handler.  */
4267   FLD (f_rn) = f_rn;
4268   if (UNLIKELY(current_cpu->trace_extract_p))
4269     {
4270       current_cpu->trace_stream
4271         << "0x" << hex << pc << dec << " (sfmt_sts_pr_compact)\t"
4272         << " f_rn:0x" << hex << f_rn << dec
4273         << endl;
4274     }
4275
4276   /* Record the fields for profiling.  */
4277   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4278     {
4279       FLD (out_rn) = f_rn;
4280     }
4281 #undef FLD
4282 }
4283
4284 void
4285 sh2_extract_sfmt_stsl_pr_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4286     sh2_insn_word insn = entire_insn;
4287 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4288     UINT f_rn;
4289
4290     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4291
4292   /* Record the fields for the semantic handler.  */
4293   FLD (f_rn) = f_rn;
4294   if (UNLIKELY(current_cpu->trace_extract_p))
4295     {
4296       current_cpu->trace_stream
4297         << "0x" << hex << pc << dec << " (sfmt_stsl_pr_compact)\t"
4298         << " f_rn:0x" << hex << f_rn << dec
4299         << endl;
4300     }
4301
4302   /* Record the fields for profiling.  */
4303   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4304     {
4305       FLD (in_rn) = f_rn;
4306       FLD (out_rn) = f_rn;
4307     }
4308 #undef FLD
4309 }
4310
4311 void
4312 sh2_extract_sfmt_tasb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4313     sh2_insn_word insn = entire_insn;
4314 #define FLD(f) abuf->fields.sfmt_addi_compact.f
4315     UINT f_rn;
4316
4317     f_rn = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
4318
4319   /* Record the fields for the semantic handler.  */
4320   FLD (f_rn) = f_rn;
4321   if (UNLIKELY(current_cpu->trace_extract_p))
4322     {
4323       current_cpu->trace_stream
4324         << "0x" << hex << pc << dec << " (sfmt_tasb_compact)\t"
4325         << " f_rn:0x" << hex << f_rn << dec
4326         << endl;
4327     }
4328
4329   /* Record the fields for profiling.  */
4330   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4331     {
4332       FLD (in_rn) = f_rn;
4333     }
4334 #undef FLD
4335 }
4336
4337 void
4338 sh2_extract_sfmt_trapa_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4339     sh2_insn_word insn = entire_insn;
4340 #define FLD(f) abuf->fields.sfmt_andi_compact.f
4341     UINT f_imm8;
4342
4343     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
4344
4345   /* Record the fields for the semantic handler.  */
4346   FLD (f_imm8) = f_imm8;
4347   if (UNLIKELY(current_cpu->trace_extract_p))
4348     {
4349       current_cpu->trace_stream
4350         << "0x" << hex << pc << dec << " (sfmt_trapa_compact)\t"
4351         << " f_imm8:0x" << hex << f_imm8 << dec
4352         << endl;
4353     }
4354
4355   /* Record the fields for profiling.  */
4356   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4357     {
4358     }
4359 #undef FLD
4360 }
4361
4362 void
4363 sh2_extract_sfmt_tsti_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4364     sh2_insn_word insn = entire_insn;
4365 #define FLD(f) abuf->fields.sfmt_andi_compact.f
4366     UINT f_imm8;
4367
4368     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
4369
4370   /* Record the fields for the semantic handler.  */
4371   FLD (f_imm8) = f_imm8;
4372   if (UNLIKELY(current_cpu->trace_extract_p))
4373     {
4374       current_cpu->trace_stream
4375         << "0x" << hex << pc << dec << " (sfmt_tsti_compact)\t"
4376         << " f_imm8:0x" << hex << f_imm8 << dec
4377         << endl;
4378     }
4379
4380   /* Record the fields for profiling.  */
4381   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4382     {
4383       FLD (in_r0) = 0;
4384     }
4385 #undef FLD
4386 }
4387
4388 void
4389 sh2_extract_sfmt_tstb_compact (sh2_scache* abuf, sh2_cpu* current_cpu, PCADDR pc, sh2_insn_word base_insn, sh2_insn_word entire_insn){
4390     sh2_insn_word insn = entire_insn;
4391 #define FLD(f) abuf->fields.sfmt_andi_compact.f
4392     UINT f_imm8;
4393
4394     f_imm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
4395
4396   /* Record the fields for the semantic handler.  */
4397   FLD (f_imm8) = f_imm8;
4398   if (UNLIKELY(current_cpu->trace_extract_p))
4399     {
4400       current_cpu->trace_stream
4401         << "0x" << hex << pc << dec << " (sfmt_tstb_compact)\t"
4402         << " f_imm8:0x" << hex << f_imm8 << dec
4403         << endl;
4404     }
4405
4406   /* Record the fields for profiling.  */
4407   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4408     {
4409       FLD (in_r0) = 0;
4410     }
4411 #undef FLD
4412 }
4413