sid/component/cgen-cpu/sh/sh5-media-decode.cxx

   1 /* Simulator instruction decoder for sh5_media.
   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 "sh5.h"
  17
  18 using namespace sh5; // FIXME: namespace organization still wip
  19
  20
  21 // The instruction descriptor array.
  22
  23 sh5_media_idesc sh5_media_idesc::idesc_table[SH5_MEDIA_INSN_XORI + 1] =
  24 {
  25   { sh5_media_sem_x_invalid, "X_INVALID", SH5_MEDIA_INSN_X_INVALID, { 0|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x40" } } },
  26   { sh5_media_sem_add, "ADD", SH5_MEDIA_INSN_ADD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  27   { sh5_media_sem_addl, "ADDL", SH5_MEDIA_INSN_ADDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  28   { sh5_media_sem_addi, "ADDI", SH5_MEDIA_INSN_ADDI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  29   { sh5_media_sem_addil, "ADDIL", SH5_MEDIA_INSN_ADDIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  30   { sh5_media_sem_addzl, "ADDZL", SH5_MEDIA_INSN_ADDZL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  31   { sh5_media_sem_alloco, "ALLOCO", SH5_MEDIA_INSN_ALLOCO, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  32   { sh5_media_sem_and, "AND", SH5_MEDIA_INSN_AND, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  33   { sh5_media_sem_andc, "ANDC", SH5_MEDIA_INSN_ANDC, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  34   { sh5_media_sem_andi, "ANDI", SH5_MEDIA_INSN_ANDI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  35   { sh5_media_sem_beq, "BEQ", SH5_MEDIA_INSN_BEQ, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  36   { sh5_media_sem_beqi, "BEQI", SH5_MEDIA_INSN_BEQI, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  37   { sh5_media_sem_bge, "BGE", SH5_MEDIA_INSN_BGE, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  38   { sh5_media_sem_bgeu, "BGEU", SH5_MEDIA_INSN_BGEU, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  39   { sh5_media_sem_bgt, "BGT", SH5_MEDIA_INSN_BGT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  40   { sh5_media_sem_bgtu, "BGTU", SH5_MEDIA_INSN_BGTU, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  41   { sh5_media_sem_blink, "BLINK", SH5_MEDIA_INSN_BLINK, { 0|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  42   { sh5_media_sem_bne, "BNE", SH5_MEDIA_INSN_BNE, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  43   { sh5_media_sem_bnei, "BNEI", SH5_MEDIA_INSN_BNEI, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x40" } } },
  44   { sh5_media_sem_brk, "BRK", SH5_MEDIA_INSN_BRK, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  45   { sh5_media_sem_byterev, "BYTEREV", SH5_MEDIA_INSN_BYTEREV, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  46   { sh5_media_sem_cmpeq, "CMPEQ", SH5_MEDIA_INSN_CMPEQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  47   { sh5_media_sem_cmpgt, "CMPGT", SH5_MEDIA_INSN_CMPGT, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  48   { sh5_media_sem_cmpgtu, "CMPGTU", SH5_MEDIA_INSN_CMPGTU, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  49   { sh5_media_sem_cmveq, "CMVEQ", SH5_MEDIA_INSN_CMVEQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  50   { sh5_media_sem_cmvne, "CMVNE", SH5_MEDIA_INSN_CMVNE, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  51   { sh5_media_sem_fabsd, "FABSD", SH5_MEDIA_INSN_FABSD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  52   { sh5_media_sem_fabss, "FABSS", SH5_MEDIA_INSN_FABSS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  53   { sh5_media_sem_faddd, "FADDD", SH5_MEDIA_INSN_FADDD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  54   { sh5_media_sem_fadds, "FADDS", SH5_MEDIA_INSN_FADDS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  55   { sh5_media_sem_fcmpeqd, "FCMPEQD", SH5_MEDIA_INSN_FCMPEQD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  56   { sh5_media_sem_fcmpeqs, "FCMPEQS", SH5_MEDIA_INSN_FCMPEQS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  57   { sh5_media_sem_fcmpged, "FCMPGED", SH5_MEDIA_INSN_FCMPGED, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  58   { sh5_media_sem_fcmpges, "FCMPGES", SH5_MEDIA_INSN_FCMPGES, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  59   { sh5_media_sem_fcmpgtd, "FCMPGTD", SH5_MEDIA_INSN_FCMPGTD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  60   { sh5_media_sem_fcmpgts, "FCMPGTS", SH5_MEDIA_INSN_FCMPGTS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  61   { sh5_media_sem_fcmpund, "FCMPUND", SH5_MEDIA_INSN_FCMPUND, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  62   { sh5_media_sem_fcmpuns, "FCMPUNS", SH5_MEDIA_INSN_FCMPUNS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  63   { sh5_media_sem_fcnvds, "FCNVDS", SH5_MEDIA_INSN_FCNVDS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  64   { sh5_media_sem_fcnvsd, "FCNVSD", SH5_MEDIA_INSN_FCNVSD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  65   { sh5_media_sem_fdivd, "FDIVD", SH5_MEDIA_INSN_FDIVD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  66   { sh5_media_sem_fdivs, "FDIVS", SH5_MEDIA_INSN_FDIVS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  67   { sh5_media_sem_fgetscr, "FGETSCR", SH5_MEDIA_INSN_FGETSCR, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  68   { sh5_media_sem_fiprs, "FIPRS", SH5_MEDIA_INSN_FIPRS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  69   { sh5_media_sem_fldd, "FLDD", SH5_MEDIA_INSN_FLDD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  70   { sh5_media_sem_fldp, "FLDP", SH5_MEDIA_INSN_FLDP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  71   { sh5_media_sem_flds, "FLDS", SH5_MEDIA_INSN_FLDS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  72   { sh5_media_sem_fldxd, "FLDXD", SH5_MEDIA_INSN_FLDXD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  73   { sh5_media_sem_fldxp, "FLDXP", SH5_MEDIA_INSN_FLDXP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  74   { sh5_media_sem_fldxs, "FLDXS", SH5_MEDIA_INSN_FLDXS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  75   { sh5_media_sem_floatld, "FLOATLD", SH5_MEDIA_INSN_FLOATLD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  76   { sh5_media_sem_floatls, "FLOATLS", SH5_MEDIA_INSN_FLOATLS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  77   { sh5_media_sem_floatqd, "FLOATQD", SH5_MEDIA_INSN_FLOATQD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  78   { sh5_media_sem_floatqs, "FLOATQS", SH5_MEDIA_INSN_FLOATQS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  79   { sh5_media_sem_fmacs, "FMACS", SH5_MEDIA_INSN_FMACS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  80   { sh5_media_sem_fmovd, "FMOVD", SH5_MEDIA_INSN_FMOVD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  81   { sh5_media_sem_fmovdq, "FMOVDQ", SH5_MEDIA_INSN_FMOVDQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  82   { sh5_media_sem_fmovls, "FMOVLS", SH5_MEDIA_INSN_FMOVLS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  83   { sh5_media_sem_fmovqd, "FMOVQD", SH5_MEDIA_INSN_FMOVQD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  84   { sh5_media_sem_fmovs, "FMOVS", SH5_MEDIA_INSN_FMOVS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  85   { sh5_media_sem_fmovsl, "FMOVSL", SH5_MEDIA_INSN_FMOVSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  86   { sh5_media_sem_fmuld, "FMULD", SH5_MEDIA_INSN_FMULD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  87   { sh5_media_sem_fmuls, "FMULS", SH5_MEDIA_INSN_FMULS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  88   { sh5_media_sem_fnegd, "FNEGD", SH5_MEDIA_INSN_FNEGD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  89   { sh5_media_sem_fnegs, "FNEGS", SH5_MEDIA_INSN_FNEGS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  90   { sh5_media_sem_fputscr, "FPUTSCR", SH5_MEDIA_INSN_FPUTSCR, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  91   { sh5_media_sem_fsqrtd, "FSQRTD", SH5_MEDIA_INSN_FSQRTD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  92   { sh5_media_sem_fsqrts, "FSQRTS", SH5_MEDIA_INSN_FSQRTS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  93   { sh5_media_sem_fstd, "FSTD", SH5_MEDIA_INSN_FSTD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  94   { sh5_media_sem_fstp, "FSTP", SH5_MEDIA_INSN_FSTP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  95   { sh5_media_sem_fsts, "FSTS", SH5_MEDIA_INSN_FSTS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  96   { sh5_media_sem_fstxd, "FSTXD", SH5_MEDIA_INSN_FSTXD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  97   { sh5_media_sem_fstxp, "FSTXP", SH5_MEDIA_INSN_FSTXP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  98   { sh5_media_sem_fstxs, "FSTXS", SH5_MEDIA_INSN_FSTXS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
  99   { sh5_media_sem_fsubd, "FSUBD", SH5_MEDIA_INSN_FSUBD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 100   { sh5_media_sem_fsubs, "FSUBS", SH5_MEDIA_INSN_FSUBS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 101   { sh5_media_sem_ftrcdl, "FTRCDL", SH5_MEDIA_INSN_FTRCDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 102   { sh5_media_sem_ftrcsl, "FTRCSL", SH5_MEDIA_INSN_FTRCSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 103   { sh5_media_sem_ftrcdq, "FTRCDQ", SH5_MEDIA_INSN_FTRCDQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 104   { sh5_media_sem_ftrcsq, "FTRCSQ", SH5_MEDIA_INSN_FTRCSQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 105   { sh5_media_sem_ftrvs, "FTRVS", SH5_MEDIA_INSN_FTRVS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 106   { sh5_media_sem_getcfg, "GETCFG", SH5_MEDIA_INSN_GETCFG, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 107   { sh5_media_sem_getcon, "GETCON", SH5_MEDIA_INSN_GETCON, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 108   { sh5_media_sem_gettr, "GETTR", SH5_MEDIA_INSN_GETTR, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 109   { sh5_media_sem_icbi, "ICBI", SH5_MEDIA_INSN_ICBI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 110   { sh5_media_sem_ldb, "LDB", SH5_MEDIA_INSN_LDB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 111   { sh5_media_sem_ldl, "LDL", SH5_MEDIA_INSN_LDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 112   { sh5_media_sem_ldq, "LDQ", SH5_MEDIA_INSN_LDQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 113   { sh5_media_sem_ldub, "LDUB", SH5_MEDIA_INSN_LDUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 114   { sh5_media_sem_lduw, "LDUW", SH5_MEDIA_INSN_LDUW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 115   { sh5_media_sem_ldw, "LDW", SH5_MEDIA_INSN_LDW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 116   { sh5_media_sem_ldhil, "LDHIL", SH5_MEDIA_INSN_LDHIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 117   { sh5_media_sem_ldhiq, "LDHIQ", SH5_MEDIA_INSN_LDHIQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 118   { sh5_media_sem_ldlol, "LDLOL", SH5_MEDIA_INSN_LDLOL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 119   { sh5_media_sem_ldloq, "LDLOQ", SH5_MEDIA_INSN_LDLOQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 120   { sh5_media_sem_ldxb, "LDXB", SH5_MEDIA_INSN_LDXB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 121   { sh5_media_sem_ldxl, "LDXL", SH5_MEDIA_INSN_LDXL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 122   { sh5_media_sem_ldxq, "LDXQ", SH5_MEDIA_INSN_LDXQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 123   { sh5_media_sem_ldxub, "LDXUB", SH5_MEDIA_INSN_LDXUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 124   { sh5_media_sem_ldxuw, "LDXUW", SH5_MEDIA_INSN_LDXUW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 125   { sh5_media_sem_ldxw, "LDXW", SH5_MEDIA_INSN_LDXW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 126   { sh5_media_sem_mabsl, "MABSL", SH5_MEDIA_INSN_MABSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 127   { sh5_media_sem_mabsw, "MABSW", SH5_MEDIA_INSN_MABSW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 128   { sh5_media_sem_maddl, "MADDL", SH5_MEDIA_INSN_MADDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 129   { sh5_media_sem_maddw, "MADDW", SH5_MEDIA_INSN_MADDW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 130   { sh5_media_sem_maddsl, "MADDSL", SH5_MEDIA_INSN_MADDSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 131   { sh5_media_sem_maddsub, "MADDSUB", SH5_MEDIA_INSN_MADDSUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 132   { sh5_media_sem_maddsw, "MADDSW", SH5_MEDIA_INSN_MADDSW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 133   { sh5_media_sem_mcmpeqb, "MCMPEQB", SH5_MEDIA_INSN_MCMPEQB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 134   { sh5_media_sem_mcmpeql, "MCMPEQL", SH5_MEDIA_INSN_MCMPEQL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 135   { sh5_media_sem_mcmpeqw, "MCMPEQW", SH5_MEDIA_INSN_MCMPEQW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 136   { sh5_media_sem_mcmpgtl, "MCMPGTL", SH5_MEDIA_INSN_MCMPGTL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 137   { sh5_media_sem_mcmpgtub, "MCMPGTUB", SH5_MEDIA_INSN_MCMPGTUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 138   { sh5_media_sem_mcmpgtw, "MCMPGTW", SH5_MEDIA_INSN_MCMPGTW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 139   { sh5_media_sem_mcmv, "MCMV", SH5_MEDIA_INSN_MCMV, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 140   { sh5_media_sem_mcnvslw, "MCNVSLW", SH5_MEDIA_INSN_MCNVSLW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 141   { sh5_media_sem_mcnvswb, "MCNVSWB", SH5_MEDIA_INSN_MCNVSWB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 142   { sh5_media_sem_mcnvswub, "MCNVSWUB", SH5_MEDIA_INSN_MCNVSWUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 143   { sh5_media_sem_mextr1, "MEXTR1", SH5_MEDIA_INSN_MEXTR1, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 144   { sh5_media_sem_mextr2, "MEXTR2", SH5_MEDIA_INSN_MEXTR2, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 145   { sh5_media_sem_mextr3, "MEXTR3", SH5_MEDIA_INSN_MEXTR3, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 146   { sh5_media_sem_mextr4, "MEXTR4", SH5_MEDIA_INSN_MEXTR4, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 147   { sh5_media_sem_mextr5, "MEXTR5", SH5_MEDIA_INSN_MEXTR5, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 148   { sh5_media_sem_mextr6, "MEXTR6", SH5_MEDIA_INSN_MEXTR6, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 149   { sh5_media_sem_mextr7, "MEXTR7", SH5_MEDIA_INSN_MEXTR7, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 150   { sh5_media_sem_mmacfxwl, "MMACFXWL", SH5_MEDIA_INSN_MMACFXWL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 151   { sh5_media_sem_mmacnfx_wl, "MMACNFX_WL", SH5_MEDIA_INSN_MMACNFX_WL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 152   { sh5_media_sem_mmull, "MMULL", SH5_MEDIA_INSN_MMULL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 153   { sh5_media_sem_mmulw, "MMULW", SH5_MEDIA_INSN_MMULW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 154   { sh5_media_sem_mmulfxl, "MMULFXL", SH5_MEDIA_INSN_MMULFXL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 155   { sh5_media_sem_mmulfxw, "MMULFXW", SH5_MEDIA_INSN_MMULFXW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 156   { sh5_media_sem_mmulfxrpw, "MMULFXRPW", SH5_MEDIA_INSN_MMULFXRPW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 157   { sh5_media_sem_mmulhiwl, "MMULHIWL", SH5_MEDIA_INSN_MMULHIWL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 158   { sh5_media_sem_mmullowl, "MMULLOWL", SH5_MEDIA_INSN_MMULLOWL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 159   { sh5_media_sem_mmulsumwq, "MMULSUMWQ", SH5_MEDIA_INSN_MMULSUMWQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 160   { sh5_media_sem_movi, "MOVI", SH5_MEDIA_INSN_MOVI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 161   { sh5_media_sem_mpermw, "MPERMW", SH5_MEDIA_INSN_MPERMW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 162   { sh5_media_sem_msadubq, "MSADUBQ", SH5_MEDIA_INSN_MSADUBQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 163   { sh5_media_sem_mshaldsl, "MSHALDSL", SH5_MEDIA_INSN_MSHALDSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 164   { sh5_media_sem_mshaldsw, "MSHALDSW", SH5_MEDIA_INSN_MSHALDSW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 165   { sh5_media_sem_mshardl, "MSHARDL", SH5_MEDIA_INSN_MSHARDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 166   { sh5_media_sem_mshardw, "MSHARDW", SH5_MEDIA_INSN_MSHARDW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 167   { sh5_media_sem_mshardsq, "MSHARDSQ", SH5_MEDIA_INSN_MSHARDSQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 168   { sh5_media_sem_mshfhib, "MSHFHIB", SH5_MEDIA_INSN_MSHFHIB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 169   { sh5_media_sem_mshfhil, "MSHFHIL", SH5_MEDIA_INSN_MSHFHIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 170   { sh5_media_sem_mshfhiw, "MSHFHIW", SH5_MEDIA_INSN_MSHFHIW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 171   { sh5_media_sem_mshflob, "MSHFLOB", SH5_MEDIA_INSN_MSHFLOB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 172   { sh5_media_sem_mshflol, "MSHFLOL", SH5_MEDIA_INSN_MSHFLOL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 173   { sh5_media_sem_mshflow, "MSHFLOW", SH5_MEDIA_INSN_MSHFLOW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 174   { sh5_media_sem_mshlldl, "MSHLLDL", SH5_MEDIA_INSN_MSHLLDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 175   { sh5_media_sem_mshlldw, "MSHLLDW", SH5_MEDIA_INSN_MSHLLDW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 176   { sh5_media_sem_mshlrdl, "MSHLRDL", SH5_MEDIA_INSN_MSHLRDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 177   { sh5_media_sem_mshlrdw, "MSHLRDW", SH5_MEDIA_INSN_MSHLRDW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 178   { sh5_media_sem_msubl, "MSUBL", SH5_MEDIA_INSN_MSUBL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 179   { sh5_media_sem_msubw, "MSUBW", SH5_MEDIA_INSN_MSUBW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 180   { sh5_media_sem_msubsl, "MSUBSL", SH5_MEDIA_INSN_MSUBSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 181   { sh5_media_sem_msubsub, "MSUBSUB", SH5_MEDIA_INSN_MSUBSUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 182   { sh5_media_sem_msubsw, "MSUBSW", SH5_MEDIA_INSN_MSUBSW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 183   { sh5_media_sem_mulsl, "MULSL", SH5_MEDIA_INSN_MULSL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 184   { sh5_media_sem_mulul, "MULUL", SH5_MEDIA_INSN_MULUL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 185   { sh5_media_sem_nop, "NOP", SH5_MEDIA_INSN_NOP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 186   { sh5_media_sem_nsb, "NSB", SH5_MEDIA_INSN_NSB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 187   { sh5_media_sem_ocbi, "OCBI", SH5_MEDIA_INSN_OCBI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 188   { sh5_media_sem_ocbp, "OCBP", SH5_MEDIA_INSN_OCBP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 189   { sh5_media_sem_ocbwb, "OCBWB", SH5_MEDIA_INSN_OCBWB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 190   { sh5_media_sem_or, "OR", SH5_MEDIA_INSN_OR, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 191   { sh5_media_sem_ori, "ORI", SH5_MEDIA_INSN_ORI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 192   { sh5_media_sem_prefi, "PREFI", SH5_MEDIA_INSN_PREFI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 193   { sh5_media_sem_pta, "PTA", SH5_MEDIA_INSN_PTA, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 194   { sh5_media_sem_ptabs, "PTABS", SH5_MEDIA_INSN_PTABS, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 195   { sh5_media_sem_ptb, "PTB", SH5_MEDIA_INSN_PTB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 196   { sh5_media_sem_ptrel, "PTREL", SH5_MEDIA_INSN_PTREL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 197   { sh5_media_sem_putcfg, "PUTCFG", SH5_MEDIA_INSN_PUTCFG, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 198   { sh5_media_sem_putcon, "PUTCON", SH5_MEDIA_INSN_PUTCON, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 199   { sh5_media_sem_rte, "RTE", SH5_MEDIA_INSN_RTE, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 200   { sh5_media_sem_shard, "SHARD", SH5_MEDIA_INSN_SHARD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 201   { sh5_media_sem_shardl, "SHARDL", SH5_MEDIA_INSN_SHARDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 202   { sh5_media_sem_shari, "SHARI", SH5_MEDIA_INSN_SHARI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 203   { sh5_media_sem_sharil, "SHARIL", SH5_MEDIA_INSN_SHARIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 204   { sh5_media_sem_shlld, "SHLLD", SH5_MEDIA_INSN_SHLLD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 205   { sh5_media_sem_shlldl, "SHLLDL", SH5_MEDIA_INSN_SHLLDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 206   { sh5_media_sem_shlli, "SHLLI", SH5_MEDIA_INSN_SHLLI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 207   { sh5_media_sem_shllil, "SHLLIL", SH5_MEDIA_INSN_SHLLIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 208   { sh5_media_sem_shlrd, "SHLRD", SH5_MEDIA_INSN_SHLRD, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 209   { sh5_media_sem_shlrdl, "SHLRDL", SH5_MEDIA_INSN_SHLRDL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 210   { sh5_media_sem_shlri, "SHLRI", SH5_MEDIA_INSN_SHLRI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 211   { sh5_media_sem_shlril, "SHLRIL", SH5_MEDIA_INSN_SHLRIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 212   { sh5_media_sem_shori, "SHORI", SH5_MEDIA_INSN_SHORI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 213   { sh5_media_sem_sleep, "SLEEP", SH5_MEDIA_INSN_SLEEP, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 214   { sh5_media_sem_stb, "STB", SH5_MEDIA_INSN_STB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 215   { sh5_media_sem_stl, "STL", SH5_MEDIA_INSN_STL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 216   { sh5_media_sem_stq, "STQ", SH5_MEDIA_INSN_STQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 217   { sh5_media_sem_stw, "STW", SH5_MEDIA_INSN_STW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 218   { sh5_media_sem_sthil, "STHIL", SH5_MEDIA_INSN_STHIL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 219   { sh5_media_sem_sthiq, "STHIQ", SH5_MEDIA_INSN_STHIQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 220   { sh5_media_sem_stlol, "STLOL", SH5_MEDIA_INSN_STLOL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 221   { sh5_media_sem_stloq, "STLOQ", SH5_MEDIA_INSN_STLOQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 222   { sh5_media_sem_stxb, "STXB", SH5_MEDIA_INSN_STXB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 223   { sh5_media_sem_stxl, "STXL", SH5_MEDIA_INSN_STXL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 224   { sh5_media_sem_stxq, "STXQ", SH5_MEDIA_INSN_STXQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 225   { sh5_media_sem_stxw, "STXW", SH5_MEDIA_INSN_STXW, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 226   { sh5_media_sem_sub, "SUB", SH5_MEDIA_INSN_SUB, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 227   { sh5_media_sem_subl, "SUBL", SH5_MEDIA_INSN_SUBL, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 228   { sh5_media_sem_swapq, "SWAPQ", SH5_MEDIA_INSN_SWAPQ, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 229   { sh5_media_sem_synci, "SYNCI", SH5_MEDIA_INSN_SYNCI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 230   { sh5_media_sem_synco, "SYNCO", SH5_MEDIA_INSN_SYNCO, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 231   { sh5_media_sem_trapa, "TRAPA", SH5_MEDIA_INSN_TRAPA, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 232   { sh5_media_sem_xor, "XOR", SH5_MEDIA_INSN_XOR, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 233   { sh5_media_sem_xori, "XORI", SH5_MEDIA_INSN_XORI, { 0, (1<<MACH_BASE), { 1, "\x40" } } },
 234
 235 };
 236
 237 // Given a canonical virtual insn id, return the target specific one.
 238
 239 sh5_media_insn_type
 240 sh5_media_idesc::lookup_virtual (virtual_insn_type vit)
 241 {
 242   switch (vit)
 243     {
 244       case VIRTUAL_INSN_INVALID: return SH5_MEDIA_INSN_X_INVALID;
 245       case VIRTUAL_INSN_COND: return SH5_MEDIA_INSN_X_INVALID;
 246     }
 247   abort ();
 248 }
 249
 250
 251 // Declare extractor functions
 252
 253 static void
 254 sh5_media_extract_sfmt_empty (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 255 static void
 256 sh5_media_extract_sfmt_add (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 257 static void
 258 sh5_media_extract_sfmt_addi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 259 static void
 260 sh5_media_extract_sfmt_alloco (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 261 static void
 262 sh5_media_extract_sfmt_beq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 263 static void
 264 sh5_media_extract_sfmt_beqi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 265 static void
 266 sh5_media_extract_sfmt_blink (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 267 static void
 268 sh5_media_extract_sfmt_brk (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 269 static void
 270 sh5_media_extract_sfmt_byterev (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 271 static void
 272 sh5_media_extract_sfmt_cmveq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 273 static void
 274 sh5_media_extract_sfmt_fabsd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 275 static void
 276 sh5_media_extract_sfmt_fabss (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 277 static void
 278 sh5_media_extract_sfmt_faddd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 279 static void
 280 sh5_media_extract_sfmt_fadds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 281 static void
 282 sh5_media_extract_sfmt_fcmpeqd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 283 static void
 284 sh5_media_extract_sfmt_fcmpeqs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 285 static void
 286 sh5_media_extract_sfmt_fcnvds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 287 static void
 288 sh5_media_extract_sfmt_fcnvsd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 289 static void
 290 sh5_media_extract_sfmt_fgetscr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 291 static void
 292 sh5_media_extract_sfmt_fiprs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 293 static void
 294 sh5_media_extract_sfmt_fldd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 295 static void
 296 sh5_media_extract_sfmt_fldp (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 297 static void
 298 sh5_media_extract_sfmt_flds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 299 static void
 300 sh5_media_extract_sfmt_fldxd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 301 static void
 302 sh5_media_extract_sfmt_fldxp (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 303 static void
 304 sh5_media_extract_sfmt_fldxs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 305 static void
 306 sh5_media_extract_sfmt_fmacs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 307 static void
 308 sh5_media_extract_sfmt_fmovdq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 309 static void
 310 sh5_media_extract_sfmt_fmovls (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 311 static void
 312 sh5_media_extract_sfmt_fmovqd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 313 static void
 314 sh5_media_extract_sfmt_fmovsl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 315 static void
 316 sh5_media_extract_sfmt_fputscr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 317 static void
 318 sh5_media_extract_sfmt_fstd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 319 static void
 320 sh5_media_extract_sfmt_fsts (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 321 static void
 322 sh5_media_extract_sfmt_fstxd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 323 static void
 324 sh5_media_extract_sfmt_fstxs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 325 static void
 326 sh5_media_extract_sfmt_ftrvs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 327 static void
 328 sh5_media_extract_sfmt_getcfg (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 329 static void
 330 sh5_media_extract_sfmt_getcon (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 331 static void
 332 sh5_media_extract_sfmt_gettr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 333 static void
 334 sh5_media_extract_sfmt_ldb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 335 static void
 336 sh5_media_extract_sfmt_ldl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 337 static void
 338 sh5_media_extract_sfmt_ldq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 339 static void
 340 sh5_media_extract_sfmt_lduw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 341 static void
 342 sh5_media_extract_sfmt_ldhil (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 343 static void
 344 sh5_media_extract_sfmt_ldhiq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 345 static void
 346 sh5_media_extract_sfmt_ldlol (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 347 static void
 348 sh5_media_extract_sfmt_ldloq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 349 static void
 350 sh5_media_extract_sfmt_ldxb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 351 static void
 352 sh5_media_extract_sfmt_ldxl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 353 static void
 354 sh5_media_extract_sfmt_ldxq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 355 static void
 356 sh5_media_extract_sfmt_ldxub (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 357 static void
 358 sh5_media_extract_sfmt_ldxuw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 359 static void
 360 sh5_media_extract_sfmt_ldxw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 361 static void
 362 sh5_media_extract_sfmt_mcmv (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 363 static void
 364 sh5_media_extract_sfmt_movi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 365 static void
 366 sh5_media_extract_sfmt_nop (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 367 static void
 368 sh5_media_extract_sfmt_ori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 369 static void
 370 sh5_media_extract_sfmt_pta (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 371 static void
 372 sh5_media_extract_sfmt_ptabs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 373 static void
 374 sh5_media_extract_sfmt_ptrel (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 375 static void
 376 sh5_media_extract_sfmt_putcfg (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 377 static void
 378 sh5_media_extract_sfmt_putcon (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 379 static void
 380 sh5_media_extract_sfmt_shari (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 381 static void
 382 sh5_media_extract_sfmt_shori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 383 static void
 384 sh5_media_extract_sfmt_stb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 385 static void
 386 sh5_media_extract_sfmt_stl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 387 static void
 388 sh5_media_extract_sfmt_stq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 389 static void
 390 sh5_media_extract_sfmt_stw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 391 static void
 392 sh5_media_extract_sfmt_sthil (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 393 static void
 394 sh5_media_extract_sfmt_sthiq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 395 static void
 396 sh5_media_extract_sfmt_stlol (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 397 static void
 398 sh5_media_extract_sfmt_stloq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 399 static void
 400 sh5_media_extract_sfmt_stxb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 401 static void
 402 sh5_media_extract_sfmt_stxl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 403 static void
 404 sh5_media_extract_sfmt_stxq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 405 static void
 406 sh5_media_extract_sfmt_stxw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 407 static void
 408 sh5_media_extract_sfmt_swapq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 409 static void
 410 sh5_media_extract_sfmt_trapa (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 411 static void
 412 sh5_media_extract_sfmt_xori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn);
 413
 414 // Fetch & decode instruction
 415 void
 416 sh5_media_scache::decode (sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn)
 417 {
 418   /* Result of decoder.  */
 419   SH5_MEDIA_INSN_TYPE itype;
 420
 421   {
 422     sh5_media_insn_word insn = base_insn;
 423
 424     {
 425       unsigned int val = (((insn >> 22) & (63 << 4)) | ((insn >> 16) & (15 << 0)));
 426       switch (val)
 427       {
 428       case 1 :
 429         if ((entire_insn & 0xfc0f000f) == 0x10000)
 430           { itype = SH5_MEDIA_INSN_CMPEQ; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 431         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 432       case 3 :
 433         if ((entire_insn & 0xfc0f000f) == 0x30000)
 434           { itype = SH5_MEDIA_INSN_CMPGT; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 435         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 436       case 7 :
 437         if ((entire_insn & 0xfc0f000f) == 0x70000)
 438           { itype = SH5_MEDIA_INSN_CMPGTU; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 439         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 440       case 8 :
 441         if ((entire_insn & 0xfc0f000f) == 0x80000)
 442           { itype = SH5_MEDIA_INSN_ADDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 443         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 444       case 9 :
 445         if ((entire_insn & 0xfc0f000f) == 0x90000)
 446           { itype = SH5_MEDIA_INSN_ADD; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 447         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 448       case 10 :
 449         if ((entire_insn & 0xfc0f000f) == 0xa0000)
 450           { itype = SH5_MEDIA_INSN_SUBL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 451         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 452       case 11 :
 453         if ((entire_insn & 0xfc0f000f) == 0xb0000)
 454           { itype = SH5_MEDIA_INSN_SUB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 455         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 456       case 12 :
 457         if ((entire_insn & 0xfc0f000f) == 0xc0000)
 458           { itype = SH5_MEDIA_INSN_ADDZL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 459         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 460       case 13 :
 461         if ((entire_insn & 0xfc0ffc0f) == 0xdfc00)
 462           { itype = SH5_MEDIA_INSN_NSB; sh5_media_extract_sfmt_byterev (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 463         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 464       case 14 :
 465         if ((entire_insn & 0xfc0f000f) == 0xe0000)
 466           { itype = SH5_MEDIA_INSN_MULUL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 467         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 468       case 15 :
 469         if ((entire_insn & 0xfc0ffc0f) == 0xffc00)
 470           { itype = SH5_MEDIA_INSN_BYTEREV; sh5_media_extract_sfmt_byterev (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 471         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 472       case 16 :
 473         if ((entire_insn & 0xfc0f000f) == 0x4000000)
 474           { itype = SH5_MEDIA_INSN_SHLLDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 475         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 476       case 17 :
 477         if ((entire_insn & 0xfc0f000f) == 0x4010000)
 478           { itype = SH5_MEDIA_INSN_SHLLD; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 479         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 480       case 18 :
 481         if ((entire_insn & 0xfc0f000f) == 0x4020000)
 482           { itype = SH5_MEDIA_INSN_SHLRDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 483         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 484       case 19 :
 485         if ((entire_insn & 0xfc0f000f) == 0x4030000)
 486           { itype = SH5_MEDIA_INSN_SHLRD; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 487         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 488       case 22 :
 489         if ((entire_insn & 0xfc0f000f) == 0x4060000)
 490           { itype = SH5_MEDIA_INSN_SHARDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 491         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 492       case 23 :
 493         if ((entire_insn & 0xfc0f000f) == 0x4070000)
 494           { itype = SH5_MEDIA_INSN_SHARD; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 495         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 496       case 25 :
 497         if ((entire_insn & 0xfc0f000f) == 0x4090000)
 498           { itype = SH5_MEDIA_INSN_OR; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 499         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 500       case 27 :
 501         if ((entire_insn & 0xfc0f000f) == 0x40b0000)
 502           { itype = SH5_MEDIA_INSN_AND; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 503         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 504       case 29 :
 505         if ((entire_insn & 0xfc0f000f) == 0x40d0000)
 506           { itype = SH5_MEDIA_INSN_XOR; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 507         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 508       case 30 :
 509         if ((entire_insn & 0xfc0f000f) == 0x40e0000)
 510           { itype = SH5_MEDIA_INSN_MULSL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 511         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 512       case 31 :
 513         if ((entire_insn & 0xfc0f000f) == 0x40f0000)
 514           { itype = SH5_MEDIA_INSN_ANDC; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 515         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 516       case 33 :
 517         if ((entire_insn & 0xfc0f000f) == 0x8010000)
 518           { itype = SH5_MEDIA_INSN_MADDW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 519         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 520       case 34 :
 521         if ((entire_insn & 0xfc0f000f) == 0x8020000)
 522           { itype = SH5_MEDIA_INSN_MADDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 523         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 524       case 36 :
 525         if ((entire_insn & 0xfc0f000f) == 0x8040000)
 526           { itype = SH5_MEDIA_INSN_MADDSUB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 527         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 528       case 37 :
 529         if ((entire_insn & 0xfc0f000f) == 0x8050000)
 530           { itype = SH5_MEDIA_INSN_MADDSW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 531         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 532       case 38 :
 533         if ((entire_insn & 0xfc0f000f) == 0x8060000)
 534           { itype = SH5_MEDIA_INSN_MADDSL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 535         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 536       case 41 :
 537         if ((entire_insn & 0xfc0f000f) == 0x8090000)
 538           { itype = SH5_MEDIA_INSN_MSUBW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 539         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 540       case 42 :
 541         if ((entire_insn & 0xfc0f000f) == 0x80a0000)
 542           { itype = SH5_MEDIA_INSN_MSUBL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 543         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 544       case 44 :
 545         if ((entire_insn & 0xfc0f000f) == 0x80c0000)
 546           { itype = SH5_MEDIA_INSN_MSUBSUB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 547         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 548       case 45 :
 549         if ((entire_insn & 0xfc0f000f) == 0x80d0000)
 550           { itype = SH5_MEDIA_INSN_MSUBSW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 551         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 552       case 46 :
 553         if ((entire_insn & 0xfc0f000f) == 0x80e0000)
 554           { itype = SH5_MEDIA_INSN_MSUBSL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 555         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 556       case 49 :
 557         if ((entire_insn & 0xfc0f000f) == 0xc010000)
 558           { itype = SH5_MEDIA_INSN_MSHLLDW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 559         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 560       case 50 :
 561         if ((entire_insn & 0xfc0f000f) == 0xc020000)
 562           { itype = SH5_MEDIA_INSN_MSHLLDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 563         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 564       case 53 :
 565         if ((entire_insn & 0xfc0f000f) == 0xc050000)
 566           { itype = SH5_MEDIA_INSN_MSHALDSW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 567         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 568       case 54 :
 569         if ((entire_insn & 0xfc0f000f) == 0xc060000)
 570           { itype = SH5_MEDIA_INSN_MSHALDSL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 571         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 572       case 57 :
 573         if ((entire_insn & 0xfc0f000f) == 0xc090000)
 574           { itype = SH5_MEDIA_INSN_MSHARDW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 575         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 576       case 58 :
 577         if ((entire_insn & 0xfc0f000f) == 0xc0a0000)
 578           { itype = SH5_MEDIA_INSN_MSHARDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 579         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 580       case 59 :
 581         if ((entire_insn & 0xfc0f000f) == 0xc0b0000)
 582           { itype = SH5_MEDIA_INSN_MSHARDSQ; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 583         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 584       case 61 :
 585         if ((entire_insn & 0xfc0f000f) == 0xc0d0000)
 586           { itype = SH5_MEDIA_INSN_MSHLRDW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 587         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 588       case 62 :
 589         if ((entire_insn & 0xfc0f000f) == 0xc0e0000)
 590           { itype = SH5_MEDIA_INSN_MSHLRDL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 591         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 592       case 86 :
 593         if ((entire_insn & 0xfc0f000f) == 0x14060000)
 594           { itype = SH5_MEDIA_INSN_FIPRS; sh5_media_extract_sfmt_fiprs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 595         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 596       case 94 :
 597         if ((entire_insn & 0xfc0f000f) == 0x140e0000)
 598           { itype = SH5_MEDIA_INSN_FTRVS; sh5_media_extract_sfmt_ftrvs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 599         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 600       case 96 :
 601         if ((entire_insn & 0xfc0f000f) == 0x18000000)
 602           { itype = SH5_MEDIA_INSN_FABSS; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 603         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 604       case 97 :
 605         if ((entire_insn & 0xfc0f000f) == 0x18010000)
 606           { itype = SH5_MEDIA_INSN_FABSD; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 607         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 608       case 98 :
 609         if ((entire_insn & 0xfc0f000f) == 0x18020000)
 610           { itype = SH5_MEDIA_INSN_FNEGS; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 611         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 612       case 99 :
 613         if ((entire_insn & 0xfc0f000f) == 0x18030000)
 614           { itype = SH5_MEDIA_INSN_FNEGD; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 615         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 616       case 112 :
 617         if ((entire_insn & 0xfc0ffc0f) == 0x1c00fc00)
 618           { itype = SH5_MEDIA_INSN_FMOVLS; sh5_media_extract_sfmt_fmovls (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 619         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 620       case 113 :
 621         if ((entire_insn & 0xfc0ffc0f) == 0x1c01fc00)
 622           { itype = SH5_MEDIA_INSN_FMOVQD; sh5_media_extract_sfmt_fmovqd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 623         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 624       case 114 :
 625         if ((entire_insn & 0xfffffc0f) == 0x1ff2fc00)
 626           { itype = SH5_MEDIA_INSN_FGETSCR; sh5_media_extract_sfmt_fgetscr (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 627         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 628       case 120 :
 629         if ((entire_insn & 0xfc0f000f) == 0x1c080000)
 630           { itype = SH5_MEDIA_INSN_FLDXS; sh5_media_extract_sfmt_fldxs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 631         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 632       case 121 :
 633         if ((entire_insn & 0xfc0f000f) == 0x1c090000)
 634           { itype = SH5_MEDIA_INSN_FLDXD; sh5_media_extract_sfmt_fldxd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 635         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 636       case 125 :
 637         if ((entire_insn & 0xfc0f000f) == 0x1c0d0000)
 638           { itype = SH5_MEDIA_INSN_FLDXP; sh5_media_extract_sfmt_fldxp (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 639         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 640       case 129 :
 641         if ((entire_insn & 0xfc0f000f) == 0x20010000)
 642           { itype = SH5_MEDIA_INSN_CMVEQ; sh5_media_extract_sfmt_cmveq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 643         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 644       case 131 :
 645         if ((entire_insn & 0xfc0f000f) == 0x20030000)
 646           { itype = SH5_MEDIA_INSN_SWAPQ; sh5_media_extract_sfmt_swapq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 647         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 648       case 133 :
 649         if ((entire_insn & 0xfc0f000f) == 0x20050000)
 650           { itype = SH5_MEDIA_INSN_CMVNE; sh5_media_extract_sfmt_cmveq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 651         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 652       case 159 :
 653         if ((entire_insn & 0xfc0ffc0f) == 0x240ffc00)
 654           { itype = SH5_MEDIA_INSN_GETCON; sh5_media_extract_sfmt_getcon (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 655         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 656       case 160 :
 657         if ((entire_insn & 0xfc0f000f) == 0x28000000)
 658           { itype = SH5_MEDIA_INSN_MCMPEQB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 659         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 660       case 161 :
 661         if ((entire_insn & 0xfc0f000f) == 0x28010000)
 662           { itype = SH5_MEDIA_INSN_MCMPEQW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 663         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 664       case 162 :
 665         if ((entire_insn & 0xfc0f000f) == 0x28020000)
 666           { itype = SH5_MEDIA_INSN_MCMPEQL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 667         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 668       case 164 :
 669         if ((entire_insn & 0xfc0f000f) == 0x28040000)
 670           { itype = SH5_MEDIA_INSN_MCMPGTUB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 671         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 672       case 165 :
 673         if ((entire_insn & 0xfc0f000f) == 0x28050000)
 674           { itype = SH5_MEDIA_INSN_MCMPGTW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 675         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 676       case 166 :
 677         if ((entire_insn & 0xfc0f000f) == 0x28060000)
 678           { itype = SH5_MEDIA_INSN_MCMPGTL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 679         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 680       case 167 :
 681         if ((entire_insn & 0xfc0f000f) == 0x28070000)
 682           { itype = SH5_MEDIA_INSN_MEXTR1; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 683         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 684       case 169 :
 685         if ((entire_insn & 0xfc0ffc0f) == 0x2809fc00)
 686           { itype = SH5_MEDIA_INSN_MABSW; sh5_media_extract_sfmt_byterev (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 687         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 688       case 170 :
 689         if ((entire_insn & 0xfc0ffc0f) == 0x280afc00)
 690           { itype = SH5_MEDIA_INSN_MABSL; sh5_media_extract_sfmt_byterev (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 691         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 692       case 171 :
 693         if ((entire_insn & 0xfc0f000f) == 0x280b0000)
 694           { itype = SH5_MEDIA_INSN_MEXTR2; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 695         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 696       case 173 :
 697         if ((entire_insn & 0xfc0f000f) == 0x280d0000)
 698           { itype = SH5_MEDIA_INSN_MPERMW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 699         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 700       case 175 :
 701         if ((entire_insn & 0xfc0f000f) == 0x280f0000)
 702           { itype = SH5_MEDIA_INSN_MEXTR3; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 703         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 704       case 176 :
 705         if ((entire_insn & 0xfc0f000f) == 0x2c000000)
 706           { itype = SH5_MEDIA_INSN_MSHFLOB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 707         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 708       case 177 :
 709         if ((entire_insn & 0xfc0f000f) == 0x2c010000)
 710           { itype = SH5_MEDIA_INSN_MSHFLOW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 711         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 712       case 178 :
 713         if ((entire_insn & 0xfc0f000f) == 0x2c020000)
 714           { itype = SH5_MEDIA_INSN_MSHFLOL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 715         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 716       case 179 :
 717         if ((entire_insn & 0xfc0f000f) == 0x2c030000)
 718           { itype = SH5_MEDIA_INSN_MEXTR4; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 719         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 720       case 180 :
 721         if ((entire_insn & 0xfc0f000f) == 0x2c040000)
 722           { itype = SH5_MEDIA_INSN_MSHFHIB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 723         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 724       case 181 :
 725         if ((entire_insn & 0xfc0f000f) == 0x2c050000)
 726           { itype = SH5_MEDIA_INSN_MSHFHIW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 727         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 728       case 182 :
 729         if ((entire_insn & 0xfc0f000f) == 0x2c060000)
 730           { itype = SH5_MEDIA_INSN_MSHFHIL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 731         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 732       case 183 :
 733         if ((entire_insn & 0xfc0f000f) == 0x2c070000)
 734           { itype = SH5_MEDIA_INSN_MEXTR5; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 735         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 736       case 187 :
 737         if ((entire_insn & 0xfc0f000f) == 0x2c0b0000)
 738           { itype = SH5_MEDIA_INSN_MEXTR6; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 739         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 740       case 191 :
 741         if ((entire_insn & 0xfc0f000f) == 0x2c0f0000)
 742           { itype = SH5_MEDIA_INSN_MEXTR7; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 743         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 744       case 192 :
 745         if ((entire_insn & 0xfc0f000f) == 0x30000000)
 746           { itype = SH5_MEDIA_INSN_FMOVSL; sh5_media_extract_sfmt_fmovsl (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 747         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 748       case 193 :
 749         if ((entire_insn & 0xfc0f000f) == 0x30010000)
 750           { itype = SH5_MEDIA_INSN_FMOVDQ; sh5_media_extract_sfmt_fmovdq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 751         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 752       case 194 :
 753         if ((entire_insn & 0xfc0f03ff) == 0x300203f0)
 754           { itype = SH5_MEDIA_INSN_FPUTSCR; sh5_media_extract_sfmt_fputscr (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 755         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 756       case 200 :
 757         if ((entire_insn & 0xfc0f000f) == 0x30080000)
 758           { itype = SH5_MEDIA_INSN_FCMPEQS; sh5_media_extract_sfmt_fcmpeqs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 759         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 760       case 201 :
 761         if ((entire_insn & 0xfc0f000f) == 0x30090000)
 762           { itype = SH5_MEDIA_INSN_FCMPEQD; sh5_media_extract_sfmt_fcmpeqd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 763         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 764       case 202 :
 765         if ((entire_insn & 0xfc0f000f) == 0x300a0000)
 766           { itype = SH5_MEDIA_INSN_FCMPUNS; sh5_media_extract_sfmt_fcmpeqs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 767         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 768       case 203 :
 769         if ((entire_insn & 0xfc0f000f) == 0x300b0000)
 770           { itype = SH5_MEDIA_INSN_FCMPUND; sh5_media_extract_sfmt_fcmpeqd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 771         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 772       case 204 :
 773         if ((entire_insn & 0xfc0f000f) == 0x300c0000)
 774           { itype = SH5_MEDIA_INSN_FCMPGTS; sh5_media_extract_sfmt_fcmpeqs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 775         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 776       case 205 :
 777         if ((entire_insn & 0xfc0f000f) == 0x300d0000)
 778           { itype = SH5_MEDIA_INSN_FCMPGTD; sh5_media_extract_sfmt_fcmpeqd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 779         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 780       case 206 :
 781         if ((entire_insn & 0xfc0f000f) == 0x300e0000)
 782           { itype = SH5_MEDIA_INSN_FCMPGES; sh5_media_extract_sfmt_fcmpeqs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 783         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 784       case 207 :
 785         if ((entire_insn & 0xfc0f000f) == 0x300f0000)
 786           { itype = SH5_MEDIA_INSN_FCMPGED; sh5_media_extract_sfmt_fcmpeqd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 787         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 788       case 208 :
 789         if ((entire_insn & 0xfc0f000f) == 0x34000000)
 790           { itype = SH5_MEDIA_INSN_FADDS; sh5_media_extract_sfmt_fadds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 791         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 792       case 209 :
 793         if ((entire_insn & 0xfc0f000f) == 0x34010000)
 794           { itype = SH5_MEDIA_INSN_FADDD; sh5_media_extract_sfmt_faddd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 795         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 796       case 210 :
 797         if ((entire_insn & 0xfc0f000f) == 0x34020000)
 798           { itype = SH5_MEDIA_INSN_FSUBS; sh5_media_extract_sfmt_fadds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 799         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 800       case 211 :
 801         if ((entire_insn & 0xfc0f000f) == 0x34030000)
 802           { itype = SH5_MEDIA_INSN_FSUBD; sh5_media_extract_sfmt_faddd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 803         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 804       case 212 :
 805         if ((entire_insn & 0xfc0f000f) == 0x34040000)
 806           { itype = SH5_MEDIA_INSN_FDIVS; sh5_media_extract_sfmt_fadds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 807         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 808       case 213 :
 809         if ((entire_insn & 0xfc0f000f) == 0x34050000)
 810           { itype = SH5_MEDIA_INSN_FDIVD; sh5_media_extract_sfmt_faddd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 811         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 812       case 214 :
 813         if ((entire_insn & 0xfc0f000f) == 0x34060000)
 814           { itype = SH5_MEDIA_INSN_FMULS; sh5_media_extract_sfmt_fadds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 815         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 816       case 215 :
 817         if ((entire_insn & 0xfc0f000f) == 0x34070000)
 818           { itype = SH5_MEDIA_INSN_FMULD; sh5_media_extract_sfmt_faddd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 819         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 820       case 222 :
 821         if ((entire_insn & 0xfc0f000f) == 0x340e0000)
 822           { itype = SH5_MEDIA_INSN_FMACS; sh5_media_extract_sfmt_fmacs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 823         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 824       case 224 :
 825         if ((entire_insn & 0xfc0f000f) == 0x38000000)
 826           { itype = SH5_MEDIA_INSN_FMOVS; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 827         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 828       case 225 :
 829         if ((entire_insn & 0xfc0f000f) == 0x38010000)
 830           { itype = SH5_MEDIA_INSN_FMOVD; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 831         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 832       case 228 :
 833         if ((entire_insn & 0xfc0f000f) == 0x38040000)
 834           { itype = SH5_MEDIA_INSN_FSQRTS; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 835         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 836       case 229 :
 837         if ((entire_insn & 0xfc0f000f) == 0x38050000)
 838           { itype = SH5_MEDIA_INSN_FSQRTD; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 839         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 840       case 230 :
 841         if ((entire_insn & 0xfc0f000f) == 0x38060000)
 842           { itype = SH5_MEDIA_INSN_FCNVSD; sh5_media_extract_sfmt_fcnvsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 843         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 844       case 231 :
 845         if ((entire_insn & 0xfc0f000f) == 0x38070000)
 846           { itype = SH5_MEDIA_INSN_FCNVDS; sh5_media_extract_sfmt_fcnvds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 847         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 848       case 232 :
 849         if ((entire_insn & 0xfc0f000f) == 0x38080000)
 850           { itype = SH5_MEDIA_INSN_FTRCSL; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 851         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 852       case 233 :
 853         if ((entire_insn & 0xfc0f000f) == 0x38090000)
 854           { itype = SH5_MEDIA_INSN_FTRCDQ; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 855         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 856       case 234 :
 857         if ((entire_insn & 0xfc0f000f) == 0x380a0000)
 858           { itype = SH5_MEDIA_INSN_FTRCSQ; sh5_media_extract_sfmt_fcnvsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 859         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 860       case 235 :
 861         if ((entire_insn & 0xfc0f000f) == 0x380b0000)
 862           { itype = SH5_MEDIA_INSN_FTRCDL; sh5_media_extract_sfmt_fcnvds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 863         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 864       case 236 :
 865         if ((entire_insn & 0xfc0f000f) == 0x380c0000)
 866           { itype = SH5_MEDIA_INSN_FLOATLS; sh5_media_extract_sfmt_fabss (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 867         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 868       case 237 :
 869         if ((entire_insn & 0xfc0f000f) == 0x380d0000)
 870           { itype = SH5_MEDIA_INSN_FLOATQD; sh5_media_extract_sfmt_fabsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 871         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 872       case 238 :
 873         if ((entire_insn & 0xfc0f000f) == 0x380e0000)
 874           { itype = SH5_MEDIA_INSN_FLOATLD; sh5_media_extract_sfmt_fcnvsd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 875         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 876       case 239 :
 877         if ((entire_insn & 0xfc0f000f) == 0x380f0000)
 878           { itype = SH5_MEDIA_INSN_FLOATQS; sh5_media_extract_sfmt_fcnvds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 879         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 880       case 248 :
 881         if ((entire_insn & 0xfc0f000f) == 0x3c080000)
 882           { itype = SH5_MEDIA_INSN_FSTXS; sh5_media_extract_sfmt_fstxs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 883         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 884       case 249 :
 885         if ((entire_insn & 0xfc0f000f) == 0x3c090000)
 886           { itype = SH5_MEDIA_INSN_FSTXD; sh5_media_extract_sfmt_fstxd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 887         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 888       case 253 :
 889         if ((entire_insn & 0xfc0f000f) == 0x3c0d0000)
 890           { itype = SH5_MEDIA_INSN_FSTXP; sh5_media_extract_sfmt_fldxp (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 891         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 892       case 256 :
 893         if ((entire_insn & 0xfc0f000f) == 0x40000000)
 894           { itype = SH5_MEDIA_INSN_LDXB; sh5_media_extract_sfmt_ldxb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 895         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 896       case 257 :
 897         if ((entire_insn & 0xfc0f000f) == 0x40010000)
 898           { itype = SH5_MEDIA_INSN_LDXW; sh5_media_extract_sfmt_ldxw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 899         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 900       case 258 :
 901         if ((entire_insn & 0xfc0f000f) == 0x40020000)
 902           { itype = SH5_MEDIA_INSN_LDXL; sh5_media_extract_sfmt_ldxl (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 903         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 904       case 259 :
 905         if ((entire_insn & 0xfc0f000f) == 0x40030000)
 906           { itype = SH5_MEDIA_INSN_LDXQ; sh5_media_extract_sfmt_ldxq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 907         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 908       case 260 :
 909         if ((entire_insn & 0xfc0f000f) == 0x40040000)
 910           { itype = SH5_MEDIA_INSN_LDXUB; sh5_media_extract_sfmt_ldxub (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 911         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 912       case 261 :
 913         if ((entire_insn & 0xfc0f000f) == 0x40050000)
 914           { itype = SH5_MEDIA_INSN_LDXUW; sh5_media_extract_sfmt_ldxuw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 915         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 916       case 273 :
 917         if ((entire_insn & 0xff8ffc0f) == 0x4401fc00)
 918           { itype = SH5_MEDIA_INSN_BLINK; sh5_media_extract_sfmt_blink (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 919         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 920       case 277 :
 921         if ((entire_insn & 0xff8ffc0f) == 0x4405fc00)
 922           { itype = SH5_MEDIA_INSN_GETTR; sh5_media_extract_sfmt_gettr (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 923         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 924       case 288 :
 925         if ((entire_insn & 0xfc0f000f) == 0x48000000)
 926           { itype = SH5_MEDIA_INSN_MSADUBQ; sh5_media_extract_sfmt_mcmv (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 927         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 928       case 289 :
 929         if ((entire_insn & 0xfc0f000f) == 0x48010000)
 930           { itype = SH5_MEDIA_INSN_MMACFXWL; sh5_media_extract_sfmt_mcmv (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 931         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 932       case 291 :
 933         if ((entire_insn & 0xfc0f000f) == 0x48030000)
 934           { itype = SH5_MEDIA_INSN_MCMV; sh5_media_extract_sfmt_mcmv (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 935         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 936       case 293 :
 937         if ((entire_insn & 0xfc0f000f) == 0x48050000)
 938           { itype = SH5_MEDIA_INSN_MMACNFX_WL; sh5_media_extract_sfmt_mcmv (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 939         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 940       case 297 :
 941         if ((entire_insn & 0xfc0f000f) == 0x48090000)
 942           { itype = SH5_MEDIA_INSN_MMULSUMWQ; sh5_media_extract_sfmt_mcmv (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 943         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 944       case 305 :
 945         if ((entire_insn & 0xfc0f000f) == 0x4c010000)
 946           { itype = SH5_MEDIA_INSN_MMULW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 947         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 948       case 306 :
 949         if ((entire_insn & 0xfc0f000f) == 0x4c020000)
 950           { itype = SH5_MEDIA_INSN_MMULL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 951         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 952       case 309 :
 953         if ((entire_insn & 0xfc0f000f) == 0x4c050000)
 954           { itype = SH5_MEDIA_INSN_MMULFXW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 955         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 956       case 310 :
 957         if ((entire_insn & 0xfc0f000f) == 0x4c060000)
 958           { itype = SH5_MEDIA_INSN_MMULFXL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 959         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 960       case 312 :
 961         if ((entire_insn & 0xfc0f000f) == 0x4c080000)
 962           { itype = SH5_MEDIA_INSN_MCNVSWB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 963         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 964       case 313 :
 965         if ((entire_insn & 0xfc0f000f) == 0x4c090000)
 966           { itype = SH5_MEDIA_INSN_MMULFXRPW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 967         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 968       case 314 :
 969         if ((entire_insn & 0xfc0f000f) == 0x4c0a0000)
 970           { itype = SH5_MEDIA_INSN_MMULLOWL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 971         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 972       case 316 :
 973         if ((entire_insn & 0xfc0f000f) == 0x4c0c0000)
 974           { itype = SH5_MEDIA_INSN_MCNVSWUB; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 975         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 976       case 317 :
 977         if ((entire_insn & 0xfc0f000f) == 0x4c0d0000)
 978           { itype = SH5_MEDIA_INSN_MCNVSLW; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 979         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 980       case 318 :
 981         if ((entire_insn & 0xfc0f000f) == 0x4c0e0000)
 982           { itype = SH5_MEDIA_INSN_MMULHIWL; sh5_media_extract_sfmt_add (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 983         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 984       case 384 :
 985         if ((entire_insn & 0xfc0f000f) == 0x60000000)
 986           { itype = SH5_MEDIA_INSN_STXB; sh5_media_extract_sfmt_stxb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 987         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 988       case 385 :
 989         if ((entire_insn & 0xfc0f000f) == 0x60010000)
 990           { itype = SH5_MEDIA_INSN_STXW; sh5_media_extract_sfmt_stxw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 991         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 992       case 386 :
 993         if ((entire_insn & 0xfc0f000f) == 0x60020000)
 994           { itype = SH5_MEDIA_INSN_STXL; sh5_media_extract_sfmt_stxl (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 995         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 996       case 387 :
 997         if ((entire_insn & 0xfc0f000f) == 0x60030000)
 998           { itype = SH5_MEDIA_INSN_STXQ; sh5_media_extract_sfmt_stxq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 999         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1000       case 401 :
1001         if ((entire_insn & 0xfc0f018f) == 0x64010000)
1002           { itype = SH5_MEDIA_INSN_BEQ; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1003         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1004       case 403 :
1005         if ((entire_insn & 0xfc0f018f) == 0x64030000)
1006           { itype = SH5_MEDIA_INSN_BGE; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1007         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1008       case 405 :
1009         if ((entire_insn & 0xfc0f018f) == 0x64050000)
1010           { itype = SH5_MEDIA_INSN_BNE; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1011         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1012       case 407 :
1013         if ((entire_insn & 0xfc0f018f) == 0x64070000)
1014           { itype = SH5_MEDIA_INSN_BGT; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1015         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1016       case 411 :
1017         if ((entire_insn & 0xfc0f018f) == 0x640b0000)
1018           { itype = SH5_MEDIA_INSN_BGEU; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1019         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1020       case 415 :
1021         if ((entire_insn & 0xfc0f018f) == 0x640f0000)
1022           { itype = SH5_MEDIA_INSN_BGTU; sh5_media_extract_sfmt_beq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1023         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1024       case 417 :
1025         if ((entire_insn & 0xffff018f) == 0x6bf10000)
1026           { itype = SH5_MEDIA_INSN_PTABS; sh5_media_extract_sfmt_ptabs (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1027         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1028       case 421 :
1029         if ((entire_insn & 0xffff018f) == 0x6bf50000)
1030           { itype = SH5_MEDIA_INSN_PTREL; sh5_media_extract_sfmt_ptrel (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1031         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1032       case 432 :
1033         if ((entire_insn & 0xffffffff) == 0x6ff0fff0)
1034           { itype = SH5_MEDIA_INSN_NOP; sh5_media_extract_sfmt_nop (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1035         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1036       case 433 :
1037         if ((entire_insn & 0xfc0fffff) == 0x6c01fff0)
1038           { itype = SH5_MEDIA_INSN_TRAPA; sh5_media_extract_sfmt_trapa (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1039         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1040       case 434 :
1041         if ((entire_insn & 0xffffffff) == 0x6ff2fff0)
1042           { itype = SH5_MEDIA_INSN_SYNCI; sh5_media_extract_sfmt_nop (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1043         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1044       case 435 :
1045         if ((entire_insn & 0xffffffff) == 0x6ff3fff0)
1046           { itype = SH5_MEDIA_INSN_RTE; sh5_media_extract_sfmt_nop (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1047         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1048       case 437 :
1049         if ((entire_insn & 0xffffffff) == 0x6ff5fff0)
1050           { itype = SH5_MEDIA_INSN_BRK; sh5_media_extract_sfmt_brk (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1051         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1052       case 438 :
1053         if ((entire_insn & 0xffffffff) == 0x6ff6fff0)
1054           { itype = SH5_MEDIA_INSN_SYNCO; sh5_media_extract_sfmt_nop (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1055         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1056       case 439 :
1057         if ((entire_insn & 0xffffffff) == 0x6ff7fff0)
1058           { itype = SH5_MEDIA_INSN_SLEEP; sh5_media_extract_sfmt_nop (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1059         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1060       case 447 :
1061         if ((entire_insn & 0xfc0ffc0f) == 0x6c0ffc00)
1062           { itype = SH5_MEDIA_INSN_PUTCON; sh5_media_extract_sfmt_putcon (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1063         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1064       case 512 : /* fall through */
1065       case 513 : /* fall through */
1066       case 514 : /* fall through */
1067       case 515 : /* fall through */
1068       case 516 : /* fall through */
1069       case 517 : /* fall through */
1070       case 518 : /* fall through */
1071       case 519 : /* fall through */
1072       case 520 : /* fall through */
1073       case 521 : /* fall through */
1074       case 522 : /* fall through */
1075       case 523 : /* fall through */
1076       case 524 : /* fall through */
1077       case 525 : /* fall through */
1078       case 526 : /* fall through */
1079       case 527 :
1080         if ((entire_insn & 0xfc00000f) == 0x80000000)
1081           { itype = SH5_MEDIA_INSN_LDB; sh5_media_extract_sfmt_ldb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1082         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1083       case 528 : /* fall through */
1084       case 529 : /* fall through */
1085       case 530 : /* fall through */
1086       case 531 : /* fall through */
1087       case 532 : /* fall through */
1088       case 533 : /* fall through */
1089       case 534 : /* fall through */
1090       case 535 : /* fall through */
1091       case 536 : /* fall through */
1092       case 537 : /* fall through */
1093       case 538 : /* fall through */
1094       case 539 : /* fall through */
1095       case 540 : /* fall through */
1096       case 541 : /* fall through */
1097       case 542 : /* fall through */
1098       case 543 :
1099         if ((entire_insn & 0xfc00000f) == 0x84000000)
1100           { itype = SH5_MEDIA_INSN_LDW; sh5_media_extract_sfmt_lduw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1101         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1102       case 544 : /* fall through */
1103       case 545 : /* fall through */
1104       case 546 : /* fall through */
1105       case 547 : /* fall through */
1106       case 548 : /* fall through */
1107       case 549 : /* fall through */
1108       case 550 : /* fall through */
1109       case 551 : /* fall through */
1110       case 552 : /* fall through */
1111       case 553 : /* fall through */
1112       case 554 : /* fall through */
1113       case 555 : /* fall through */
1114       case 556 : /* fall through */
1115       case 557 : /* fall through */
1116       case 558 : /* fall through */
1117       case 559 :
1118         if ((entire_insn & 0xfc00000f) == 0x88000000)
1119           { itype = SH5_MEDIA_INSN_LDL; sh5_media_extract_sfmt_ldl (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1120         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1121       case 560 : /* fall through */
1122       case 561 : /* fall through */
1123       case 562 : /* fall through */
1124       case 563 : /* fall through */
1125       case 564 : /* fall through */
1126       case 565 : /* fall through */
1127       case 566 : /* fall through */
1128       case 567 : /* fall through */
1129       case 568 : /* fall through */
1130       case 569 : /* fall through */
1131       case 570 : /* fall through */
1132       case 571 : /* fall through */
1133       case 572 : /* fall through */
1134       case 573 : /* fall through */
1135       case 574 : /* fall through */
1136       case 575 :
1137         if ((entire_insn & 0xfc00000f) == 0x8c000000)
1138           { itype = SH5_MEDIA_INSN_LDQ; sh5_media_extract_sfmt_ldq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1139         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1140       case 576 : /* fall through */
1141       case 577 : /* fall through */
1142       case 578 : /* fall through */
1143       case 579 : /* fall through */
1144       case 580 : /* fall through */
1145       case 581 : /* fall through */
1146       case 582 : /* fall through */
1147       case 583 : /* fall through */
1148       case 584 : /* fall through */
1149       case 585 : /* fall through */
1150       case 586 : /* fall through */
1151       case 587 : /* fall through */
1152       case 588 : /* fall through */
1153       case 589 : /* fall through */
1154       case 590 : /* fall through */
1155       case 591 :
1156         if ((entire_insn & 0xfc00000f) == 0x90000000)
1157           { itype = SH5_MEDIA_INSN_LDUB; sh5_media_extract_sfmt_ldb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1158         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1159       case 592 : /* fall through */
1160       case 593 : /* fall through */
1161       case 594 : /* fall through */
1162       case 595 : /* fall through */
1163       case 596 : /* fall through */
1164       case 597 : /* fall through */
1165       case 598 : /* fall through */
1166       case 599 : /* fall through */
1167       case 600 : /* fall through */
1168       case 601 : /* fall through */
1169       case 602 : /* fall through */
1170       case 603 : /* fall through */
1171       case 604 : /* fall through */
1172       case 605 : /* fall through */
1173       case 606 : /* fall through */
1174       case 607 :
1175         if ((entire_insn & 0xfc00000f) == 0x94000000)
1176           { itype = SH5_MEDIA_INSN_FLDS; sh5_media_extract_sfmt_flds (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1177         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1178       case 608 : /* fall through */
1179       case 609 : /* fall through */
1180       case 610 : /* fall through */
1181       case 611 : /* fall through */
1182       case 612 : /* fall through */
1183       case 613 : /* fall through */
1184       case 614 : /* fall through */
1185       case 615 : /* fall through */
1186       case 616 : /* fall through */
1187       case 617 : /* fall through */
1188       case 618 : /* fall through */
1189       case 619 : /* fall through */
1190       case 620 : /* fall through */
1191       case 621 : /* fall through */
1192       case 622 : /* fall through */
1193       case 623 :
1194         if ((entire_insn & 0xfc00000f) == 0x98000000)
1195           { itype = SH5_MEDIA_INSN_FLDP; sh5_media_extract_sfmt_fldp (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1196         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1197       case 624 : /* fall through */
1198       case 625 : /* fall through */
1199       case 626 : /* fall through */
1200       case 627 : /* fall through */
1201       case 628 : /* fall through */
1202       case 629 : /* fall through */
1203       case 630 : /* fall through */
1204       case 631 : /* fall through */
1205       case 632 : /* fall through */
1206       case 633 : /* fall through */
1207       case 634 : /* fall through */
1208       case 635 : /* fall through */
1209       case 636 : /* fall through */
1210       case 637 : /* fall through */
1211       case 638 : /* fall through */
1212       case 639 :
1213         if ((entire_insn & 0xfc00000f) == 0x9c000000)
1214           { itype = SH5_MEDIA_INSN_FLDD; sh5_media_extract_sfmt_fldd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1215         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1216       case 640 : /* fall through */
1217       case 641 : /* fall through */
1218       case 642 : /* fall through */
1219       case 643 : /* fall through */
1220       case 644 : /* fall through */
1221       case 645 : /* fall through */
1222       case 646 : /* fall through */
1223       case 647 : /* fall through */
1224       case 648 : /* fall through */
1225       case 649 : /* fall through */
1226       case 650 : /* fall through */
1227       case 651 : /* fall through */
1228       case 652 : /* fall through */
1229       case 653 : /* fall through */
1230       case 654 : /* fall through */
1231       case 655 :
1232         if ((entire_insn & 0xfc00000f) == 0xa0000000)
1233           { itype = SH5_MEDIA_INSN_STB; sh5_media_extract_sfmt_stb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1234         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1235       case 656 : /* fall through */
1236       case 657 : /* fall through */
1237       case 658 : /* fall through */
1238       case 659 : /* fall through */
1239       case 660 : /* fall through */
1240       case 661 : /* fall through */
1241       case 662 : /* fall through */
1242       case 663 : /* fall through */
1243       case 664 : /* fall through */
1244       case 665 : /* fall through */
1245       case 666 : /* fall through */
1246       case 667 : /* fall through */
1247       case 668 : /* fall through */
1248       case 669 : /* fall through */
1249       case 670 : /* fall through */
1250       case 671 :
1251         if ((entire_insn & 0xfc00000f) == 0xa4000000)
1252           { itype = SH5_MEDIA_INSN_STW; sh5_media_extract_sfmt_stw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1253         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1254       case 672 : /* fall through */
1255       case 673 : /* fall through */
1256       case 674 : /* fall through */
1257       case 675 : /* fall through */
1258       case 676 : /* fall through */
1259       case 677 : /* fall through */
1260       case 678 : /* fall through */
1261       case 679 : /* fall through */
1262       case 680 : /* fall through */
1263       case 681 : /* fall through */
1264       case 682 : /* fall through */
1265       case 683 : /* fall through */
1266       case 684 : /* fall through */
1267       case 685 : /* fall through */
1268       case 686 : /* fall through */
1269       case 687 :
1270         if ((entire_insn & 0xfc00000f) == 0xa8000000)
1271           { itype = SH5_MEDIA_INSN_STL; sh5_media_extract_sfmt_stl (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1272         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1273       case 688 : /* fall through */
1274       case 689 : /* fall through */
1275       case 690 : /* fall through */
1276       case 691 : /* fall through */
1277       case 692 : /* fall through */
1278       case 693 : /* fall through */
1279       case 694 : /* fall through */
1280       case 695 : /* fall through */
1281       case 696 : /* fall through */
1282       case 697 : /* fall through */
1283       case 698 : /* fall through */
1284       case 699 : /* fall through */
1285       case 700 : /* fall through */
1286       case 701 : /* fall through */
1287       case 702 : /* fall through */
1288       case 703 :
1289         if ((entire_insn & 0xfc00000f) == 0xac000000)
1290           { itype = SH5_MEDIA_INSN_STQ; sh5_media_extract_sfmt_stq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1291         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1292       case 704 : /* fall through */
1293       case 705 : /* fall through */
1294       case 706 : /* fall through */
1295       case 707 : /* fall through */
1296       case 708 : /* fall through */
1297       case 709 : /* fall through */
1298       case 710 : /* fall through */
1299       case 711 : /* fall through */
1300       case 712 : /* fall through */
1301       case 713 : /* fall through */
1302       case 714 : /* fall through */
1303       case 715 : /* fall through */
1304       case 716 : /* fall through */
1305       case 717 : /* fall through */
1306       case 718 : /* fall through */
1307       case 719 :
1308         if ((entire_insn & 0xfc00000f) == 0xb0000000)
1309           { itype = SH5_MEDIA_INSN_LDUW; sh5_media_extract_sfmt_lduw (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1310         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1311       case 720 : /* fall through */
1312       case 721 : /* fall through */
1313       case 722 : /* fall through */
1314       case 723 : /* fall through */
1315       case 724 : /* fall through */
1316       case 725 : /* fall through */
1317       case 726 : /* fall through */
1318       case 727 : /* fall through */
1319       case 728 : /* fall through */
1320       case 729 : /* fall through */
1321       case 730 : /* fall through */
1322       case 731 : /* fall through */
1323       case 732 : /* fall through */
1324       case 733 : /* fall through */
1325       case 734 : /* fall through */
1326       case 735 :
1327         if ((entire_insn & 0xfc00000f) == 0xb4000000)
1328           { itype = SH5_MEDIA_INSN_FSTS; sh5_media_extract_sfmt_fsts (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1329         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1330       case 736 : /* fall through */
1331       case 737 : /* fall through */
1332       case 738 : /* fall through */
1333       case 739 : /* fall through */
1334       case 740 : /* fall through */
1335       case 741 : /* fall through */
1336       case 742 : /* fall through */
1337       case 743 : /* fall through */
1338       case 744 : /* fall through */
1339       case 745 : /* fall through */
1340       case 746 : /* fall through */
1341       case 747 : /* fall through */
1342       case 748 : /* fall through */
1343       case 749 : /* fall through */
1344       case 750 : /* fall through */
1345       case 751 :
1346         if ((entire_insn & 0xfc00000f) == 0xb8000000)
1347           { itype = SH5_MEDIA_INSN_FSTP; sh5_media_extract_sfmt_fldp (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1348         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1349       case 752 : /* fall through */
1350       case 753 : /* fall through */
1351       case 754 : /* fall through */
1352       case 755 : /* fall through */
1353       case 756 : /* fall through */
1354       case 757 : /* fall through */
1355       case 758 : /* fall through */
1356       case 759 : /* fall through */
1357       case 760 : /* fall through */
1358       case 761 : /* fall through */
1359       case 762 : /* fall through */
1360       case 763 : /* fall through */
1361       case 764 : /* fall through */
1362       case 765 : /* fall through */
1363       case 766 : /* fall through */
1364       case 767 :
1365         if ((entire_insn & 0xfc00000f) == 0xbc000000)
1366           { itype = SH5_MEDIA_INSN_FSTD; sh5_media_extract_sfmt_fstd (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1367         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1368       case 770 :
1369         if ((entire_insn & 0xfc0f000f) == 0xc0020000)
1370           { itype = SH5_MEDIA_INSN_LDLOL; sh5_media_extract_sfmt_ldlol (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1371         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1372       case 771 :
1373         if ((entire_insn & 0xfc0f000f) == 0xc0030000)
1374           { itype = SH5_MEDIA_INSN_LDLOQ; sh5_media_extract_sfmt_ldloq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1375         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1376       case 774 :
1377         if ((entire_insn & 0xfc0f000f) == 0xc0060000)
1378           { itype = SH5_MEDIA_INSN_LDHIL; sh5_media_extract_sfmt_ldhil (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1379         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1380       case 775 :
1381         if ((entire_insn & 0xfc0f000f) == 0xc0070000)
1382           { itype = SH5_MEDIA_INSN_LDHIQ; sh5_media_extract_sfmt_ldhiq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1383         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1384       case 783 :
1385         if ((entire_insn & 0xfc0f000f) == 0xc00f0000)
1386           { itype = SH5_MEDIA_INSN_GETCFG; sh5_media_extract_sfmt_getcfg (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1387         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1388       case 784 :
1389         if ((entire_insn & 0xfc0f000f) == 0xc4000000)
1390           { itype = SH5_MEDIA_INSN_SHLLIL; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1391         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1392       case 785 :
1393         if ((entire_insn & 0xfc0f000f) == 0xc4010000)
1394           { itype = SH5_MEDIA_INSN_SHLLI; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1395         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1396       case 786 :
1397         if ((entire_insn & 0xfc0f000f) == 0xc4020000)
1398           { itype = SH5_MEDIA_INSN_SHLRIL; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1399         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1400       case 787 :
1401         if ((entire_insn & 0xfc0f000f) == 0xc4030000)
1402           { itype = SH5_MEDIA_INSN_SHLRI; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1403         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1404       case 790 :
1405         if ((entire_insn & 0xfc0f000f) == 0xc4060000)
1406           { itype = SH5_MEDIA_INSN_SHARIL; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1407         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1408       case 791 :
1409         if ((entire_insn & 0xfc0f000f) == 0xc4070000)
1410           { itype = SH5_MEDIA_INSN_SHARI; sh5_media_extract_sfmt_shari (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1411         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1412       case 797 :
1413         if ((entire_insn & 0xfc0f000f) == 0xc40d0000)
1414           { itype = SH5_MEDIA_INSN_XORI; sh5_media_extract_sfmt_xori (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1415         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1416       case 800 : /* fall through */
1417       case 801 : /* fall through */
1418       case 802 : /* fall through */
1419       case 803 : /* fall through */
1420       case 804 : /* fall through */
1421       case 805 : /* fall through */
1422       case 806 : /* fall through */
1423       case 807 : /* fall through */
1424       case 808 : /* fall through */
1425       case 809 : /* fall through */
1426       case 810 : /* fall through */
1427       case 811 : /* fall through */
1428       case 812 : /* fall through */
1429       case 813 : /* fall through */
1430       case 814 : /* fall through */
1431       case 815 :
1432         if ((entire_insn & 0xfc00000f) == 0xc8000000)
1433           { itype = SH5_MEDIA_INSN_SHORI; sh5_media_extract_sfmt_shori (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1434         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1435       case 816 : /* fall through */
1436       case 817 : /* fall through */
1437       case 818 : /* fall through */
1438       case 819 : /* fall through */
1439       case 820 : /* fall through */
1440       case 821 : /* fall through */
1441       case 822 : /* fall through */
1442       case 823 : /* fall through */
1443       case 824 : /* fall through */
1444       case 825 : /* fall through */
1445       case 826 : /* fall through */
1446       case 827 : /* fall through */
1447       case 828 : /* fall through */
1448       case 829 : /* fall through */
1449       case 830 : /* fall through */
1450       case 831 :
1451         if ((entire_insn & 0xfc00000f) == 0xcc000000)
1452           { itype = SH5_MEDIA_INSN_MOVI; sh5_media_extract_sfmt_movi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1453         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1454       case 832 : /* fall through */
1455       case 833 : /* fall through */
1456       case 834 : /* fall through */
1457       case 835 : /* fall through */
1458       case 836 : /* fall through */
1459       case 837 : /* fall through */
1460       case 838 : /* fall through */
1461       case 839 : /* fall through */
1462       case 840 : /* fall through */
1463       case 841 : /* fall through */
1464       case 842 : /* fall through */
1465       case 843 : /* fall through */
1466       case 844 : /* fall through */
1467       case 845 : /* fall through */
1468       case 846 : /* fall through */
1469       case 847 :
1470         if ((entire_insn & 0xfc00000f) == 0xd0000000)
1471           { itype = SH5_MEDIA_INSN_ADDI; sh5_media_extract_sfmt_addi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1472         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1473       case 848 : /* fall through */
1474       case 849 : /* fall through */
1475       case 850 : /* fall through */
1476       case 851 : /* fall through */
1477       case 852 : /* fall through */
1478       case 853 : /* fall through */
1479       case 854 : /* fall through */
1480       case 855 : /* fall through */
1481       case 856 : /* fall through */
1482       case 857 : /* fall through */
1483       case 858 : /* fall through */
1484       case 859 : /* fall through */
1485       case 860 : /* fall through */
1486       case 861 : /* fall through */
1487       case 862 : /* fall through */
1488       case 863 :
1489         if ((entire_insn & 0xfc00000f) == 0xd4000000)
1490           { itype = SH5_MEDIA_INSN_ADDIL; sh5_media_extract_sfmt_addi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1491         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1492       case 864 : /* fall through */
1493       case 865 : /* fall through */
1494       case 866 : /* fall through */
1495       case 867 : /* fall through */
1496       case 868 : /* fall through */
1497       case 869 : /* fall through */
1498       case 870 : /* fall through */
1499       case 871 : /* fall through */
1500       case 872 : /* fall through */
1501       case 873 : /* fall through */
1502       case 874 : /* fall through */
1503       case 875 : /* fall through */
1504       case 876 : /* fall through */
1505       case 877 : /* fall through */
1506       case 878 : /* fall through */
1507       case 879 :
1508         if ((entire_insn & 0xfc00000f) == 0xd8000000)
1509           { itype = SH5_MEDIA_INSN_ANDI; sh5_media_extract_sfmt_addi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1510         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1511       case 880 : /* fall through */
1512       case 881 : /* fall through */
1513       case 882 : /* fall through */
1514       case 883 : /* fall through */
1515       case 884 : /* fall through */
1516       case 885 : /* fall through */
1517       case 886 : /* fall through */
1518       case 887 : /* fall through */
1519       case 888 : /* fall through */
1520       case 889 : /* fall through */
1521       case 890 : /* fall through */
1522       case 891 : /* fall through */
1523       case 892 : /* fall through */
1524       case 893 : /* fall through */
1525       case 894 : /* fall through */
1526       case 895 :
1527         if ((entire_insn & 0xfc00000f) == 0xdc000000)
1528           { itype = SH5_MEDIA_INSN_ORI; sh5_media_extract_sfmt_ori (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1529         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1530       case 897 :
1531         if ((entire_insn & 0xfc0ffc0f) == 0xe001fc00)
1532           { itype = SH5_MEDIA_INSN_PREFI; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1533         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1534       case 898 :
1535         if ((entire_insn & 0xfc0f000f) == 0xe0020000)
1536           { itype = SH5_MEDIA_INSN_STLOL; sh5_media_extract_sfmt_stlol (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1537         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1538       case 899 :
1539         if ((entire_insn & 0xfc0f000f) == 0xe0030000)
1540           { itype = SH5_MEDIA_INSN_STLOQ; sh5_media_extract_sfmt_stloq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1541         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1542       case 900 :
1543         if ((entire_insn & 0xfc0f03ff) == 0xe00403f0)
1544           { itype = SH5_MEDIA_INSN_ALLOCO; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1545         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1546       case 901 :
1547         if ((entire_insn & 0xfc0f03ff) == 0xe00503f0)
1548           { itype = SH5_MEDIA_INSN_ICBI; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1549         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1550       case 902 :
1551         if ((entire_insn & 0xfc0f000f) == 0xe0060000)
1552           { itype = SH5_MEDIA_INSN_STHIL; sh5_media_extract_sfmt_sthil (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1553         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1554       case 903 :
1555         if ((entire_insn & 0xfc0f000f) == 0xe0070000)
1556           { itype = SH5_MEDIA_INSN_STHIQ; sh5_media_extract_sfmt_sthiq (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1557         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1558       case 904 :
1559         if ((entire_insn & 0xfc0f03ff) == 0xe00803f0)
1560           { itype = SH5_MEDIA_INSN_OCBP; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1561         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1562       case 905 :
1563         if ((entire_insn & 0xfc0f03ff) == 0xe00903f0)
1564           { itype = SH5_MEDIA_INSN_OCBI; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1565         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1566       case 908 :
1567         if ((entire_insn & 0xfc0f03ff) == 0xe00c03f0)
1568           { itype = SH5_MEDIA_INSN_OCBWB; sh5_media_extract_sfmt_alloco (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1569         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1570       case 911 :
1571         if ((entire_insn & 0xfc0f000f) == 0xe00f0000)
1572           { itype = SH5_MEDIA_INSN_PUTCFG; sh5_media_extract_sfmt_putcfg (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1573         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1574       case 913 :
1575         if ((entire_insn & 0xfc0f018f) == 0xe4010000)
1576           { itype = SH5_MEDIA_INSN_BEQI; sh5_media_extract_sfmt_beqi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1577         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1578       case 917 :
1579         if ((entire_insn & 0xfc0f018f) == 0xe4050000)
1580           { itype = SH5_MEDIA_INSN_BNEI; sh5_media_extract_sfmt_beqi (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1581         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1582       case 928 : /* fall through */
1583       case 929 : /* fall through */
1584       case 930 : /* fall through */
1585       case 931 : /* fall through */
1586       case 932 : /* fall through */
1587       case 933 : /* fall through */
1588       case 934 : /* fall through */
1589       case 935 : /* fall through */
1590       case 936 : /* fall through */
1591       case 937 : /* fall through */
1592       case 938 : /* fall through */
1593       case 939 : /* fall through */
1594       case 940 : /* fall through */
1595       case 941 : /* fall through */
1596       case 942 : /* fall through */
1597       case 943 :
1598         if ((entire_insn & 0xfc00018f) == 0xe8000000)
1599           { itype = SH5_MEDIA_INSN_PTA; sh5_media_extract_sfmt_pta (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1600         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1601       case 944 : /* fall through */
1602       case 945 : /* fall through */
1603       case 946 : /* fall through */
1604       case 947 : /* fall through */
1605       case 948 : /* fall through */
1606       case 949 : /* fall through */
1607       case 950 : /* fall through */
1608       case 951 : /* fall through */
1609       case 952 : /* fall through */
1610       case 953 : /* fall through */
1611       case 954 : /* fall through */
1612       case 955 : /* fall through */
1613       case 956 : /* fall through */
1614       case 957 : /* fall through */
1615       case 958 : /* fall through */
1616       case 959 :
1617         if ((entire_insn & 0xfc00018f) == 0xec000000)
1618           { itype = SH5_MEDIA_INSN_PTB; sh5_media_extract_sfmt_pta (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1619         itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1620       default : itype = SH5_MEDIA_INSN_X_INVALID; sh5_media_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1621       }
1622     }
1623
1624   }
1625
1626   /* The instruction has been decoded and fields extracted.  */
1627   done:
1628
1629   this->addr = pc;
1630   // FIXME: To be redone (to handle ISA variants).
1631   this->idesc = & sh5_media_idesc::idesc_table[itype];
1632   // ??? record semantic handler?
1633   assert(this->idesc->sem_index == itype);
1634 }
1635
1636 void
1637 sh5_media_extract_sfmt_empty (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1638     sh5_media_insn_word insn = entire_insn;
1639 #define FLD(f) abuf->fields.fmt_empty.f
1640
1641
1642   /* Record the fields for the semantic handler.  */
1643   if (UNLIKELY(current_cpu->trace_extract_p))
1644     {
1645       current_cpu->trace_stream
1646         << "0x" << hex << pc << dec << " (sfmt_empty)\t"
1647         << endl;
1648     }
1649
1650 #undef FLD
1651 }
1652
1653 void
1654 sh5_media_extract_sfmt_add (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1655     sh5_media_insn_word insn = entire_insn;
1656 #define FLD(f) abuf->fields.sfmt_mcmv.f
1657     UINT f_left;
1658     UINT f_right;
1659     UINT f_dest;
1660
1661     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1662     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
1663     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1664
1665   /* Record the fields for the semantic handler.  */
1666   FLD (f_left) = f_left;
1667   FLD (f_right) = f_right;
1668   FLD (f_dest) = f_dest;
1669   if (UNLIKELY(current_cpu->trace_extract_p))
1670     {
1671       current_cpu->trace_stream
1672         << "0x" << hex << pc << dec << " (sfmt_add)\t"
1673         << " f_left:0x" << hex << f_left << dec
1674         << " f_right:0x" << hex << f_right << dec
1675         << " f_dest:0x" << hex << f_dest << dec
1676         << endl;
1677     }
1678
1679   /* Record the fields for profiling.  */
1680   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1681     {
1682       FLD (in_rm) = f_left;
1683       FLD (in_rn) = f_right;
1684       FLD (out_rd) = f_dest;
1685     }
1686 #undef FLD
1687 }
1688
1689 void
1690 sh5_media_extract_sfmt_addi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1691     sh5_media_insn_word insn = entire_insn;
1692 #define FLD(f) abuf->fields.sfmt_addi.f
1693     UINT f_left;
1694     INT f_disp10;
1695     UINT f_dest;
1696
1697     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1698     f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
1699     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1700
1701   /* Record the fields for the semantic handler.  */
1702   FLD (f_disp10) = f_disp10;
1703   FLD (f_left) = f_left;
1704   FLD (f_dest) = f_dest;
1705   if (UNLIKELY(current_cpu->trace_extract_p))
1706     {
1707       current_cpu->trace_stream
1708         << "0x" << hex << pc << dec << " (sfmt_addi)\t"
1709         << " f_disp10:0x" << hex << f_disp10 << dec
1710         << " f_left:0x" << hex << f_left << dec
1711         << " f_dest:0x" << hex << f_dest << dec
1712         << endl;
1713     }
1714
1715   /* Record the fields for profiling.  */
1716   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1717     {
1718       FLD (in_rm) = f_left;
1719       FLD (out_rd) = f_dest;
1720     }
1721 #undef FLD
1722 }
1723
1724 void
1725 sh5_media_extract_sfmt_alloco (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1726     sh5_media_insn_word insn = entire_insn;
1727 #define FLD(f) abuf->fields.sfmt_alloco.f
1728     UINT f_left;
1729
1730     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1731
1732   /* Record the fields for the semantic handler.  */
1733   FLD (f_left) = f_left;
1734   if (UNLIKELY(current_cpu->trace_extract_p))
1735     {
1736       current_cpu->trace_stream
1737         << "0x" << hex << pc << dec << " (sfmt_alloco)\t"
1738         << " f_left:0x" << hex << f_left << dec
1739         << endl;
1740     }
1741
1742   /* Record the fields for profiling.  */
1743   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1744     {
1745       FLD (in_rm) = f_left;
1746       FLD (out_rm) = f_left;
1747     }
1748 #undef FLD
1749 }
1750
1751 void
1752 sh5_media_extract_sfmt_beq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1753     sh5_media_insn_word insn = entire_insn;
1754 #define FLD(f) abuf->fields.sfmt_beq.f
1755     UINT f_left;
1756     UINT f_right;
1757     UINT f_likely;
1758     UINT f_tra;
1759
1760     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1761     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
1762     f_likely = EXTRACT_MSB0_UINT (insn, 32, 22, 1);
1763     f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
1764
1765   /* Record the fields for the semantic handler.  */
1766   FLD (f_likely) = f_likely;
1767   FLD (f_left) = f_left;
1768   FLD (f_right) = f_right;
1769   FLD (f_tra) = f_tra;
1770   if (UNLIKELY(current_cpu->trace_extract_p))
1771     {
1772       current_cpu->trace_stream
1773         << "0x" << hex << pc << dec << " (sfmt_beq)\t"
1774         << " f_likely:0x" << hex << f_likely << dec
1775         << " f_left:0x" << hex << f_left << dec
1776         << " f_right:0x" << hex << f_right << dec
1777         << " f_tra:0x" << hex << f_tra << dec
1778         << endl;
1779     }
1780
1781   /* Record the fields for profiling.  */
1782   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1783     {
1784       FLD (in_rm) = f_left;
1785       FLD (in_rn) = f_right;
1786       FLD (in_tra) = f_tra;
1787     }
1788 #undef FLD
1789 }
1790
1791 void
1792 sh5_media_extract_sfmt_beqi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1793     sh5_media_insn_word insn = entire_insn;
1794 #define FLD(f) abuf->fields.sfmt_beqi.f
1795     UINT f_left;
1796     INT f_imm6;
1797     UINT f_likely;
1798     UINT f_tra;
1799
1800     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1801     f_imm6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
1802     f_likely = EXTRACT_MSB0_UINT (insn, 32, 22, 1);
1803     f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
1804
1805   /* Record the fields for the semantic handler.  */
1806   FLD (f_imm6) = f_imm6;
1807   FLD (f_likely) = f_likely;
1808   FLD (f_left) = f_left;
1809   FLD (f_tra) = f_tra;
1810   if (UNLIKELY(current_cpu->trace_extract_p))
1811     {
1812       current_cpu->trace_stream
1813         << "0x" << hex << pc << dec << " (sfmt_beqi)\t"
1814         << " f_imm6:0x" << hex << f_imm6 << dec
1815         << " f_likely:0x" << hex << f_likely << dec
1816         << " f_left:0x" << hex << f_left << dec
1817         << " f_tra:0x" << hex << f_tra << dec
1818         << endl;
1819     }
1820
1821   /* Record the fields for profiling.  */
1822   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1823     {
1824       FLD (in_rm) = f_left;
1825       FLD (in_tra) = f_tra;
1826     }
1827 #undef FLD
1828 }
1829
1830 void
1831 sh5_media_extract_sfmt_blink (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1832     sh5_media_insn_word insn = entire_insn;
1833 #define FLD(f) abuf->fields.sfmt_blink.f
1834     UINT f_trb;
1835     UINT f_dest;
1836
1837     f_trb = EXTRACT_MSB0_UINT (insn, 32, 9, 3);
1838     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1839
1840   /* Record the fields for the semantic handler.  */
1841   FLD (f_dest) = f_dest;
1842   FLD (f_trb) = f_trb;
1843   if (UNLIKELY(current_cpu->trace_extract_p))
1844     {
1845       current_cpu->trace_stream
1846         << "0x" << hex << pc << dec << " (sfmt_blink)\t"
1847         << " f_dest:0x" << hex << f_dest << dec
1848         << " f_trb:0x" << hex << f_trb << dec
1849         << endl;
1850     }
1851
1852   /* Record the fields for profiling.  */
1853   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1854     {
1855       FLD (in_trb) = f_trb;
1856       FLD (out_rd) = f_dest;
1857     }
1858 #undef FLD
1859 }
1860
1861 void
1862 sh5_media_extract_sfmt_brk (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1863     sh5_media_insn_word insn = entire_insn;
1864 #define FLD(f) abuf->fields.fmt_empty.f
1865
1866
1867   /* Record the fields for the semantic handler.  */
1868   if (UNLIKELY(current_cpu->trace_extract_p))
1869     {
1870       current_cpu->trace_stream
1871         << "0x" << hex << pc << dec << " (sfmt_brk)\t"
1872         << endl;
1873     }
1874
1875   /* Record the fields for profiling.  */
1876   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1877     {
1878     }
1879 #undef FLD
1880 }
1881
1882 void
1883 sh5_media_extract_sfmt_byterev (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1884     sh5_media_insn_word insn = entire_insn;
1885 #define FLD(f) abuf->fields.sfmt_xori.f
1886     UINT f_left;
1887     UINT f_dest;
1888
1889     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1890     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1891
1892   /* Record the fields for the semantic handler.  */
1893   FLD (f_left) = f_left;
1894   FLD (f_dest) = f_dest;
1895   if (UNLIKELY(current_cpu->trace_extract_p))
1896     {
1897       current_cpu->trace_stream
1898         << "0x" << hex << pc << dec << " (sfmt_byterev)\t"
1899         << " f_left:0x" << hex << f_left << dec
1900         << " f_dest:0x" << hex << f_dest << dec
1901         << endl;
1902     }
1903
1904   /* Record the fields for profiling.  */
1905   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1906     {
1907       FLD (in_rm) = f_left;
1908       FLD (out_rd) = f_dest;
1909     }
1910 #undef FLD
1911 }
1912
1913 void
1914 sh5_media_extract_sfmt_cmveq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1915     sh5_media_insn_word insn = entire_insn;
1916 #define FLD(f) abuf->fields.sfmt_mcmv.f
1917     UINT f_left;
1918     UINT f_right;
1919     UINT f_dest;
1920
1921     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1922     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
1923     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1924
1925   /* Record the fields for the semantic handler.  */
1926   FLD (f_left) = f_left;
1927   FLD (f_right) = f_right;
1928   FLD (f_dest) = f_dest;
1929   if (UNLIKELY(current_cpu->trace_extract_p))
1930     {
1931       current_cpu->trace_stream
1932         << "0x" << hex << pc << dec << " (sfmt_cmveq)\t"
1933         << " f_left:0x" << hex << f_left << dec
1934         << " f_right:0x" << hex << f_right << dec
1935         << " f_dest:0x" << hex << f_dest << dec
1936         << endl;
1937     }
1938
1939   /* Record the fields for profiling.  */
1940   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1941     {
1942       FLD (in_rm) = f_left;
1943       FLD (in_rn) = f_right;
1944       FLD (out_rd) = f_dest;
1945     }
1946 #undef FLD
1947 }
1948
1949 void
1950 sh5_media_extract_sfmt_fabsd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1951     sh5_media_insn_word insn = entire_insn;
1952 #define FLD(f) abuf->fields.sfmt_fabsd.f
1953     UINT f_left;
1954     UINT f_right;
1955     UINT f_dest;
1956     UINT f_left_right;
1957
1958     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1959     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
1960     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1961   f_left_right = f_left;
1962
1963   /* Record the fields for the semantic handler.  */
1964   FLD (f_left_right) = f_left_right;
1965   FLD (f_dest) = f_dest;
1966   if (UNLIKELY(current_cpu->trace_extract_p))
1967     {
1968       current_cpu->trace_stream
1969         << "0x" << hex << pc << dec << " (sfmt_fabsd)\t"
1970         << " f_left_right:0x" << hex << f_left_right << dec
1971         << " f_dest:0x" << hex << f_dest << dec
1972         << endl;
1973     }
1974
1975   /* Record the fields for profiling.  */
1976   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
1977     {
1978       FLD (in_drgh) = f_left_right;
1979       FLD (out_drf) = f_dest;
1980     }
1981 #undef FLD
1982 }
1983
1984 void
1985 sh5_media_extract_sfmt_fabss (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
1986     sh5_media_insn_word insn = entire_insn;
1987 #define FLD(f) abuf->fields.sfmt_fabss.f
1988     UINT f_left;
1989     UINT f_right;
1990     UINT f_dest;
1991     UINT f_left_right;
1992
1993     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1994     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
1995     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1996   f_left_right = f_left;
1997
1998   /* Record the fields for the semantic handler.  */
1999   FLD (f_left_right) = f_left_right;
2000   FLD (f_dest) = f_dest;
2001   if (UNLIKELY(current_cpu->trace_extract_p))
2002     {
2003       current_cpu->trace_stream
2004         << "0x" << hex << pc << dec << " (sfmt_fabss)\t"
2005         << " f_left_right:0x" << hex << f_left_right << dec
2006         << " f_dest:0x" << hex << f_dest << dec
2007         << endl;
2008     }
2009
2010   /* Record the fields for profiling.  */
2011   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2012     {
2013       FLD (in_frgh) = f_left_right;
2014       FLD (out_frf) = f_dest;
2015     }
2016 #undef FLD
2017 }
2018
2019 void
2020 sh5_media_extract_sfmt_faddd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2021     sh5_media_insn_word insn = entire_insn;
2022 #define FLD(f) abuf->fields.sfmt_faddd.f
2023     UINT f_left;
2024     UINT f_right;
2025     UINT f_dest;
2026
2027     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2028     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2029     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2030
2031   /* Record the fields for the semantic handler.  */
2032   FLD (f_left) = f_left;
2033   FLD (f_right) = f_right;
2034   FLD (f_dest) = f_dest;
2035   if (UNLIKELY(current_cpu->trace_extract_p))
2036     {
2037       current_cpu->trace_stream
2038         << "0x" << hex << pc << dec << " (sfmt_faddd)\t"
2039         << " f_left:0x" << hex << f_left << dec
2040         << " f_right:0x" << hex << f_right << dec
2041         << " f_dest:0x" << hex << f_dest << dec
2042         << endl;
2043     }
2044
2045   /* Record the fields for profiling.  */
2046   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2047     {
2048       FLD (in_drg) = f_left;
2049       FLD (in_drh) = f_right;
2050       FLD (out_drf) = f_dest;
2051     }
2052 #undef FLD
2053 }
2054
2055 void
2056 sh5_media_extract_sfmt_fadds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2057     sh5_media_insn_word insn = entire_insn;
2058 #define FLD(f) abuf->fields.sfmt_fmacs.f
2059     UINT f_left;
2060     UINT f_right;
2061     UINT f_dest;
2062
2063     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2064     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2065     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2066
2067   /* Record the fields for the semantic handler.  */
2068   FLD (f_left) = f_left;
2069   FLD (f_right) = f_right;
2070   FLD (f_dest) = f_dest;
2071   if (UNLIKELY(current_cpu->trace_extract_p))
2072     {
2073       current_cpu->trace_stream
2074         << "0x" << hex << pc << dec << " (sfmt_fadds)\t"
2075         << " f_left:0x" << hex << f_left << dec
2076         << " f_right:0x" << hex << f_right << dec
2077         << " f_dest:0x" << hex << f_dest << dec
2078         << endl;
2079     }
2080
2081   /* Record the fields for profiling.  */
2082   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2083     {
2084       FLD (in_frg) = f_left;
2085       FLD (in_frh) = f_right;
2086       FLD (out_frf) = f_dest;
2087     }
2088 #undef FLD
2089 }
2090
2091 void
2092 sh5_media_extract_sfmt_fcmpeqd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2093     sh5_media_insn_word insn = entire_insn;
2094 #define FLD(f) abuf->fields.sfmt_fcmpeqd.f
2095     UINT f_left;
2096     UINT f_right;
2097     UINT f_dest;
2098
2099     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2100     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2101     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2102
2103   /* Record the fields for the semantic handler.  */
2104   FLD (f_left) = f_left;
2105   FLD (f_right) = f_right;
2106   FLD (f_dest) = f_dest;
2107   if (UNLIKELY(current_cpu->trace_extract_p))
2108     {
2109       current_cpu->trace_stream
2110         << "0x" << hex << pc << dec << " (sfmt_fcmpeqd)\t"
2111         << " f_left:0x" << hex << f_left << dec
2112         << " f_right:0x" << hex << f_right << dec
2113         << " f_dest:0x" << hex << f_dest << dec
2114         << endl;
2115     }
2116
2117   /* Record the fields for profiling.  */
2118   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2119     {
2120       FLD (in_drg) = f_left;
2121       FLD (in_drh) = f_right;
2122       FLD (out_rd) = f_dest;
2123     }
2124 #undef FLD
2125 }
2126
2127 void
2128 sh5_media_extract_sfmt_fcmpeqs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2129     sh5_media_insn_word insn = entire_insn;
2130 #define FLD(f) abuf->fields.sfmt_fcmpeqs.f
2131     UINT f_left;
2132     UINT f_right;
2133     UINT f_dest;
2134
2135     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2136     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2137     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2138
2139   /* Record the fields for the semantic handler.  */
2140   FLD (f_left) = f_left;
2141   FLD (f_right) = f_right;
2142   FLD (f_dest) = f_dest;
2143   if (UNLIKELY(current_cpu->trace_extract_p))
2144     {
2145       current_cpu->trace_stream
2146         << "0x" << hex << pc << dec << " (sfmt_fcmpeqs)\t"
2147         << " f_left:0x" << hex << f_left << dec
2148         << " f_right:0x" << hex << f_right << dec
2149         << " f_dest:0x" << hex << f_dest << dec
2150         << endl;
2151     }
2152
2153   /* Record the fields for profiling.  */
2154   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2155     {
2156       FLD (in_frg) = f_left;
2157       FLD (in_frh) = f_right;
2158       FLD (out_rd) = f_dest;
2159     }
2160 #undef FLD
2161 }
2162
2163 void
2164 sh5_media_extract_sfmt_fcnvds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2165     sh5_media_insn_word insn = entire_insn;
2166 #define FLD(f) abuf->fields.sfmt_fcnvds.f
2167     UINT f_left;
2168     UINT f_right;
2169     UINT f_dest;
2170     UINT f_left_right;
2171
2172     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2173     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2174     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2175   f_left_right = f_left;
2176
2177   /* Record the fields for the semantic handler.  */
2178   FLD (f_left_right) = f_left_right;
2179   FLD (f_dest) = f_dest;
2180   if (UNLIKELY(current_cpu->trace_extract_p))
2181     {
2182       current_cpu->trace_stream
2183         << "0x" << hex << pc << dec << " (sfmt_fcnvds)\t"
2184         << " f_left_right:0x" << hex << f_left_right << dec
2185         << " f_dest:0x" << hex << f_dest << dec
2186         << endl;
2187     }
2188
2189   /* Record the fields for profiling.  */
2190   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2191     {
2192       FLD (in_drgh) = f_left_right;
2193       FLD (out_frf) = f_dest;
2194     }
2195 #undef FLD
2196 }
2197
2198 void
2199 sh5_media_extract_sfmt_fcnvsd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2200     sh5_media_insn_word insn = entire_insn;
2201 #define FLD(f) abuf->fields.sfmt_fcnvsd.f
2202     UINT f_left;
2203     UINT f_right;
2204     UINT f_dest;
2205     UINT f_left_right;
2206
2207     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2208     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2209     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2210   f_left_right = f_left;
2211
2212   /* Record the fields for the semantic handler.  */
2213   FLD (f_left_right) = f_left_right;
2214   FLD (f_dest) = f_dest;
2215   if (UNLIKELY(current_cpu->trace_extract_p))
2216     {
2217       current_cpu->trace_stream
2218         << "0x" << hex << pc << dec << " (sfmt_fcnvsd)\t"
2219         << " f_left_right:0x" << hex << f_left_right << dec
2220         << " f_dest:0x" << hex << f_dest << dec
2221         << endl;
2222     }
2223
2224   /* Record the fields for profiling.  */
2225   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2226     {
2227       FLD (in_frgh) = f_left_right;
2228       FLD (out_drf) = f_dest;
2229     }
2230 #undef FLD
2231 }
2232
2233 void
2234 sh5_media_extract_sfmt_fgetscr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2235     sh5_media_insn_word insn = entire_insn;
2236 #define FLD(f) abuf->fields.sfmt_fcnvds.f
2237     UINT f_dest;
2238
2239     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2240
2241   /* Record the fields for the semantic handler.  */
2242   FLD (f_dest) = f_dest;
2243   if (UNLIKELY(current_cpu->trace_extract_p))
2244     {
2245       current_cpu->trace_stream
2246         << "0x" << hex << pc << dec << " (sfmt_fgetscr)\t"
2247         << " f_dest:0x" << hex << f_dest << dec
2248         << endl;
2249     }
2250
2251   /* Record the fields for profiling.  */
2252   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2253     {
2254       FLD (out_frf) = f_dest;
2255     }
2256 #undef FLD
2257 }
2258
2259 void
2260 sh5_media_extract_sfmt_fiprs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2261     sh5_media_insn_word insn = entire_insn;
2262 #define FLD(f) abuf->fields.sfmt_fiprs.f
2263     UINT f_left;
2264     UINT f_right;
2265     UINT f_dest;
2266
2267     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2268     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2269     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2270
2271   /* Record the fields for the semantic handler.  */
2272   FLD (f_left) = f_left;
2273   FLD (f_right) = f_right;
2274   FLD (f_dest) = f_dest;
2275   if (UNLIKELY(current_cpu->trace_extract_p))
2276     {
2277       current_cpu->trace_stream
2278         << "0x" << hex << pc << dec << " (sfmt_fiprs)\t"
2279         << " f_left:0x" << hex << f_left << dec
2280         << " f_right:0x" << hex << f_right << dec
2281         << " f_dest:0x" << hex << f_dest << dec
2282         << endl;
2283     }
2284
2285   /* Record the fields for profiling.  */
2286   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2287     {
2288       FLD (in_fvg) = f_left;
2289       FLD (in_fvh) = f_right;
2290       FLD (out_frf) = f_dest;
2291       FLD (out_fvg) = f_left;
2292       FLD (out_fvh) = f_right;
2293     }
2294 #undef FLD
2295 }
2296
2297 void
2298 sh5_media_extract_sfmt_fldd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2299     sh5_media_insn_word insn = entire_insn;
2300 #define FLD(f) abuf->fields.sfmt_fldd.f
2301     UINT f_left;
2302     SI f_disp10x8;
2303     UINT f_dest;
2304
2305     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2306     f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2307     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2308
2309   /* Record the fields for the semantic handler.  */
2310   FLD (f_disp10x8) = f_disp10x8;
2311   FLD (f_left) = f_left;
2312   FLD (f_dest) = f_dest;
2313   if (UNLIKELY(current_cpu->trace_extract_p))
2314     {
2315       current_cpu->trace_stream
2316         << "0x" << hex << pc << dec << " (sfmt_fldd)\t"
2317         << " f_disp10x8:0x" << hex << f_disp10x8 << dec
2318         << " f_left:0x" << hex << f_left << dec
2319         << " f_dest:0x" << hex << f_dest << dec
2320         << endl;
2321     }
2322
2323   /* Record the fields for profiling.  */
2324   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2325     {
2326       FLD (in_rm) = f_left;
2327       FLD (out_drf) = f_dest;
2328     }
2329 #undef FLD
2330 }
2331
2332 void
2333 sh5_media_extract_sfmt_fldp (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2334     sh5_media_insn_word insn = entire_insn;
2335 #define FLD(f) abuf->fields.sfmt_fldp.f
2336     UINT f_left;
2337     SI f_disp10x8;
2338     UINT f_dest;
2339
2340     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2341     f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2342     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2343
2344   /* Record the fields for the semantic handler.  */
2345   FLD (f_disp10x8) = f_disp10x8;
2346   FLD (f_dest) = f_dest;
2347   FLD (f_left) = f_left;
2348   if (UNLIKELY(current_cpu->trace_extract_p))
2349     {
2350       current_cpu->trace_stream
2351         << "0x" << hex << pc << dec << " (sfmt_fldp)\t"
2352         << " f_disp10x8:0x" << hex << f_disp10x8 << dec
2353         << " f_dest:0x" << hex << f_dest << dec
2354         << " f_left:0x" << hex << f_left << dec
2355         << endl;
2356     }
2357
2358   /* Record the fields for profiling.  */
2359   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2360     {
2361       FLD (in_fpf) = f_dest;
2362       FLD (in_rm) = f_left;
2363       FLD (out_fpf) = f_dest;
2364     }
2365 #undef FLD
2366 }
2367
2368 void
2369 sh5_media_extract_sfmt_flds (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2370     sh5_media_insn_word insn = entire_insn;
2371 #define FLD(f) abuf->fields.sfmt_flds.f
2372     UINT f_left;
2373     SI f_disp10x4;
2374     UINT f_dest;
2375
2376     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2377     f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
2378     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2379
2380   /* Record the fields for the semantic handler.  */
2381   FLD (f_disp10x4) = f_disp10x4;
2382   FLD (f_left) = f_left;
2383   FLD (f_dest) = f_dest;
2384   if (UNLIKELY(current_cpu->trace_extract_p))
2385     {
2386       current_cpu->trace_stream
2387         << "0x" << hex << pc << dec << " (sfmt_flds)\t"
2388         << " f_disp10x4:0x" << hex << f_disp10x4 << dec
2389         << " f_left:0x" << hex << f_left << dec
2390         << " f_dest:0x" << hex << f_dest << dec
2391         << endl;
2392     }
2393
2394   /* Record the fields for profiling.  */
2395   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2396     {
2397       FLD (in_rm) = f_left;
2398       FLD (out_frf) = f_dest;
2399     }
2400 #undef FLD
2401 }
2402
2403 void
2404 sh5_media_extract_sfmt_fldxd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2405     sh5_media_insn_word insn = entire_insn;
2406 #define FLD(f) abuf->fields.sfmt_fldxd.f
2407     UINT f_left;
2408     UINT f_right;
2409     UINT f_dest;
2410
2411     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2412     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2413     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2414
2415   /* Record the fields for the semantic handler.  */
2416   FLD (f_left) = f_left;
2417   FLD (f_right) = f_right;
2418   FLD (f_dest) = f_dest;
2419   if (UNLIKELY(current_cpu->trace_extract_p))
2420     {
2421       current_cpu->trace_stream
2422         << "0x" << hex << pc << dec << " (sfmt_fldxd)\t"
2423         << " f_left:0x" << hex << f_left << dec
2424         << " f_right:0x" << hex << f_right << dec
2425         << " f_dest:0x" << hex << f_dest << dec
2426         << endl;
2427     }
2428
2429   /* Record the fields for profiling.  */
2430   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2431     {
2432       FLD (in_rm) = f_left;
2433       FLD (in_rn) = f_right;
2434       FLD (out_drf) = f_dest;
2435     }
2436 #undef FLD
2437 }
2438
2439 void
2440 sh5_media_extract_sfmt_fldxp (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2441     sh5_media_insn_word insn = entire_insn;
2442 #define FLD(f) abuf->fields.sfmt_fldxp.f
2443     UINT f_left;
2444     UINT f_right;
2445     UINT f_dest;
2446
2447     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2448     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2449     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2450
2451   /* Record the fields for the semantic handler.  */
2452   FLD (f_dest) = f_dest;
2453   FLD (f_left) = f_left;
2454   FLD (f_right) = f_right;
2455   if (UNLIKELY(current_cpu->trace_extract_p))
2456     {
2457       current_cpu->trace_stream
2458         << "0x" << hex << pc << dec << " (sfmt_fldxp)\t"
2459         << " f_dest:0x" << hex << f_dest << dec
2460         << " f_left:0x" << hex << f_left << dec
2461         << " f_right:0x" << hex << f_right << dec
2462         << endl;
2463     }
2464
2465   /* Record the fields for profiling.  */
2466   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2467     {
2468       FLD (in_fpf) = f_dest;
2469       FLD (in_rm) = f_left;
2470       FLD (in_rn) = f_right;
2471       FLD (out_fpf) = f_dest;
2472     }
2473 #undef FLD
2474 }
2475
2476 void
2477 sh5_media_extract_sfmt_fldxs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2478     sh5_media_insn_word insn = entire_insn;
2479 #define FLD(f) abuf->fields.sfmt_fldxs.f
2480     UINT f_left;
2481     UINT f_right;
2482     UINT f_dest;
2483
2484     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2485     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2486     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2487
2488   /* Record the fields for the semantic handler.  */
2489   FLD (f_left) = f_left;
2490   FLD (f_right) = f_right;
2491   FLD (f_dest) = f_dest;
2492   if (UNLIKELY(current_cpu->trace_extract_p))
2493     {
2494       current_cpu->trace_stream
2495         << "0x" << hex << pc << dec << " (sfmt_fldxs)\t"
2496         << " f_left:0x" << hex << f_left << dec
2497         << " f_right:0x" << hex << f_right << dec
2498         << " f_dest:0x" << hex << f_dest << dec
2499         << endl;
2500     }
2501
2502   /* Record the fields for profiling.  */
2503   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2504     {
2505       FLD (in_rm) = f_left;
2506       FLD (in_rn) = f_right;
2507       FLD (out_frf) = f_dest;
2508     }
2509 #undef FLD
2510 }
2511
2512 void
2513 sh5_media_extract_sfmt_fmacs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2514     sh5_media_insn_word insn = entire_insn;
2515 #define FLD(f) abuf->fields.sfmt_fmacs.f
2516     UINT f_left;
2517     UINT f_right;
2518     UINT f_dest;
2519
2520     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2521     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2522     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2523
2524   /* Record the fields for the semantic handler.  */
2525   FLD (f_dest) = f_dest;
2526   FLD (f_left) = f_left;
2527   FLD (f_right) = f_right;
2528   if (UNLIKELY(current_cpu->trace_extract_p))
2529     {
2530       current_cpu->trace_stream
2531         << "0x" << hex << pc << dec << " (sfmt_fmacs)\t"
2532         << " f_dest:0x" << hex << f_dest << dec
2533         << " f_left:0x" << hex << f_left << dec
2534         << " f_right:0x" << hex << f_right << dec
2535         << endl;
2536     }
2537
2538   /* Record the fields for profiling.  */
2539   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2540     {
2541       FLD (in_frf) = f_dest;
2542       FLD (in_frg) = f_left;
2543       FLD (in_frh) = f_right;
2544       FLD (out_frf) = f_dest;
2545     }
2546 #undef FLD
2547 }
2548
2549 void
2550 sh5_media_extract_sfmt_fmovdq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2551     sh5_media_insn_word insn = entire_insn;
2552 #define FLD(f) abuf->fields.sfmt_fmovdq.f
2553     UINT f_left;
2554     UINT f_right;
2555     UINT f_dest;
2556     UINT f_left_right;
2557
2558     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2559     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2560     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2561   f_left_right = f_left;
2562
2563   /* Record the fields for the semantic handler.  */
2564   FLD (f_left_right) = f_left_right;
2565   FLD (f_dest) = f_dest;
2566   if (UNLIKELY(current_cpu->trace_extract_p))
2567     {
2568       current_cpu->trace_stream
2569         << "0x" << hex << pc << dec << " (sfmt_fmovdq)\t"
2570         << " f_left_right:0x" << hex << f_left_right << dec
2571         << " f_dest:0x" << hex << f_dest << dec
2572         << endl;
2573     }
2574
2575   /* Record the fields for profiling.  */
2576   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2577     {
2578       FLD (in_drgh) = f_left_right;
2579       FLD (out_rd) = f_dest;
2580     }
2581 #undef FLD
2582 }
2583
2584 void
2585 sh5_media_extract_sfmt_fmovls (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2586     sh5_media_insn_word insn = entire_insn;
2587 #define FLD(f) abuf->fields.sfmt_flds.f
2588     UINT f_left;
2589     UINT f_dest;
2590
2591     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2592     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2593
2594   /* Record the fields for the semantic handler.  */
2595   FLD (f_left) = f_left;
2596   FLD (f_dest) = f_dest;
2597   if (UNLIKELY(current_cpu->trace_extract_p))
2598     {
2599       current_cpu->trace_stream
2600         << "0x" << hex << pc << dec << " (sfmt_fmovls)\t"
2601         << " f_left:0x" << hex << f_left << dec
2602         << " f_dest:0x" << hex << f_dest << dec
2603         << endl;
2604     }
2605
2606   /* Record the fields for profiling.  */
2607   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2608     {
2609       FLD (in_rm) = f_left;
2610       FLD (out_frf) = f_dest;
2611     }
2612 #undef FLD
2613 }
2614
2615 void
2616 sh5_media_extract_sfmt_fmovqd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2617     sh5_media_insn_word insn = entire_insn;
2618 #define FLD(f) abuf->fields.sfmt_fldd.f
2619     UINT f_left;
2620     UINT f_dest;
2621
2622     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2623     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2624
2625   /* Record the fields for the semantic handler.  */
2626   FLD (f_left) = f_left;
2627   FLD (f_dest) = f_dest;
2628   if (UNLIKELY(current_cpu->trace_extract_p))
2629     {
2630       current_cpu->trace_stream
2631         << "0x" << hex << pc << dec << " (sfmt_fmovqd)\t"
2632         << " f_left:0x" << hex << f_left << dec
2633         << " f_dest:0x" << hex << f_dest << dec
2634         << endl;
2635     }
2636
2637   /* Record the fields for profiling.  */
2638   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2639     {
2640       FLD (in_rm) = f_left;
2641       FLD (out_drf) = f_dest;
2642     }
2643 #undef FLD
2644 }
2645
2646 void
2647 sh5_media_extract_sfmt_fmovsl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2648     sh5_media_insn_word insn = entire_insn;
2649 #define FLD(f) abuf->fields.sfmt_fmovsl.f
2650     UINT f_left;
2651     UINT f_right;
2652     UINT f_dest;
2653     UINT f_left_right;
2654
2655     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2656     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2657     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2658   f_left_right = f_left;
2659
2660   /* Record the fields for the semantic handler.  */
2661   FLD (f_left_right) = f_left_right;
2662   FLD (f_dest) = f_dest;
2663   if (UNLIKELY(current_cpu->trace_extract_p))
2664     {
2665       current_cpu->trace_stream
2666         << "0x" << hex << pc << dec << " (sfmt_fmovsl)\t"
2667         << " f_left_right:0x" << hex << f_left_right << dec
2668         << " f_dest:0x" << hex << f_dest << dec
2669         << endl;
2670     }
2671
2672   /* Record the fields for profiling.  */
2673   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2674     {
2675       FLD (in_frgh) = f_left_right;
2676       FLD (out_rd) = f_dest;
2677     }
2678 #undef FLD
2679 }
2680
2681 void
2682 sh5_media_extract_sfmt_fputscr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2683     sh5_media_insn_word insn = entire_insn;
2684 #define FLD(f) abuf->fields.sfmt_fmovsl.f
2685     UINT f_left;
2686     UINT f_right;
2687     UINT f_left_right;
2688
2689     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2690     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2691   f_left_right = f_left;
2692
2693   /* Record the fields for the semantic handler.  */
2694   FLD (f_left_right) = f_left_right;
2695   if (UNLIKELY(current_cpu->trace_extract_p))
2696     {
2697       current_cpu->trace_stream
2698         << "0x" << hex << pc << dec << " (sfmt_fputscr)\t"
2699         << " f_left_right:0x" << hex << f_left_right << dec
2700         << endl;
2701     }
2702
2703   /* Record the fields for profiling.  */
2704   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2705     {
2706       FLD (in_frgh) = f_left_right;
2707     }
2708 #undef FLD
2709 }
2710
2711 void
2712 sh5_media_extract_sfmt_fstd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2713     sh5_media_insn_word insn = entire_insn;
2714 #define FLD(f) abuf->fields.sfmt_fstd.f
2715     UINT f_left;
2716     SI f_disp10x8;
2717     UINT f_dest;
2718
2719     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2720     f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2721     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2722
2723   /* Record the fields for the semantic handler.  */
2724   FLD (f_disp10x8) = f_disp10x8;
2725   FLD (f_dest) = f_dest;
2726   FLD (f_left) = f_left;
2727   if (UNLIKELY(current_cpu->trace_extract_p))
2728     {
2729       current_cpu->trace_stream
2730         << "0x" << hex << pc << dec << " (sfmt_fstd)\t"
2731         << " f_disp10x8:0x" << hex << f_disp10x8 << dec
2732         << " f_dest:0x" << hex << f_dest << dec
2733         << " f_left:0x" << hex << f_left << dec
2734         << endl;
2735     }
2736
2737   /* Record the fields for profiling.  */
2738   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2739     {
2740       FLD (in_drf) = f_dest;
2741       FLD (in_rm) = f_left;
2742     }
2743 #undef FLD
2744 }
2745
2746 void
2747 sh5_media_extract_sfmt_fsts (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2748     sh5_media_insn_word insn = entire_insn;
2749 #define FLD(f) abuf->fields.sfmt_fsts.f
2750     UINT f_left;
2751     SI f_disp10x4;
2752     UINT f_dest;
2753
2754     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2755     f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
2756     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2757
2758   /* Record the fields for the semantic handler.  */
2759   FLD (f_disp10x4) = f_disp10x4;
2760   FLD (f_dest) = f_dest;
2761   FLD (f_left) = f_left;
2762   if (UNLIKELY(current_cpu->trace_extract_p))
2763     {
2764       current_cpu->trace_stream
2765         << "0x" << hex << pc << dec << " (sfmt_fsts)\t"
2766         << " f_disp10x4:0x" << hex << f_disp10x4 << dec
2767         << " f_dest:0x" << hex << f_dest << dec
2768         << " f_left:0x" << hex << f_left << dec
2769         << endl;
2770     }
2771
2772   /* Record the fields for profiling.  */
2773   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2774     {
2775       FLD (in_frf) = f_dest;
2776       FLD (in_rm) = f_left;
2777     }
2778 #undef FLD
2779 }
2780
2781 void
2782 sh5_media_extract_sfmt_fstxd (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2783     sh5_media_insn_word insn = entire_insn;
2784 #define FLD(f) abuf->fields.sfmt_fstxd.f
2785     UINT f_left;
2786     UINT f_right;
2787     UINT f_dest;
2788
2789     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2790     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2791     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2792
2793   /* Record the fields for the semantic handler.  */
2794   FLD (f_dest) = f_dest;
2795   FLD (f_left) = f_left;
2796   FLD (f_right) = f_right;
2797   if (UNLIKELY(current_cpu->trace_extract_p))
2798     {
2799       current_cpu->trace_stream
2800         << "0x" << hex << pc << dec << " (sfmt_fstxd)\t"
2801         << " f_dest:0x" << hex << f_dest << dec
2802         << " f_left:0x" << hex << f_left << dec
2803         << " f_right:0x" << hex << f_right << dec
2804         << endl;
2805     }
2806
2807   /* Record the fields for profiling.  */
2808   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2809     {
2810       FLD (in_drf) = f_dest;
2811       FLD (in_rm) = f_left;
2812       FLD (in_rn) = f_right;
2813     }
2814 #undef FLD
2815 }
2816
2817 void
2818 sh5_media_extract_sfmt_fstxs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2819     sh5_media_insn_word insn = entire_insn;
2820 #define FLD(f) abuf->fields.sfmt_fstxs.f
2821     UINT f_left;
2822     UINT f_right;
2823     UINT f_dest;
2824
2825     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2826     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2827     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2828
2829   /* Record the fields for the semantic handler.  */
2830   FLD (f_dest) = f_dest;
2831   FLD (f_left) = f_left;
2832   FLD (f_right) = f_right;
2833   if (UNLIKELY(current_cpu->trace_extract_p))
2834     {
2835       current_cpu->trace_stream
2836         << "0x" << hex << pc << dec << " (sfmt_fstxs)\t"
2837         << " f_dest:0x" << hex << f_dest << dec
2838         << " f_left:0x" << hex << f_left << dec
2839         << " f_right:0x" << hex << f_right << dec
2840         << endl;
2841     }
2842
2843   /* Record the fields for profiling.  */
2844   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2845     {
2846       FLD (in_frf) = f_dest;
2847       FLD (in_rm) = f_left;
2848       FLD (in_rn) = f_right;
2849     }
2850 #undef FLD
2851 }
2852
2853 void
2854 sh5_media_extract_sfmt_ftrvs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2855     sh5_media_insn_word insn = entire_insn;
2856 #define FLD(f) abuf->fields.sfmt_ftrvs.f
2857     UINT f_left;
2858     UINT f_right;
2859     UINT f_dest;
2860
2861     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2862     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
2863     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2864
2865   /* Record the fields for the semantic handler.  */
2866   FLD (f_dest) = f_dest;
2867   FLD (f_left) = f_left;
2868   FLD (f_right) = f_right;
2869   if (UNLIKELY(current_cpu->trace_extract_p))
2870     {
2871       current_cpu->trace_stream
2872         << "0x" << hex << pc << dec << " (sfmt_ftrvs)\t"
2873         << " f_dest:0x" << hex << f_dest << dec
2874         << " f_left:0x" << hex << f_left << dec
2875         << " f_right:0x" << hex << f_right << dec
2876         << endl;
2877     }
2878
2879   /* Record the fields for profiling.  */
2880   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2881     {
2882       FLD (in_fvf) = f_dest;
2883       FLD (in_fvh) = f_right;
2884       FLD (in_mtrxg) = f_left;
2885       FLD (out_fvf) = f_dest;
2886       FLD (out_fvh) = f_right;
2887       FLD (out_mtrxg) = f_left;
2888     }
2889 #undef FLD
2890 }
2891
2892 void
2893 sh5_media_extract_sfmt_getcfg (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2894     sh5_media_insn_word insn = entire_insn;
2895 #define FLD(f) abuf->fields.sfmt_getcfg.f
2896     UINT f_left;
2897     INT f_disp6;
2898     UINT f_dest;
2899
2900     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2901     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2902     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2903
2904   /* Record the fields for the semantic handler.  */
2905   FLD (f_disp6) = f_disp6;
2906   FLD (f_left) = f_left;
2907   FLD (f_dest) = f_dest;
2908   if (UNLIKELY(current_cpu->trace_extract_p))
2909     {
2910       current_cpu->trace_stream
2911         << "0x" << hex << pc << dec << " (sfmt_getcfg)\t"
2912         << " f_disp6:0x" << hex << f_disp6 << dec
2913         << " f_left:0x" << hex << f_left << dec
2914         << " f_dest:0x" << hex << f_dest << dec
2915         << endl;
2916     }
2917
2918   /* Record the fields for profiling.  */
2919   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2920     {
2921       FLD (in_rm) = f_left;
2922       FLD (out_rd) = f_dest;
2923     }
2924 #undef FLD
2925 }
2926
2927 void
2928 sh5_media_extract_sfmt_getcon (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2929     sh5_media_insn_word insn = entire_insn;
2930 #define FLD(f) abuf->fields.sfmt_xori.f
2931     UINT f_left;
2932     UINT f_dest;
2933
2934     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2935     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2936
2937   /* Record the fields for the semantic handler.  */
2938   FLD (f_left) = f_left;
2939   FLD (f_dest) = f_dest;
2940   if (UNLIKELY(current_cpu->trace_extract_p))
2941     {
2942       current_cpu->trace_stream
2943         << "0x" << hex << pc << dec << " (sfmt_getcon)\t"
2944         << " f_left:0x" << hex << f_left << dec
2945         << " f_dest:0x" << hex << f_dest << dec
2946         << endl;
2947     }
2948
2949   /* Record the fields for profiling.  */
2950   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2951     {
2952       FLD (out_rd) = f_dest;
2953     }
2954 #undef FLD
2955 }
2956
2957 void
2958 sh5_media_extract_sfmt_gettr (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2959     sh5_media_insn_word insn = entire_insn;
2960 #define FLD(f) abuf->fields.sfmt_blink.f
2961     UINT f_trb;
2962     UINT f_dest;
2963
2964     f_trb = EXTRACT_MSB0_UINT (insn, 32, 9, 3);
2965     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2966
2967   /* Record the fields for the semantic handler.  */
2968   FLD (f_trb) = f_trb;
2969   FLD (f_dest) = f_dest;
2970   if (UNLIKELY(current_cpu->trace_extract_p))
2971     {
2972       current_cpu->trace_stream
2973         << "0x" << hex << pc << dec << " (sfmt_gettr)\t"
2974         << " f_trb:0x" << hex << f_trb << dec
2975         << " f_dest:0x" << hex << f_dest << dec
2976         << endl;
2977     }
2978
2979   /* Record the fields for profiling.  */
2980   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
2981     {
2982       FLD (in_trb) = f_trb;
2983       FLD (out_rd) = f_dest;
2984     }
2985 #undef FLD
2986 }
2987
2988 void
2989 sh5_media_extract_sfmt_ldb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
2990     sh5_media_insn_word insn = entire_insn;
2991 #define FLD(f) abuf->fields.sfmt_addi.f
2992     UINT f_left;
2993     INT f_disp10;
2994     UINT f_dest;
2995
2996     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2997     f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
2998     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2999
3000   /* Record the fields for the semantic handler.  */
3001   FLD (f_disp10) = f_disp10;
3002   FLD (f_left) = f_left;
3003   FLD (f_dest) = f_dest;
3004   if (UNLIKELY(current_cpu->trace_extract_p))
3005     {
3006       current_cpu->trace_stream
3007         << "0x" << hex << pc << dec << " (sfmt_ldb)\t"
3008         << " f_disp10:0x" << hex << f_disp10 << dec
3009         << " f_left:0x" << hex << f_left << dec
3010         << " f_dest:0x" << hex << f_dest << dec
3011         << endl;
3012     }
3013
3014   /* Record the fields for profiling.  */
3015   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3016     {
3017       FLD (in_rm) = f_left;
3018       FLD (out_rd) = f_dest;
3019     }
3020 #undef FLD
3021 }
3022
3023 void
3024 sh5_media_extract_sfmt_ldl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3025     sh5_media_insn_word insn = entire_insn;
3026 #define FLD(f) abuf->fields.sfmt_ldl.f
3027     UINT f_left;
3028     SI f_disp10x4;
3029     UINT f_dest;
3030
3031     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3032     f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
3033     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3034
3035   /* Record the fields for the semantic handler.  */
3036   FLD (f_disp10x4) = f_disp10x4;
3037   FLD (f_left) = f_left;
3038   FLD (f_dest) = f_dest;
3039   if (UNLIKELY(current_cpu->trace_extract_p))
3040     {
3041       current_cpu->trace_stream
3042         << "0x" << hex << pc << dec << " (sfmt_ldl)\t"
3043         << " f_disp10x4:0x" << hex << f_disp10x4 << dec
3044         << " f_left:0x" << hex << f_left << dec
3045         << " f_dest:0x" << hex << f_dest << dec
3046         << endl;
3047     }
3048
3049   /* Record the fields for profiling.  */
3050   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3051     {
3052       FLD (in_rm) = f_left;
3053       FLD (out_rd) = f_dest;
3054     }
3055 #undef FLD
3056 }
3057
3058 void
3059 sh5_media_extract_sfmt_ldq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3060     sh5_media_insn_word insn = entire_insn;
3061 #define FLD(f) abuf->fields.sfmt_ldq.f
3062     UINT f_left;
3063     SI f_disp10x8;
3064     UINT f_dest;
3065
3066     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3067     f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
3068     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3069
3070   /* Record the fields for the semantic handler.  */
3071   FLD (f_disp10x8) = f_disp10x8;
3072   FLD (f_left) = f_left;
3073   FLD (f_dest) = f_dest;
3074   if (UNLIKELY(current_cpu->trace_extract_p))
3075     {
3076       current_cpu->trace_stream
3077         << "0x" << hex << pc << dec << " (sfmt_ldq)\t"
3078         << " f_disp10x8:0x" << hex << f_disp10x8 << dec
3079         << " f_left:0x" << hex << f_left << dec
3080         << " f_dest:0x" << hex << f_dest << dec
3081         << endl;
3082     }
3083
3084   /* Record the fields for profiling.  */
3085   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3086     {
3087       FLD (in_rm) = f_left;
3088       FLD (out_rd) = f_dest;
3089     }
3090 #undef FLD
3091 }
3092
3093 void
3094 sh5_media_extract_sfmt_lduw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3095     sh5_media_insn_word insn = entire_insn;
3096 #define FLD(f) abuf->fields.sfmt_lduw.f
3097     UINT f_left;
3098     SI f_disp10x2;
3099     UINT f_dest;
3100
3101     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3102     f_disp10x2 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (1));
3103     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3104
3105   /* Record the fields for the semantic handler.  */
3106   FLD (f_disp10x2) = f_disp10x2;
3107   FLD (f_left) = f_left;
3108   FLD (f_dest) = f_dest;
3109   if (UNLIKELY(current_cpu->trace_extract_p))
3110     {
3111       current_cpu->trace_stream
3112         << "0x" << hex << pc << dec << " (sfmt_lduw)\t"
3113         << " f_disp10x2:0x" << hex << f_disp10x2 << dec
3114         << " f_left:0x" << hex << f_left << dec
3115         << " f_dest:0x" << hex << f_dest << dec
3116         << endl;
3117     }
3118
3119   /* Record the fields for profiling.  */
3120   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3121     {
3122       FLD (in_rm) = f_left;
3123       FLD (out_rd) = f_dest;
3124     }
3125 #undef FLD
3126 }
3127
3128 void
3129 sh5_media_extract_sfmt_ldhil (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3130     sh5_media_insn_word insn = entire_insn;
3131 #define FLD(f) abuf->fields.sfmt_getcfg.f
3132     UINT f_left;
3133     INT f_disp6;
3134     UINT f_dest;
3135
3136     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3137     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3138     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3139
3140   /* Record the fields for the semantic handler.  */
3141   FLD (f_disp6) = f_disp6;
3142   FLD (f_left) = f_left;
3143   FLD (f_dest) = f_dest;
3144   if (UNLIKELY(current_cpu->trace_extract_p))
3145     {
3146       current_cpu->trace_stream
3147         << "0x" << hex << pc << dec << " (sfmt_ldhil)\t"
3148         << " f_disp6:0x" << hex << f_disp6 << dec
3149         << " f_left:0x" << hex << f_left << dec
3150         << " f_dest:0x" << hex << f_dest << 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_left;
3158       FLD (out_rd) = f_dest;
3159     }
3160 #undef FLD
3161 }
3162
3163 void
3164 sh5_media_extract_sfmt_ldhiq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3165     sh5_media_insn_word insn = entire_insn;
3166 #define FLD(f) abuf->fields.sfmt_getcfg.f
3167     UINT f_left;
3168     INT f_disp6;
3169     UINT f_dest;
3170
3171     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3172     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3173     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3174
3175   /* Record the fields for the semantic handler.  */
3176   FLD (f_disp6) = f_disp6;
3177   FLD (f_left) = f_left;
3178   FLD (f_dest) = f_dest;
3179   if (UNLIKELY(current_cpu->trace_extract_p))
3180     {
3181       current_cpu->trace_stream
3182         << "0x" << hex << pc << dec << " (sfmt_ldhiq)\t"
3183         << " f_disp6:0x" << hex << f_disp6 << dec
3184         << " f_left:0x" << hex << f_left << dec
3185         << " f_dest:0x" << hex << f_dest << dec
3186         << endl;
3187     }
3188
3189   /* Record the fields for profiling.  */
3190   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3191     {
3192       FLD (in_rm) = f_left;
3193       FLD (out_rd) = f_dest;
3194     }
3195 #undef FLD
3196 }
3197
3198 void
3199 sh5_media_extract_sfmt_ldlol (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3200     sh5_media_insn_word insn = entire_insn;
3201 #define FLD(f) abuf->fields.sfmt_getcfg.f
3202     UINT f_left;
3203     INT f_disp6;
3204     UINT f_dest;
3205
3206     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3207     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3208     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3209
3210   /* Record the fields for the semantic handler.  */
3211   FLD (f_disp6) = f_disp6;
3212   FLD (f_left) = f_left;
3213   FLD (f_dest) = f_dest;
3214   if (UNLIKELY(current_cpu->trace_extract_p))
3215     {
3216       current_cpu->trace_stream
3217         << "0x" << hex << pc << dec << " (sfmt_ldlol)\t"
3218         << " f_disp6:0x" << hex << f_disp6 << dec
3219         << " f_left:0x" << hex << f_left << dec
3220         << " f_dest:0x" << hex << f_dest << dec
3221         << endl;
3222     }
3223
3224   /* Record the fields for profiling.  */
3225   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3226     {
3227       FLD (in_rm) = f_left;
3228       FLD (out_rd) = f_dest;
3229     }
3230 #undef FLD
3231 }
3232
3233 void
3234 sh5_media_extract_sfmt_ldloq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3235     sh5_media_insn_word insn = entire_insn;
3236 #define FLD(f) abuf->fields.sfmt_getcfg.f
3237     UINT f_left;
3238     INT f_disp6;
3239     UINT f_dest;
3240
3241     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3242     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3243     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3244
3245   /* Record the fields for the semantic handler.  */
3246   FLD (f_disp6) = f_disp6;
3247   FLD (f_left) = f_left;
3248   FLD (f_dest) = f_dest;
3249   if (UNLIKELY(current_cpu->trace_extract_p))
3250     {
3251       current_cpu->trace_stream
3252         << "0x" << hex << pc << dec << " (sfmt_ldloq)\t"
3253         << " f_disp6:0x" << hex << f_disp6 << dec
3254         << " f_left:0x" << hex << f_left << dec
3255         << " f_dest:0x" << hex << f_dest << dec
3256         << endl;
3257     }
3258
3259   /* Record the fields for profiling.  */
3260   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3261     {
3262       FLD (in_rm) = f_left;
3263       FLD (out_rd) = f_dest;
3264     }
3265 #undef FLD
3266 }
3267
3268 void
3269 sh5_media_extract_sfmt_ldxb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3270     sh5_media_insn_word insn = entire_insn;
3271 #define FLD(f) abuf->fields.sfmt_mcmv.f
3272     UINT f_left;
3273     UINT f_right;
3274     UINT f_dest;
3275
3276     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3277     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3278     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3279
3280   /* Record the fields for the semantic handler.  */
3281   FLD (f_left) = f_left;
3282   FLD (f_right) = f_right;
3283   FLD (f_dest) = f_dest;
3284   if (UNLIKELY(current_cpu->trace_extract_p))
3285     {
3286       current_cpu->trace_stream
3287         << "0x" << hex << pc << dec << " (sfmt_ldxb)\t"
3288         << " f_left:0x" << hex << f_left << dec
3289         << " f_right:0x" << hex << f_right << dec
3290         << " f_dest:0x" << hex << f_dest << dec
3291         << endl;
3292     }
3293
3294   /* Record the fields for profiling.  */
3295   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3296     {
3297       FLD (in_rm) = f_left;
3298       FLD (in_rn) = f_right;
3299       FLD (out_rd) = f_dest;
3300     }
3301 #undef FLD
3302 }
3303
3304 void
3305 sh5_media_extract_sfmt_ldxl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3306     sh5_media_insn_word insn = entire_insn;
3307 #define FLD(f) abuf->fields.sfmt_mcmv.f
3308     UINT f_left;
3309     UINT f_right;
3310     UINT f_dest;
3311
3312     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3313     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3314     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3315
3316   /* Record the fields for the semantic handler.  */
3317   FLD (f_left) = f_left;
3318   FLD (f_right) = f_right;
3319   FLD (f_dest) = f_dest;
3320   if (UNLIKELY(current_cpu->trace_extract_p))
3321     {
3322       current_cpu->trace_stream
3323         << "0x" << hex << pc << dec << " (sfmt_ldxl)\t"
3324         << " f_left:0x" << hex << f_left << dec
3325         << " f_right:0x" << hex << f_right << dec
3326         << " f_dest:0x" << hex << f_dest << dec
3327         << endl;
3328     }
3329
3330   /* Record the fields for profiling.  */
3331   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3332     {
3333       FLD (in_rm) = f_left;
3334       FLD (in_rn) = f_right;
3335       FLD (out_rd) = f_dest;
3336     }
3337 #undef FLD
3338 }
3339
3340 void
3341 sh5_media_extract_sfmt_ldxq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3342     sh5_media_insn_word insn = entire_insn;
3343 #define FLD(f) abuf->fields.sfmt_mcmv.f
3344     UINT f_left;
3345     UINT f_right;
3346     UINT f_dest;
3347
3348     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3349     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3350     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3351
3352   /* Record the fields for the semantic handler.  */
3353   FLD (f_left) = f_left;
3354   FLD (f_right) = f_right;
3355   FLD (f_dest) = f_dest;
3356   if (UNLIKELY(current_cpu->trace_extract_p))
3357     {
3358       current_cpu->trace_stream
3359         << "0x" << hex << pc << dec << " (sfmt_ldxq)\t"
3360         << " f_left:0x" << hex << f_left << dec
3361         << " f_right:0x" << hex << f_right << dec
3362         << " f_dest:0x" << hex << f_dest << dec
3363         << endl;
3364     }
3365
3366   /* Record the fields for profiling.  */
3367   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3368     {
3369       FLD (in_rm) = f_left;
3370       FLD (in_rn) = f_right;
3371       FLD (out_rd) = f_dest;
3372     }
3373 #undef FLD
3374 }
3375
3376 void
3377 sh5_media_extract_sfmt_ldxub (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3378     sh5_media_insn_word insn = entire_insn;
3379 #define FLD(f) abuf->fields.sfmt_mcmv.f
3380     UINT f_left;
3381     UINT f_right;
3382     UINT f_dest;
3383
3384     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3385     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3386     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3387
3388   /* Record the fields for the semantic handler.  */
3389   FLD (f_left) = f_left;
3390   FLD (f_right) = f_right;
3391   FLD (f_dest) = f_dest;
3392   if (UNLIKELY(current_cpu->trace_extract_p))
3393     {
3394       current_cpu->trace_stream
3395         << "0x" << hex << pc << dec << " (sfmt_ldxub)\t"
3396         << " f_left:0x" << hex << f_left << dec
3397         << " f_right:0x" << hex << f_right << dec
3398         << " f_dest:0x" << hex << f_dest << dec
3399         << endl;
3400     }
3401
3402   /* Record the fields for profiling.  */
3403   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3404     {
3405       FLD (in_rm) = f_left;
3406       FLD (in_rn) = f_right;
3407       FLD (out_rd) = f_dest;
3408     }
3409 #undef FLD
3410 }
3411
3412 void
3413 sh5_media_extract_sfmt_ldxuw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3414     sh5_media_insn_word insn = entire_insn;
3415 #define FLD(f) abuf->fields.sfmt_mcmv.f
3416     UINT f_left;
3417     UINT f_right;
3418     UINT f_dest;
3419
3420     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3421     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3422     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3423
3424   /* Record the fields for the semantic handler.  */
3425   FLD (f_left) = f_left;
3426   FLD (f_right) = f_right;
3427   FLD (f_dest) = f_dest;
3428   if (UNLIKELY(current_cpu->trace_extract_p))
3429     {
3430       current_cpu->trace_stream
3431         << "0x" << hex << pc << dec << " (sfmt_ldxuw)\t"
3432         << " f_left:0x" << hex << f_left << dec
3433         << " f_right:0x" << hex << f_right << dec
3434         << " f_dest:0x" << hex << f_dest << dec
3435         << endl;
3436     }
3437
3438   /* Record the fields for profiling.  */
3439   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3440     {
3441       FLD (in_rm) = f_left;
3442       FLD (in_rn) = f_right;
3443       FLD (out_rd) = f_dest;
3444     }
3445 #undef FLD
3446 }
3447
3448 void
3449 sh5_media_extract_sfmt_ldxw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3450     sh5_media_insn_word insn = entire_insn;
3451 #define FLD(f) abuf->fields.sfmt_mcmv.f
3452     UINT f_left;
3453     UINT f_right;
3454     UINT f_dest;
3455
3456     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3457     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3458     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3459
3460   /* Record the fields for the semantic handler.  */
3461   FLD (f_left) = f_left;
3462   FLD (f_right) = f_right;
3463   FLD (f_dest) = f_dest;
3464   if (UNLIKELY(current_cpu->trace_extract_p))
3465     {
3466       current_cpu->trace_stream
3467         << "0x" << hex << pc << dec << " (sfmt_ldxw)\t"
3468         << " f_left:0x" << hex << f_left << dec
3469         << " f_right:0x" << hex << f_right << dec
3470         << " f_dest:0x" << hex << f_dest << dec
3471         << endl;
3472     }
3473
3474   /* Record the fields for profiling.  */
3475   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3476     {
3477       FLD (in_rm) = f_left;
3478       FLD (in_rn) = f_right;
3479       FLD (out_rd) = f_dest;
3480     }
3481 #undef FLD
3482 }
3483
3484 void
3485 sh5_media_extract_sfmt_mcmv (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3486     sh5_media_insn_word insn = entire_insn;
3487 #define FLD(f) abuf->fields.sfmt_mcmv.f
3488     UINT f_left;
3489     UINT f_right;
3490     UINT f_dest;
3491
3492     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3493     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3494     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3495
3496   /* Record the fields for the semantic handler.  */
3497   FLD (f_dest) = f_dest;
3498   FLD (f_left) = f_left;
3499   FLD (f_right) = f_right;
3500   if (UNLIKELY(current_cpu->trace_extract_p))
3501     {
3502       current_cpu->trace_stream
3503         << "0x" << hex << pc << dec << " (sfmt_mcmv)\t"
3504         << " f_dest:0x" << hex << f_dest << dec
3505         << " f_left:0x" << hex << f_left << dec
3506         << " f_right:0x" << hex << f_right << dec
3507         << endl;
3508     }
3509
3510   /* Record the fields for profiling.  */
3511   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3512     {
3513       FLD (in_rd) = f_dest;
3514       FLD (in_rm) = f_left;
3515       FLD (in_rn) = f_right;
3516       FLD (out_rd) = f_dest;
3517     }
3518 #undef FLD
3519 }
3520
3521 void
3522 sh5_media_extract_sfmt_movi (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3523     sh5_media_insn_word insn = entire_insn;
3524 #define FLD(f) abuf->fields.sfmt_movi.f
3525     INT f_imm16;
3526     UINT f_dest;
3527
3528     f_imm16 = EXTRACT_MSB0_SINT (insn, 32, 6, 16);
3529     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3530
3531   /* Record the fields for the semantic handler.  */
3532   FLD (f_imm16) = f_imm16;
3533   FLD (f_dest) = f_dest;
3534   if (UNLIKELY(current_cpu->trace_extract_p))
3535     {
3536       current_cpu->trace_stream
3537         << "0x" << hex << pc << dec << " (sfmt_movi)\t"
3538         << " f_imm16:0x" << hex << f_imm16 << dec
3539         << " f_dest:0x" << hex << f_dest << dec
3540         << endl;
3541     }
3542
3543   /* Record the fields for profiling.  */
3544   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3545     {
3546       FLD (out_rd) = f_dest;
3547     }
3548 #undef FLD
3549 }
3550
3551 void
3552 sh5_media_extract_sfmt_nop (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3553     sh5_media_insn_word insn = entire_insn;
3554 #define FLD(f) abuf->fields.fmt_empty.f
3555
3556
3557   /* Record the fields for the semantic handler.  */
3558   if (UNLIKELY(current_cpu->trace_extract_p))
3559     {
3560       current_cpu->trace_stream
3561         << "0x" << hex << pc << dec << " (sfmt_nop)\t"
3562         << endl;
3563     }
3564
3565 #undef FLD
3566 }
3567
3568 void
3569 sh5_media_extract_sfmt_ori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3570     sh5_media_insn_word insn = entire_insn;
3571 #define FLD(f) abuf->fields.sfmt_ori.f
3572     UINT f_left;
3573     INT f_imm10;
3574     UINT f_dest;
3575
3576     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3577     f_imm10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
3578     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3579
3580   /* Record the fields for the semantic handler.  */
3581   FLD (f_imm10) = f_imm10;
3582   FLD (f_left) = f_left;
3583   FLD (f_dest) = f_dest;
3584   if (UNLIKELY(current_cpu->trace_extract_p))
3585     {
3586       current_cpu->trace_stream
3587         << "0x" << hex << pc << dec << " (sfmt_ori)\t"
3588         << " f_imm10:0x" << hex << f_imm10 << dec
3589         << " f_left:0x" << hex << f_left << dec
3590         << " f_dest:0x" << hex << f_dest << dec
3591         << endl;
3592     }
3593
3594   /* Record the fields for profiling.  */
3595   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3596     {
3597       FLD (in_rm) = f_left;
3598       FLD (out_rd) = f_dest;
3599     }
3600 #undef FLD
3601 }
3602
3603 void
3604 sh5_media_extract_sfmt_pta (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3605     sh5_media_insn_word insn = entire_insn;
3606 #define FLD(f) abuf->fields.sfmt_pta.f
3607     DI f_disp16;
3608     UINT f_likely;
3609     UINT f_tra;
3610
3611     f_disp16 = ((((EXTRACT_MSB0_SINT (insn, 32, 6, 16)) << (2))) + (pc));
3612     f_likely = EXTRACT_MSB0_UINT (insn, 32, 22, 1);
3613     f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
3614
3615   /* Record the fields for the semantic handler.  */
3616   FLD (f_disp16) = f_disp16;
3617   FLD (f_tra) = f_tra;
3618   FLD (f_likely) = f_likely;
3619   if (UNLIKELY(current_cpu->trace_extract_p))
3620     {
3621       current_cpu->trace_stream
3622         << "0x" << hex << pc << dec << " (sfmt_pta)\t"
3623         << " f_disp16:0x" << hex << f_disp16 << dec
3624         << " f_tra:0x" << hex << f_tra << dec
3625         << " f_likely:0x" << hex << f_likely << dec
3626         << endl;
3627     }
3628
3629   /* Record the fields for profiling.  */
3630   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3631     {
3632       FLD (out_tra) = f_tra;
3633     }
3634 #undef FLD
3635 }
3636
3637 void
3638 sh5_media_extract_sfmt_ptabs (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3639     sh5_media_insn_word insn = entire_insn;
3640 #define FLD(f) abuf->fields.sfmt_ptabs.f
3641     UINT f_right;
3642     UINT f_likely;
3643     UINT f_tra;
3644
3645     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3646     f_likely = EXTRACT_MSB0_UINT (insn, 32, 22, 1);
3647     f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
3648
3649   /* Record the fields for the semantic handler.  */
3650   FLD (f_tra) = f_tra;
3651   FLD (f_likely) = f_likely;
3652   FLD (f_right) = f_right;
3653   if (UNLIKELY(current_cpu->trace_extract_p))
3654     {
3655       current_cpu->trace_stream
3656         << "0x" << hex << pc << dec << " (sfmt_ptabs)\t"
3657         << " f_tra:0x" << hex << f_tra << dec
3658         << " f_likely:0x" << hex << f_likely << dec
3659         << " f_right:0x" << hex << f_right << dec
3660         << endl;
3661     }
3662
3663   /* Record the fields for profiling.  */
3664   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3665     {
3666       FLD (in_rn) = f_right;
3667       FLD (out_tra) = f_tra;
3668     }
3669 #undef FLD
3670 }
3671
3672 void
3673 sh5_media_extract_sfmt_ptrel (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3674     sh5_media_insn_word insn = entire_insn;
3675 #define FLD(f) abuf->fields.sfmt_ptabs.f
3676     UINT f_right;
3677     UINT f_likely;
3678     UINT f_tra;
3679
3680     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3681     f_likely = EXTRACT_MSB0_UINT (insn, 32, 22, 1);
3682     f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
3683
3684   /* Record the fields for the semantic handler.  */
3685   FLD (f_tra) = f_tra;
3686   FLD (f_likely) = f_likely;
3687   FLD (f_right) = f_right;
3688   if (UNLIKELY(current_cpu->trace_extract_p))
3689     {
3690       current_cpu->trace_stream
3691         << "0x" << hex << pc << dec << " (sfmt_ptrel)\t"
3692         << " f_tra:0x" << hex << f_tra << dec
3693         << " f_likely:0x" << hex << f_likely << dec
3694         << " f_right:0x" << hex << f_right << dec
3695         << endl;
3696     }
3697
3698   /* Record the fields for profiling.  */
3699   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3700     {
3701       FLD (in_rn) = f_right;
3702       FLD (out_tra) = f_tra;
3703     }
3704 #undef FLD
3705 }
3706
3707 void
3708 sh5_media_extract_sfmt_putcfg (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3709     sh5_media_insn_word insn = entire_insn;
3710 #define FLD(f) abuf->fields.sfmt_putcfg.f
3711     UINT f_left;
3712     INT f_disp6;
3713     UINT f_dest;
3714
3715     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3716     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3717     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3718
3719   /* Record the fields for the semantic handler.  */
3720   FLD (f_disp6) = f_disp6;
3721   FLD (f_dest) = f_dest;
3722   FLD (f_left) = f_left;
3723   if (UNLIKELY(current_cpu->trace_extract_p))
3724     {
3725       current_cpu->trace_stream
3726         << "0x" << hex << pc << dec << " (sfmt_putcfg)\t"
3727         << " f_disp6:0x" << hex << f_disp6 << dec
3728         << " f_dest:0x" << hex << f_dest << dec
3729         << " f_left:0x" << hex << f_left << dec
3730         << endl;
3731     }
3732
3733   /* Record the fields for profiling.  */
3734   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3735     {
3736       FLD (in_rd) = f_dest;
3737       FLD (in_rm) = f_left;
3738     }
3739 #undef FLD
3740 }
3741
3742 void
3743 sh5_media_extract_sfmt_putcon (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3744     sh5_media_insn_word insn = entire_insn;
3745 #define FLD(f) abuf->fields.sfmt_xori.f
3746     UINT f_left;
3747     UINT f_dest;
3748
3749     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3750     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3751
3752   /* Record the fields for the semantic handler.  */
3753   FLD (f_left) = f_left;
3754   FLD (f_dest) = f_dest;
3755   if (UNLIKELY(current_cpu->trace_extract_p))
3756     {
3757       current_cpu->trace_stream
3758         << "0x" << hex << pc << dec << " (sfmt_putcon)\t"
3759         << " f_left:0x" << hex << f_left << dec
3760         << " f_dest:0x" << hex << f_dest << dec
3761         << endl;
3762     }
3763
3764   /* Record the fields for profiling.  */
3765   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3766     {
3767       FLD (in_rm) = f_left;
3768     }
3769 #undef FLD
3770 }
3771
3772 void
3773 sh5_media_extract_sfmt_shari (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3774     sh5_media_insn_word insn = entire_insn;
3775 #define FLD(f) abuf->fields.sfmt_shari.f
3776     UINT f_left;
3777     UINT f_uimm6;
3778     UINT f_dest;
3779
3780     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3781     f_uimm6 = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3782     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3783
3784   /* Record the fields for the semantic handler.  */
3785   FLD (f_left) = f_left;
3786   FLD (f_uimm6) = f_uimm6;
3787   FLD (f_dest) = f_dest;
3788   if (UNLIKELY(current_cpu->trace_extract_p))
3789     {
3790       current_cpu->trace_stream
3791         << "0x" << hex << pc << dec << " (sfmt_shari)\t"
3792         << " f_left:0x" << hex << f_left << dec
3793         << " f_uimm6:0x" << hex << f_uimm6 << dec
3794         << " f_dest:0x" << hex << f_dest << dec
3795         << endl;
3796     }
3797
3798   /* Record the fields for profiling.  */
3799   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3800     {
3801       FLD (in_rm) = f_left;
3802       FLD (out_rd) = f_dest;
3803     }
3804 #undef FLD
3805 }
3806
3807 void
3808 sh5_media_extract_sfmt_shori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3809     sh5_media_insn_word insn = entire_insn;
3810 #define FLD(f) abuf->fields.sfmt_shori.f
3811     UINT f_uimm16;
3812     UINT f_dest;
3813
3814     f_uimm16 = EXTRACT_MSB0_UINT (insn, 32, 6, 16);
3815     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3816
3817   /* Record the fields for the semantic handler.  */
3818   FLD (f_dest) = f_dest;
3819   FLD (f_uimm16) = f_uimm16;
3820   if (UNLIKELY(current_cpu->trace_extract_p))
3821     {
3822       current_cpu->trace_stream
3823         << "0x" << hex << pc << dec << " (sfmt_shori)\t"
3824         << " f_dest:0x" << hex << f_dest << dec
3825         << " f_uimm16:0x" << hex << f_uimm16 << dec
3826         << endl;
3827     }
3828
3829   /* Record the fields for profiling.  */
3830   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3831     {
3832       FLD (in_rd) = f_dest;
3833       FLD (out_rd) = f_dest;
3834     }
3835 #undef FLD
3836 }
3837
3838 void
3839 sh5_media_extract_sfmt_stb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3840     sh5_media_insn_word insn = entire_insn;
3841 #define FLD(f) abuf->fields.sfmt_stb.f
3842     UINT f_left;
3843     INT f_disp10;
3844     UINT f_dest;
3845
3846     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3847     f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
3848     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3849
3850   /* Record the fields for the semantic handler.  */
3851   FLD (f_disp10) = f_disp10;
3852   FLD (f_dest) = f_dest;
3853   FLD (f_left) = f_left;
3854   if (UNLIKELY(current_cpu->trace_extract_p))
3855     {
3856       current_cpu->trace_stream
3857         << "0x" << hex << pc << dec << " (sfmt_stb)\t"
3858         << " f_disp10:0x" << hex << f_disp10 << dec
3859         << " f_dest:0x" << hex << f_dest << dec
3860         << " f_left:0x" << hex << f_left << dec
3861         << endl;
3862     }
3863
3864   /* Record the fields for profiling.  */
3865   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3866     {
3867       FLD (in_rd) = f_dest;
3868       FLD (in_rm) = f_left;
3869     }
3870 #undef FLD
3871 }
3872
3873 void
3874 sh5_media_extract_sfmt_stl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3875     sh5_media_insn_word insn = entire_insn;
3876 #define FLD(f) abuf->fields.sfmt_stl.f
3877     UINT f_left;
3878     SI f_disp10x4;
3879     UINT f_dest;
3880
3881     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3882     f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
3883     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3884
3885   /* Record the fields for the semantic handler.  */
3886   FLD (f_disp10x4) = f_disp10x4;
3887   FLD (f_dest) = f_dest;
3888   FLD (f_left) = f_left;
3889   if (UNLIKELY(current_cpu->trace_extract_p))
3890     {
3891       current_cpu->trace_stream
3892         << "0x" << hex << pc << dec << " (sfmt_stl)\t"
3893         << " f_disp10x4:0x" << hex << f_disp10x4 << dec
3894         << " f_dest:0x" << hex << f_dest << dec
3895         << " f_left:0x" << hex << f_left << dec
3896         << endl;
3897     }
3898
3899   /* Record the fields for profiling.  */
3900   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3901     {
3902       FLD (in_rd) = f_dest;
3903       FLD (in_rm) = f_left;
3904     }
3905 #undef FLD
3906 }
3907
3908 void
3909 sh5_media_extract_sfmt_stq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3910     sh5_media_insn_word insn = entire_insn;
3911 #define FLD(f) abuf->fields.sfmt_stq.f
3912     UINT f_left;
3913     SI f_disp10x8;
3914     UINT f_dest;
3915
3916     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3917     f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
3918     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3919
3920   /* Record the fields for the semantic handler.  */
3921   FLD (f_disp10x8) = f_disp10x8;
3922   FLD (f_dest) = f_dest;
3923   FLD (f_left) = f_left;
3924   if (UNLIKELY(current_cpu->trace_extract_p))
3925     {
3926       current_cpu->trace_stream
3927         << "0x" << hex << pc << dec << " (sfmt_stq)\t"
3928         << " f_disp10x8:0x" << hex << f_disp10x8 << dec
3929         << " f_dest:0x" << hex << f_dest << dec
3930         << " f_left:0x" << hex << f_left << dec
3931         << endl;
3932     }
3933
3934   /* Record the fields for profiling.  */
3935   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3936     {
3937       FLD (in_rd) = f_dest;
3938       FLD (in_rm) = f_left;
3939     }
3940 #undef FLD
3941 }
3942
3943 void
3944 sh5_media_extract_sfmt_stw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3945     sh5_media_insn_word insn = entire_insn;
3946 #define FLD(f) abuf->fields.sfmt_stw.f
3947     UINT f_left;
3948     SI f_disp10x2;
3949     UINT f_dest;
3950
3951     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3952     f_disp10x2 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (1));
3953     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3954
3955   /* Record the fields for the semantic handler.  */
3956   FLD (f_disp10x2) = f_disp10x2;
3957   FLD (f_dest) = f_dest;
3958   FLD (f_left) = f_left;
3959   if (UNLIKELY(current_cpu->trace_extract_p))
3960     {
3961       current_cpu->trace_stream
3962         << "0x" << hex << pc << dec << " (sfmt_stw)\t"
3963         << " f_disp10x2:0x" << hex << f_disp10x2 << dec
3964         << " f_dest:0x" << hex << f_dest << dec
3965         << " f_left:0x" << hex << f_left << dec
3966         << endl;
3967     }
3968
3969   /* Record the fields for profiling.  */
3970   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
3971     {
3972       FLD (in_rd) = f_dest;
3973       FLD (in_rm) = f_left;
3974     }
3975 #undef FLD
3976 }
3977
3978 void
3979 sh5_media_extract_sfmt_sthil (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
3980     sh5_media_insn_word insn = entire_insn;
3981 #define FLD(f) abuf->fields.sfmt_putcfg.f
3982     UINT f_left;
3983     INT f_disp6;
3984     UINT f_dest;
3985
3986     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3987     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3988     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3989
3990   /* Record the fields for the semantic handler.  */
3991   FLD (f_disp6) = f_disp6;
3992   FLD (f_dest) = f_dest;
3993   FLD (f_left) = f_left;
3994   if (UNLIKELY(current_cpu->trace_extract_p))
3995     {
3996       current_cpu->trace_stream
3997         << "0x" << hex << pc << dec << " (sfmt_sthil)\t"
3998         << " f_disp6:0x" << hex << f_disp6 << dec
3999         << " f_dest:0x" << hex << f_dest << dec
4000         << " f_left:0x" << hex << f_left << dec
4001         << endl;
4002     }
4003
4004   /* Record the fields for profiling.  */
4005   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4006     {
4007       FLD (in_rd) = f_dest;
4008       FLD (in_rm) = f_left;
4009     }
4010 #undef FLD
4011 }
4012
4013 void
4014 sh5_media_extract_sfmt_sthiq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4015     sh5_media_insn_word insn = entire_insn;
4016 #define FLD(f) abuf->fields.sfmt_putcfg.f
4017     UINT f_left;
4018     INT f_disp6;
4019     UINT f_dest;
4020
4021     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4022     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
4023     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4024
4025   /* Record the fields for the semantic handler.  */
4026   FLD (f_disp6) = f_disp6;
4027   FLD (f_dest) = f_dest;
4028   FLD (f_left) = f_left;
4029   if (UNLIKELY(current_cpu->trace_extract_p))
4030     {
4031       current_cpu->trace_stream
4032         << "0x" << hex << pc << dec << " (sfmt_sthiq)\t"
4033         << " f_disp6:0x" << hex << f_disp6 << dec
4034         << " f_dest:0x" << hex << f_dest << dec
4035         << " f_left:0x" << hex << f_left << dec
4036         << endl;
4037     }
4038
4039   /* Record the fields for profiling.  */
4040   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4041     {
4042       FLD (in_rd) = f_dest;
4043       FLD (in_rm) = f_left;
4044     }
4045 #undef FLD
4046 }
4047
4048 void
4049 sh5_media_extract_sfmt_stlol (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4050     sh5_media_insn_word insn = entire_insn;
4051 #define FLD(f) abuf->fields.sfmt_putcfg.f
4052     UINT f_left;
4053     INT f_disp6;
4054     UINT f_dest;
4055
4056     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4057     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
4058     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4059
4060   /* Record the fields for the semantic handler.  */
4061   FLD (f_disp6) = f_disp6;
4062   FLD (f_dest) = f_dest;
4063   FLD (f_left) = f_left;
4064   if (UNLIKELY(current_cpu->trace_extract_p))
4065     {
4066       current_cpu->trace_stream
4067         << "0x" << hex << pc << dec << " (sfmt_stlol)\t"
4068         << " f_disp6:0x" << hex << f_disp6 << dec
4069         << " f_dest:0x" << hex << f_dest << dec
4070         << " f_left:0x" << hex << f_left << dec
4071         << endl;
4072     }
4073
4074   /* Record the fields for profiling.  */
4075   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4076     {
4077       FLD (in_rd) = f_dest;
4078       FLD (in_rm) = f_left;
4079     }
4080 #undef FLD
4081 }
4082
4083 void
4084 sh5_media_extract_sfmt_stloq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4085     sh5_media_insn_word insn = entire_insn;
4086 #define FLD(f) abuf->fields.sfmt_putcfg.f
4087     UINT f_left;
4088     INT f_disp6;
4089     UINT f_dest;
4090
4091     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4092     f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
4093     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4094
4095   /* Record the fields for the semantic handler.  */
4096   FLD (f_disp6) = f_disp6;
4097   FLD (f_dest) = f_dest;
4098   FLD (f_left) = f_left;
4099   if (UNLIKELY(current_cpu->trace_extract_p))
4100     {
4101       current_cpu->trace_stream
4102         << "0x" << hex << pc << dec << " (sfmt_stloq)\t"
4103         << " f_disp6:0x" << hex << f_disp6 << dec
4104         << " f_dest:0x" << hex << f_dest << dec
4105         << " f_left:0x" << hex << f_left << dec
4106         << endl;
4107     }
4108
4109   /* Record the fields for profiling.  */
4110   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4111     {
4112       FLD (in_rd) = f_dest;
4113       FLD (in_rm) = f_left;
4114     }
4115 #undef FLD
4116 }
4117
4118 void
4119 sh5_media_extract_sfmt_stxb (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4120     sh5_media_insn_word insn = entire_insn;
4121 #define FLD(f) abuf->fields.sfmt_mcmv.f
4122     UINT f_left;
4123     UINT f_right;
4124     UINT f_dest;
4125
4126     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4127     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
4128     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4129
4130   /* Record the fields for the semantic handler.  */
4131   FLD (f_dest) = f_dest;
4132   FLD (f_left) = f_left;
4133   FLD (f_right) = f_right;
4134   if (UNLIKELY(current_cpu->trace_extract_p))
4135     {
4136       current_cpu->trace_stream
4137         << "0x" << hex << pc << dec << " (sfmt_stxb)\t"
4138         << " f_dest:0x" << hex << f_dest << dec
4139         << " f_left:0x" << hex << f_left << dec
4140         << " f_right:0x" << hex << f_right << dec
4141         << endl;
4142     }
4143
4144   /* Record the fields for profiling.  */
4145   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4146     {
4147       FLD (in_rd) = f_dest;
4148       FLD (in_rm) = f_left;
4149       FLD (in_rn) = f_right;
4150     }
4151 #undef FLD
4152 }
4153
4154 void
4155 sh5_media_extract_sfmt_stxl (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4156     sh5_media_insn_word insn = entire_insn;
4157 #define FLD(f) abuf->fields.sfmt_mcmv.f
4158     UINT f_left;
4159     UINT f_right;
4160     UINT f_dest;
4161
4162     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4163     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
4164     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4165
4166   /* Record the fields for the semantic handler.  */
4167   FLD (f_dest) = f_dest;
4168   FLD (f_left) = f_left;
4169   FLD (f_right) = f_right;
4170   if (UNLIKELY(current_cpu->trace_extract_p))
4171     {
4172       current_cpu->trace_stream
4173         << "0x" << hex << pc << dec << " (sfmt_stxl)\t"
4174         << " f_dest:0x" << hex << f_dest << dec
4175         << " f_left:0x" << hex << f_left << dec
4176         << " f_right:0x" << hex << f_right << dec
4177         << endl;
4178     }
4179
4180   /* Record the fields for profiling.  */
4181   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4182     {
4183       FLD (in_rd) = f_dest;
4184       FLD (in_rm) = f_left;
4185       FLD (in_rn) = f_right;
4186     }
4187 #undef FLD
4188 }
4189
4190 void
4191 sh5_media_extract_sfmt_stxq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4192     sh5_media_insn_word insn = entire_insn;
4193 #define FLD(f) abuf->fields.sfmt_mcmv.f
4194     UINT f_left;
4195     UINT f_right;
4196     UINT f_dest;
4197
4198     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4199     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
4200     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4201
4202   /* Record the fields for the semantic handler.  */
4203   FLD (f_dest) = f_dest;
4204   FLD (f_left) = f_left;
4205   FLD (f_right) = f_right;
4206   if (UNLIKELY(current_cpu->trace_extract_p))
4207     {
4208       current_cpu->trace_stream
4209         << "0x" << hex << pc << dec << " (sfmt_stxq)\t"
4210         << " f_dest:0x" << hex << f_dest << dec
4211         << " f_left:0x" << hex << f_left << dec
4212         << " f_right:0x" << hex << f_right << dec
4213         << endl;
4214     }
4215
4216   /* Record the fields for profiling.  */
4217   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4218     {
4219       FLD (in_rd) = f_dest;
4220       FLD (in_rm) = f_left;
4221       FLD (in_rn) = f_right;
4222     }
4223 #undef FLD
4224 }
4225
4226 void
4227 sh5_media_extract_sfmt_stxw (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4228     sh5_media_insn_word insn = entire_insn;
4229 #define FLD(f) abuf->fields.sfmt_mcmv.f
4230     UINT f_left;
4231     UINT f_right;
4232     UINT f_dest;
4233
4234     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4235     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
4236     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4237
4238   /* Record the fields for the semantic handler.  */
4239   FLD (f_dest) = f_dest;
4240   FLD (f_left) = f_left;
4241   FLD (f_right) = f_right;
4242   if (UNLIKELY(current_cpu->trace_extract_p))
4243     {
4244       current_cpu->trace_stream
4245         << "0x" << hex << pc << dec << " (sfmt_stxw)\t"
4246         << " f_dest:0x" << hex << f_dest << dec
4247         << " f_left:0x" << hex << f_left << dec
4248         << " f_right:0x" << hex << f_right << dec
4249         << endl;
4250     }
4251
4252   /* Record the fields for profiling.  */
4253   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4254     {
4255       FLD (in_rd) = f_dest;
4256       FLD (in_rm) = f_left;
4257       FLD (in_rn) = f_right;
4258     }
4259 #undef FLD
4260 }
4261
4262 void
4263 sh5_media_extract_sfmt_swapq (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4264     sh5_media_insn_word insn = entire_insn;
4265 #define FLD(f) abuf->fields.sfmt_mcmv.f
4266     UINT f_left;
4267     UINT f_right;
4268     UINT f_dest;
4269
4270     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4271     f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
4272     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4273
4274   /* Record the fields for the semantic handler.  */
4275   FLD (f_dest) = f_dest;
4276   FLD (f_left) = f_left;
4277   FLD (f_right) = f_right;
4278   if (UNLIKELY(current_cpu->trace_extract_p))
4279     {
4280       current_cpu->trace_stream
4281         << "0x" << hex << pc << dec << " (sfmt_swapq)\t"
4282         << " f_dest:0x" << hex << f_dest << dec
4283         << " f_left:0x" << hex << f_left << dec
4284         << " f_right:0x" << hex << f_right << dec
4285         << endl;
4286     }
4287
4288   /* Record the fields for profiling.  */
4289   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4290     {
4291       FLD (in_rd) = f_dest;
4292       FLD (in_rm) = f_left;
4293       FLD (in_rn) = f_right;
4294       FLD (out_rd) = f_dest;
4295     }
4296 #undef FLD
4297 }
4298
4299 void
4300 sh5_media_extract_sfmt_trapa (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4301     sh5_media_insn_word insn = entire_insn;
4302 #define FLD(f) abuf->fields.sfmt_alloco.f
4303     UINT f_left;
4304
4305     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4306
4307   /* Record the fields for the semantic handler.  */
4308   FLD (f_left) = f_left;
4309   if (UNLIKELY(current_cpu->trace_extract_p))
4310     {
4311       current_cpu->trace_stream
4312         << "0x" << hex << pc << dec << " (sfmt_trapa)\t"
4313         << " f_left:0x" << hex << f_left << dec
4314         << endl;
4315     }
4316
4317   /* Record the fields for profiling.  */
4318   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4319     {
4320       FLD (in_rm) = f_left;
4321     }
4322 #undef FLD
4323 }
4324
4325 void
4326 sh5_media_extract_sfmt_xori (sh5_media_scache* abuf, sh5_cpu* current_cpu, PCADDR pc, sh5_media_insn_word base_insn, sh5_media_insn_word entire_insn){
4327     sh5_media_insn_word insn = entire_insn;
4328 #define FLD(f) abuf->fields.sfmt_xori.f
4329     UINT f_left;
4330     INT f_imm6;
4331     UINT f_dest;
4332
4333     f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
4334     f_imm6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
4335     f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
4336
4337   /* Record the fields for the semantic handler.  */
4338   FLD (f_imm6) = f_imm6;
4339   FLD (f_left) = f_left;
4340   FLD (f_dest) = f_dest;
4341   if (UNLIKELY(current_cpu->trace_extract_p))
4342     {
4343       current_cpu->trace_stream
4344         << "0x" << hex << pc << dec << " (sfmt_xori)\t"
4345         << " f_imm6:0x" << hex << f_imm6 << dec
4346         << " f_left:0x" << hex << f_left << dec
4347         << " f_dest:0x" << hex << f_dest << dec
4348         << endl;
4349     }
4350
4351   /* Record the fields for profiling.  */
4352   if (UNLIKELY (current_cpu->trace_counter_p || current_cpu->final_insn_count_p))
4353     {
4354       FLD (in_rm) = f_left;
4355       FLD (out_rd) = f_dest;
4356     }
4357 #undef FLD
4358 }
4359