sim/iq2000/decode.c

   1 /* Simulator instruction decoder for iq2000bf.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU simulators.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 */
  23
  24 #define WANT_CPU iq2000bf
  25 #define WANT_CPU_IQ2000BF
  26
  27 #include "sim-main.h"
  28 #include "sim-assert.h"
  29
  30 /* The instruction descriptor array.
  31    This is computed at runtime.  Space for it is not malloc'd to save a
  32    teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
  33    but won't be done until necessary (we don't currently support the runtime
  34    addition of instructions nor an SMP machine with different cpus).  */
  35 static IDESC iq2000bf_insn_data[IQ2000BF_INSN_BMB + 1];
  36
  37 /* Commas between elements are contained in the macros.
  38    Some of these are conditionally compiled out.  */
  39
  40 static const struct insn_sem iq2000bf_insn_sem[] =
  41 {
  42   { VIRTUAL_INSN_X_INVALID, IQ2000BF_INSN_X_INVALID, IQ2000BF_SFMT_EMPTY },
  43   { VIRTUAL_INSN_X_AFTER, IQ2000BF_INSN_X_AFTER, IQ2000BF_SFMT_EMPTY },
  44   { VIRTUAL_INSN_X_BEFORE, IQ2000BF_INSN_X_BEFORE, IQ2000BF_SFMT_EMPTY },
  45   { VIRTUAL_INSN_X_CTI_CHAIN, IQ2000BF_INSN_X_CTI_CHAIN, IQ2000BF_SFMT_EMPTY },
  46   { VIRTUAL_INSN_X_CHAIN, IQ2000BF_INSN_X_CHAIN, IQ2000BF_SFMT_EMPTY },
  47   { VIRTUAL_INSN_X_BEGIN, IQ2000BF_INSN_X_BEGIN, IQ2000BF_SFMT_EMPTY },
  48   { IQ2000_INSN_ADD, IQ2000BF_INSN_ADD, IQ2000BF_SFMT_ADD },
  49   { IQ2000_INSN_ADDI, IQ2000BF_INSN_ADDI, IQ2000BF_SFMT_ADDI },
  50   { IQ2000_INSN_ADDIU, IQ2000BF_INSN_ADDIU, IQ2000BF_SFMT_ADDI },
  51   { IQ2000_INSN_ADDU, IQ2000BF_INSN_ADDU, IQ2000BF_SFMT_ADD },
  52   { IQ2000_INSN_ADO16, IQ2000BF_INSN_ADO16, IQ2000BF_SFMT_ADO16 },
  53   { IQ2000_INSN_AND, IQ2000BF_INSN_AND, IQ2000BF_SFMT_ADD },
  54   { IQ2000_INSN_ANDI, IQ2000BF_INSN_ANDI, IQ2000BF_SFMT_ADDI },
  55   { IQ2000_INSN_ANDOI, IQ2000BF_INSN_ANDOI, IQ2000BF_SFMT_ADDI },
  56   { IQ2000_INSN_NOR, IQ2000BF_INSN_NOR, IQ2000BF_SFMT_ADD },
  57   { IQ2000_INSN_OR, IQ2000BF_INSN_OR, IQ2000BF_SFMT_ADD },
  58   { IQ2000_INSN_ORI, IQ2000BF_INSN_ORI, IQ2000BF_SFMT_ADDI },
  59   { IQ2000_INSN_RAM, IQ2000BF_INSN_RAM, IQ2000BF_SFMT_RAM },
  60   { IQ2000_INSN_SLL, IQ2000BF_INSN_SLL, IQ2000BF_SFMT_SLL },
  61   { IQ2000_INSN_SLLV, IQ2000BF_INSN_SLLV, IQ2000BF_SFMT_ADD },
  62   { IQ2000_INSN_SLMV, IQ2000BF_INSN_SLMV, IQ2000BF_SFMT_SLMV },
  63   { IQ2000_INSN_SLT, IQ2000BF_INSN_SLT, IQ2000BF_SFMT_SLT },
  64   { IQ2000_INSN_SLTI, IQ2000BF_INSN_SLTI, IQ2000BF_SFMT_SLTI },
  65   { IQ2000_INSN_SLTIU, IQ2000BF_INSN_SLTIU, IQ2000BF_SFMT_SLTI },
  66   { IQ2000_INSN_SLTU, IQ2000BF_INSN_SLTU, IQ2000BF_SFMT_SLT },
  67   { IQ2000_INSN_SRA, IQ2000BF_INSN_SRA, IQ2000BF_SFMT_SLL },
  68   { IQ2000_INSN_SRAV, IQ2000BF_INSN_SRAV, IQ2000BF_SFMT_ADD },
  69   { IQ2000_INSN_SRL, IQ2000BF_INSN_SRL, IQ2000BF_SFMT_SLL },
  70   { IQ2000_INSN_SRLV, IQ2000BF_INSN_SRLV, IQ2000BF_SFMT_ADD },
  71   { IQ2000_INSN_SRMV, IQ2000BF_INSN_SRMV, IQ2000BF_SFMT_SLMV },
  72   { IQ2000_INSN_SUB, IQ2000BF_INSN_SUB, IQ2000BF_SFMT_ADD },
  73   { IQ2000_INSN_SUBU, IQ2000BF_INSN_SUBU, IQ2000BF_SFMT_ADD },
  74   { IQ2000_INSN_XOR, IQ2000BF_INSN_XOR, IQ2000BF_SFMT_ADD },
  75   { IQ2000_INSN_XORI, IQ2000BF_INSN_XORI, IQ2000BF_SFMT_ADDI },
  76   { IQ2000_INSN_BBI, IQ2000BF_INSN_BBI, IQ2000BF_SFMT_BBI },
  77   { IQ2000_INSN_BBIN, IQ2000BF_INSN_BBIN, IQ2000BF_SFMT_BBI },
  78   { IQ2000_INSN_BBV, IQ2000BF_INSN_BBV, IQ2000BF_SFMT_BBV },
  79   { IQ2000_INSN_BBVN, IQ2000BF_INSN_BBVN, IQ2000BF_SFMT_BBV },
  80   { IQ2000_INSN_BEQ, IQ2000BF_INSN_BEQ, IQ2000BF_SFMT_BBV },
  81   { IQ2000_INSN_BEQL, IQ2000BF_INSN_BEQL, IQ2000BF_SFMT_BBV },
  82   { IQ2000_INSN_BGEZ, IQ2000BF_INSN_BGEZ, IQ2000BF_SFMT_BGEZ },
  83   { IQ2000_INSN_BGEZAL, IQ2000BF_INSN_BGEZAL, IQ2000BF_SFMT_BGEZAL },
  84   { IQ2000_INSN_BGEZALL, IQ2000BF_INSN_BGEZALL, IQ2000BF_SFMT_BGEZAL },
  85   { IQ2000_INSN_BGEZL, IQ2000BF_INSN_BGEZL, IQ2000BF_SFMT_BGEZ },
  86   { IQ2000_INSN_BLTZ, IQ2000BF_INSN_BLTZ, IQ2000BF_SFMT_BGEZ },
  87   { IQ2000_INSN_BLTZL, IQ2000BF_INSN_BLTZL, IQ2000BF_SFMT_BGEZ },
  88   { IQ2000_INSN_BLTZAL, IQ2000BF_INSN_BLTZAL, IQ2000BF_SFMT_BGEZAL },
  89   { IQ2000_INSN_BLTZALL, IQ2000BF_INSN_BLTZALL, IQ2000BF_SFMT_BGEZAL },
  90   { IQ2000_INSN_BMB0, IQ2000BF_INSN_BMB0, IQ2000BF_SFMT_BBV },
  91   { IQ2000_INSN_BMB1, IQ2000BF_INSN_BMB1, IQ2000BF_SFMT_BBV },
  92   { IQ2000_INSN_BMB2, IQ2000BF_INSN_BMB2, IQ2000BF_SFMT_BBV },
  93   { IQ2000_INSN_BMB3, IQ2000BF_INSN_BMB3, IQ2000BF_SFMT_BBV },
  94   { IQ2000_INSN_BNE, IQ2000BF_INSN_BNE, IQ2000BF_SFMT_BBV },
  95   { IQ2000_INSN_BNEL, IQ2000BF_INSN_BNEL, IQ2000BF_SFMT_BBV },
  96   { IQ2000_INSN_JALR, IQ2000BF_INSN_JALR, IQ2000BF_SFMT_JALR },
  97   { IQ2000_INSN_JR, IQ2000BF_INSN_JR, IQ2000BF_SFMT_JR },
  98   { IQ2000_INSN_LB, IQ2000BF_INSN_LB, IQ2000BF_SFMT_LB },
  99   { IQ2000_INSN_LBU, IQ2000BF_INSN_LBU, IQ2000BF_SFMT_LB },
 100   { IQ2000_INSN_LH, IQ2000BF_INSN_LH, IQ2000BF_SFMT_LH },
 101   { IQ2000_INSN_LHU, IQ2000BF_INSN_LHU, IQ2000BF_SFMT_LH },
 102   { IQ2000_INSN_LUI, IQ2000BF_INSN_LUI, IQ2000BF_SFMT_LUI },
 103   { IQ2000_INSN_LW, IQ2000BF_INSN_LW, IQ2000BF_SFMT_LW },
 104   { IQ2000_INSN_SB, IQ2000BF_INSN_SB, IQ2000BF_SFMT_SB },
 105   { IQ2000_INSN_SH, IQ2000BF_INSN_SH, IQ2000BF_SFMT_SH },
 106   { IQ2000_INSN_SW, IQ2000BF_INSN_SW, IQ2000BF_SFMT_SW },
 107   { IQ2000_INSN_BREAK, IQ2000BF_INSN_BREAK, IQ2000BF_SFMT_BREAK },
 108   { IQ2000_INSN_SYSCALL, IQ2000BF_INSN_SYSCALL, IQ2000BF_SFMT_SYSCALL },
 109   { IQ2000_INSN_ANDOUI, IQ2000BF_INSN_ANDOUI, IQ2000BF_SFMT_ANDOUI },
 110   { IQ2000_INSN_ORUI, IQ2000BF_INSN_ORUI, IQ2000BF_SFMT_ANDOUI },
 111   { IQ2000_INSN_BGTZ, IQ2000BF_INSN_BGTZ, IQ2000BF_SFMT_BGEZ },
 112   { IQ2000_INSN_BGTZL, IQ2000BF_INSN_BGTZL, IQ2000BF_SFMT_BGEZ },
 113   { IQ2000_INSN_BLEZ, IQ2000BF_INSN_BLEZ, IQ2000BF_SFMT_BGEZ },
 114   { IQ2000_INSN_BLEZL, IQ2000BF_INSN_BLEZL, IQ2000BF_SFMT_BGEZ },
 115   { IQ2000_INSN_MRGB, IQ2000BF_INSN_MRGB, IQ2000BF_SFMT_MRGB },
 116   { IQ2000_INSN_BCTXT, IQ2000BF_INSN_BCTXT, IQ2000BF_SFMT_BCTXT },
 117   { IQ2000_INSN_BC0F, IQ2000BF_INSN_BC0F, IQ2000BF_SFMT_BCTXT },
 118   { IQ2000_INSN_BC0FL, IQ2000BF_INSN_BC0FL, IQ2000BF_SFMT_BCTXT },
 119   { IQ2000_INSN_BC3F, IQ2000BF_INSN_BC3F, IQ2000BF_SFMT_BCTXT },
 120   { IQ2000_INSN_BC3FL, IQ2000BF_INSN_BC3FL, IQ2000BF_SFMT_BCTXT },
 121   { IQ2000_INSN_BC0T, IQ2000BF_INSN_BC0T, IQ2000BF_SFMT_BCTXT },
 122   { IQ2000_INSN_BC0TL, IQ2000BF_INSN_BC0TL, IQ2000BF_SFMT_BCTXT },
 123   { IQ2000_INSN_BC3T, IQ2000BF_INSN_BC3T, IQ2000BF_SFMT_BCTXT },
 124   { IQ2000_INSN_BC3TL, IQ2000BF_INSN_BC3TL, IQ2000BF_SFMT_BCTXT },
 125   { IQ2000_INSN_CFC0, IQ2000BF_INSN_CFC0, IQ2000BF_SFMT_SYSCALL },
 126   { IQ2000_INSN_CFC1, IQ2000BF_INSN_CFC1, IQ2000BF_SFMT_SYSCALL },
 127   { IQ2000_INSN_CFC2, IQ2000BF_INSN_CFC2, IQ2000BF_SFMT_SYSCALL },
 128   { IQ2000_INSN_CFC3, IQ2000BF_INSN_CFC3, IQ2000BF_SFMT_SYSCALL },
 129   { IQ2000_INSN_CHKHDR, IQ2000BF_INSN_CHKHDR, IQ2000BF_SFMT_SYSCALL },
 130   { IQ2000_INSN_CTC0, IQ2000BF_INSN_CTC0, IQ2000BF_SFMT_SYSCALL },
 131   { IQ2000_INSN_CTC1, IQ2000BF_INSN_CTC1, IQ2000BF_SFMT_SYSCALL },
 132   { IQ2000_INSN_CTC2, IQ2000BF_INSN_CTC2, IQ2000BF_SFMT_SYSCALL },
 133   { IQ2000_INSN_CTC3, IQ2000BF_INSN_CTC3, IQ2000BF_SFMT_SYSCALL },
 134   { IQ2000_INSN_JCR, IQ2000BF_INSN_JCR, IQ2000BF_SFMT_BCTXT },
 135   { IQ2000_INSN_LUC32, IQ2000BF_INSN_LUC32, IQ2000BF_SFMT_SYSCALL },
 136   { IQ2000_INSN_LUC32L, IQ2000BF_INSN_LUC32L, IQ2000BF_SFMT_SYSCALL },
 137   { IQ2000_INSN_LUC64, IQ2000BF_INSN_LUC64, IQ2000BF_SFMT_SYSCALL },
 138   { IQ2000_INSN_LUC64L, IQ2000BF_INSN_LUC64L, IQ2000BF_SFMT_SYSCALL },
 139   { IQ2000_INSN_LUK, IQ2000BF_INSN_LUK, IQ2000BF_SFMT_SYSCALL },
 140   { IQ2000_INSN_LULCK, IQ2000BF_INSN_LULCK, IQ2000BF_SFMT_SYSCALL },
 141   { IQ2000_INSN_LUM32, IQ2000BF_INSN_LUM32, IQ2000BF_SFMT_SYSCALL },
 142   { IQ2000_INSN_LUM32L, IQ2000BF_INSN_LUM32L, IQ2000BF_SFMT_SYSCALL },
 143   { IQ2000_INSN_LUM64, IQ2000BF_INSN_LUM64, IQ2000BF_SFMT_SYSCALL },
 144   { IQ2000_INSN_LUM64L, IQ2000BF_INSN_LUM64L, IQ2000BF_SFMT_SYSCALL },
 145   { IQ2000_INSN_LUR, IQ2000BF_INSN_LUR, IQ2000BF_SFMT_SYSCALL },
 146   { IQ2000_INSN_LURL, IQ2000BF_INSN_LURL, IQ2000BF_SFMT_SYSCALL },
 147   { IQ2000_INSN_LUULCK, IQ2000BF_INSN_LUULCK, IQ2000BF_SFMT_SYSCALL },
 148   { IQ2000_INSN_MFC0, IQ2000BF_INSN_MFC0, IQ2000BF_SFMT_SYSCALL },
 149   { IQ2000_INSN_MFC1, IQ2000BF_INSN_MFC1, IQ2000BF_SFMT_SYSCALL },
 150   { IQ2000_INSN_MFC2, IQ2000BF_INSN_MFC2, IQ2000BF_SFMT_SYSCALL },
 151   { IQ2000_INSN_MFC3, IQ2000BF_INSN_MFC3, IQ2000BF_SFMT_SYSCALL },
 152   { IQ2000_INSN_MTC0, IQ2000BF_INSN_MTC0, IQ2000BF_SFMT_SYSCALL },
 153   { IQ2000_INSN_MTC1, IQ2000BF_INSN_MTC1, IQ2000BF_SFMT_SYSCALL },
 154   { IQ2000_INSN_MTC2, IQ2000BF_INSN_MTC2, IQ2000BF_SFMT_SYSCALL },
 155   { IQ2000_INSN_MTC3, IQ2000BF_INSN_MTC3, IQ2000BF_SFMT_SYSCALL },
 156   { IQ2000_INSN_PKRL, IQ2000BF_INSN_PKRL, IQ2000BF_SFMT_SYSCALL },
 157   { IQ2000_INSN_PKRLR1, IQ2000BF_INSN_PKRLR1, IQ2000BF_SFMT_SYSCALL },
 158   { IQ2000_INSN_PKRLR30, IQ2000BF_INSN_PKRLR30, IQ2000BF_SFMT_SYSCALL },
 159   { IQ2000_INSN_RB, IQ2000BF_INSN_RB, IQ2000BF_SFMT_SYSCALL },
 160   { IQ2000_INSN_RBR1, IQ2000BF_INSN_RBR1, IQ2000BF_SFMT_SYSCALL },
 161   { IQ2000_INSN_RBR30, IQ2000BF_INSN_RBR30, IQ2000BF_SFMT_SYSCALL },
 162   { IQ2000_INSN_RFE, IQ2000BF_INSN_RFE, IQ2000BF_SFMT_SYSCALL },
 163   { IQ2000_INSN_RX, IQ2000BF_INSN_RX, IQ2000BF_SFMT_SYSCALL },
 164   { IQ2000_INSN_RXR1, IQ2000BF_INSN_RXR1, IQ2000BF_SFMT_SYSCALL },
 165   { IQ2000_INSN_RXR30, IQ2000BF_INSN_RXR30, IQ2000BF_SFMT_SYSCALL },
 166   { IQ2000_INSN_SLEEP, IQ2000BF_INSN_SLEEP, IQ2000BF_SFMT_SYSCALL },
 167   { IQ2000_INSN_SRRD, IQ2000BF_INSN_SRRD, IQ2000BF_SFMT_SYSCALL },
 168   { IQ2000_INSN_SRRDL, IQ2000BF_INSN_SRRDL, IQ2000BF_SFMT_SYSCALL },
 169   { IQ2000_INSN_SRULCK, IQ2000BF_INSN_SRULCK, IQ2000BF_SFMT_SYSCALL },
 170   { IQ2000_INSN_SRWR, IQ2000BF_INSN_SRWR, IQ2000BF_SFMT_SYSCALL },
 171   { IQ2000_INSN_SRWRU, IQ2000BF_INSN_SRWRU, IQ2000BF_SFMT_SYSCALL },
 172   { IQ2000_INSN_TRAPQFL, IQ2000BF_INSN_TRAPQFL, IQ2000BF_SFMT_SYSCALL },
 173   { IQ2000_INSN_TRAPQNE, IQ2000BF_INSN_TRAPQNE, IQ2000BF_SFMT_SYSCALL },
 174   { IQ2000_INSN_TRAPREL, IQ2000BF_INSN_TRAPREL, IQ2000BF_SFMT_SYSCALL },
 175   { IQ2000_INSN_WB, IQ2000BF_INSN_WB, IQ2000BF_SFMT_SYSCALL },
 176   { IQ2000_INSN_WBU, IQ2000BF_INSN_WBU, IQ2000BF_SFMT_SYSCALL },
 177   { IQ2000_INSN_WBR1, IQ2000BF_INSN_WBR1, IQ2000BF_SFMT_SYSCALL },
 178   { IQ2000_INSN_WBR1U, IQ2000BF_INSN_WBR1U, IQ2000BF_SFMT_SYSCALL },
 179   { IQ2000_INSN_WBR30, IQ2000BF_INSN_WBR30, IQ2000BF_SFMT_SYSCALL },
 180   { IQ2000_INSN_WBR30U, IQ2000BF_INSN_WBR30U, IQ2000BF_SFMT_SYSCALL },
 181   { IQ2000_INSN_WX, IQ2000BF_INSN_WX, IQ2000BF_SFMT_SYSCALL },
 182   { IQ2000_INSN_WXU, IQ2000BF_INSN_WXU, IQ2000BF_SFMT_SYSCALL },
 183   { IQ2000_INSN_WXR1, IQ2000BF_INSN_WXR1, IQ2000BF_SFMT_SYSCALL },
 184   { IQ2000_INSN_WXR1U, IQ2000BF_INSN_WXR1U, IQ2000BF_SFMT_SYSCALL },
 185   { IQ2000_INSN_WXR30, IQ2000BF_INSN_WXR30, IQ2000BF_SFMT_SYSCALL },
 186   { IQ2000_INSN_WXR30U, IQ2000BF_INSN_WXR30U, IQ2000BF_SFMT_SYSCALL },
 187   { IQ2000_INSN_LDW, IQ2000BF_INSN_LDW, IQ2000BF_SFMT_LDW },
 188   { IQ2000_INSN_SDW, IQ2000BF_INSN_SDW, IQ2000BF_SFMT_SDW },
 189   { IQ2000_INSN_J, IQ2000BF_INSN_J, IQ2000BF_SFMT_J },
 190   { IQ2000_INSN_JAL, IQ2000BF_INSN_JAL, IQ2000BF_SFMT_JAL },
 191   { IQ2000_INSN_BMB, IQ2000BF_INSN_BMB, IQ2000BF_SFMT_BBV },
 192 };
 193
 194 static const struct insn_sem iq2000bf_insn_sem_invalid = {
 195   VIRTUAL_INSN_X_INVALID, IQ2000BF_INSN_X_INVALID, IQ2000BF_SFMT_EMPTY
 196 };
 197
 198 /* Initialize an IDESC from the compile-time computable parts.  */
 199
 200 static INLINE void
 201 init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t)
 202 {
 203   const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries;
 204
 205   id->num = t->index;
 206   id->sfmt = t->sfmt;
 207   if ((int) t->type <= 0)
 208     id->idata = & cgen_virtual_insn_table[- (int) t->type];
 209   else
 210     id->idata = & insn_table[t->type];
 211   id->attrs = CGEN_INSN_ATTRS (id->idata);
 212   /* Oh my god, a magic number.  */
 213   id->length = CGEN_INSN_BITSIZE (id->idata) / 8;
 214
 215 #if WITH_PROFILE_MODEL_P
 216   id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index];
 217   {
 218     SIM_DESC sd = CPU_STATE (cpu);
 219     SIM_ASSERT (t->index == id->timing->num);
 220   }
 221 #endif
 222
 223   /* Semantic pointers are initialized elsewhere.  */
 224 }
 225
 226 /* Initialize the instruction descriptor table.  */
 227
 228 void
 229 iq2000bf_init_idesc_table (SIM_CPU *cpu)
 230 {
 231   IDESC *id,*tabend;
 232   const struct insn_sem *t,*tend;
 233   int tabsize = sizeof (iq2000bf_insn_data) / sizeof (IDESC);
 234   IDESC *table = iq2000bf_insn_data;
 235
 236   memset (table, 0, tabsize * sizeof (IDESC));
 237
 238   /* First set all entries to the `invalid insn'.  */
 239   t = & iq2000bf_insn_sem_invalid;
 240   for (id = table, tabend = table + tabsize; id < tabend; ++id)
 241     init_idesc (cpu, id, t);
 242
 243   /* Now fill in the values for the chosen cpu.  */
 244   for (t = iq2000bf_insn_sem, tend = t + sizeof (iq2000bf_insn_sem) / sizeof (*t);
 245        t != tend; ++t)
 246     {
 247       init_idesc (cpu, & table[t->index], t);
 248     }
 249
 250   /* Link the IDESC table into the cpu.  */
 251   CPU_IDESC (cpu) = table;
 252 }
 253
 254 /* Given an instruction, return a pointer to its IDESC entry.  */
 255
 256 const IDESC *
 257 iq2000bf_decode (SIM_CPU *current_cpu, IADDR pc,
 258               CGEN_INSN_INT base_insn, CGEN_INSN_INT entire_insn,
 259               ARGBUF *abuf)
 260 {
 261   /* Result of decoder.  */
 262   IQ2000BF_INSN_TYPE itype;
 263
 264   {
 265     CGEN_INSN_INT insn = base_insn;
 266
 267     {
 268       unsigned int val = (((insn >> 26) & (63 << 0)));
 269       switch (val)
 270       {
 271       case 0 :
 272         {
 273           unsigned int val = (((insn >> 1) & (1 << 4)) | ((insn >> 0) & (15 << 0)));
 274           switch (val)
 275           {
 276           case 0 : itype = IQ2000BF_INSN_SLL;goto extract_sfmt_sll;
 277           case 1 : itype = IQ2000BF_INSN_SLMV;goto extract_sfmt_slmv;
 278           case 2 : itype = IQ2000BF_INSN_SRL;goto extract_sfmt_sll;
 279           case 3 : itype = IQ2000BF_INSN_SRA;goto extract_sfmt_sll;
 280           case 4 : itype = IQ2000BF_INSN_SLLV;goto extract_sfmt_add;
 281           case 5 : itype = IQ2000BF_INSN_SRMV;goto extract_sfmt_slmv;
 282           case 6 : itype = IQ2000BF_INSN_SRLV;goto extract_sfmt_add;
 283           case 7 : itype = IQ2000BF_INSN_SRAV;goto extract_sfmt_add;
 284           case 8 : itype = IQ2000BF_INSN_JR;goto extract_sfmt_jr;
 285           case 9 : itype = IQ2000BF_INSN_JALR;goto extract_sfmt_jalr;
 286           case 10 : itype = IQ2000BF_INSN_JCR;goto extract_sfmt_bctxt;
 287           case 12 : itype = IQ2000BF_INSN_SYSCALL;goto extract_sfmt_syscall;
 288           case 13 : itype = IQ2000BF_INSN_BREAK;goto extract_sfmt_break;
 289           case 14 : itype = IQ2000BF_INSN_SLEEP;goto extract_sfmt_syscall;
 290           case 16 : itype = IQ2000BF_INSN_ADD;goto extract_sfmt_add;
 291           case 17 : itype = IQ2000BF_INSN_ADDU;goto extract_sfmt_add;
 292           case 18 : itype = IQ2000BF_INSN_SUB;goto extract_sfmt_add;
 293           case 19 : itype = IQ2000BF_INSN_SUBU;goto extract_sfmt_add;
 294           case 20 : itype = IQ2000BF_INSN_AND;goto extract_sfmt_add;
 295           case 21 : itype = IQ2000BF_INSN_OR;goto extract_sfmt_add;
 296           case 22 : itype = IQ2000BF_INSN_XOR;goto extract_sfmt_add;
 297           case 23 : itype = IQ2000BF_INSN_NOR;goto extract_sfmt_add;
 298           case 25 : itype = IQ2000BF_INSN_ADO16;goto extract_sfmt_ado16;
 299           case 26 : itype = IQ2000BF_INSN_SLT;goto extract_sfmt_slt;
 300           case 27 : itype = IQ2000BF_INSN_SLTU;goto extract_sfmt_slt;
 301           case 29 : itype = IQ2000BF_INSN_MRGB;goto extract_sfmt_mrgb;
 302           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 303           }
 304         }
 305       case 1 :
 306         {
 307           unsigned int val = (((insn >> 17) & (1 << 3)) | ((insn >> 16) & (7 << 0)));
 308           switch (val)
 309           {
 310           case 0 : itype = IQ2000BF_INSN_BLTZ;goto extract_sfmt_bgez;
 311           case 1 : itype = IQ2000BF_INSN_BGEZ;goto extract_sfmt_bgez;
 312           case 2 : itype = IQ2000BF_INSN_BLTZL;goto extract_sfmt_bgez;
 313           case 3 : itype = IQ2000BF_INSN_BGEZL;goto extract_sfmt_bgez;
 314           case 6 : itype = IQ2000BF_INSN_BCTXT;goto extract_sfmt_bctxt;
 315           case 8 : itype = IQ2000BF_INSN_BLTZAL;goto extract_sfmt_bgezal;
 316           case 9 : itype = IQ2000BF_INSN_BGEZAL;goto extract_sfmt_bgezal;
 317           case 10 : itype = IQ2000BF_INSN_BLTZALL;goto extract_sfmt_bgezal;
 318           case 11 : itype = IQ2000BF_INSN_BGEZALL;goto extract_sfmt_bgezal;
 319           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 320           }
 321         }
 322       case 2 : itype = IQ2000BF_INSN_J;goto extract_sfmt_j;
 323       case 3 : itype = IQ2000BF_INSN_JAL;goto extract_sfmt_jal;
 324       case 4 : itype = IQ2000BF_INSN_BEQ;goto extract_sfmt_bbv;
 325       case 5 : itype = IQ2000BF_INSN_BNE;goto extract_sfmt_bbv;
 326       case 6 : itype = IQ2000BF_INSN_BLEZ;goto extract_sfmt_bgez;
 327       case 7 : itype = IQ2000BF_INSN_BGTZ;goto extract_sfmt_bgez;
 328       case 8 : itype = IQ2000BF_INSN_ADDI;goto extract_sfmt_addi;
 329       case 9 : itype = IQ2000BF_INSN_ADDIU;goto extract_sfmt_addi;
 330       case 10 : itype = IQ2000BF_INSN_SLTI;goto extract_sfmt_slti;
 331       case 11 : itype = IQ2000BF_INSN_SLTIU;goto extract_sfmt_slti;
 332       case 12 : itype = IQ2000BF_INSN_ANDI;goto extract_sfmt_addi;
 333       case 13 : itype = IQ2000BF_INSN_ORI;goto extract_sfmt_addi;
 334       case 14 : itype = IQ2000BF_INSN_XORI;goto extract_sfmt_addi;
 335       case 15 : itype = IQ2000BF_INSN_LUI;goto extract_sfmt_lui;
 336       case 16 :
 337         {
 338           unsigned int val = (((insn >> 19) & (15 << 3)) | ((insn >> 15) & (3 << 1)) | ((insn >> 4) & (1 << 0)));
 339           switch (val)
 340           {
 341           case 0 : /* fall through */
 342           case 2 : /* fall through */
 343           case 4 : /* fall through */
 344           case 6 : itype = IQ2000BF_INSN_MFC0;goto extract_sfmt_syscall;
 345           case 8 : /* fall through */
 346           case 10 : /* fall through */
 347           case 12 : /* fall through */
 348           case 14 : itype = IQ2000BF_INSN_CFC0;goto extract_sfmt_syscall;
 349           case 16 : /* fall through */
 350           case 18 : /* fall through */
 351           case 20 : /* fall through */
 352           case 22 : itype = IQ2000BF_INSN_MTC0;goto extract_sfmt_syscall;
 353           case 24 : /* fall through */
 354           case 26 : /* fall through */
 355           case 28 : /* fall through */
 356           case 30 : itype = IQ2000BF_INSN_CTC0;goto extract_sfmt_syscall;
 357           case 32 : /* fall through */
 358           case 33 : itype = IQ2000BF_INSN_BC0F;goto extract_sfmt_bctxt;
 359           case 34 : /* fall through */
 360           case 35 : itype = IQ2000BF_INSN_BC0T;goto extract_sfmt_bctxt;
 361           case 36 : /* fall through */
 362           case 37 : itype = IQ2000BF_INSN_BC0FL;goto extract_sfmt_bctxt;
 363           case 38 : /* fall through */
 364           case 39 : itype = IQ2000BF_INSN_BC0TL;goto extract_sfmt_bctxt;
 365           case 65 : itype = IQ2000BF_INSN_RFE;goto extract_sfmt_syscall;
 366           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 367           }
 368         }
 369       case 17 :
 370         {
 371           unsigned int val = (((insn >> 22) & (3 << 0)));
 372           switch (val)
 373           {
 374           case 0 : itype = IQ2000BF_INSN_MFC1;goto extract_sfmt_syscall;
 375           case 1 : itype = IQ2000BF_INSN_CFC1;goto extract_sfmt_syscall;
 376           case 2 : itype = IQ2000BF_INSN_MTC1;goto extract_sfmt_syscall;
 377           case 3 : itype = IQ2000BF_INSN_CTC1;goto extract_sfmt_syscall;
 378           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 379           }
 380         }
 381       case 18 :
 382         {
 383           unsigned int val = (((insn >> 16) & (3 << 5)) | ((insn >> 0) & (31 << 0)));
 384           switch (val)
 385           {
 386           case 0 :
 387             {
 388               unsigned int val = (((insn >> 23) & (1 << 0)));
 389               switch (val)
 390               {
 391               case 0 : itype = IQ2000BF_INSN_MFC2;goto extract_sfmt_syscall;
 392               case 1 : itype = IQ2000BF_INSN_MTC2;goto extract_sfmt_syscall;
 393               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 394               }
 395             }
 396           case 32 : itype = IQ2000BF_INSN_LUULCK;goto extract_sfmt_syscall;
 397           case 33 : itype = IQ2000BF_INSN_LUR;goto extract_sfmt_syscall;
 398           case 34 : itype = IQ2000BF_INSN_LUM32;goto extract_sfmt_syscall;
 399           case 35 : itype = IQ2000BF_INSN_LUC32;goto extract_sfmt_syscall;
 400           case 36 : itype = IQ2000BF_INSN_LULCK;goto extract_sfmt_syscall;
 401           case 37 : itype = IQ2000BF_INSN_LURL;goto extract_sfmt_syscall;
 402           case 38 : itype = IQ2000BF_INSN_LUM32L;goto extract_sfmt_syscall;
 403           case 39 : itype = IQ2000BF_INSN_LUC32L;goto extract_sfmt_syscall;
 404           case 40 : itype = IQ2000BF_INSN_LUK;goto extract_sfmt_syscall;
 405           case 42 : itype = IQ2000BF_INSN_LUM64;goto extract_sfmt_syscall;
 406           case 43 : itype = IQ2000BF_INSN_LUC64;goto extract_sfmt_syscall;
 407           case 46 : itype = IQ2000BF_INSN_LUM64L;goto extract_sfmt_syscall;
 408           case 47 : itype = IQ2000BF_INSN_LUC64L;goto extract_sfmt_syscall;
 409           case 48 : itype = IQ2000BF_INSN_SRRD;goto extract_sfmt_syscall;
 410           case 49 : itype = IQ2000BF_INSN_SRWR;goto extract_sfmt_syscall;
 411           case 52 : itype = IQ2000BF_INSN_SRRDL;goto extract_sfmt_syscall;
 412           case 53 : itype = IQ2000BF_INSN_SRWRU;goto extract_sfmt_syscall;
 413           case 54 : itype = IQ2000BF_INSN_SRULCK;goto extract_sfmt_syscall;
 414           case 64 :
 415             {
 416               unsigned int val = (((insn >> 23) & (1 << 0)));
 417               switch (val)
 418               {
 419               case 0 : itype = IQ2000BF_INSN_CFC2;goto extract_sfmt_syscall;
 420               case 1 : itype = IQ2000BF_INSN_CTC2;goto extract_sfmt_syscall;
 421               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 422               }
 423             }
 424           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 425           }
 426         }
 427       case 19 :
 428         {
 429           unsigned int val = (((insn >> 19) & (31 << 2)) | ((insn >> 0) & (3 << 0)));
 430           switch (val)
 431           {
 432           case 0 : itype = IQ2000BF_INSN_MFC3;goto extract_sfmt_syscall;
 433           case 4 :
 434             {
 435               unsigned int val = (((insn >> 2) & (3 << 0)));
 436               switch (val)
 437               {
 438               case 0 : itype = IQ2000BF_INSN_WB;goto extract_sfmt_syscall;
 439               case 1 : itype = IQ2000BF_INSN_RB;goto extract_sfmt_syscall;
 440               case 2 : itype = IQ2000BF_INSN_TRAPQFL;goto extract_sfmt_syscall;
 441               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 442               }
 443             }
 444           case 5 :
 445             {
 446               unsigned int val = (((insn >> 3) & (1 << 0)));
 447               switch (val)
 448               {
 449               case 0 : itype = IQ2000BF_INSN_WBU;goto extract_sfmt_syscall;
 450               case 1 : itype = IQ2000BF_INSN_TRAPQNE;goto extract_sfmt_syscall;
 451               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 452               }
 453             }
 454           case 6 :
 455             {
 456               unsigned int val = (((insn >> 2) & (3 << 0)));
 457               switch (val)
 458               {
 459               case 0 : itype = IQ2000BF_INSN_WX;goto extract_sfmt_syscall;
 460               case 1 : itype = IQ2000BF_INSN_RX;goto extract_sfmt_syscall;
 461               case 2 : itype = IQ2000BF_INSN_TRAPREL;goto extract_sfmt_syscall;
 462               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 463               }
 464             }
 465           case 7 :
 466             {
 467               unsigned int val = (((insn >> 2) & (1 << 0)));
 468               switch (val)
 469               {
 470               case 0 : itype = IQ2000BF_INSN_WXU;goto extract_sfmt_syscall;
 471               case 1 : itype = IQ2000BF_INSN_PKRL;goto extract_sfmt_syscall;
 472               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 473               }
 474             }
 475           case 8 : itype = IQ2000BF_INSN_CFC3;goto extract_sfmt_syscall;
 476           case 16 : itype = IQ2000BF_INSN_MTC3;goto extract_sfmt_syscall;
 477           case 24 : itype = IQ2000BF_INSN_CTC3;goto extract_sfmt_syscall;
 478           case 32 : /* fall through */
 479           case 33 : /* fall through */
 480           case 34 : /* fall through */
 481           case 35 :
 482             {
 483               unsigned int val = (((insn >> 16) & (3 << 0)));
 484               switch (val)
 485               {
 486               case 0 : itype = IQ2000BF_INSN_BC3F;goto extract_sfmt_bctxt;
 487               case 1 : itype = IQ2000BF_INSN_BC3T;goto extract_sfmt_bctxt;
 488               case 2 : itype = IQ2000BF_INSN_BC3FL;goto extract_sfmt_bctxt;
 489               case 3 : itype = IQ2000BF_INSN_BC3TL;goto extract_sfmt_bctxt;
 490               default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 491               }
 492             }
 493           case 36 : itype = IQ2000BF_INSN_CHKHDR;goto extract_sfmt_syscall;
 494           case 64 : /* fall through */
 495           case 65 : /* fall through */
 496           case 66 : /* fall through */
 497           case 67 : itype = IQ2000BF_INSN_WBR1;goto extract_sfmt_syscall;
 498           case 68 : /* fall through */
 499           case 69 : /* fall through */
 500           case 70 : /* fall through */
 501           case 71 : itype = IQ2000BF_INSN_WBR1U;goto extract_sfmt_syscall;
 502           case 72 : /* fall through */
 503           case 73 : /* fall through */
 504           case 74 : /* fall through */
 505           case 75 : itype = IQ2000BF_INSN_WBR30;goto extract_sfmt_syscall;
 506           case 76 : /* fall through */
 507           case 77 : /* fall through */
 508           case 78 : /* fall through */
 509           case 79 : itype = IQ2000BF_INSN_WBR30U;goto extract_sfmt_syscall;
 510           case 80 : /* fall through */
 511           case 81 : /* fall through */
 512           case 82 : /* fall through */
 513           case 83 : itype = IQ2000BF_INSN_WXR1;goto extract_sfmt_syscall;
 514           case 84 : /* fall through */
 515           case 85 : /* fall through */
 516           case 86 : /* fall through */
 517           case 87 : itype = IQ2000BF_INSN_WXR1U;goto extract_sfmt_syscall;
 518           case 88 : /* fall through */
 519           case 89 : /* fall through */
 520           case 90 : /* fall through */
 521           case 91 : itype = IQ2000BF_INSN_WXR30;goto extract_sfmt_syscall;
 522           case 92 : /* fall through */
 523           case 93 : /* fall through */
 524           case 94 : /* fall through */
 525           case 95 : itype = IQ2000BF_INSN_WXR30U;goto extract_sfmt_syscall;
 526           case 96 : /* fall through */
 527           case 97 : /* fall through */
 528           case 98 : /* fall through */
 529           case 99 : itype = IQ2000BF_INSN_RBR1;goto extract_sfmt_syscall;
 530           case 104 : /* fall through */
 531           case 105 : /* fall through */
 532           case 106 : /* fall through */
 533           case 107 : itype = IQ2000BF_INSN_RBR30;goto extract_sfmt_syscall;
 534           case 112 : /* fall through */
 535           case 113 : /* fall through */
 536           case 114 : /* fall through */
 537           case 115 : itype = IQ2000BF_INSN_RXR1;goto extract_sfmt_syscall;
 538           case 116 : /* fall through */
 539           case 117 : /* fall through */
 540           case 118 : /* fall through */
 541           case 119 : itype = IQ2000BF_INSN_PKRLR1;goto extract_sfmt_syscall;
 542           case 120 : /* fall through */
 543           case 121 : /* fall through */
 544           case 122 : /* fall through */
 545           case 123 : itype = IQ2000BF_INSN_RXR30;goto extract_sfmt_syscall;
 546           case 124 : /* fall through */
 547           case 125 : /* fall through */
 548           case 126 : /* fall through */
 549           case 127 : itype = IQ2000BF_INSN_PKRLR30;goto extract_sfmt_syscall;
 550           default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 551           }
 552         }
 553       case 20 : itype = IQ2000BF_INSN_BEQL;goto extract_sfmt_bbv;
 554       case 21 : itype = IQ2000BF_INSN_BNEL;goto extract_sfmt_bbv;
 555       case 22 : itype = IQ2000BF_INSN_BLEZL;goto extract_sfmt_bgez;
 556       case 23 : itype = IQ2000BF_INSN_BGTZL;goto extract_sfmt_bgez;
 557       case 24 : itype = IQ2000BF_INSN_BMB0;goto extract_sfmt_bbv;
 558       case 25 : itype = IQ2000BF_INSN_BMB1;goto extract_sfmt_bbv;
 559       case 26 : itype = IQ2000BF_INSN_BMB2;goto extract_sfmt_bbv;
 560       case 27 : itype = IQ2000BF_INSN_BMB3;goto extract_sfmt_bbv;
 561       case 28 : itype = IQ2000BF_INSN_BBI;goto extract_sfmt_bbi;
 562       case 29 : itype = IQ2000BF_INSN_BBV;goto extract_sfmt_bbv;
 563       case 30 : itype = IQ2000BF_INSN_BBIN;goto extract_sfmt_bbi;
 564       case 31 : itype = IQ2000BF_INSN_BBVN;goto extract_sfmt_bbv;
 565       case 32 : itype = IQ2000BF_INSN_LB;goto extract_sfmt_lb;
 566       case 33 : itype = IQ2000BF_INSN_LH;goto extract_sfmt_lh;
 567       case 35 : itype = IQ2000BF_INSN_LW;goto extract_sfmt_lw;
 568       case 36 : itype = IQ2000BF_INSN_LBU;goto extract_sfmt_lb;
 569       case 37 : itype = IQ2000BF_INSN_LHU;goto extract_sfmt_lh;
 570       case 39 : itype = IQ2000BF_INSN_RAM;goto extract_sfmt_ram;
 571       case 40 : itype = IQ2000BF_INSN_SB;goto extract_sfmt_sb;
 572       case 41 : itype = IQ2000BF_INSN_SH;goto extract_sfmt_sh;
 573       case 43 : itype = IQ2000BF_INSN_SW;goto extract_sfmt_sw;
 574       case 44 : itype = IQ2000BF_INSN_ANDOI;goto extract_sfmt_addi;
 575       case 45 : itype = IQ2000BF_INSN_BMB;goto extract_sfmt_bbv;
 576       case 47 : itype = IQ2000BF_INSN_ORUI;goto extract_sfmt_andoui;
 577       case 48 : itype = IQ2000BF_INSN_LDW;goto extract_sfmt_ldw;
 578       case 56 : itype = IQ2000BF_INSN_SDW;goto extract_sfmt_sdw;
 579       case 63 : itype = IQ2000BF_INSN_ANDOUI;goto extract_sfmt_andoui;
 580       default : itype = IQ2000BF_INSN_X_INVALID; goto extract_sfmt_empty;
 581       }
 582     }
 583   }
 584
 585   /* The instruction has been decoded, now extract the fields.  */
 586
 587  extract_sfmt_empty:
 588   {
 589     const IDESC *idesc = &iq2000bf_insn_data[itype];
 590 #define FLD(f) abuf->fields.fmt_empty.f
 591
 592
 593   /* Record the fields for the semantic handler.  */
 594   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_empty", (char *) 0));
 595
 596 #undef FLD
 597     return idesc;
 598   }
 599
 600  extract_sfmt_add:
 601   {
 602     const IDESC *idesc = &iq2000bf_insn_data[itype];
 603     CGEN_INSN_INT insn = entire_insn;
 604 #define FLD(f) abuf->fields.sfmt_mrgb.f
 605     UINT f_rs;
 606     UINT f_rt;
 607     UINT f_rd;
 608
 609     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 610     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 611     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 612
 613   /* Record the fields for the semantic handler.  */
 614   FLD (f_rs) = f_rs;
 615   FLD (f_rt) = f_rt;
 616   FLD (f_rd) = f_rd;
 617   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_add", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 618
 619 #undef FLD
 620     return idesc;
 621   }
 622
 623  extract_sfmt_addi:
 624   {
 625     const IDESC *idesc = &iq2000bf_insn_data[itype];
 626     CGEN_INSN_INT insn = entire_insn;
 627 #define FLD(f) abuf->fields.sfmt_addi.f
 628     UINT f_rs;
 629     UINT f_rt;
 630     UINT f_imm;
 631
 632     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 633     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 634     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
 635
 636   /* Record the fields for the semantic handler.  */
 637   FLD (f_imm) = f_imm;
 638   FLD (f_rs) = f_rs;
 639   FLD (f_rt) = f_rt;
 640   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addi", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
 641
 642 #undef FLD
 643     return idesc;
 644   }
 645
 646  extract_sfmt_ado16:
 647   {
 648     const IDESC *idesc = &iq2000bf_insn_data[itype];
 649     CGEN_INSN_INT insn = entire_insn;
 650 #define FLD(f) abuf->fields.sfmt_mrgb.f
 651     UINT f_rs;
 652     UINT f_rt;
 653     UINT f_rd;
 654
 655     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 656     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 657     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 658
 659   /* Record the fields for the semantic handler.  */
 660   FLD (f_rs) = f_rs;
 661   FLD (f_rt) = f_rt;
 662   FLD (f_rd) = f_rd;
 663   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ado16", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 664
 665 #undef FLD
 666     return idesc;
 667   }
 668
 669  extract_sfmt_ram:
 670   {
 671     const IDESC *idesc = &iq2000bf_insn_data[itype];
 672     CGEN_INSN_INT insn = entire_insn;
 673 #define FLD(f) abuf->fields.sfmt_ram.f
 674     UINT f_rs;
 675     UINT f_rt;
 676     UINT f_rd;
 677     UINT f_shamt;
 678     UINT f_maskl;
 679
 680     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 681     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 682     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 683     f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
 684     f_maskl = EXTRACT_LSB0_UINT (insn, 32, 4, 5);
 685
 686   /* Record the fields for the semantic handler.  */
 687   FLD (f_maskl) = f_maskl;
 688   FLD (f_rs) = f_rs;
 689   FLD (f_rd) = f_rd;
 690   FLD (f_rt) = f_rt;
 691   FLD (f_shamt) = f_shamt;
 692   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ram", "f_maskl 0x%x", 'x', f_maskl, "f_rs 0x%x", 'x', f_rs, "f_rd 0x%x", 'x', f_rd, "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, (char *) 0));
 693
 694 #undef FLD
 695     return idesc;
 696   }
 697
 698  extract_sfmt_sll:
 699   {
 700     const IDESC *idesc = &iq2000bf_insn_data[itype];
 701     CGEN_INSN_INT insn = entire_insn;
 702 #define FLD(f) abuf->fields.sfmt_ram.f
 703     UINT f_rt;
 704     UINT f_rd;
 705     UINT f_shamt;
 706
 707     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 708     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 709     f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
 710
 711   /* Record the fields for the semantic handler.  */
 712   FLD (f_rt) = f_rt;
 713   FLD (f_shamt) = f_shamt;
 714   FLD (f_rd) = f_rd;
 715   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sll", "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 716
 717 #undef FLD
 718     return idesc;
 719   }
 720
 721  extract_sfmt_slmv:
 722   {
 723     const IDESC *idesc = &iq2000bf_insn_data[itype];
 724     CGEN_INSN_INT insn = entire_insn;
 725 #define FLD(f) abuf->fields.sfmt_ram.f
 726     UINT f_rs;
 727     UINT f_rt;
 728     UINT f_rd;
 729     UINT f_shamt;
 730
 731     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 732     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 733     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 734     f_shamt = EXTRACT_LSB0_UINT (insn, 32, 10, 5);
 735
 736   /* Record the fields for the semantic handler.  */
 737   FLD (f_rs) = f_rs;
 738   FLD (f_rt) = f_rt;
 739   FLD (f_shamt) = f_shamt;
 740   FLD (f_rd) = f_rd;
 741   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slmv", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_shamt 0x%x", 'x', f_shamt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 742
 743 #undef FLD
 744     return idesc;
 745   }
 746
 747  extract_sfmt_slt:
 748   {
 749     const IDESC *idesc = &iq2000bf_insn_data[itype];
 750     CGEN_INSN_INT insn = entire_insn;
 751 #define FLD(f) abuf->fields.sfmt_mrgb.f
 752     UINT f_rs;
 753     UINT f_rt;
 754     UINT f_rd;
 755
 756     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 757     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 758     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 759
 760   /* Record the fields for the semantic handler.  */
 761   FLD (f_rs) = f_rs;
 762   FLD (f_rt) = f_rt;
 763   FLD (f_rd) = f_rd;
 764   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slt", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 765
 766 #undef FLD
 767     return idesc;
 768   }
 769
 770  extract_sfmt_slti:
 771   {
 772     const IDESC *idesc = &iq2000bf_insn_data[itype];
 773     CGEN_INSN_INT insn = entire_insn;
 774 #define FLD(f) abuf->fields.sfmt_addi.f
 775     UINT f_rs;
 776     UINT f_rt;
 777     UINT f_imm;
 778
 779     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 780     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 781     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
 782
 783   /* Record the fields for the semantic handler.  */
 784   FLD (f_imm) = f_imm;
 785   FLD (f_rs) = f_rs;
 786   FLD (f_rt) = f_rt;
 787   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slti", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
 788
 789 #undef FLD
 790     return idesc;
 791   }
 792
 793  extract_sfmt_bbi:
 794   {
 795     const IDESC *idesc = &iq2000bf_insn_data[itype];
 796     CGEN_INSN_INT insn = entire_insn;
 797 #define FLD(f) abuf->fields.sfmt_bbi.f
 798     UINT f_rs;
 799     UINT f_rt;
 800     SI f_offset;
 801
 802     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 803     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 804     f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
 805
 806   /* Record the fields for the semantic handler.  */
 807   FLD (f_rt) = f_rt;
 808   FLD (f_rs) = f_rs;
 809   FLD (i_offset) = f_offset;
 810   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bbi", "f_rt 0x%x", 'x', f_rt, "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
 811
 812 #if WITH_PROFILE_MODEL_P
 813   /* Record the fields for profiling.  */
 814   if (PROFILE_MODEL_P (current_cpu))
 815     {
 816     }
 817 #endif
 818 #undef FLD
 819     return idesc;
 820   }
 821
 822  extract_sfmt_bbv:
 823   {
 824     const IDESC *idesc = &iq2000bf_insn_data[itype];
 825     CGEN_INSN_INT insn = entire_insn;
 826 #define FLD(f) abuf->fields.sfmt_bbi.f
 827     UINT f_rs;
 828     UINT f_rt;
 829     SI f_offset;
 830
 831     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 832     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 833     f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
 834
 835   /* Record the fields for the semantic handler.  */
 836   FLD (f_rs) = f_rs;
 837   FLD (f_rt) = f_rt;
 838   FLD (i_offset) = f_offset;
 839   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bbv", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "offset 0x%x", 'x', f_offset, (char *) 0));
 840
 841 #if WITH_PROFILE_MODEL_P
 842   /* Record the fields for profiling.  */
 843   if (PROFILE_MODEL_P (current_cpu))
 844     {
 845     }
 846 #endif
 847 #undef FLD
 848     return idesc;
 849   }
 850
 851  extract_sfmt_bgez:
 852   {
 853     const IDESC *idesc = &iq2000bf_insn_data[itype];
 854     CGEN_INSN_INT insn = entire_insn;
 855 #define FLD(f) abuf->fields.sfmt_bbi.f
 856     UINT f_rs;
 857     SI f_offset;
 858
 859     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 860     f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
 861
 862   /* Record the fields for the semantic handler.  */
 863   FLD (f_rs) = f_rs;
 864   FLD (i_offset) = f_offset;
 865   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bgez", "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
 866
 867 #if WITH_PROFILE_MODEL_P
 868   /* Record the fields for profiling.  */
 869   if (PROFILE_MODEL_P (current_cpu))
 870     {
 871     }
 872 #endif
 873 #undef FLD
 874     return idesc;
 875   }
 876
 877  extract_sfmt_bgezal:
 878   {
 879     const IDESC *idesc = &iq2000bf_insn_data[itype];
 880     CGEN_INSN_INT insn = entire_insn;
 881 #define FLD(f) abuf->fields.sfmt_bbi.f
 882     UINT f_rs;
 883     SI f_offset;
 884
 885     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 886     f_offset = ((((EXTRACT_LSB0_INT (insn, 32, 15, 16)) << (2))) + (((pc) + (4))));
 887
 888   /* Record the fields for the semantic handler.  */
 889   FLD (f_rs) = f_rs;
 890   FLD (i_offset) = f_offset;
 891   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bgezal", "f_rs 0x%x", 'x', f_rs, "offset 0x%x", 'x', f_offset, (char *) 0));
 892
 893 #if WITH_PROFILE_MODEL_P
 894   /* Record the fields for profiling.  */
 895   if (PROFILE_MODEL_P (current_cpu))
 896     {
 897     }
 898 #endif
 899 #undef FLD
 900     return idesc;
 901   }
 902
 903  extract_sfmt_jalr:
 904   {
 905     const IDESC *idesc = &iq2000bf_insn_data[itype];
 906     CGEN_INSN_INT insn = entire_insn;
 907 #define FLD(f) abuf->fields.sfmt_mrgb.f
 908     UINT f_rs;
 909     UINT f_rd;
 910
 911     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 912     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
 913
 914   /* Record the fields for the semantic handler.  */
 915   FLD (f_rs) = f_rs;
 916   FLD (f_rd) = f_rd;
 917   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jalr", "f_rs 0x%x", 'x', f_rs, "f_rd 0x%x", 'x', f_rd, (char *) 0));
 918
 919 #if WITH_PROFILE_MODEL_P
 920   /* Record the fields for profiling.  */
 921   if (PROFILE_MODEL_P (current_cpu))
 922     {
 923     }
 924 #endif
 925 #undef FLD
 926     return idesc;
 927   }
 928
 929  extract_sfmt_jr:
 930   {
 931     const IDESC *idesc = &iq2000bf_insn_data[itype];
 932     CGEN_INSN_INT insn = entire_insn;
 933 #define FLD(f) abuf->fields.sfmt_bbi.f
 934     UINT f_rs;
 935
 936     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 937
 938   /* Record the fields for the semantic handler.  */
 939   FLD (f_rs) = f_rs;
 940   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jr", "f_rs 0x%x", 'x', f_rs, (char *) 0));
 941
 942 #if WITH_PROFILE_MODEL_P
 943   /* Record the fields for profiling.  */
 944   if (PROFILE_MODEL_P (current_cpu))
 945     {
 946     }
 947 #endif
 948 #undef FLD
 949     return idesc;
 950   }
 951
 952  extract_sfmt_lb:
 953   {
 954     const IDESC *idesc = &iq2000bf_insn_data[itype];
 955     CGEN_INSN_INT insn = entire_insn;
 956 #define FLD(f) abuf->fields.sfmt_addi.f
 957     UINT f_rs;
 958     UINT f_rt;
 959     UINT f_imm;
 960
 961     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 962     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 963     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
 964
 965   /* Record the fields for the semantic handler.  */
 966   FLD (f_rs) = f_rs;
 967   FLD (f_imm) = f_imm;
 968   FLD (f_rt) = f_rt;
 969   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lb", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
 970
 971 #undef FLD
 972     return idesc;
 973   }
 974
 975  extract_sfmt_lh:
 976   {
 977     const IDESC *idesc = &iq2000bf_insn_data[itype];
 978     CGEN_INSN_INT insn = entire_insn;
 979 #define FLD(f) abuf->fields.sfmt_addi.f
 980     UINT f_rs;
 981     UINT f_rt;
 982     UINT f_imm;
 983
 984     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
 985     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
 986     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
 987
 988   /* Record the fields for the semantic handler.  */
 989   FLD (f_rs) = f_rs;
 990   FLD (f_imm) = f_imm;
 991   FLD (f_rt) = f_rt;
 992   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lh", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
 993
 994 #undef FLD
 995     return idesc;
 996   }
 997
 998  extract_sfmt_lui:
 999   {
1000     const IDESC *idesc = &iq2000bf_insn_data[itype];
1001     CGEN_INSN_INT insn = entire_insn;
1002 #define FLD(f) abuf->fields.sfmt_addi.f
1003     UINT f_rt;
1004     UINT f_imm;
1005
1006     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1007     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1008
1009   /* Record the fields for the semantic handler.  */
1010   FLD (f_imm) = f_imm;
1011   FLD (f_rt) = f_rt;
1012   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lui", "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1013
1014 #undef FLD
1015     return idesc;
1016   }
1017
1018  extract_sfmt_lw:
1019   {
1020     const IDESC *idesc = &iq2000bf_insn_data[itype];
1021     CGEN_INSN_INT insn = entire_insn;
1022 #define FLD(f) abuf->fields.sfmt_addi.f
1023     UINT f_rs;
1024     UINT f_rt;
1025     UINT f_imm;
1026
1027     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1028     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1029     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1030
1031   /* Record the fields for the semantic handler.  */
1032   FLD (f_rs) = f_rs;
1033   FLD (f_imm) = f_imm;
1034   FLD (f_rt) = f_rt;
1035   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lw", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1036
1037 #undef FLD
1038     return idesc;
1039   }
1040
1041  extract_sfmt_sb:
1042   {
1043     const IDESC *idesc = &iq2000bf_insn_data[itype];
1044     CGEN_INSN_INT insn = entire_insn;
1045 #define FLD(f) abuf->fields.sfmt_addi.f
1046     UINT f_rs;
1047     UINT f_rt;
1048     UINT f_imm;
1049
1050     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1051     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1052     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1053
1054   /* Record the fields for the semantic handler.  */
1055   FLD (f_rs) = f_rs;
1056   FLD (f_imm) = f_imm;
1057   FLD (f_rt) = f_rt;
1058   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sb", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1059
1060 #undef FLD
1061     return idesc;
1062   }
1063
1064  extract_sfmt_sh:
1065   {
1066     const IDESC *idesc = &iq2000bf_insn_data[itype];
1067     CGEN_INSN_INT insn = entire_insn;
1068 #define FLD(f) abuf->fields.sfmt_addi.f
1069     UINT f_rs;
1070     UINT f_rt;
1071     UINT f_imm;
1072
1073     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1074     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1075     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1076
1077   /* Record the fields for the semantic handler.  */
1078   FLD (f_rs) = f_rs;
1079   FLD (f_imm) = f_imm;
1080   FLD (f_rt) = f_rt;
1081   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sh", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1082
1083 #undef FLD
1084     return idesc;
1085   }
1086
1087  extract_sfmt_sw:
1088   {
1089     const IDESC *idesc = &iq2000bf_insn_data[itype];
1090     CGEN_INSN_INT insn = entire_insn;
1091 #define FLD(f) abuf->fields.sfmt_addi.f
1092     UINT f_rs;
1093     UINT f_rt;
1094     UINT f_imm;
1095
1096     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1097     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1098     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1099
1100   /* Record the fields for the semantic handler.  */
1101   FLD (f_rs) = f_rs;
1102   FLD (f_imm) = f_imm;
1103   FLD (f_rt) = f_rt;
1104   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sw", "f_rs 0x%x", 'x', f_rs, "f_imm 0x%x", 'x', f_imm, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1105
1106 #undef FLD
1107     return idesc;
1108   }
1109
1110  extract_sfmt_break:
1111   {
1112     const IDESC *idesc = &iq2000bf_insn_data[itype];
1113 #define FLD(f) abuf->fields.fmt_empty.f
1114
1115
1116   /* Record the fields for the semantic handler.  */
1117   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_break", (char *) 0));
1118
1119 #if WITH_PROFILE_MODEL_P
1120   /* Record the fields for profiling.  */
1121   if (PROFILE_MODEL_P (current_cpu))
1122     {
1123     }
1124 #endif
1125 #undef FLD
1126     return idesc;
1127   }
1128
1129  extract_sfmt_syscall:
1130   {
1131     const IDESC *idesc = &iq2000bf_insn_data[itype];
1132 #define FLD(f) abuf->fields.fmt_empty.f
1133
1134
1135   /* Record the fields for the semantic handler.  */
1136   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_syscall", (char *) 0));
1137
1138 #undef FLD
1139     return idesc;
1140   }
1141
1142  extract_sfmt_andoui:
1143   {
1144     const IDESC *idesc = &iq2000bf_insn_data[itype];
1145     CGEN_INSN_INT insn = entire_insn;
1146 #define FLD(f) abuf->fields.sfmt_addi.f
1147     UINT f_rs;
1148     UINT f_rt;
1149     UINT f_imm;
1150
1151     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1152     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1153     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1154
1155   /* Record the fields for the semantic handler.  */
1156   FLD (f_imm) = f_imm;
1157   FLD (f_rs) = f_rs;
1158   FLD (f_rt) = f_rt;
1159   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_andoui", "f_imm 0x%x", 'x', f_imm, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, (char *) 0));
1160
1161 #undef FLD
1162     return idesc;
1163   }
1164
1165  extract_sfmt_mrgb:
1166   {
1167     const IDESC *idesc = &iq2000bf_insn_data[itype];
1168     CGEN_INSN_INT insn = entire_insn;
1169 #define FLD(f) abuf->fields.sfmt_mrgb.f
1170     UINT f_rs;
1171     UINT f_rt;
1172     UINT f_rd;
1173     UINT f_mask;
1174
1175     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1176     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1177     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 5);
1178     f_mask = EXTRACT_LSB0_UINT (insn, 32, 9, 4);
1179
1180   /* Record the fields for the semantic handler.  */
1181   FLD (f_mask) = f_mask;
1182   FLD (f_rs) = f_rs;
1183   FLD (f_rt) = f_rt;
1184   FLD (f_rd) = f_rd;
1185   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mrgb", "f_mask 0x%x", 'x', f_mask, "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_rd 0x%x", 'x', f_rd, (char *) 0));
1186
1187 #undef FLD
1188     return idesc;
1189   }
1190
1191  extract_sfmt_bctxt:
1192   {
1193     const IDESC *idesc = &iq2000bf_insn_data[itype];
1194 #define FLD(f) abuf->fields.fmt_empty.f
1195
1196
1197   /* Record the fields for the semantic handler.  */
1198   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bctxt", (char *) 0));
1199
1200 #undef FLD
1201     return idesc;
1202   }
1203
1204  extract_sfmt_ldw:
1205   {
1206     const IDESC *idesc = &iq2000bf_insn_data[itype];
1207     CGEN_INSN_INT insn = entire_insn;
1208 #define FLD(f) abuf->fields.sfmt_addi.f
1209     UINT f_rs;
1210     UINT f_rt;
1211     UINT f_imm;
1212
1213     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1214     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1215     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1216
1217   /* Record the fields for the semantic handler.  */
1218   FLD (f_rs) = f_rs;
1219   FLD (f_rt) = f_rt;
1220   FLD (f_imm) = f_imm;
1221   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldw", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_imm 0x%x", 'x', f_imm, (char *) 0));
1222
1223 #undef FLD
1224     return idesc;
1225   }
1226
1227  extract_sfmt_sdw:
1228   {
1229     const IDESC *idesc = &iq2000bf_insn_data[itype];
1230     CGEN_INSN_INT insn = entire_insn;
1231 #define FLD(f) abuf->fields.sfmt_addi.f
1232     UINT f_rs;
1233     UINT f_rt;
1234     UINT f_imm;
1235
1236     f_rs = EXTRACT_LSB0_UINT (insn, 32, 25, 5);
1237     f_rt = EXTRACT_LSB0_UINT (insn, 32, 20, 5);
1238     f_imm = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
1239
1240   /* Record the fields for the semantic handler.  */
1241   FLD (f_rs) = f_rs;
1242   FLD (f_rt) = f_rt;
1243   FLD (f_imm) = f_imm;
1244   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sdw", "f_rs 0x%x", 'x', f_rs, "f_rt 0x%x", 'x', f_rt, "f_imm 0x%x", 'x', f_imm, (char *) 0));
1245
1246 #undef FLD
1247     return idesc;
1248   }
1249
1250  extract_sfmt_j:
1251   {
1252     const IDESC *idesc = &iq2000bf_insn_data[itype];
1253     CGEN_INSN_INT insn = entire_insn;
1254 #define FLD(f) abuf->fields.sfmt_j.f
1255     USI f_jtarg;
1256
1257     f_jtarg = ((((pc) & (0xf0000000))) | (((EXTRACT_LSB0_UINT (insn, 32, 15, 16)) << (2))));
1258
1259   /* Record the fields for the semantic handler.  */
1260   FLD (i_jmptarg) = f_jtarg;
1261   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_j", "jmptarg 0x%x", 'x', f_jtarg, (char *) 0));
1262
1263 #if WITH_PROFILE_MODEL_P
1264   /* Record the fields for profiling.  */
1265   if (PROFILE_MODEL_P (current_cpu))
1266     {
1267     }
1268 #endif
1269 #undef FLD
1270     return idesc;
1271   }
1272
1273  extract_sfmt_jal:
1274   {
1275     const IDESC *idesc = &iq2000bf_insn_data[itype];
1276     CGEN_INSN_INT insn = entire_insn;
1277 #define FLD(f) abuf->fields.sfmt_j.f
1278     USI f_jtarg;
1279
1280     f_jtarg = ((((pc) & (0xf0000000))) | (((EXTRACT_LSB0_UINT (insn, 32, 15, 16)) << (2))));
1281
1282   /* Record the fields for the semantic handler.  */
1283   FLD (i_jmptarg) = f_jtarg;
1284   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jal", "jmptarg 0x%x", 'x', f_jtarg, (char *) 0));
1285
1286 #if WITH_PROFILE_MODEL_P
1287   /* Record the fields for profiling.  */
1288   if (PROFILE_MODEL_P (current_cpu))
1289     {
1290     }
1291 #endif
1292 #undef FLD
1293     return idesc;
1294   }
1295
1296 }