sim/fr30/decode.c

   1 /* Simulator instruction decoder for fr30bf.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 1996, 1997, 1998, 1999 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 2, or (at your option)
  12 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 along
  20 with this program; if not, write to the Free Software Foundation, Inc.,
  21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23 */
  24
  25 #define WANT_CPU fr30bf
  26 #define WANT_CPU_FR30BF
  27
  28 #include "sim-main.h"
  29 #include "sim-assert.h"
  30
  31 /* FIXME: Need to review choices for the following.  */
  32
  33 #if WITH_SEM_SWITCH_FULL
  34 #define FULL(fn)
  35 #else
  36 #define FULL(fn) CONCAT3 (fr30bf,_sem_,fn) ,
  37 #endif
  38
  39 #if WITH_FAST
  40 #if WITH_SEM_SWITCH_FAST
  41 #define FAST(fn)
  42 #else
  43 #define FAST(fn) CONCAT3 (fr30bf,_semf_,fn) , /* f for fast */
  44 #endif
  45 #else
  46 #define FAST(fn)
  47 #endif
  48
  49 /* The instruction descriptor array.
  50    This is computed at runtime.  Space for it is not malloc'd to save a
  51    teensy bit of cpu in the decoder.  Moving it to malloc space is trivial
  52    but won't be done until necessary (we don't currently support the runtime
  53    addition of instructions nor an SMP machine with different cpus).  */
  54 static IDESC fr30bf_insn_data[FR30BF_INSN_MAX];
  55
  56 /* The INSN_ prefix is not here and is instead part of the `insn' argument
  57    to avoid collisions with header files (e.g. `AND' in ansidecl.h).  */
  58 #define IDX(insn) CONCAT2 (FR30BF_,insn)
  59 #define TYPE(insn) CONCAT2 (FR30_,insn)
  60
  61 /* Commas between elements are contained in the macros.
  62    Some of these are conditionally compiled out.  */
  63
  64 static const struct insn_sem fr30bf_insn_sem[] =
  65 {
  66   { VIRTUAL_INSN_X_INVALID, IDX (INSN_X_INVALID), FULL (x_invalid) FAST (x_invalid) },
  67   { VIRTUAL_INSN_X_AFTER, IDX (INSN_X_AFTER), FULL (x_after) FAST (x_after) },
  68   { VIRTUAL_INSN_X_BEFORE, IDX (INSN_X_BEFORE), FULL (x_before) FAST (x_before) },
  69   { VIRTUAL_INSN_X_CTI_CHAIN, IDX (INSN_X_CTI_CHAIN), FULL (x_cti_chain) FAST (x_cti_chain) },
  70   { VIRTUAL_INSN_X_CHAIN, IDX (INSN_X_CHAIN), FULL (x_chain) FAST (x_chain) },
  71   { VIRTUAL_INSN_X_BEGIN, IDX (INSN_X_BEGIN), FULL (x_begin) FAST (x_begin) },
  72   { TYPE (INSN_ADD), IDX (INSN_ADD), FULL (add) FAST (add) },
  73   { TYPE (INSN_ADDI), IDX (INSN_ADDI), FULL (addi) FAST (addi) },
  74   { TYPE (INSN_ADD2), IDX (INSN_ADD2), FULL (add2) FAST (add2) },
  75   { TYPE (INSN_ADDC), IDX (INSN_ADDC), FULL (addc) FAST (addc) },
  76   { TYPE (INSN_ADDN), IDX (INSN_ADDN), FULL (addn) FAST (addn) },
  77   { TYPE (INSN_ADDNI), IDX (INSN_ADDNI), FULL (addni) FAST (addni) },
  78   { TYPE (INSN_ADDN2), IDX (INSN_ADDN2), FULL (addn2) FAST (addn2) },
  79   { TYPE (INSN_SUB), IDX (INSN_SUB), FULL (sub) FAST (sub) },
  80   { TYPE (INSN_SUBC), IDX (INSN_SUBC), FULL (subc) FAST (subc) },
  81   { TYPE (INSN_SUBN), IDX (INSN_SUBN), FULL (subn) FAST (subn) },
  82   { TYPE (INSN_CMP), IDX (INSN_CMP), FULL (cmp) FAST (cmp) },
  83   { TYPE (INSN_CMPI), IDX (INSN_CMPI), FULL (cmpi) FAST (cmpi) },
  84   { TYPE (INSN_CMP2), IDX (INSN_CMP2), FULL (cmp2) FAST (cmp2) },
  85   { TYPE (INSN_AND), IDX (INSN_AND), FULL (and) FAST (and) },
  86   { TYPE (INSN_OR), IDX (INSN_OR), FULL (or) FAST (or) },
  87   { TYPE (INSN_EOR), IDX (INSN_EOR), FULL (eor) FAST (eor) },
  88   { TYPE (INSN_ANDM), IDX (INSN_ANDM), FULL (andm) FAST (andm) },
  89   { TYPE (INSN_ANDH), IDX (INSN_ANDH), FULL (andh) FAST (andh) },
  90   { TYPE (INSN_ANDB), IDX (INSN_ANDB), FULL (andb) FAST (andb) },
  91   { TYPE (INSN_ORM), IDX (INSN_ORM), FULL (orm) FAST (orm) },
  92   { TYPE (INSN_ORH), IDX (INSN_ORH), FULL (orh) FAST (orh) },
  93   { TYPE (INSN_ORB), IDX (INSN_ORB), FULL (orb) FAST (orb) },
  94   { TYPE (INSN_EORM), IDX (INSN_EORM), FULL (eorm) FAST (eorm) },
  95   { TYPE (INSN_EORH), IDX (INSN_EORH), FULL (eorh) FAST (eorh) },
  96   { TYPE (INSN_EORB), IDX (INSN_EORB), FULL (eorb) FAST (eorb) },
  97   { TYPE (INSN_BANDL), IDX (INSN_BANDL), FULL (bandl) FAST (bandl) },
  98   { TYPE (INSN_BORL), IDX (INSN_BORL), FULL (borl) FAST (borl) },
  99   { TYPE (INSN_BEORL), IDX (INSN_BEORL), FULL (beorl) FAST (beorl) },
 100   { TYPE (INSN_BANDH), IDX (INSN_BANDH), FULL (bandh) FAST (bandh) },
 101   { TYPE (INSN_BORH), IDX (INSN_BORH), FULL (borh) FAST (borh) },
 102   { TYPE (INSN_BEORH), IDX (INSN_BEORH), FULL (beorh) FAST (beorh) },
 103   { TYPE (INSN_BTSTL), IDX (INSN_BTSTL), FULL (btstl) FAST (btstl) },
 104   { TYPE (INSN_BTSTH), IDX (INSN_BTSTH), FULL (btsth) FAST (btsth) },
 105   { TYPE (INSN_MUL), IDX (INSN_MUL), FULL (mul) FAST (mul) },
 106   { TYPE (INSN_MULU), IDX (INSN_MULU), FULL (mulu) FAST (mulu) },
 107   { TYPE (INSN_MULH), IDX (INSN_MULH), FULL (mulh) FAST (mulh) },
 108   { TYPE (INSN_MULUH), IDX (INSN_MULUH), FULL (muluh) FAST (muluh) },
 109   { TYPE (INSN_DIV0S), IDX (INSN_DIV0S), FULL (div0s) FAST (div0s) },
 110   { TYPE (INSN_DIV0U), IDX (INSN_DIV0U), FULL (div0u) FAST (div0u) },
 111   { TYPE (INSN_DIV1), IDX (INSN_DIV1), FULL (div1) FAST (div1) },
 112   { TYPE (INSN_DIV2), IDX (INSN_DIV2), FULL (div2) FAST (div2) },
 113   { TYPE (INSN_DIV3), IDX (INSN_DIV3), FULL (div3) FAST (div3) },
 114   { TYPE (INSN_DIV4S), IDX (INSN_DIV4S), FULL (div4s) FAST (div4s) },
 115   { TYPE (INSN_LSL), IDX (INSN_LSL), FULL (lsl) FAST (lsl) },
 116   { TYPE (INSN_LSLI), IDX (INSN_LSLI), FULL (lsli) FAST (lsli) },
 117   { TYPE (INSN_LSL2), IDX (INSN_LSL2), FULL (lsl2) FAST (lsl2) },
 118   { TYPE (INSN_LSR), IDX (INSN_LSR), FULL (lsr) FAST (lsr) },
 119   { TYPE (INSN_LSRI), IDX (INSN_LSRI), FULL (lsri) FAST (lsri) },
 120   { TYPE (INSN_LSR2), IDX (INSN_LSR2), FULL (lsr2) FAST (lsr2) },
 121   { TYPE (INSN_ASR), IDX (INSN_ASR), FULL (asr) FAST (asr) },
 122   { TYPE (INSN_ASRI), IDX (INSN_ASRI), FULL (asri) FAST (asri) },
 123   { TYPE (INSN_ASR2), IDX (INSN_ASR2), FULL (asr2) FAST (asr2) },
 124   { TYPE (INSN_LDI8), IDX (INSN_LDI8), FULL (ldi8) FAST (ldi8) },
 125   { TYPE (INSN_LDI20), IDX (INSN_LDI20), FULL (ldi20) FAST (ldi20) },
 126   { TYPE (INSN_LDI32), IDX (INSN_LDI32), FULL (ldi32) FAST (ldi32) },
 127   { TYPE (INSN_LD), IDX (INSN_LD), FULL (ld) FAST (ld) },
 128   { TYPE (INSN_LDUH), IDX (INSN_LDUH), FULL (lduh) FAST (lduh) },
 129   { TYPE (INSN_LDUB), IDX (INSN_LDUB), FULL (ldub) FAST (ldub) },
 130   { TYPE (INSN_LDR13), IDX (INSN_LDR13), FULL (ldr13) FAST (ldr13) },
 131   { TYPE (INSN_LDR13UH), IDX (INSN_LDR13UH), FULL (ldr13uh) FAST (ldr13uh) },
 132   { TYPE (INSN_LDR13UB), IDX (INSN_LDR13UB), FULL (ldr13ub) FAST (ldr13ub) },
 133   { TYPE (INSN_LDR14), IDX (INSN_LDR14), FULL (ldr14) FAST (ldr14) },
 134   { TYPE (INSN_LDR14UH), IDX (INSN_LDR14UH), FULL (ldr14uh) FAST (ldr14uh) },
 135   { TYPE (INSN_LDR14UB), IDX (INSN_LDR14UB), FULL (ldr14ub) FAST (ldr14ub) },
 136   { TYPE (INSN_LDR15), IDX (INSN_LDR15), FULL (ldr15) FAST (ldr15) },
 137   { TYPE (INSN_LDR15GR), IDX (INSN_LDR15GR), FULL (ldr15gr) FAST (ldr15gr) },
 138   { TYPE (INSN_LDR15DR), IDX (INSN_LDR15DR), FULL (ldr15dr) FAST (ldr15dr) },
 139   { TYPE (INSN_LDR15PS), IDX (INSN_LDR15PS), FULL (ldr15ps) FAST (ldr15ps) },
 140   { TYPE (INSN_ST), IDX (INSN_ST), FULL (st) FAST (st) },
 141   { TYPE (INSN_STH), IDX (INSN_STH), FULL (sth) FAST (sth) },
 142   { TYPE (INSN_STB), IDX (INSN_STB), FULL (stb) FAST (stb) },
 143   { TYPE (INSN_STR13), IDX (INSN_STR13), FULL (str13) FAST (str13) },
 144   { TYPE (INSN_STR13H), IDX (INSN_STR13H), FULL (str13h) FAST (str13h) },
 145   { TYPE (INSN_STR13B), IDX (INSN_STR13B), FULL (str13b) FAST (str13b) },
 146   { TYPE (INSN_STR14), IDX (INSN_STR14), FULL (str14) FAST (str14) },
 147   { TYPE (INSN_STR14H), IDX (INSN_STR14H), FULL (str14h) FAST (str14h) },
 148   { TYPE (INSN_STR14B), IDX (INSN_STR14B), FULL (str14b) FAST (str14b) },
 149   { TYPE (INSN_STR15), IDX (INSN_STR15), FULL (str15) FAST (str15) },
 150   { TYPE (INSN_STR15GR), IDX (INSN_STR15GR), FULL (str15gr) FAST (str15gr) },
 151   { TYPE (INSN_STR15DR), IDX (INSN_STR15DR), FULL (str15dr) FAST (str15dr) },
 152   { TYPE (INSN_STR15PS), IDX (INSN_STR15PS), FULL (str15ps) FAST (str15ps) },
 153   { TYPE (INSN_MOV), IDX (INSN_MOV), FULL (mov) FAST (mov) },
 154   { TYPE (INSN_MOVDR), IDX (INSN_MOVDR), FULL (movdr) FAST (movdr) },
 155   { TYPE (INSN_MOVPS), IDX (INSN_MOVPS), FULL (movps) FAST (movps) },
 156   { TYPE (INSN_MOV2DR), IDX (INSN_MOV2DR), FULL (mov2dr) FAST (mov2dr) },
 157   { TYPE (INSN_MOV2PS), IDX (INSN_MOV2PS), FULL (mov2ps) FAST (mov2ps) },
 158   { TYPE (INSN_JMP), IDX (INSN_JMP), FULL (jmp) FAST (jmp) },
 159   { TYPE (INSN_JMPD), IDX (INSN_JMPD), FULL (jmpd) FAST (jmpd) },
 160   { TYPE (INSN_CALLR), IDX (INSN_CALLR), FULL (callr) FAST (callr) },
 161   { TYPE (INSN_CALLRD), IDX (INSN_CALLRD), FULL (callrd) FAST (callrd) },
 162   { TYPE (INSN_CALL), IDX (INSN_CALL), FULL (call) FAST (call) },
 163   { TYPE (INSN_CALLD), IDX (INSN_CALLD), FULL (calld) FAST (calld) },
 164   { TYPE (INSN_RET), IDX (INSN_RET), FULL (ret) FAST (ret) },
 165   { TYPE (INSN_RET_D), IDX (INSN_RET_D), FULL (ret_d) FAST (ret_d) },
 166   { TYPE (INSN_INT), IDX (INSN_INT), FULL (int) FAST (int) },
 167   { TYPE (INSN_INTE), IDX (INSN_INTE), FULL (inte) FAST (inte) },
 168   { TYPE (INSN_RETI), IDX (INSN_RETI), FULL (reti) FAST (reti) },
 169   { TYPE (INSN_BRAD), IDX (INSN_BRAD), FULL (brad) FAST (brad) },
 170   { TYPE (INSN_BRA), IDX (INSN_BRA), FULL (bra) FAST (bra) },
 171   { TYPE (INSN_BNOD), IDX (INSN_BNOD), FULL (bnod) FAST (bnod) },
 172   { TYPE (INSN_BNO), IDX (INSN_BNO), FULL (bno) FAST (bno) },
 173   { TYPE (INSN_BEQD), IDX (INSN_BEQD), FULL (beqd) FAST (beqd) },
 174   { TYPE (INSN_BEQ), IDX (INSN_BEQ), FULL (beq) FAST (beq) },
 175   { TYPE (INSN_BNED), IDX (INSN_BNED), FULL (bned) FAST (bned) },
 176   { TYPE (INSN_BNE), IDX (INSN_BNE), FULL (bne) FAST (bne) },
 177   { TYPE (INSN_BCD), IDX (INSN_BCD), FULL (bcd) FAST (bcd) },
 178   { TYPE (INSN_BC), IDX (INSN_BC), FULL (bc) FAST (bc) },
 179   { TYPE (INSN_BNCD), IDX (INSN_BNCD), FULL (bncd) FAST (bncd) },
 180   { TYPE (INSN_BNC), IDX (INSN_BNC), FULL (bnc) FAST (bnc) },
 181   { TYPE (INSN_BND), IDX (INSN_BND), FULL (bnd) FAST (bnd) },
 182   { TYPE (INSN_BN), IDX (INSN_BN), FULL (bn) FAST (bn) },
 183   { TYPE (INSN_BPD), IDX (INSN_BPD), FULL (bpd) FAST (bpd) },
 184   { TYPE (INSN_BP), IDX (INSN_BP), FULL (bp) FAST (bp) },
 185   { TYPE (INSN_BVD), IDX (INSN_BVD), FULL (bvd) FAST (bvd) },
 186   { TYPE (INSN_BV), IDX (INSN_BV), FULL (bv) FAST (bv) },
 187   { TYPE (INSN_BNVD), IDX (INSN_BNVD), FULL (bnvd) FAST (bnvd) },
 188   { TYPE (INSN_BNV), IDX (INSN_BNV), FULL (bnv) FAST (bnv) },
 189   { TYPE (INSN_BLTD), IDX (INSN_BLTD), FULL (bltd) FAST (bltd) },
 190   { TYPE (INSN_BLT), IDX (INSN_BLT), FULL (blt) FAST (blt) },
 191   { TYPE (INSN_BGED), IDX (INSN_BGED), FULL (bged) FAST (bged) },
 192   { TYPE (INSN_BGE), IDX (INSN_BGE), FULL (bge) FAST (bge) },
 193   { TYPE (INSN_BLED), IDX (INSN_BLED), FULL (bled) FAST (bled) },
 194   { TYPE (INSN_BLE), IDX (INSN_BLE), FULL (ble) FAST (ble) },
 195   { TYPE (INSN_BGTD), IDX (INSN_BGTD), FULL (bgtd) FAST (bgtd) },
 196   { TYPE (INSN_BGT), IDX (INSN_BGT), FULL (bgt) FAST (bgt) },
 197   { TYPE (INSN_BLSD), IDX (INSN_BLSD), FULL (blsd) FAST (blsd) },
 198   { TYPE (INSN_BLS), IDX (INSN_BLS), FULL (bls) FAST (bls) },
 199   { TYPE (INSN_BHID), IDX (INSN_BHID), FULL (bhid) FAST (bhid) },
 200   { TYPE (INSN_BHI), IDX (INSN_BHI), FULL (bhi) FAST (bhi) },
 201   { TYPE (INSN_DMOVR13), IDX (INSN_DMOVR13), FULL (dmovr13) FAST (dmovr13) },
 202   { TYPE (INSN_DMOVR13H), IDX (INSN_DMOVR13H), FULL (dmovr13h) FAST (dmovr13h) },
 203   { TYPE (INSN_DMOVR13B), IDX (INSN_DMOVR13B), FULL (dmovr13b) FAST (dmovr13b) },
 204   { TYPE (INSN_DMOVR13PI), IDX (INSN_DMOVR13PI), FULL (dmovr13pi) FAST (dmovr13pi) },
 205   { TYPE (INSN_DMOVR13PIH), IDX (INSN_DMOVR13PIH), FULL (dmovr13pih) FAST (dmovr13pih) },
 206   { TYPE (INSN_DMOVR13PIB), IDX (INSN_DMOVR13PIB), FULL (dmovr13pib) FAST (dmovr13pib) },
 207   { TYPE (INSN_DMOVR15PI), IDX (INSN_DMOVR15PI), FULL (dmovr15pi) FAST (dmovr15pi) },
 208   { TYPE (INSN_DMOV2R13), IDX (INSN_DMOV2R13), FULL (dmov2r13) FAST (dmov2r13) },
 209   { TYPE (INSN_DMOV2R13H), IDX (INSN_DMOV2R13H), FULL (dmov2r13h) FAST (dmov2r13h) },
 210   { TYPE (INSN_DMOV2R13B), IDX (INSN_DMOV2R13B), FULL (dmov2r13b) FAST (dmov2r13b) },
 211   { TYPE (INSN_DMOV2R13PI), IDX (INSN_DMOV2R13PI), FULL (dmov2r13pi) FAST (dmov2r13pi) },
 212   { TYPE (INSN_DMOV2R13PIH), IDX (INSN_DMOV2R13PIH), FULL (dmov2r13pih) FAST (dmov2r13pih) },
 213   { TYPE (INSN_DMOV2R13PIB), IDX (INSN_DMOV2R13PIB), FULL (dmov2r13pib) FAST (dmov2r13pib) },
 214   { TYPE (INSN_DMOV2R15PD), IDX (INSN_DMOV2R15PD), FULL (dmov2r15pd) FAST (dmov2r15pd) },
 215   { TYPE (INSN_LDRES), IDX (INSN_LDRES), FULL (ldres) FAST (ldres) },
 216   { TYPE (INSN_STRES), IDX (INSN_STRES), FULL (stres) FAST (stres) },
 217   { TYPE (INSN_COPOP), IDX (INSN_COPOP), FULL (copop) FAST (copop) },
 218   { TYPE (INSN_COPLD), IDX (INSN_COPLD), FULL (copld) FAST (copld) },
 219   { TYPE (INSN_COPST), IDX (INSN_COPST), FULL (copst) FAST (copst) },
 220   { TYPE (INSN_COPSV), IDX (INSN_COPSV), FULL (copsv) FAST (copsv) },
 221   { TYPE (INSN_NOP), IDX (INSN_NOP), FULL (nop) FAST (nop) },
 222   { TYPE (INSN_ANDCCR), IDX (INSN_ANDCCR), FULL (andccr) FAST (andccr) },
 223   { TYPE (INSN_ORCCR), IDX (INSN_ORCCR), FULL (orccr) FAST (orccr) },
 224   { TYPE (INSN_STILM), IDX (INSN_STILM), FULL (stilm) FAST (stilm) },
 225   { TYPE (INSN_ADDSP), IDX (INSN_ADDSP), FULL (addsp) FAST (addsp) },
 226   { TYPE (INSN_EXTSB), IDX (INSN_EXTSB), FULL (extsb) FAST (extsb) },
 227   { TYPE (INSN_EXTUB), IDX (INSN_EXTUB), FULL (extub) FAST (extub) },
 228   { TYPE (INSN_EXTSH), IDX (INSN_EXTSH), FULL (extsh) FAST (extsh) },
 229   { TYPE (INSN_EXTUH), IDX (INSN_EXTUH), FULL (extuh) FAST (extuh) },
 230   { TYPE (INSN_LDM0), IDX (INSN_LDM0), FULL (ldm0) FAST (ldm0) },
 231   { TYPE (INSN_LDM1), IDX (INSN_LDM1), FULL (ldm1) FAST (ldm1) },
 232   { TYPE (INSN_STM0), IDX (INSN_STM0), FULL (stm0) FAST (stm0) },
 233   { TYPE (INSN_STM1), IDX (INSN_STM1), FULL (stm1) FAST (stm1) },
 234   { TYPE (INSN_ENTER), IDX (INSN_ENTER), FULL (enter) FAST (enter) },
 235   { TYPE (INSN_LEAVE), IDX (INSN_LEAVE), FULL (leave) FAST (leave) },
 236   { TYPE (INSN_XCHB), IDX (INSN_XCHB), FULL (xchb) FAST (xchb) },
 237 };
 238
 239 static const struct insn_sem fr30bf_insn_sem_invalid =
 240 {
 241   VIRTUAL_INSN_X_INVALID, IDX (INSN_X_INVALID), FULL (x_invalid) FAST (x_invalid)
 242 };
 243
 244 #undef IDX
 245 #undef TYPE
 246
 247 /* Initialize an IDESC from the compile-time computable parts.  */
 248
 249 static INLINE void
 250 init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t)
 251 {
 252   const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries;
 253
 254   id->num = t->index;
 255   if ((int) t->type <= 0)
 256     id->idata = & cgen_virtual_insn_table[- (int) t->type];
 257   else
 258     id->idata = & insn_table[t->type];
 259   id->attrs = CGEN_INSN_ATTRS (id->idata);
 260   /* Oh my god, a magic number.  */
 261   id->length = CGEN_INSN_BITSIZE (id->idata) / 8;
 262 #if ! WITH_SEM_SWITCH_FULL
 263   id->sem_full = t->sem_full;
 264 #endif
 265 #if WITH_FAST && ! WITH_SEM_SWITCH_FAST
 266   id->sem_fast = t->sem_fast;
 267 #endif
 268 #if WITH_PROFILE_MODEL_P
 269   id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index];
 270   {
 271     SIM_DESC sd = CPU_STATE (cpu);
 272     SIM_ASSERT (t->index == id->timing->num);
 273   }
 274 #endif
 275 }
 276
 277 /* Initialize the instruction descriptor table.  */
 278
 279 void
 280 fr30bf_init_idesc_table (SIM_CPU *cpu)
 281 {
 282   IDESC *id,*tabend;
 283   const struct insn_sem *t,*tend;
 284   int tabsize = FR30BF_INSN_MAX;
 285   IDESC *table = fr30bf_insn_data;
 286
 287   memset (table, 0, tabsize * sizeof (IDESC));
 288
 289   /* First set all entries to the `invalid insn'.  */
 290   t = & fr30bf_insn_sem_invalid;
 291   for (id = table, tabend = table + tabsize; id < tabend; ++id)
 292     init_idesc (cpu, id, t);
 293
 294   /* Now fill in the values for the chosen cpu.  */
 295   for (t = fr30bf_insn_sem, tend = t + sizeof (fr30bf_insn_sem) / sizeof (*t);
 296        t != tend; ++t)
 297     {
 298       init_idesc (cpu, & table[t->index], t);
 299     }
 300
 301   /* Link the IDESC table into the cpu.  */
 302   CPU_IDESC (cpu) = table;
 303 }
 304
 305 /* Enum declaration for all instruction semantic formats.  */
 306 typedef enum sfmt {
 307   FMT_EMPTY, FMT_ADD, FMT_ADDI, FMT_ADD2
 308  , FMT_ADDC, FMT_ADDN, FMT_ADDNI, FMT_ADDN2
 309  , FMT_CMP, FMT_CMPI, FMT_CMP2, FMT_AND
 310  , FMT_ANDM, FMT_ANDH, FMT_ANDB, FMT_BANDL
 311  , FMT_BTSTL, FMT_MUL, FMT_MULU, FMT_MULH
 312  , FMT_DIV0S, FMT_DIV0U, FMT_DIV1, FMT_DIV2
 313  , FMT_DIV3, FMT_DIV4S, FMT_LSL, FMT_LSLI
 314  , FMT_LDI8, FMT_LDI20, FMT_LDI32, FMT_LD
 315  , FMT_LDUH, FMT_LDUB, FMT_LDR13, FMT_LDR13UH
 316  , FMT_LDR13UB, FMT_LDR14, FMT_LDR14UH, FMT_LDR14UB
 317  , FMT_LDR15, FMT_LDR15GR, FMT_LDR15DR, FMT_LDR15PS
 318  , FMT_ST, FMT_STH, FMT_STB, FMT_STR13
 319  , FMT_STR13H, FMT_STR13B, FMT_STR14, FMT_STR14H
 320  , FMT_STR14B, FMT_STR15, FMT_STR15GR, FMT_STR15DR
 321  , FMT_STR15PS, FMT_MOV, FMT_MOVDR, FMT_MOVPS
 322  , FMT_MOV2DR, FMT_MOV2PS, FMT_JMP, FMT_CALLR
 323  , FMT_CALL, FMT_RET, FMT_INT, FMT_INTE
 324  , FMT_RETI, FMT_BRAD, FMT_BNOD, FMT_BEQD
 325  , FMT_BCD, FMT_BND, FMT_BVD, FMT_BLTD
 326  , FMT_BLED, FMT_BLSD, FMT_DMOVR13, FMT_DMOVR13H
 327  , FMT_DMOVR13B, FMT_DMOVR13PI, FMT_DMOVR13PIH, FMT_DMOVR13PIB
 328  , FMT_DMOVR15PI, FMT_DMOV2R13, FMT_DMOV2R13H, FMT_DMOV2R13B
 329  , FMT_DMOV2R13PI, FMT_DMOV2R13PIH, FMT_DMOV2R13PIB, FMT_DMOV2R15PD
 330  , FMT_LDRES, FMT_COPOP, FMT_COPLD, FMT_COPST
 331  , FMT_NOP, FMT_ANDCCR, FMT_STILM, FMT_ADDSP
 332  , FMT_EXTSB, FMT_EXTUB, FMT_EXTSH, FMT_EXTUH
 333  , FMT_LDM0, FMT_LDM1, FMT_STM0, FMT_STM1
 334  , FMT_ENTER, FMT_LEAVE, FMT_XCHB
 335 } SFMT;
 336
 337 /* The decoder uses this to record insns and direct extraction handling.  */
 338
 339 typedef struct {
 340   const IDESC *idesc;
 341 #ifdef __GNUC__
 342   void *sfmt;
 343 #else
 344   enum sfmt sfmt;
 345 #endif
 346 } DECODE_DESC;
 347
 348 /* Macro to go from decode phase to extraction phase.  */
 349
 350 #ifdef __GNUC__
 351 #define GOTO_EXTRACT(id) goto *(id)->sfmt
 352 #else
 353 #define GOTO_EXTRACT(id) goto extract
 354 #endif
 355
 356 /* The decoder needs a slightly different computed goto switch control.  */
 357 #ifdef __GNUC__
 358 #define DECODE_SWITCH(N, X) goto *labels_##N[X];
 359 #else
 360 #define DECODE_SWITCH(N, X) switch (X)
 361 #endif
 362
 363 /* Given an instruction, return a pointer to its IDESC entry.  */
 364
 365 const IDESC *
 366 fr30bf_decode (SIM_CPU *current_cpu, IADDR pc,
 367               CGEN_INSN_INT base_insn,
 368               ARGBUF *abuf)
 369 {
 370   /* Result of decoder, used by extractor.  */
 371   const DECODE_DESC *idecode;
 372
 373   /* First decode the instruction.  */
 374
 375   {
 376 #define I(insn) & fr30bf_insn_data[CONCAT2 (FR30BF_,insn)]
 377 #ifdef __GNUC__
 378 #define E(fmt) && case_ex_##fmt
 379 #else
 380 #define E(fmt) fmt
 381 #endif
 382     CGEN_INSN_INT insn = base_insn;
 383     static const DECODE_DESC idecode_invalid = { I (INSN_X_INVALID), E (FMT_EMPTY) };
 384
 385     {
 386 #ifdef __GNUC__
 387       static const void *labels_0[256] = {
 388         && default_0, && default_0, && default_0, && default_0,
 389         && default_0, && default_0, && default_0, && case_0_7,
 390         && default_0, && default_0, && default_0, && default_0,
 391         && default_0, && default_0, && default_0, && default_0,
 392         && default_0, && default_0, && default_0, && default_0,
 393         && default_0, && default_0, && default_0, && case_0_23,
 394         && default_0, && default_0, && default_0, && default_0,
 395         && default_0, && default_0, && default_0, && default_0,
 396         && default_0, && default_0, && default_0, && default_0,
 397         && default_0, && default_0, && default_0, && default_0,
 398         && default_0, && default_0, && default_0, && default_0,
 399         && default_0, && default_0, && default_0, && default_0,
 400         && default_0, && default_0, && default_0, && default_0,
 401         && default_0, && default_0, && default_0, && default_0,
 402         && default_0, && default_0, && default_0, && default_0,
 403         && default_0, && default_0, && default_0, && default_0,
 404         && default_0, && default_0, && default_0, && default_0,
 405         && default_0, && default_0, && default_0, && default_0,
 406         && default_0, && default_0, && default_0, && default_0,
 407         && default_0, && default_0, && default_0, && default_0,
 408         && default_0, && default_0, && default_0, && default_0,
 409         && default_0, && default_0, && default_0, && default_0,
 410         && default_0, && default_0, && default_0, && default_0,
 411         && default_0, && default_0, && default_0, && default_0,
 412         && default_0, && default_0, && default_0, && default_0,
 413         && default_0, && default_0, && default_0, && default_0,
 414         && default_0, && default_0, && default_0, && default_0,
 415         && default_0, && default_0, && default_0, && default_0,
 416         && default_0, && default_0, && default_0, && default_0,
 417         && default_0, && default_0, && default_0, && default_0,
 418         && default_0, && default_0, && default_0, && default_0,
 419         && default_0, && default_0, && default_0, && default_0,
 420         && default_0, && default_0, && default_0, && default_0,
 421         && default_0, && default_0, && default_0, && default_0,
 422         && default_0, && default_0, && default_0, && default_0,
 423         && default_0, && default_0, && default_0, && default_0,
 424         && default_0, && default_0, && default_0, && default_0,
 425         && default_0, && default_0, && default_0, && case_0_151,
 426         && default_0, && default_0, && default_0, && default_0,
 427         && default_0, && default_0, && default_0, && case_0_159,
 428         && default_0, && default_0, && default_0, && default_0,
 429         && default_0, && default_0, && default_0, && default_0,
 430         && default_0, && default_0, && default_0, && default_0,
 431         && default_0, && default_0, && default_0, && default_0,
 432         && default_0, && default_0, && default_0, && default_0,
 433         && default_0, && default_0, && default_0, && default_0,
 434         && default_0, && default_0, && default_0, && default_0,
 435         && default_0, && default_0, && default_0, && default_0,
 436         && default_0, && default_0, && default_0, && default_0,
 437         && default_0, && default_0, && default_0, && default_0,
 438         && default_0, && default_0, && default_0, && default_0,
 439         && default_0, && default_0, && default_0, && default_0,
 440         && default_0, && default_0, && default_0, && default_0,
 441         && default_0, && default_0, && default_0, && default_0,
 442         && default_0, && default_0, && default_0, && default_0,
 443         && default_0, && default_0, && default_0, && default_0,
 444         && default_0, && default_0, && default_0, && default_0,
 445         && default_0, && default_0, && default_0, && default_0,
 446         && default_0, && default_0, && default_0, && default_0,
 447         && default_0, && default_0, && default_0, && default_0,
 448         && default_0, && default_0, && default_0, && default_0,
 449         && default_0, && default_0, && default_0, && default_0,
 450         && default_0, && default_0, && default_0, && default_0,
 451         && default_0, && default_0, && default_0, && default_0,
 452       };
 453 #endif
 454       static const DECODE_DESC insns[256] = {
 455         { I (INSN_LDR13), E (FMT_LDR13) }, { I (INSN_LDR13UH), E (FMT_LDR13UH) },
 456         { I (INSN_LDR13UB), E (FMT_LDR13UB) }, { I (INSN_LDR15), E (FMT_LDR15) },
 457         { I (INSN_LD), E (FMT_LD) }, { I (INSN_LDUH), E (FMT_LDUH) },
 458         { I (INSN_LDUB), E (FMT_LDUB) }, { 0 },
 459         { I (INSN_DMOV2R13), E (FMT_DMOV2R13) }, { I (INSN_DMOV2R13H), E (FMT_DMOV2R13H) },
 460         { I (INSN_DMOV2R13B), E (FMT_DMOV2R13B) }, { I (INSN_DMOV2R15PD), E (FMT_DMOV2R15PD) },
 461         { I (INSN_DMOV2R13PI), E (FMT_DMOV2R13PI) }, { I (INSN_DMOV2R13PIH), E (FMT_DMOV2R13PIH) },
 462         { I (INSN_DMOV2R13PIB), E (FMT_DMOV2R13PIB) }, { I (INSN_ENTER), E (FMT_ENTER) },
 463         { I (INSN_STR13), E (FMT_STR13) }, { I (INSN_STR13H), E (FMT_STR13H) },
 464         { I (INSN_STR13B), E (FMT_STR13B) }, { I (INSN_STR15), E (FMT_STR15) },
 465         { I (INSN_ST), E (FMT_ST) }, { I (INSN_STH), E (FMT_STH) },
 466         { I (INSN_STB), E (FMT_STB) }, { 0 },
 467         { I (INSN_DMOVR13), E (FMT_DMOVR13) }, { I (INSN_DMOVR13H), E (FMT_DMOVR13H) },
 468         { I (INSN_DMOVR13B), E (FMT_DMOVR13B) }, { I (INSN_DMOVR15PI), E (FMT_DMOVR15PI) },
 469         { I (INSN_DMOVR13PI), E (FMT_DMOVR13PI) }, { I (INSN_DMOVR13PIH), E (FMT_DMOVR13PIH) },
 470         { I (INSN_DMOVR13PIB), E (FMT_DMOVR13PIB) }, { I (INSN_INT), E (FMT_INT) },
 471         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 472         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 473         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 474         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 475         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 476         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 477         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 478         { I (INSN_LDR14), E (FMT_LDR14) }, { I (INSN_LDR14), E (FMT_LDR14) },
 479         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 480         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 481         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 482         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 483         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 484         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 485         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 486         { I (INSN_STR14), E (FMT_STR14) }, { I (INSN_STR14), E (FMT_STR14) },
 487         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 488         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 489         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 490         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 491         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 492         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 493         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 494         { I (INSN_LDR14UH), E (FMT_LDR14UH) }, { I (INSN_LDR14UH), E (FMT_LDR14UH) },
 495         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 496         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 497         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 498         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 499         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 500         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 501         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 502         { I (INSN_STR14H), E (FMT_STR14H) }, { I (INSN_STR14H), E (FMT_STR14H) },
 503         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 504         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 505         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 506         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 507         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 508         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 509         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 510         { I (INSN_LDR14UB), E (FMT_LDR14UB) }, { I (INSN_LDR14UB), E (FMT_LDR14UB) },
 511         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 512         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 513         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 514         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 515         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 516         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 517         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 518         { I (INSN_STR14B), E (FMT_STR14B) }, { I (INSN_STR14B), E (FMT_STR14B) },
 519         { I (INSN_BANDL), E (FMT_BANDL) }, { I (INSN_BANDH), E (FMT_BANDL) },
 520         { I (INSN_AND), E (FMT_AND) }, { I (INSN_ANDCCR), E (FMT_ANDCCR) },
 521         { I (INSN_ANDM), E (FMT_ANDM) }, { I (INSN_ANDH), E (FMT_ANDH) },
 522         { I (INSN_ANDB), E (FMT_ANDB) }, { I (INSN_STILM), E (FMT_STILM) },
 523         { I (INSN_BTSTL), E (FMT_BTSTL) }, { I (INSN_BTSTH), E (FMT_BTSTL) },
 524         { I (INSN_XCHB), E (FMT_XCHB) }, { I (INSN_MOV), E (FMT_MOV) },
 525         { I (INSN_LDM0), E (FMT_LDM0) }, { I (INSN_LDM1), E (FMT_LDM1) },
 526         { I (INSN_STM0), E (FMT_STM0) }, { I (INSN_STM1), E (FMT_STM1) },
 527         { I (INSN_BORL), E (FMT_BANDL) }, { I (INSN_BORH), E (FMT_BANDL) },
 528         { I (INSN_OR), E (FMT_AND) }, { I (INSN_ORCCR), E (FMT_ANDCCR) },
 529         { I (INSN_ORM), E (FMT_ANDM) }, { I (INSN_ORH), E (FMT_ANDH) },
 530         { I (INSN_ORB), E (FMT_ANDB) }, { 0 },
 531         { I (INSN_BEORL), E (FMT_BANDL) }, { I (INSN_BEORH), E (FMT_BANDL) },
 532         { I (INSN_EOR), E (FMT_AND) }, { I (INSN_LDI20), E (FMT_LDI20) },
 533         { I (INSN_EORM), E (FMT_ANDM) }, { I (INSN_EORH), E (FMT_ANDH) },
 534         { I (INSN_EORB), E (FMT_ANDB) }, { 0 },
 535         { I (INSN_ADDNI), E (FMT_ADDNI) }, { I (INSN_ADDN2), E (FMT_ADDN2) },
 536         { I (INSN_ADDN), E (FMT_ADDN) }, { I (INSN_ADDSP), E (FMT_ADDSP) },
 537         { I (INSN_ADDI), E (FMT_ADDI) }, { I (INSN_ADD2), E (FMT_ADD2) },
 538         { I (INSN_ADD), E (FMT_ADD) }, { I (INSN_ADDC), E (FMT_ADDC) },
 539         { I (INSN_CMPI), E (FMT_CMPI) }, { I (INSN_CMP2), E (FMT_CMP2) },
 540         { I (INSN_CMP), E (FMT_CMP) }, { I (INSN_MULU), E (FMT_MULU) },
 541         { I (INSN_SUB), E (FMT_ADD) }, { I (INSN_SUBC), E (FMT_ADDC) },
 542         { I (INSN_SUBN), E (FMT_ADDN) }, { I (INSN_MUL), E (FMT_MUL) },
 543         { I (INSN_LSRI), E (FMT_LSLI) }, { I (INSN_LSR2), E (FMT_LSLI) },
 544         { I (INSN_LSR), E (FMT_LSL) }, { I (INSN_MOV2DR), E (FMT_MOV2DR) },
 545         { I (INSN_LSLI), E (FMT_LSLI) }, { I (INSN_LSL2), E (FMT_LSLI) },
 546         { I (INSN_LSL), E (FMT_LSL) }, { I (INSN_MOVDR), E (FMT_MOVDR) },
 547         { I (INSN_ASRI), E (FMT_LSLI) }, { I (INSN_ASR2), E (FMT_LSLI) },
 548         { I (INSN_ASR), E (FMT_LSL) }, { I (INSN_MULUH), E (FMT_MULH) },
 549         { I (INSN_LDRES), E (FMT_LDRES) }, { I (INSN_STRES), E (FMT_LDRES) },
 550         { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_MULH), E (FMT_MULH) },
 551         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 552         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 553         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 554         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 555         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 556         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 557         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 558         { I (INSN_LDI8), E (FMT_LDI8) }, { I (INSN_LDI8), E (FMT_LDI8) },
 559         { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) },
 560         { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) },
 561         { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) },
 562         { I (INSN_CALL), E (FMT_CALL) }, { I (INSN_CALL), E (FMT_CALL) },
 563         { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) },
 564         { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) },
 565         { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) },
 566         { I (INSN_CALLD), E (FMT_CALL) }, { I (INSN_CALLD), E (FMT_CALL) },
 567         { I (INSN_BRA), E (FMT_BRAD) }, { I (INSN_BNO), E (FMT_BNOD) },
 568         { I (INSN_BEQ), E (FMT_BEQD) }, { I (INSN_BNE), E (FMT_BEQD) },
 569         { I (INSN_BC), E (FMT_BCD) }, { I (INSN_BNC), E (FMT_BCD) },
 570         { I (INSN_BN), E (FMT_BND) }, { I (INSN_BP), E (FMT_BND) },
 571         { I (INSN_BV), E (FMT_BVD) }, { I (INSN_BNV), E (FMT_BVD) },
 572         { I (INSN_BLT), E (FMT_BLTD) }, { I (INSN_BGE), E (FMT_BLTD) },
 573         { I (INSN_BLE), E (FMT_BLED) }, { I (INSN_BGT), E (FMT_BLED) },
 574         { I (INSN_BLS), E (FMT_BLSD) }, { I (INSN_BHI), E (FMT_BLSD) },
 575         { I (INSN_BRAD), E (FMT_BRAD) }, { I (INSN_BNOD), E (FMT_BNOD) },
 576         { I (INSN_BEQD), E (FMT_BEQD) }, { I (INSN_BNED), E (FMT_BEQD) },
 577         { I (INSN_BCD), E (FMT_BCD) }, { I (INSN_BNCD), E (FMT_BCD) },
 578         { I (INSN_BND), E (FMT_BND) }, { I (INSN_BPD), E (FMT_BND) },
 579         { I (INSN_BVD), E (FMT_BVD) }, { I (INSN_BNVD), E (FMT_BVD) },
 580         { I (INSN_BLTD), E (FMT_BLTD) }, { I (INSN_BGED), E (FMT_BLTD) },
 581         { I (INSN_BLED), E (FMT_BLED) }, { I (INSN_BGTD), E (FMT_BLED) },
 582         { I (INSN_BLSD), E (FMT_BLSD) }, { I (INSN_BHID), E (FMT_BLSD) },
 583       };
 584       unsigned int val;
 585       val = (((insn >> 8) & (255 << 0)));
 586       DECODE_SWITCH (0, val)
 587         {
 588         CASE (0, 7) :
 589           {
 590             static const DECODE_DESC insns[16] = {
 591               { I (INSN_LDR15GR), E (FMT_LDR15GR) }, { I (INSN_MOV2PS), E (FMT_MOV2PS) },
 592               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 593               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 594               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 595               { I (INSN_LDR15DR), E (FMT_LDR15DR) }, { I (INSN_LDR15PS), E (FMT_LDR15PS) },
 596               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 597               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 598               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 599             };
 600             unsigned int val = (((insn >> 4) & (15 << 0)));
 601             idecode = &insns[val];
 602             GOTO_EXTRACT (idecode);
 603           }
 604         CASE (0, 23) :
 605           {
 606             static const DECODE_DESC insns[16] = {
 607               { I (INSN_STR15GR), E (FMT_STR15GR) }, { I (INSN_MOVPS), E (FMT_MOVPS) },
 608               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 609               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 610               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 611               { I (INSN_STR15DR), E (FMT_STR15DR) }, { I (INSN_STR15PS), E (FMT_STR15PS) },
 612               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 613               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 614               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 615             };
 616             unsigned int val = (((insn >> 4) & (15 << 0)));
 617             idecode = &insns[val];
 618             GOTO_EXTRACT (idecode);
 619           }
 620         CASE (0, 151) :
 621           {
 622             static const DECODE_DESC insns[16] = {
 623               { I (INSN_JMP), E (FMT_JMP) }, { I (INSN_CALLR), E (FMT_CALLR) },
 624               { I (INSN_RET), E (FMT_RET) }, { I (INSN_RETI), E (FMT_RETI) },
 625               { I (INSN_DIV0S), E (FMT_DIV0S) }, { I (INSN_DIV0U), E (FMT_DIV0U) },
 626               { I (INSN_DIV1), E (FMT_DIV1) }, { I (INSN_DIV2), E (FMT_DIV2) },
 627               { I (INSN_EXTSB), E (FMT_EXTSB) }, { I (INSN_EXTUB), E (FMT_EXTUB) },
 628               { I (INSN_EXTSH), E (FMT_EXTSH) }, { I (INSN_EXTUH), E (FMT_EXTUH) },
 629               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 630               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 631             };
 632             unsigned int val = (((insn >> 4) & (15 << 0)));
 633             idecode = &insns[val];
 634             GOTO_EXTRACT (idecode);
 635           }
 636         CASE (0, 159) :
 637           {
 638             static const DECODE_DESC insns[16] = {
 639               { I (INSN_JMPD), E (FMT_JMP) }, { I (INSN_CALLRD), E (FMT_CALLR) },
 640               { I (INSN_RET_D), E (FMT_RET) }, { I (INSN_INTE), E (FMT_INTE) },
 641               { I (INSN_X_INVALID), E (FMT_EMPTY) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 642               { I (INSN_DIV3), E (FMT_DIV3) }, { I (INSN_DIV4S), E (FMT_DIV4S) },
 643               { I (INSN_LDI32), E (FMT_LDI32) }, { I (INSN_LEAVE), E (FMT_LEAVE) },
 644               { I (INSN_NOP), E (FMT_NOP) }, { I (INSN_X_INVALID), E (FMT_EMPTY) },
 645               { I (INSN_COPOP), E (FMT_COPOP) }, { I (INSN_COPLD), E (FMT_COPLD) },
 646               { I (INSN_COPST), E (FMT_COPST) }, { I (INSN_COPSV), E (FMT_COPST) },
 647             };
 648             unsigned int val = (((insn >> 4) & (15 << 0)));
 649             idecode = &insns[val];
 650             GOTO_EXTRACT (idecode);
 651           }
 652         DEFAULT (0) :
 653           idecode = &insns[val];
 654           GOTO_EXTRACT (idecode);
 655         }
 656       ENDSWITCH (0)
 657     }
 658 #undef I
 659 #undef E
 660   }
 661
 662   /* The instruction has been decoded, now extract the fields.  */
 663
 664  extract:
 665   {
 666 #ifndef __GNUC__
 667     switch (idecode->sfmt)
 668 #endif
 669       {
 670
 671   CASE (ex, FMT_EMPTY) :
 672   {
 673     CGEN_INSN_INT insn = base_insn;
 674 #define FLD(f) abuf->fields.fmt_empty.f
 675   EXTRACT_IFMT_EMPTY_VARS /* */
 676
 677   EXTRACT_IFMT_EMPTY_CODE
 678
 679   /* Record the fields for the semantic handler.  */
 680   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_empty", (char *) 0));
 681
 682 #undef FLD
 683   BREAK (ex);
 684   }
 685
 686   CASE (ex, FMT_ADD) :
 687   {
 688     CGEN_INSN_INT insn = base_insn;
 689 #define FLD(f) abuf->fields.fmt_add.f
 690   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 691
 692   EXTRACT_IFMT_ADD_CODE
 693
 694   /* Record the fields for the semantic handler.  */
 695   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 696   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 697   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_add", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 698
 699 #if WITH_PROFILE_MODEL_P
 700   /* Record the fields for profiling.  */
 701   if (PROFILE_MODEL_P (current_cpu))
 702     {
 703       FLD (in_Ri) = f_Ri;
 704       FLD (in_Rj) = f_Rj;
 705       FLD (out_Ri) = f_Ri;
 706     }
 707 #endif
 708 #undef FLD
 709   BREAK (ex);
 710   }
 711
 712   CASE (ex, FMT_ADDI) :
 713   {
 714     CGEN_INSN_INT insn = base_insn;
 715 #define FLD(f) abuf->fields.fmt_addi.f
 716   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
 717
 718   EXTRACT_IFMT_ADDI_CODE
 719
 720   /* Record the fields for the semantic handler.  */
 721   FLD (f_u4) = f_u4;
 722   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 723   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addi", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 724
 725 #if WITH_PROFILE_MODEL_P
 726   /* Record the fields for profiling.  */
 727   if (PROFILE_MODEL_P (current_cpu))
 728     {
 729       FLD (in_Ri) = f_Ri;
 730       FLD (out_Ri) = f_Ri;
 731     }
 732 #endif
 733 #undef FLD
 734   BREAK (ex);
 735   }
 736
 737   CASE (ex, FMT_ADD2) :
 738   {
 739     CGEN_INSN_INT insn = base_insn;
 740 #define FLD(f) abuf->fields.fmt_add2.f
 741   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
 742
 743   EXTRACT_IFMT_ADD2_CODE
 744
 745   /* Record the fields for the semantic handler.  */
 746   FLD (f_m4) = f_m4;
 747   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 748   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_add2", "f_m4 0x%x", 'x', f_m4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 749
 750 #if WITH_PROFILE_MODEL_P
 751   /* Record the fields for profiling.  */
 752   if (PROFILE_MODEL_P (current_cpu))
 753     {
 754       FLD (in_Ri) = f_Ri;
 755       FLD (out_Ri) = f_Ri;
 756     }
 757 #endif
 758 #undef FLD
 759   BREAK (ex);
 760   }
 761
 762   CASE (ex, FMT_ADDC) :
 763   {
 764     CGEN_INSN_INT insn = base_insn;
 765 #define FLD(f) abuf->fields.fmt_addc.f
 766   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 767
 768   EXTRACT_IFMT_ADD_CODE
 769
 770   /* Record the fields for the semantic handler.  */
 771   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 772   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 773   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addc", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 774
 775 #if WITH_PROFILE_MODEL_P
 776   /* Record the fields for profiling.  */
 777   if (PROFILE_MODEL_P (current_cpu))
 778     {
 779       FLD (in_Ri) = f_Ri;
 780       FLD (in_Rj) = f_Rj;
 781       FLD (out_Ri) = f_Ri;
 782     }
 783 #endif
 784 #undef FLD
 785   BREAK (ex);
 786   }
 787
 788   CASE (ex, FMT_ADDN) :
 789   {
 790     CGEN_INSN_INT insn = base_insn;
 791 #define FLD(f) abuf->fields.fmt_addn.f
 792   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 793
 794   EXTRACT_IFMT_ADD_CODE
 795
 796   /* Record the fields for the semantic handler.  */
 797   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 798   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 799   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addn", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 800
 801 #if WITH_PROFILE_MODEL_P
 802   /* Record the fields for profiling.  */
 803   if (PROFILE_MODEL_P (current_cpu))
 804     {
 805       FLD (in_Ri) = f_Ri;
 806       FLD (in_Rj) = f_Rj;
 807       FLD (out_Ri) = f_Ri;
 808     }
 809 #endif
 810 #undef FLD
 811   BREAK (ex);
 812   }
 813
 814   CASE (ex, FMT_ADDNI) :
 815   {
 816     CGEN_INSN_INT insn = base_insn;
 817 #define FLD(f) abuf->fields.fmt_addni.f
 818   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
 819
 820   EXTRACT_IFMT_ADDI_CODE
 821
 822   /* Record the fields for the semantic handler.  */
 823   FLD (f_u4) = f_u4;
 824   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 825   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addni", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 826
 827 #if WITH_PROFILE_MODEL_P
 828   /* Record the fields for profiling.  */
 829   if (PROFILE_MODEL_P (current_cpu))
 830     {
 831       FLD (in_Ri) = f_Ri;
 832       FLD (out_Ri) = f_Ri;
 833     }
 834 #endif
 835 #undef FLD
 836   BREAK (ex);
 837   }
 838
 839   CASE (ex, FMT_ADDN2) :
 840   {
 841     CGEN_INSN_INT insn = base_insn;
 842 #define FLD(f) abuf->fields.fmt_addn2.f
 843   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
 844
 845   EXTRACT_IFMT_ADD2_CODE
 846
 847   /* Record the fields for the semantic handler.  */
 848   FLD (f_m4) = f_m4;
 849   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 850   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addn2", "f_m4 0x%x", 'x', f_m4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 851
 852 #if WITH_PROFILE_MODEL_P
 853   /* Record the fields for profiling.  */
 854   if (PROFILE_MODEL_P (current_cpu))
 855     {
 856       FLD (in_Ri) = f_Ri;
 857       FLD (out_Ri) = f_Ri;
 858     }
 859 #endif
 860 #undef FLD
 861   BREAK (ex);
 862   }
 863
 864   CASE (ex, FMT_CMP) :
 865   {
 866     CGEN_INSN_INT insn = base_insn;
 867 #define FLD(f) abuf->fields.fmt_cmp.f
 868   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 869
 870   EXTRACT_IFMT_ADD_CODE
 871
 872   /* Record the fields for the semantic handler.  */
 873   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 874   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 875   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_cmp", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 876
 877 #if WITH_PROFILE_MODEL_P
 878   /* Record the fields for profiling.  */
 879   if (PROFILE_MODEL_P (current_cpu))
 880     {
 881       FLD (in_Ri) = f_Ri;
 882       FLD (in_Rj) = f_Rj;
 883     }
 884 #endif
 885 #undef FLD
 886   BREAK (ex);
 887   }
 888
 889   CASE (ex, FMT_CMPI) :
 890   {
 891     CGEN_INSN_INT insn = base_insn;
 892 #define FLD(f) abuf->fields.fmt_cmpi.f
 893   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
 894
 895   EXTRACT_IFMT_ADDI_CODE
 896
 897   /* Record the fields for the semantic handler.  */
 898   FLD (f_u4) = f_u4;
 899   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 900   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_cmpi", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 901
 902 #if WITH_PROFILE_MODEL_P
 903   /* Record the fields for profiling.  */
 904   if (PROFILE_MODEL_P (current_cpu))
 905     {
 906       FLD (in_Ri) = f_Ri;
 907     }
 908 #endif
 909 #undef FLD
 910   BREAK (ex);
 911   }
 912
 913   CASE (ex, FMT_CMP2) :
 914   {
 915     CGEN_INSN_INT insn = base_insn;
 916 #define FLD(f) abuf->fields.fmt_cmp2.f
 917   EXTRACT_IFMT_ADD2_VARS /* f-op1 f-op2 f-m4 f-Ri */
 918
 919   EXTRACT_IFMT_ADD2_CODE
 920
 921   /* Record the fields for the semantic handler.  */
 922   FLD (f_m4) = f_m4;
 923   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 924   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_cmp2", "f_m4 0x%x", 'x', f_m4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
 925
 926 #if WITH_PROFILE_MODEL_P
 927   /* Record the fields for profiling.  */
 928   if (PROFILE_MODEL_P (current_cpu))
 929     {
 930       FLD (in_Ri) = f_Ri;
 931     }
 932 #endif
 933 #undef FLD
 934   BREAK (ex);
 935   }
 936
 937   CASE (ex, FMT_AND) :
 938   {
 939     CGEN_INSN_INT insn = base_insn;
 940 #define FLD(f) abuf->fields.fmt_and.f
 941   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 942
 943   EXTRACT_IFMT_ADD_CODE
 944
 945   /* Record the fields for the semantic handler.  */
 946   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 947   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 948   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_and", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 949
 950 #if WITH_PROFILE_MODEL_P
 951   /* Record the fields for profiling.  */
 952   if (PROFILE_MODEL_P (current_cpu))
 953     {
 954       FLD (in_Ri) = f_Ri;
 955       FLD (in_Rj) = f_Rj;
 956       FLD (out_Ri) = f_Ri;
 957     }
 958 #endif
 959 #undef FLD
 960   BREAK (ex);
 961   }
 962
 963   CASE (ex, FMT_ANDM) :
 964   {
 965     CGEN_INSN_INT insn = base_insn;
 966 #define FLD(f) abuf->fields.fmt_andm.f
 967   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 968
 969   EXTRACT_IFMT_ADD_CODE
 970
 971   /* Record the fields for the semantic handler.  */
 972   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 973   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 974   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_andm", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
 975
 976 #if WITH_PROFILE_MODEL_P
 977   /* Record the fields for profiling.  */
 978   if (PROFILE_MODEL_P (current_cpu))
 979     {
 980       FLD (in_Ri) = f_Ri;
 981       FLD (in_Rj) = f_Rj;
 982     }
 983 #endif
 984 #undef FLD
 985   BREAK (ex);
 986   }
 987
 988   CASE (ex, FMT_ANDH) :
 989   {
 990     CGEN_INSN_INT insn = base_insn;
 991 #define FLD(f) abuf->fields.fmt_andh.f
 992   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
 993
 994   EXTRACT_IFMT_ADD_CODE
 995
 996   /* Record the fields for the semantic handler.  */
 997   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
 998   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
 999   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_andh", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1000
1001 #if WITH_PROFILE_MODEL_P
1002   /* Record the fields for profiling.  */
1003   if (PROFILE_MODEL_P (current_cpu))
1004     {
1005       FLD (in_Ri) = f_Ri;
1006       FLD (in_Rj) = f_Rj;
1007     }
1008 #endif
1009 #undef FLD
1010   BREAK (ex);
1011   }
1012
1013   CASE (ex, FMT_ANDB) :
1014   {
1015     CGEN_INSN_INT insn = base_insn;
1016 #define FLD(f) abuf->fields.fmt_andb.f
1017   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1018
1019   EXTRACT_IFMT_ADD_CODE
1020
1021   /* Record the fields for the semantic handler.  */
1022   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1023   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1024   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_andb", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1025
1026 #if WITH_PROFILE_MODEL_P
1027   /* Record the fields for profiling.  */
1028   if (PROFILE_MODEL_P (current_cpu))
1029     {
1030       FLD (in_Ri) = f_Ri;
1031       FLD (in_Rj) = f_Rj;
1032     }
1033 #endif
1034 #undef FLD
1035   BREAK (ex);
1036   }
1037
1038   CASE (ex, FMT_BANDL) :
1039   {
1040     CGEN_INSN_INT insn = base_insn;
1041 #define FLD(f) abuf->fields.fmt_bandl.f
1042   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
1043
1044   EXTRACT_IFMT_ADDI_CODE
1045
1046   /* Record the fields for the semantic handler.  */
1047   FLD (f_u4) = f_u4;
1048   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1049   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bandl", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1050
1051 #if WITH_PROFILE_MODEL_P
1052   /* Record the fields for profiling.  */
1053   if (PROFILE_MODEL_P (current_cpu))
1054     {
1055       FLD (in_Ri) = f_Ri;
1056     }
1057 #endif
1058 #undef FLD
1059   BREAK (ex);
1060   }
1061
1062   CASE (ex, FMT_BTSTL) :
1063   {
1064     CGEN_INSN_INT insn = base_insn;
1065 #define FLD(f) abuf->fields.fmt_btstl.f
1066   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
1067
1068   EXTRACT_IFMT_ADDI_CODE
1069
1070   /* Record the fields for the semantic handler.  */
1071   FLD (f_u4) = f_u4;
1072   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1073   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_btstl", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1074
1075 #if WITH_PROFILE_MODEL_P
1076   /* Record the fields for profiling.  */
1077   if (PROFILE_MODEL_P (current_cpu))
1078     {
1079       FLD (in_Ri) = f_Ri;
1080     }
1081 #endif
1082 #undef FLD
1083   BREAK (ex);
1084   }
1085
1086   CASE (ex, FMT_MUL) :
1087   {
1088     CGEN_INSN_INT insn = base_insn;
1089 #define FLD(f) abuf->fields.fmt_mul.f
1090   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1091
1092   EXTRACT_IFMT_ADD_CODE
1093
1094   /* Record the fields for the semantic handler.  */
1095   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1096   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1097   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mul", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1098
1099 #if WITH_PROFILE_MODEL_P
1100   /* Record the fields for profiling.  */
1101   if (PROFILE_MODEL_P (current_cpu))
1102     {
1103       FLD (in_Ri) = f_Ri;
1104       FLD (in_Rj) = f_Rj;
1105     }
1106 #endif
1107 #undef FLD
1108   BREAK (ex);
1109   }
1110
1111   CASE (ex, FMT_MULU) :
1112   {
1113     CGEN_INSN_INT insn = base_insn;
1114 #define FLD(f) abuf->fields.fmt_mulu.f
1115   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1116
1117   EXTRACT_IFMT_ADD_CODE
1118
1119   /* Record the fields for the semantic handler.  */
1120   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1121   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1122   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mulu", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1123
1124 #if WITH_PROFILE_MODEL_P
1125   /* Record the fields for profiling.  */
1126   if (PROFILE_MODEL_P (current_cpu))
1127     {
1128       FLD (in_Ri) = f_Ri;
1129       FLD (in_Rj) = f_Rj;
1130     }
1131 #endif
1132 #undef FLD
1133   BREAK (ex);
1134   }
1135
1136   CASE (ex, FMT_MULH) :
1137   {
1138     CGEN_INSN_INT insn = base_insn;
1139 #define FLD(f) abuf->fields.fmt_mulh.f
1140   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1141
1142   EXTRACT_IFMT_ADD_CODE
1143
1144   /* Record the fields for the semantic handler.  */
1145   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1146   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1147   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mulh", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1148
1149 #if WITH_PROFILE_MODEL_P
1150   /* Record the fields for profiling.  */
1151   if (PROFILE_MODEL_P (current_cpu))
1152     {
1153       FLD (in_Ri) = f_Ri;
1154       FLD (in_Rj) = f_Rj;
1155     }
1156 #endif
1157 #undef FLD
1158   BREAK (ex);
1159   }
1160
1161   CASE (ex, FMT_DIV0S) :
1162   {
1163     CGEN_INSN_INT insn = base_insn;
1164 #define FLD(f) abuf->fields.fmt_div0s.f
1165   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1166
1167   EXTRACT_IFMT_DIV0S_CODE
1168
1169   /* Record the fields for the semantic handler.  */
1170   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1171   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div0s", "Ri 0x%x", 'x', f_Ri, (char *) 0));
1172
1173 #if WITH_PROFILE_MODEL_P
1174   /* Record the fields for profiling.  */
1175   if (PROFILE_MODEL_P (current_cpu))
1176     {
1177       FLD (in_Ri) = f_Ri;
1178     }
1179 #endif
1180 #undef FLD
1181   BREAK (ex);
1182   }
1183
1184   CASE (ex, FMT_DIV0U) :
1185   {
1186     CGEN_INSN_INT insn = base_insn;
1187 #define FLD(f) abuf->fields.fmt_div0u.f
1188   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1189
1190   EXTRACT_IFMT_DIV0S_CODE
1191
1192   /* Record the fields for the semantic handler.  */
1193   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div0u", (char *) 0));
1194
1195 #undef FLD
1196   BREAK (ex);
1197   }
1198
1199   CASE (ex, FMT_DIV1) :
1200   {
1201     CGEN_INSN_INT insn = base_insn;
1202 #define FLD(f) abuf->fields.fmt_div1.f
1203   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1204
1205   EXTRACT_IFMT_DIV0S_CODE
1206
1207   /* Record the fields for the semantic handler.  */
1208   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1209   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div1", "Ri 0x%x", 'x', f_Ri, (char *) 0));
1210
1211 #if WITH_PROFILE_MODEL_P
1212   /* Record the fields for profiling.  */
1213   if (PROFILE_MODEL_P (current_cpu))
1214     {
1215       FLD (in_Ri) = f_Ri;
1216     }
1217 #endif
1218 #undef FLD
1219   BREAK (ex);
1220   }
1221
1222   CASE (ex, FMT_DIV2) :
1223   {
1224     CGEN_INSN_INT insn = base_insn;
1225 #define FLD(f) abuf->fields.fmt_div2.f
1226   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1227
1228   EXTRACT_IFMT_DIV0S_CODE
1229
1230   /* Record the fields for the semantic handler.  */
1231   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1232   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div2", "Ri 0x%x", 'x', f_Ri, (char *) 0));
1233
1234 #if WITH_PROFILE_MODEL_P
1235   /* Record the fields for profiling.  */
1236   if (PROFILE_MODEL_P (current_cpu))
1237     {
1238       FLD (in_Ri) = f_Ri;
1239     }
1240 #endif
1241 #undef FLD
1242   BREAK (ex);
1243   }
1244
1245   CASE (ex, FMT_DIV3) :
1246   {
1247     CGEN_INSN_INT insn = base_insn;
1248 #define FLD(f) abuf->fields.fmt_div3.f
1249   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
1250
1251   EXTRACT_IFMT_DIV3_CODE
1252
1253   /* Record the fields for the semantic handler.  */
1254   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div3", (char *) 0));
1255
1256 #undef FLD
1257   BREAK (ex);
1258   }
1259
1260   CASE (ex, FMT_DIV4S) :
1261   {
1262     CGEN_INSN_INT insn = base_insn;
1263 #define FLD(f) abuf->fields.fmt_div4s.f
1264   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
1265
1266   EXTRACT_IFMT_DIV3_CODE
1267
1268   /* Record the fields for the semantic handler.  */
1269   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_div4s", (char *) 0));
1270
1271 #undef FLD
1272   BREAK (ex);
1273   }
1274
1275   CASE (ex, FMT_LSL) :
1276   {
1277     CGEN_INSN_INT insn = base_insn;
1278 #define FLD(f) abuf->fields.fmt_lsl.f
1279   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1280
1281   EXTRACT_IFMT_ADD_CODE
1282
1283   /* Record the fields for the semantic handler.  */
1284   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1285   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1286   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_lsl", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1287
1288 #if WITH_PROFILE_MODEL_P
1289   /* Record the fields for profiling.  */
1290   if (PROFILE_MODEL_P (current_cpu))
1291     {
1292       FLD (in_Ri) = f_Ri;
1293       FLD (in_Rj) = f_Rj;
1294       FLD (out_Ri) = f_Ri;
1295     }
1296 #endif
1297 #undef FLD
1298   BREAK (ex);
1299   }
1300
1301   CASE (ex, FMT_LSLI) :
1302   {
1303     CGEN_INSN_INT insn = base_insn;
1304 #define FLD(f) abuf->fields.fmt_lsli.f
1305   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
1306
1307   EXTRACT_IFMT_ADDI_CODE
1308
1309   /* Record the fields for the semantic handler.  */
1310   FLD (f_u4) = f_u4;
1311   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1312   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_lsli", "f_u4 0x%x", 'x', f_u4, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1313
1314 #if WITH_PROFILE_MODEL_P
1315   /* Record the fields for profiling.  */
1316   if (PROFILE_MODEL_P (current_cpu))
1317     {
1318       FLD (in_Ri) = f_Ri;
1319       FLD (out_Ri) = f_Ri;
1320     }
1321 #endif
1322 #undef FLD
1323   BREAK (ex);
1324   }
1325
1326   CASE (ex, FMT_LDI8) :
1327   {
1328     CGEN_INSN_INT insn = base_insn;
1329 #define FLD(f) abuf->fields.fmt_ldi8.f
1330   EXTRACT_IFMT_LDI8_VARS /* f-op1 f-i8 f-Ri */
1331
1332   EXTRACT_IFMT_LDI8_CODE
1333
1334   /* Record the fields for the semantic handler.  */
1335   FLD (f_i8) = f_i8;
1336   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1337   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldi8", "f_i8 0x%x", 'x', f_i8, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1338
1339 #if WITH_PROFILE_MODEL_P
1340   /* Record the fields for profiling.  */
1341   if (PROFILE_MODEL_P (current_cpu))
1342     {
1343       FLD (out_Ri) = f_Ri;
1344     }
1345 #endif
1346 #undef FLD
1347   BREAK (ex);
1348   }
1349
1350   CASE (ex, FMT_LDI20) :
1351   {
1352     CGEN_INSN_INT insn = base_insn;
1353 #define FLD(f) abuf->fields.fmt_ldi20.f
1354   EXTRACT_IFMT_LDI20_VARS /* f-op1 f-i20 f-op2 f-Ri */
1355
1356   EXTRACT_IFMT_LDI20_CODE
1357
1358   /* Record the fields for the semantic handler.  */
1359   FLD (f_i20) = f_i20;
1360   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1361   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldi20", "f_i20 0x%x", 'x', f_i20, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1362
1363 #if WITH_PROFILE_MODEL_P
1364   /* Record the fields for profiling.  */
1365   if (PROFILE_MODEL_P (current_cpu))
1366     {
1367       FLD (out_Ri) = f_Ri;
1368     }
1369 #endif
1370 #undef FLD
1371   BREAK (ex);
1372   }
1373
1374   CASE (ex, FMT_LDI32) :
1375   {
1376     CGEN_INSN_INT insn = base_insn;
1377 #define FLD(f) abuf->fields.fmt_ldi32.f
1378   EXTRACT_IFMT_LDI32_VARS /* f-op1 f-i32 f-op2 f-op3 f-Ri */
1379
1380   EXTRACT_IFMT_LDI32_CODE
1381
1382   /* Record the fields for the semantic handler.  */
1383   FLD (f_i32) = f_i32;
1384   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1385   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldi32", "f_i32 0x%x", 'x', f_i32, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1386
1387 #if WITH_PROFILE_MODEL_P
1388   /* Record the fields for profiling.  */
1389   if (PROFILE_MODEL_P (current_cpu))
1390     {
1391       FLD (out_Ri) = f_Ri;
1392     }
1393 #endif
1394 #undef FLD
1395   BREAK (ex);
1396   }
1397
1398   CASE (ex, FMT_LD) :
1399   {
1400     CGEN_INSN_INT insn = base_insn;
1401 #define FLD(f) abuf->fields.fmt_ld.f
1402   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1403
1404   EXTRACT_IFMT_ADD_CODE
1405
1406   /* Record the fields for the semantic handler.  */
1407   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1408   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1409   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ld", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1410
1411 #if WITH_PROFILE_MODEL_P
1412   /* Record the fields for profiling.  */
1413   if (PROFILE_MODEL_P (current_cpu))
1414     {
1415       FLD (in_Rj) = f_Rj;
1416       FLD (out_Ri) = f_Ri;
1417     }
1418 #endif
1419 #undef FLD
1420   BREAK (ex);
1421   }
1422
1423   CASE (ex, FMT_LDUH) :
1424   {
1425     CGEN_INSN_INT insn = base_insn;
1426 #define FLD(f) abuf->fields.fmt_lduh.f
1427   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1428
1429   EXTRACT_IFMT_ADD_CODE
1430
1431   /* Record the fields for the semantic handler.  */
1432   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1433   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1434   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_lduh", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1435
1436 #if WITH_PROFILE_MODEL_P
1437   /* Record the fields for profiling.  */
1438   if (PROFILE_MODEL_P (current_cpu))
1439     {
1440       FLD (in_Rj) = f_Rj;
1441       FLD (out_Ri) = f_Ri;
1442     }
1443 #endif
1444 #undef FLD
1445   BREAK (ex);
1446   }
1447
1448   CASE (ex, FMT_LDUB) :
1449   {
1450     CGEN_INSN_INT insn = base_insn;
1451 #define FLD(f) abuf->fields.fmt_ldub.f
1452   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1453
1454   EXTRACT_IFMT_ADD_CODE
1455
1456   /* Record the fields for the semantic handler.  */
1457   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1458   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1459   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldub", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1460
1461 #if WITH_PROFILE_MODEL_P
1462   /* Record the fields for profiling.  */
1463   if (PROFILE_MODEL_P (current_cpu))
1464     {
1465       FLD (in_Rj) = f_Rj;
1466       FLD (out_Ri) = f_Ri;
1467     }
1468 #endif
1469 #undef FLD
1470   BREAK (ex);
1471   }
1472
1473   CASE (ex, FMT_LDR13) :
1474   {
1475     CGEN_INSN_INT insn = base_insn;
1476 #define FLD(f) abuf->fields.fmt_ldr13.f
1477   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1478
1479   EXTRACT_IFMT_ADD_CODE
1480
1481   /* Record the fields for the semantic handler.  */
1482   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1483   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1484   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr13", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1485
1486 #if WITH_PROFILE_MODEL_P
1487   /* Record the fields for profiling.  */
1488   if (PROFILE_MODEL_P (current_cpu))
1489     {
1490       FLD (in_Rj) = f_Rj;
1491       FLD (in_h_gr_13) = 13;
1492       FLD (out_Ri) = f_Ri;
1493     }
1494 #endif
1495 #undef FLD
1496   BREAK (ex);
1497   }
1498
1499   CASE (ex, FMT_LDR13UH) :
1500   {
1501     CGEN_INSN_INT insn = base_insn;
1502 #define FLD(f) abuf->fields.fmt_ldr13uh.f
1503   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1504
1505   EXTRACT_IFMT_ADD_CODE
1506
1507   /* Record the fields for the semantic handler.  */
1508   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1509   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1510   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr13uh", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1511
1512 #if WITH_PROFILE_MODEL_P
1513   /* Record the fields for profiling.  */
1514   if (PROFILE_MODEL_P (current_cpu))
1515     {
1516       FLD (in_Rj) = f_Rj;
1517       FLD (in_h_gr_13) = 13;
1518       FLD (out_Ri) = f_Ri;
1519     }
1520 #endif
1521 #undef FLD
1522   BREAK (ex);
1523   }
1524
1525   CASE (ex, FMT_LDR13UB) :
1526   {
1527     CGEN_INSN_INT insn = base_insn;
1528 #define FLD(f) abuf->fields.fmt_ldr13ub.f
1529   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1530
1531   EXTRACT_IFMT_ADD_CODE
1532
1533   /* Record the fields for the semantic handler.  */
1534   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1535   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1536   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr13ub", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1537
1538 #if WITH_PROFILE_MODEL_P
1539   /* Record the fields for profiling.  */
1540   if (PROFILE_MODEL_P (current_cpu))
1541     {
1542       FLD (in_Rj) = f_Rj;
1543       FLD (in_h_gr_13) = 13;
1544       FLD (out_Ri) = f_Ri;
1545     }
1546 #endif
1547 #undef FLD
1548   BREAK (ex);
1549   }
1550
1551   CASE (ex, FMT_LDR14) :
1552   {
1553     CGEN_INSN_INT insn = base_insn;
1554 #define FLD(f) abuf->fields.fmt_ldr14.f
1555   EXTRACT_IFMT_LDR14_VARS /* f-op1 f-disp10 f-Ri */
1556
1557   EXTRACT_IFMT_LDR14_CODE
1558
1559   /* Record the fields for the semantic handler.  */
1560   FLD (f_disp10) = f_disp10;
1561   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1562   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr14", "f_disp10 0x%x", 'x', f_disp10, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1563
1564 #if WITH_PROFILE_MODEL_P
1565   /* Record the fields for profiling.  */
1566   if (PROFILE_MODEL_P (current_cpu))
1567     {
1568       FLD (in_h_gr_14) = 14;
1569       FLD (out_Ri) = f_Ri;
1570     }
1571 #endif
1572 #undef FLD
1573   BREAK (ex);
1574   }
1575
1576   CASE (ex, FMT_LDR14UH) :
1577   {
1578     CGEN_INSN_INT insn = base_insn;
1579 #define FLD(f) abuf->fields.fmt_ldr14uh.f
1580   EXTRACT_IFMT_LDR14UH_VARS /* f-op1 f-disp9 f-Ri */
1581
1582   EXTRACT_IFMT_LDR14UH_CODE
1583
1584   /* Record the fields for the semantic handler.  */
1585   FLD (f_disp9) = f_disp9;
1586   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1587   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr14uh", "f_disp9 0x%x", 'x', f_disp9, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1588
1589 #if WITH_PROFILE_MODEL_P
1590   /* Record the fields for profiling.  */
1591   if (PROFILE_MODEL_P (current_cpu))
1592     {
1593       FLD (in_h_gr_14) = 14;
1594       FLD (out_Ri) = f_Ri;
1595     }
1596 #endif
1597 #undef FLD
1598   BREAK (ex);
1599   }
1600
1601   CASE (ex, FMT_LDR14UB) :
1602   {
1603     CGEN_INSN_INT insn = base_insn;
1604 #define FLD(f) abuf->fields.fmt_ldr14ub.f
1605   EXTRACT_IFMT_LDR14UB_VARS /* f-op1 f-disp8 f-Ri */
1606
1607   EXTRACT_IFMT_LDR14UB_CODE
1608
1609   /* Record the fields for the semantic handler.  */
1610   FLD (f_disp8) = f_disp8;
1611   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1612   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr14ub", "f_disp8 0x%x", 'x', f_disp8, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1613
1614 #if WITH_PROFILE_MODEL_P
1615   /* Record the fields for profiling.  */
1616   if (PROFILE_MODEL_P (current_cpu))
1617     {
1618       FLD (in_h_gr_14) = 14;
1619       FLD (out_Ri) = f_Ri;
1620     }
1621 #endif
1622 #undef FLD
1623   BREAK (ex);
1624   }
1625
1626   CASE (ex, FMT_LDR15) :
1627   {
1628     CGEN_INSN_INT insn = base_insn;
1629 #define FLD(f) abuf->fields.fmt_ldr15.f
1630   EXTRACT_IFMT_LDR15_VARS /* f-op1 f-op2 f-udisp6 f-Ri */
1631
1632   EXTRACT_IFMT_LDR15_CODE
1633
1634   /* Record the fields for the semantic handler.  */
1635   FLD (f_udisp6) = f_udisp6;
1636   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1637   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr15", "f_udisp6 0x%x", 'x', f_udisp6, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1638
1639 #if WITH_PROFILE_MODEL_P
1640   /* Record the fields for profiling.  */
1641   if (PROFILE_MODEL_P (current_cpu))
1642     {
1643       FLD (in_h_gr_15) = 15;
1644       FLD (out_Ri) = f_Ri;
1645     }
1646 #endif
1647 #undef FLD
1648   BREAK (ex);
1649   }
1650
1651   CASE (ex, FMT_LDR15GR) :
1652   {
1653     CGEN_INSN_INT insn = base_insn;
1654 #define FLD(f) abuf->fields.fmt_ldr15gr.f
1655   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1656
1657   EXTRACT_IFMT_DIV0S_CODE
1658
1659   /* Record the fields for the semantic handler.  */
1660   FLD (f_Ri) = f_Ri;
1661   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1662   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr15gr", "f_Ri 0x%x", 'x', f_Ri, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1663
1664 #if WITH_PROFILE_MODEL_P
1665   /* Record the fields for profiling.  */
1666   if (PROFILE_MODEL_P (current_cpu))
1667     {
1668       FLD (in_h_gr_15) = 15;
1669       FLD (out_Ri) = f_Ri;
1670       FLD (out_h_gr_15) = 15;
1671     }
1672 #endif
1673 #undef FLD
1674   BREAK (ex);
1675   }
1676
1677   CASE (ex, FMT_LDR15DR) :
1678   {
1679     CGEN_INSN_INT insn = base_insn;
1680 #define FLD(f) abuf->fields.fmt_ldr15dr.f
1681   EXTRACT_IFMT_LDR15DR_VARS /* f-op1 f-op2 f-op3 f-Rs2 */
1682
1683   EXTRACT_IFMT_LDR15DR_CODE
1684
1685   /* Record the fields for the semantic handler.  */
1686   FLD (f_Rs2) = f_Rs2;
1687   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr15dr", "f_Rs2 0x%x", 'x', f_Rs2, (char *) 0));
1688
1689 #if WITH_PROFILE_MODEL_P
1690   /* Record the fields for profiling.  */
1691   if (PROFILE_MODEL_P (current_cpu))
1692     {
1693       FLD (in_h_gr_15) = 15;
1694       FLD (out_h_gr_15) = 15;
1695     }
1696 #endif
1697 #undef FLD
1698   BREAK (ex);
1699   }
1700
1701   CASE (ex, FMT_LDR15PS) :
1702   {
1703     CGEN_INSN_INT insn = base_insn;
1704 #define FLD(f) abuf->fields.fmt_ldr15ps.f
1705   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
1706
1707   EXTRACT_IFMT_DIV3_CODE
1708
1709   /* Record the fields for the semantic handler.  */
1710   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldr15ps", (char *) 0));
1711
1712 #if WITH_PROFILE_MODEL_P
1713   /* Record the fields for profiling.  */
1714   if (PROFILE_MODEL_P (current_cpu))
1715     {
1716       FLD (in_h_gr_15) = 15;
1717       FLD (out_h_gr_15) = 15;
1718     }
1719 #endif
1720 #undef FLD
1721   BREAK (ex);
1722   }
1723
1724   CASE (ex, FMT_ST) :
1725   {
1726     CGEN_INSN_INT insn = base_insn;
1727 #define FLD(f) abuf->fields.fmt_st.f
1728   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1729
1730   EXTRACT_IFMT_ADD_CODE
1731
1732   /* Record the fields for the semantic handler.  */
1733   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1734   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1735   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_st", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1736
1737 #if WITH_PROFILE_MODEL_P
1738   /* Record the fields for profiling.  */
1739   if (PROFILE_MODEL_P (current_cpu))
1740     {
1741       FLD (in_Ri) = f_Ri;
1742       FLD (in_Rj) = f_Rj;
1743     }
1744 #endif
1745 #undef FLD
1746   BREAK (ex);
1747   }
1748
1749   CASE (ex, FMT_STH) :
1750   {
1751     CGEN_INSN_INT insn = base_insn;
1752 #define FLD(f) abuf->fields.fmt_sth.f
1753   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1754
1755   EXTRACT_IFMT_ADD_CODE
1756
1757   /* Record the fields for the semantic handler.  */
1758   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1759   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1760   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_sth", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1761
1762 #if WITH_PROFILE_MODEL_P
1763   /* Record the fields for profiling.  */
1764   if (PROFILE_MODEL_P (current_cpu))
1765     {
1766       FLD (in_Ri) = f_Ri;
1767       FLD (in_Rj) = f_Rj;
1768     }
1769 #endif
1770 #undef FLD
1771   BREAK (ex);
1772   }
1773
1774   CASE (ex, FMT_STB) :
1775   {
1776     CGEN_INSN_INT insn = base_insn;
1777 #define FLD(f) abuf->fields.fmt_stb.f
1778   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1779
1780   EXTRACT_IFMT_ADD_CODE
1781
1782   /* Record the fields for the semantic handler.  */
1783   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1784   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1785   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_stb", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1786
1787 #if WITH_PROFILE_MODEL_P
1788   /* Record the fields for profiling.  */
1789   if (PROFILE_MODEL_P (current_cpu))
1790     {
1791       FLD (in_Ri) = f_Ri;
1792       FLD (in_Rj) = f_Rj;
1793     }
1794 #endif
1795 #undef FLD
1796   BREAK (ex);
1797   }
1798
1799   CASE (ex, FMT_STR13) :
1800   {
1801     CGEN_INSN_INT insn = base_insn;
1802 #define FLD(f) abuf->fields.fmt_str13.f
1803   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1804
1805   EXTRACT_IFMT_ADD_CODE
1806
1807   /* Record the fields for the semantic handler.  */
1808   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1809   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1810   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str13", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1811
1812 #if WITH_PROFILE_MODEL_P
1813   /* Record the fields for profiling.  */
1814   if (PROFILE_MODEL_P (current_cpu))
1815     {
1816       FLD (in_Ri) = f_Ri;
1817       FLD (in_Rj) = f_Rj;
1818       FLD (in_h_gr_13) = 13;
1819     }
1820 #endif
1821 #undef FLD
1822   BREAK (ex);
1823   }
1824
1825   CASE (ex, FMT_STR13H) :
1826   {
1827     CGEN_INSN_INT insn = base_insn;
1828 #define FLD(f) abuf->fields.fmt_str13h.f
1829   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1830
1831   EXTRACT_IFMT_ADD_CODE
1832
1833   /* Record the fields for the semantic handler.  */
1834   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1835   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1836   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str13h", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1837
1838 #if WITH_PROFILE_MODEL_P
1839   /* Record the fields for profiling.  */
1840   if (PROFILE_MODEL_P (current_cpu))
1841     {
1842       FLD (in_Ri) = f_Ri;
1843       FLD (in_Rj) = f_Rj;
1844       FLD (in_h_gr_13) = 13;
1845     }
1846 #endif
1847 #undef FLD
1848   BREAK (ex);
1849   }
1850
1851   CASE (ex, FMT_STR13B) :
1852   {
1853     CGEN_INSN_INT insn = base_insn;
1854 #define FLD(f) abuf->fields.fmt_str13b.f
1855   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
1856
1857   EXTRACT_IFMT_ADD_CODE
1858
1859   /* Record the fields for the semantic handler.  */
1860   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1861   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
1862   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str13b", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
1863
1864 #if WITH_PROFILE_MODEL_P
1865   /* Record the fields for profiling.  */
1866   if (PROFILE_MODEL_P (current_cpu))
1867     {
1868       FLD (in_Ri) = f_Ri;
1869       FLD (in_Rj) = f_Rj;
1870       FLD (in_h_gr_13) = 13;
1871     }
1872 #endif
1873 #undef FLD
1874   BREAK (ex);
1875   }
1876
1877   CASE (ex, FMT_STR14) :
1878   {
1879     CGEN_INSN_INT insn = base_insn;
1880 #define FLD(f) abuf->fields.fmt_str14.f
1881   EXTRACT_IFMT_LDR14_VARS /* f-op1 f-disp10 f-Ri */
1882
1883   EXTRACT_IFMT_LDR14_CODE
1884
1885   /* Record the fields for the semantic handler.  */
1886   FLD (f_disp10) = f_disp10;
1887   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1888   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str14", "f_disp10 0x%x", 'x', f_disp10, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1889
1890 #if WITH_PROFILE_MODEL_P
1891   /* Record the fields for profiling.  */
1892   if (PROFILE_MODEL_P (current_cpu))
1893     {
1894       FLD (in_Ri) = f_Ri;
1895       FLD (in_h_gr_14) = 14;
1896     }
1897 #endif
1898 #undef FLD
1899   BREAK (ex);
1900   }
1901
1902   CASE (ex, FMT_STR14H) :
1903   {
1904     CGEN_INSN_INT insn = base_insn;
1905 #define FLD(f) abuf->fields.fmt_str14h.f
1906   EXTRACT_IFMT_LDR14UH_VARS /* f-op1 f-disp9 f-Ri */
1907
1908   EXTRACT_IFMT_LDR14UH_CODE
1909
1910   /* Record the fields for the semantic handler.  */
1911   FLD (f_disp9) = f_disp9;
1912   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1913   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str14h", "f_disp9 0x%x", 'x', f_disp9, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1914
1915 #if WITH_PROFILE_MODEL_P
1916   /* Record the fields for profiling.  */
1917   if (PROFILE_MODEL_P (current_cpu))
1918     {
1919       FLD (in_Ri) = f_Ri;
1920       FLD (in_h_gr_14) = 14;
1921     }
1922 #endif
1923 #undef FLD
1924   BREAK (ex);
1925   }
1926
1927   CASE (ex, FMT_STR14B) :
1928   {
1929     CGEN_INSN_INT insn = base_insn;
1930 #define FLD(f) abuf->fields.fmt_str14b.f
1931   EXTRACT_IFMT_LDR14UB_VARS /* f-op1 f-disp8 f-Ri */
1932
1933   EXTRACT_IFMT_LDR14UB_CODE
1934
1935   /* Record the fields for the semantic handler.  */
1936   FLD (f_disp8) = f_disp8;
1937   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1938   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str14b", "f_disp8 0x%x", 'x', f_disp8, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1939
1940 #if WITH_PROFILE_MODEL_P
1941   /* Record the fields for profiling.  */
1942   if (PROFILE_MODEL_P (current_cpu))
1943     {
1944       FLD (in_Ri) = f_Ri;
1945       FLD (in_h_gr_14) = 14;
1946     }
1947 #endif
1948 #undef FLD
1949   BREAK (ex);
1950   }
1951
1952   CASE (ex, FMT_STR15) :
1953   {
1954     CGEN_INSN_INT insn = base_insn;
1955 #define FLD(f) abuf->fields.fmt_str15.f
1956   EXTRACT_IFMT_LDR15_VARS /* f-op1 f-op2 f-udisp6 f-Ri */
1957
1958   EXTRACT_IFMT_LDR15_CODE
1959
1960   /* Record the fields for the semantic handler.  */
1961   FLD (f_udisp6) = f_udisp6;
1962   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1963   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str15", "f_udisp6 0x%x", 'x', f_udisp6, "Ri 0x%x", 'x', f_Ri, (char *) 0));
1964
1965 #if WITH_PROFILE_MODEL_P
1966   /* Record the fields for profiling.  */
1967   if (PROFILE_MODEL_P (current_cpu))
1968     {
1969       FLD (in_Ri) = f_Ri;
1970       FLD (in_h_gr_15) = 15;
1971     }
1972 #endif
1973 #undef FLD
1974   BREAK (ex);
1975   }
1976
1977   CASE (ex, FMT_STR15GR) :
1978   {
1979     CGEN_INSN_INT insn = base_insn;
1980 #define FLD(f) abuf->fields.fmt_str15gr.f
1981   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
1982
1983   EXTRACT_IFMT_DIV0S_CODE
1984
1985   /* Record the fields for the semantic handler.  */
1986   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
1987   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str15gr", "Ri 0x%x", 'x', f_Ri, (char *) 0));
1988
1989 #if WITH_PROFILE_MODEL_P
1990   /* Record the fields for profiling.  */
1991   if (PROFILE_MODEL_P (current_cpu))
1992     {
1993       FLD (in_Ri) = f_Ri;
1994       FLD (in_h_gr_15) = 15;
1995       FLD (out_h_gr_15) = 15;
1996     }
1997 #endif
1998 #undef FLD
1999   BREAK (ex);
2000   }
2001
2002   CASE (ex, FMT_STR15DR) :
2003   {
2004     CGEN_INSN_INT insn = base_insn;
2005 #define FLD(f) abuf->fields.fmt_str15dr.f
2006   EXTRACT_IFMT_LDR15DR_VARS /* f-op1 f-op2 f-op3 f-Rs2 */
2007
2008   EXTRACT_IFMT_LDR15DR_CODE
2009
2010   /* Record the fields for the semantic handler.  */
2011   FLD (f_Rs2) = f_Rs2;
2012   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str15dr", "f_Rs2 0x%x", 'x', f_Rs2, (char *) 0));
2013
2014 #if WITH_PROFILE_MODEL_P
2015   /* Record the fields for profiling.  */
2016   if (PROFILE_MODEL_P (current_cpu))
2017     {
2018       FLD (in_h_gr_15) = 15;
2019       FLD (out_h_gr_15) = 15;
2020     }
2021 #endif
2022 #undef FLD
2023   BREAK (ex);
2024   }
2025
2026   CASE (ex, FMT_STR15PS) :
2027   {
2028     CGEN_INSN_INT insn = base_insn;
2029 #define FLD(f) abuf->fields.fmt_str15ps.f
2030   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
2031
2032   EXTRACT_IFMT_DIV3_CODE
2033
2034   /* Record the fields for the semantic handler.  */
2035   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_str15ps", (char *) 0));
2036
2037 #if WITH_PROFILE_MODEL_P
2038   /* Record the fields for profiling.  */
2039   if (PROFILE_MODEL_P (current_cpu))
2040     {
2041       FLD (in_h_gr_15) = 15;
2042       FLD (out_h_gr_15) = 15;
2043     }
2044 #endif
2045 #undef FLD
2046   BREAK (ex);
2047   }
2048
2049   CASE (ex, FMT_MOV) :
2050   {
2051     CGEN_INSN_INT insn = base_insn;
2052 #define FLD(f) abuf->fields.fmt_mov.f
2053   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
2054
2055   EXTRACT_IFMT_ADD_CODE
2056
2057   /* Record the fields for the semantic handler.  */
2058   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
2059   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2060   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mov", "Rj 0x%x", 'x', f_Rj, "Ri 0x%x", 'x', f_Ri, (char *) 0));
2061
2062 #if WITH_PROFILE_MODEL_P
2063   /* Record the fields for profiling.  */
2064   if (PROFILE_MODEL_P (current_cpu))
2065     {
2066       FLD (in_Rj) = f_Rj;
2067       FLD (out_Ri) = f_Ri;
2068     }
2069 #endif
2070 #undef FLD
2071   BREAK (ex);
2072   }
2073
2074   CASE (ex, FMT_MOVDR) :
2075   {
2076     CGEN_INSN_INT insn = base_insn;
2077 #define FLD(f) abuf->fields.fmt_movdr.f
2078   EXTRACT_IFMT_MOVDR_VARS /* f-op1 f-op2 f-Rs1 f-Ri */
2079
2080   EXTRACT_IFMT_MOVDR_CODE
2081
2082   /* Record the fields for the semantic handler.  */
2083   FLD (f_Rs1) = f_Rs1;
2084   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2085   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_movdr", "f_Rs1 0x%x", 'x', f_Rs1, "Ri 0x%x", 'x', f_Ri, (char *) 0));
2086
2087 #if WITH_PROFILE_MODEL_P
2088   /* Record the fields for profiling.  */
2089   if (PROFILE_MODEL_P (current_cpu))
2090     {
2091       FLD (out_Ri) = f_Ri;
2092     }
2093 #endif
2094 #undef FLD
2095   BREAK (ex);
2096   }
2097
2098   CASE (ex, FMT_MOVPS) :
2099   {
2100     CGEN_INSN_INT insn = base_insn;
2101 #define FLD(f) abuf->fields.fmt_movps.f
2102   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
2103
2104   EXTRACT_IFMT_DIV0S_CODE
2105
2106   /* Record the fields for the semantic handler.  */
2107   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2108   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_movps", "Ri 0x%x", 'x', f_Ri, (char *) 0));
2109
2110 #if WITH_PROFILE_MODEL_P
2111   /* Record the fields for profiling.  */
2112   if (PROFILE_MODEL_P (current_cpu))
2113     {
2114       FLD (out_Ri) = f_Ri;
2115     }
2116 #endif
2117 #undef FLD
2118   BREAK (ex);
2119   }
2120
2121   CASE (ex, FMT_MOV2DR) :
2122   {
2123     CGEN_INSN_INT insn = base_insn;
2124 #define FLD(f) abuf->fields.fmt_mov2dr.f
2125   EXTRACT_IFMT_MOVDR_VARS /* f-op1 f-op2 f-Rs1 f-Ri */
2126
2127   EXTRACT_IFMT_MOVDR_CODE
2128
2129   /* Record the fields for the semantic handler.  */
2130   FLD (f_Rs1) = f_Rs1;
2131   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2132   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mov2dr", "f_Rs1 0x%x", 'x', f_Rs1, "Ri 0x%x", 'x', f_Ri, (char *) 0));
2133
2134 #if WITH_PROFILE_MODEL_P
2135   /* Record the fields for profiling.  */
2136   if (PROFILE_MODEL_P (current_cpu))
2137     {
2138       FLD (in_Ri) = f_Ri;
2139     }
2140 #endif
2141 #undef FLD
2142   BREAK (ex);
2143   }
2144
2145   CASE (ex, FMT_MOV2PS) :
2146   {
2147     CGEN_INSN_INT insn = base_insn;
2148 #define FLD(f) abuf->fields.fmt_mov2ps.f
2149   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
2150
2151   EXTRACT_IFMT_DIV0S_CODE
2152
2153   /* Record the fields for the semantic handler.  */
2154   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2155   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_mov2ps", "Ri 0x%x", 'x', f_Ri, (char *) 0));
2156
2157 #if WITH_PROFILE_MODEL_P
2158   /* Record the fields for profiling.  */
2159   if (PROFILE_MODEL_P (current_cpu))
2160     {
2161       FLD (in_Ri) = f_Ri;
2162     }
2163 #endif
2164 #undef FLD
2165   BREAK (ex);
2166   }
2167
2168   CASE (ex, FMT_JMP) :
2169   {
2170     CGEN_INSN_INT insn = base_insn;
2171 #define FLD(f) abuf->fields.cti.fields.fmt_jmp.f
2172   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
2173
2174   EXTRACT_IFMT_DIV0S_CODE
2175
2176   /* Record the fields for the semantic handler.  */
2177   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2178   SEM_BRANCH_INIT_EXTRACT (abuf);
2179   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_jmp", "Ri 0x%x", 'x', f_Ri, (char *) 0));
2180
2181 #if WITH_PROFILE_MODEL_P
2182   /* Record the fields for profiling.  */
2183   if (PROFILE_MODEL_P (current_cpu))
2184     {
2185       FLD (in_Ri) = f_Ri;
2186     }
2187 #endif
2188 #undef FLD
2189   BREAK (ex);
2190   }
2191
2192   CASE (ex, FMT_CALLR) :
2193   {
2194     CGEN_INSN_INT insn = base_insn;
2195 #define FLD(f) abuf->fields.cti.fields.fmt_callr.f
2196   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
2197
2198   EXTRACT_IFMT_DIV0S_CODE
2199
2200   /* Record the fields for the semantic handler.  */
2201   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2202   SEM_BRANCH_INIT_EXTRACT (abuf);
2203   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_callr", "Ri 0x%x", 'x', f_Ri, (char *) 0));
2204
2205 #if WITH_PROFILE_MODEL_P
2206   /* Record the fields for profiling.  */
2207   if (PROFILE_MODEL_P (current_cpu))
2208     {
2209       FLD (in_Ri) = f_Ri;
2210     }
2211 #endif
2212 #undef FLD
2213   BREAK (ex);
2214   }
2215
2216   CASE (ex, FMT_CALL) :
2217   {
2218     CGEN_INSN_INT insn = base_insn;
2219 #define FLD(f) abuf->fields.cti.fields.fmt_call.f
2220   EXTRACT_IFMT_CALL_VARS /* f-op1 f-op5 f-rel12 */
2221
2222   EXTRACT_IFMT_CALL_CODE
2223
2224   /* Record the fields for the semantic handler.  */
2225   FLD (i_label12) = f_rel12;
2226   SEM_BRANCH_INIT_EXTRACT (abuf);
2227   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_call", "label12 0x%x", 'x', f_rel12, (char *) 0));
2228
2229 #if WITH_PROFILE_MODEL_P
2230   /* Record the fields for profiling.  */
2231   if (PROFILE_MODEL_P (current_cpu))
2232     {
2233     }
2234 #endif
2235 #undef FLD
2236   BREAK (ex);
2237   }
2238
2239   CASE (ex, FMT_RET) :
2240   {
2241     CGEN_INSN_INT insn = base_insn;
2242 #define FLD(f) abuf->fields.cti.fields.fmt_ret.f
2243   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
2244
2245   EXTRACT_IFMT_DIV3_CODE
2246
2247   /* Record the fields for the semantic handler.  */
2248   SEM_BRANCH_INIT_EXTRACT (abuf);
2249   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ret", (char *) 0));
2250
2251 #if WITH_PROFILE_MODEL_P
2252   /* Record the fields for profiling.  */
2253   if (PROFILE_MODEL_P (current_cpu))
2254     {
2255     }
2256 #endif
2257 #undef FLD
2258   BREAK (ex);
2259   }
2260
2261   CASE (ex, FMT_INT) :
2262   {
2263     CGEN_INSN_INT insn = base_insn;
2264 #define FLD(f) abuf->fields.cti.fields.fmt_int.f
2265   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
2266
2267   EXTRACT_IFMT_INT_CODE
2268
2269   /* Record the fields for the semantic handler.  */
2270   FLD (f_u8) = f_u8;
2271   SEM_BRANCH_INIT_EXTRACT (abuf);
2272   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_int", "f_u8 0x%x", 'x', f_u8, (char *) 0));
2273
2274 #if WITH_PROFILE_MODEL_P
2275   /* Record the fields for profiling.  */
2276   if (PROFILE_MODEL_P (current_cpu))
2277     {
2278     }
2279 #endif
2280 #undef FLD
2281   BREAK (ex);
2282   }
2283
2284   CASE (ex, FMT_INTE) :
2285   {
2286     CGEN_INSN_INT insn = base_insn;
2287 #define FLD(f) abuf->fields.cti.fields.fmt_inte.f
2288   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
2289
2290   EXTRACT_IFMT_DIV3_CODE
2291
2292   /* Record the fields for the semantic handler.  */
2293   SEM_BRANCH_INIT_EXTRACT (abuf);
2294   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_inte", (char *) 0));
2295
2296 #if WITH_PROFILE_MODEL_P
2297   /* Record the fields for profiling.  */
2298   if (PROFILE_MODEL_P (current_cpu))
2299     {
2300     }
2301 #endif
2302 #undef FLD
2303   BREAK (ex);
2304   }
2305
2306   CASE (ex, FMT_RETI) :
2307   {
2308     CGEN_INSN_INT insn = base_insn;
2309 #define FLD(f) abuf->fields.cti.fields.fmt_reti.f
2310   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
2311
2312   EXTRACT_IFMT_DIV3_CODE
2313
2314   /* Record the fields for the semantic handler.  */
2315   SEM_BRANCH_INIT_EXTRACT (abuf);
2316   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_reti", (char *) 0));
2317
2318 #if WITH_PROFILE_MODEL_P
2319   /* Record the fields for profiling.  */
2320   if (PROFILE_MODEL_P (current_cpu))
2321     {
2322     }
2323 #endif
2324 #undef FLD
2325   BREAK (ex);
2326   }
2327
2328   CASE (ex, FMT_BRAD) :
2329   {
2330     CGEN_INSN_INT insn = base_insn;
2331 #define FLD(f) abuf->fields.cti.fields.fmt_brad.f
2332   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2333
2334   EXTRACT_IFMT_BRAD_CODE
2335
2336   /* Record the fields for the semantic handler.  */
2337   FLD (i_label9) = f_rel9;
2338   SEM_BRANCH_INIT_EXTRACT (abuf);
2339   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_brad", "label9 0x%x", 'x', f_rel9, (char *) 0));
2340
2341 #if WITH_PROFILE_MODEL_P
2342   /* Record the fields for profiling.  */
2343   if (PROFILE_MODEL_P (current_cpu))
2344     {
2345     }
2346 #endif
2347 #undef FLD
2348   BREAK (ex);
2349   }
2350
2351   CASE (ex, FMT_BNOD) :
2352   {
2353     CGEN_INSN_INT insn = base_insn;
2354 #define FLD(f) abuf->fields.fmt_bnod.f
2355   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2356
2357   EXTRACT_IFMT_BRAD_CODE
2358
2359   /* Record the fields for the semantic handler.  */
2360   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bnod", (char *) 0));
2361
2362 #undef FLD
2363   BREAK (ex);
2364   }
2365
2366   CASE (ex, FMT_BEQD) :
2367   {
2368     CGEN_INSN_INT insn = base_insn;
2369 #define FLD(f) abuf->fields.cti.fields.fmt_beqd.f
2370   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2371
2372   EXTRACT_IFMT_BRAD_CODE
2373
2374   /* Record the fields for the semantic handler.  */
2375   FLD (i_label9) = f_rel9;
2376   SEM_BRANCH_INIT_EXTRACT (abuf);
2377   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_beqd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2378
2379 #if WITH_PROFILE_MODEL_P
2380   /* Record the fields for profiling.  */
2381   if (PROFILE_MODEL_P (current_cpu))
2382     {
2383     }
2384 #endif
2385 #undef FLD
2386   BREAK (ex);
2387   }
2388
2389   CASE (ex, FMT_BCD) :
2390   {
2391     CGEN_INSN_INT insn = base_insn;
2392 #define FLD(f) abuf->fields.cti.fields.fmt_bcd.f
2393   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2394
2395   EXTRACT_IFMT_BRAD_CODE
2396
2397   /* Record the fields for the semantic handler.  */
2398   FLD (i_label9) = f_rel9;
2399   SEM_BRANCH_INIT_EXTRACT (abuf);
2400   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bcd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2401
2402 #if WITH_PROFILE_MODEL_P
2403   /* Record the fields for profiling.  */
2404   if (PROFILE_MODEL_P (current_cpu))
2405     {
2406     }
2407 #endif
2408 #undef FLD
2409   BREAK (ex);
2410   }
2411
2412   CASE (ex, FMT_BND) :
2413   {
2414     CGEN_INSN_INT insn = base_insn;
2415 #define FLD(f) abuf->fields.cti.fields.fmt_bnd.f
2416   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2417
2418   EXTRACT_IFMT_BRAD_CODE
2419
2420   /* Record the fields for the semantic handler.  */
2421   FLD (i_label9) = f_rel9;
2422   SEM_BRANCH_INIT_EXTRACT (abuf);
2423   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bnd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2424
2425 #if WITH_PROFILE_MODEL_P
2426   /* Record the fields for profiling.  */
2427   if (PROFILE_MODEL_P (current_cpu))
2428     {
2429     }
2430 #endif
2431 #undef FLD
2432   BREAK (ex);
2433   }
2434
2435   CASE (ex, FMT_BVD) :
2436   {
2437     CGEN_INSN_INT insn = base_insn;
2438 #define FLD(f) abuf->fields.cti.fields.fmt_bvd.f
2439   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2440
2441   EXTRACT_IFMT_BRAD_CODE
2442
2443   /* Record the fields for the semantic handler.  */
2444   FLD (i_label9) = f_rel9;
2445   SEM_BRANCH_INIT_EXTRACT (abuf);
2446   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bvd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2447
2448 #if WITH_PROFILE_MODEL_P
2449   /* Record the fields for profiling.  */
2450   if (PROFILE_MODEL_P (current_cpu))
2451     {
2452     }
2453 #endif
2454 #undef FLD
2455   BREAK (ex);
2456   }
2457
2458   CASE (ex, FMT_BLTD) :
2459   {
2460     CGEN_INSN_INT insn = base_insn;
2461 #define FLD(f) abuf->fields.cti.fields.fmt_bltd.f
2462   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2463
2464   EXTRACT_IFMT_BRAD_CODE
2465
2466   /* Record the fields for the semantic handler.  */
2467   FLD (i_label9) = f_rel9;
2468   SEM_BRANCH_INIT_EXTRACT (abuf);
2469   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bltd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2470
2471 #if WITH_PROFILE_MODEL_P
2472   /* Record the fields for profiling.  */
2473   if (PROFILE_MODEL_P (current_cpu))
2474     {
2475     }
2476 #endif
2477 #undef FLD
2478   BREAK (ex);
2479   }
2480
2481   CASE (ex, FMT_BLED) :
2482   {
2483     CGEN_INSN_INT insn = base_insn;
2484 #define FLD(f) abuf->fields.cti.fields.fmt_bled.f
2485   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2486
2487   EXTRACT_IFMT_BRAD_CODE
2488
2489   /* Record the fields for the semantic handler.  */
2490   FLD (i_label9) = f_rel9;
2491   SEM_BRANCH_INIT_EXTRACT (abuf);
2492   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_bled", "label9 0x%x", 'x', f_rel9, (char *) 0));
2493
2494 #if WITH_PROFILE_MODEL_P
2495   /* Record the fields for profiling.  */
2496   if (PROFILE_MODEL_P (current_cpu))
2497     {
2498     }
2499 #endif
2500 #undef FLD
2501   BREAK (ex);
2502   }
2503
2504   CASE (ex, FMT_BLSD) :
2505   {
2506     CGEN_INSN_INT insn = base_insn;
2507 #define FLD(f) abuf->fields.cti.fields.fmt_blsd.f
2508   EXTRACT_IFMT_BRAD_VARS /* f-op1 f-cc f-rel9 */
2509
2510   EXTRACT_IFMT_BRAD_CODE
2511
2512   /* Record the fields for the semantic handler.  */
2513   FLD (i_label9) = f_rel9;
2514   SEM_BRANCH_INIT_EXTRACT (abuf);
2515   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_blsd", "label9 0x%x", 'x', f_rel9, (char *) 0));
2516
2517 #if WITH_PROFILE_MODEL_P
2518   /* Record the fields for profiling.  */
2519   if (PROFILE_MODEL_P (current_cpu))
2520     {
2521     }
2522 #endif
2523 #undef FLD
2524   BREAK (ex);
2525   }
2526
2527   CASE (ex, FMT_DMOVR13) :
2528   {
2529     CGEN_INSN_INT insn = base_insn;
2530 #define FLD(f) abuf->fields.fmt_dmovr13.f
2531   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2532
2533   EXTRACT_IFMT_DMOVR13_CODE
2534
2535   /* Record the fields for the semantic handler.  */
2536   FLD (f_dir10) = f_dir10;
2537   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2538
2539 #if WITH_PROFILE_MODEL_P
2540   /* Record the fields for profiling.  */
2541   if (PROFILE_MODEL_P (current_cpu))
2542     {
2543       FLD (in_h_gr_13) = 13;
2544     }
2545 #endif
2546 #undef FLD
2547   BREAK (ex);
2548   }
2549
2550   CASE (ex, FMT_DMOVR13H) :
2551   {
2552     CGEN_INSN_INT insn = base_insn;
2553 #define FLD(f) abuf->fields.fmt_dmovr13h.f
2554   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
2555
2556   EXTRACT_IFMT_DMOVR13H_CODE
2557
2558   /* Record the fields for the semantic handler.  */
2559   FLD (f_dir9) = f_dir9;
2560   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13h", "f_dir9 0x%x", 'x', f_dir9, (char *) 0));
2561
2562 #if WITH_PROFILE_MODEL_P
2563   /* Record the fields for profiling.  */
2564   if (PROFILE_MODEL_P (current_cpu))
2565     {
2566       FLD (in_h_gr_13) = 13;
2567     }
2568 #endif
2569 #undef FLD
2570   BREAK (ex);
2571   }
2572
2573   CASE (ex, FMT_DMOVR13B) :
2574   {
2575     CGEN_INSN_INT insn = base_insn;
2576 #define FLD(f) abuf->fields.fmt_dmovr13b.f
2577   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
2578
2579   EXTRACT_IFMT_DMOVR13B_CODE
2580
2581   /* Record the fields for the semantic handler.  */
2582   FLD (f_dir8) = f_dir8;
2583   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13b", "f_dir8 0x%x", 'x', f_dir8, (char *) 0));
2584
2585 #if WITH_PROFILE_MODEL_P
2586   /* Record the fields for profiling.  */
2587   if (PROFILE_MODEL_P (current_cpu))
2588     {
2589       FLD (in_h_gr_13) = 13;
2590     }
2591 #endif
2592 #undef FLD
2593   BREAK (ex);
2594   }
2595
2596   CASE (ex, FMT_DMOVR13PI) :
2597   {
2598     CGEN_INSN_INT insn = base_insn;
2599 #define FLD(f) abuf->fields.fmt_dmovr13pi.f
2600   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2601
2602   EXTRACT_IFMT_DMOVR13_CODE
2603
2604   /* Record the fields for the semantic handler.  */
2605   FLD (f_dir10) = f_dir10;
2606   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13pi", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2607
2608 #if WITH_PROFILE_MODEL_P
2609   /* Record the fields for profiling.  */
2610   if (PROFILE_MODEL_P (current_cpu))
2611     {
2612       FLD (in_h_gr_13) = 13;
2613       FLD (out_h_gr_13) = 13;
2614     }
2615 #endif
2616 #undef FLD
2617   BREAK (ex);
2618   }
2619
2620   CASE (ex, FMT_DMOVR13PIH) :
2621   {
2622     CGEN_INSN_INT insn = base_insn;
2623 #define FLD(f) abuf->fields.fmt_dmovr13pih.f
2624   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
2625
2626   EXTRACT_IFMT_DMOVR13H_CODE
2627
2628   /* Record the fields for the semantic handler.  */
2629   FLD (f_dir9) = f_dir9;
2630   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13pih", "f_dir9 0x%x", 'x', f_dir9, (char *) 0));
2631
2632 #if WITH_PROFILE_MODEL_P
2633   /* Record the fields for profiling.  */
2634   if (PROFILE_MODEL_P (current_cpu))
2635     {
2636       FLD (in_h_gr_13) = 13;
2637       FLD (out_h_gr_13) = 13;
2638     }
2639 #endif
2640 #undef FLD
2641   BREAK (ex);
2642   }
2643
2644   CASE (ex, FMT_DMOVR13PIB) :
2645   {
2646     CGEN_INSN_INT insn = base_insn;
2647 #define FLD(f) abuf->fields.fmt_dmovr13pib.f
2648   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
2649
2650   EXTRACT_IFMT_DMOVR13B_CODE
2651
2652   /* Record the fields for the semantic handler.  */
2653   FLD (f_dir8) = f_dir8;
2654   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr13pib", "f_dir8 0x%x", 'x', f_dir8, (char *) 0));
2655
2656 #if WITH_PROFILE_MODEL_P
2657   /* Record the fields for profiling.  */
2658   if (PROFILE_MODEL_P (current_cpu))
2659     {
2660       FLD (in_h_gr_13) = 13;
2661       FLD (out_h_gr_13) = 13;
2662     }
2663 #endif
2664 #undef FLD
2665   BREAK (ex);
2666   }
2667
2668   CASE (ex, FMT_DMOVR15PI) :
2669   {
2670     CGEN_INSN_INT insn = base_insn;
2671 #define FLD(f) abuf->fields.fmt_dmovr15pi.f
2672   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2673
2674   EXTRACT_IFMT_DMOVR13_CODE
2675
2676   /* Record the fields for the semantic handler.  */
2677   FLD (f_dir10) = f_dir10;
2678   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmovr15pi", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2679
2680 #if WITH_PROFILE_MODEL_P
2681   /* Record the fields for profiling.  */
2682   if (PROFILE_MODEL_P (current_cpu))
2683     {
2684       FLD (in_h_gr_15) = 15;
2685       FLD (out_h_gr_15) = 15;
2686     }
2687 #endif
2688 #undef FLD
2689   BREAK (ex);
2690   }
2691
2692   CASE (ex, FMT_DMOV2R13) :
2693   {
2694     CGEN_INSN_INT insn = base_insn;
2695 #define FLD(f) abuf->fields.fmt_dmov2r13.f
2696   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2697
2698   EXTRACT_IFMT_DMOVR13_CODE
2699
2700   /* Record the fields for the semantic handler.  */
2701   FLD (f_dir10) = f_dir10;
2702   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2703
2704 #if WITH_PROFILE_MODEL_P
2705   /* Record the fields for profiling.  */
2706   if (PROFILE_MODEL_P (current_cpu))
2707     {
2708       FLD (out_h_gr_13) = 13;
2709     }
2710 #endif
2711 #undef FLD
2712   BREAK (ex);
2713   }
2714
2715   CASE (ex, FMT_DMOV2R13H) :
2716   {
2717     CGEN_INSN_INT insn = base_insn;
2718 #define FLD(f) abuf->fields.fmt_dmov2r13h.f
2719   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
2720
2721   EXTRACT_IFMT_DMOVR13H_CODE
2722
2723   /* Record the fields for the semantic handler.  */
2724   FLD (f_dir9) = f_dir9;
2725   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13h", "f_dir9 0x%x", 'x', f_dir9, (char *) 0));
2726
2727 #if WITH_PROFILE_MODEL_P
2728   /* Record the fields for profiling.  */
2729   if (PROFILE_MODEL_P (current_cpu))
2730     {
2731       FLD (out_h_gr_13) = 13;
2732     }
2733 #endif
2734 #undef FLD
2735   BREAK (ex);
2736   }
2737
2738   CASE (ex, FMT_DMOV2R13B) :
2739   {
2740     CGEN_INSN_INT insn = base_insn;
2741 #define FLD(f) abuf->fields.fmt_dmov2r13b.f
2742   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
2743
2744   EXTRACT_IFMT_DMOVR13B_CODE
2745
2746   /* Record the fields for the semantic handler.  */
2747   FLD (f_dir8) = f_dir8;
2748   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13b", "f_dir8 0x%x", 'x', f_dir8, (char *) 0));
2749
2750 #if WITH_PROFILE_MODEL_P
2751   /* Record the fields for profiling.  */
2752   if (PROFILE_MODEL_P (current_cpu))
2753     {
2754       FLD (out_h_gr_13) = 13;
2755     }
2756 #endif
2757 #undef FLD
2758   BREAK (ex);
2759   }
2760
2761   CASE (ex, FMT_DMOV2R13PI) :
2762   {
2763     CGEN_INSN_INT insn = base_insn;
2764 #define FLD(f) abuf->fields.fmt_dmov2r13pi.f
2765   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2766
2767   EXTRACT_IFMT_DMOVR13_CODE
2768
2769   /* Record the fields for the semantic handler.  */
2770   FLD (f_dir10) = f_dir10;
2771   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13pi", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2772
2773 #if WITH_PROFILE_MODEL_P
2774   /* Record the fields for profiling.  */
2775   if (PROFILE_MODEL_P (current_cpu))
2776     {
2777       FLD (in_h_gr_13) = 13;
2778       FLD (out_h_gr_13) = 13;
2779     }
2780 #endif
2781 #undef FLD
2782   BREAK (ex);
2783   }
2784
2785   CASE (ex, FMT_DMOV2R13PIH) :
2786   {
2787     CGEN_INSN_INT insn = base_insn;
2788 #define FLD(f) abuf->fields.fmt_dmov2r13pih.f
2789   EXTRACT_IFMT_DMOVR13H_VARS /* f-op1 f-op2 f-dir9 */
2790
2791   EXTRACT_IFMT_DMOVR13H_CODE
2792
2793   /* Record the fields for the semantic handler.  */
2794   FLD (f_dir9) = f_dir9;
2795   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13pih", "f_dir9 0x%x", 'x', f_dir9, (char *) 0));
2796
2797 #if WITH_PROFILE_MODEL_P
2798   /* Record the fields for profiling.  */
2799   if (PROFILE_MODEL_P (current_cpu))
2800     {
2801       FLD (in_h_gr_13) = 13;
2802       FLD (out_h_gr_13) = 13;
2803     }
2804 #endif
2805 #undef FLD
2806   BREAK (ex);
2807   }
2808
2809   CASE (ex, FMT_DMOV2R13PIB) :
2810   {
2811     CGEN_INSN_INT insn = base_insn;
2812 #define FLD(f) abuf->fields.fmt_dmov2r13pib.f
2813   EXTRACT_IFMT_DMOVR13B_VARS /* f-op1 f-op2 f-dir8 */
2814
2815   EXTRACT_IFMT_DMOVR13B_CODE
2816
2817   /* Record the fields for the semantic handler.  */
2818   FLD (f_dir8) = f_dir8;
2819   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r13pib", "f_dir8 0x%x", 'x', f_dir8, (char *) 0));
2820
2821 #if WITH_PROFILE_MODEL_P
2822   /* Record the fields for profiling.  */
2823   if (PROFILE_MODEL_P (current_cpu))
2824     {
2825       FLD (in_h_gr_13) = 13;
2826       FLD (out_h_gr_13) = 13;
2827     }
2828 #endif
2829 #undef FLD
2830   BREAK (ex);
2831   }
2832
2833   CASE (ex, FMT_DMOV2R15PD) :
2834   {
2835     CGEN_INSN_INT insn = base_insn;
2836 #define FLD(f) abuf->fields.fmt_dmov2r15pd.f
2837   EXTRACT_IFMT_DMOVR13_VARS /* f-op1 f-op2 f-dir10 */
2838
2839   EXTRACT_IFMT_DMOVR13_CODE
2840
2841   /* Record the fields for the semantic handler.  */
2842   FLD (f_dir10) = f_dir10;
2843   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_dmov2r15pd", "f_dir10 0x%x", 'x', f_dir10, (char *) 0));
2844
2845 #if WITH_PROFILE_MODEL_P
2846   /* Record the fields for profiling.  */
2847   if (PROFILE_MODEL_P (current_cpu))
2848     {
2849       FLD (in_h_gr_15) = 15;
2850       FLD (out_h_gr_15) = 15;
2851     }
2852 #endif
2853 #undef FLD
2854   BREAK (ex);
2855   }
2856
2857   CASE (ex, FMT_LDRES) :
2858   {
2859     CGEN_INSN_INT insn = base_insn;
2860 #define FLD(f) abuf->fields.fmt_ldres.f
2861   EXTRACT_IFMT_ADDI_VARS /* f-op1 f-op2 f-u4 f-Ri */
2862
2863   EXTRACT_IFMT_ADDI_CODE
2864
2865   /* Record the fields for the semantic handler.  */
2866   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
2867   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldres", "Ri 0x%x", 'x', f_Ri, (char *) 0));
2868
2869 #if WITH_PROFILE_MODEL_P
2870   /* Record the fields for profiling.  */
2871   if (PROFILE_MODEL_P (current_cpu))
2872     {
2873       FLD (in_Ri) = f_Ri;
2874       FLD (out_Ri) = f_Ri;
2875     }
2876 #endif
2877 #undef FLD
2878   BREAK (ex);
2879   }
2880
2881   CASE (ex, FMT_COPOP) :
2882   {
2883     CGEN_INSN_INT insn = base_insn;
2884 #define FLD(f) abuf->fields.fmt_copop.f
2885   EXTRACT_IFMT_COPOP_VARS /* f-op1 f-ccc f-op2 f-op3 f-CRj f-u4c f-CRi */
2886
2887   EXTRACT_IFMT_COPOP_CODE
2888
2889   /* Record the fields for the semantic handler.  */
2890   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copop", (char *) 0));
2891
2892 #undef FLD
2893   BREAK (ex);
2894   }
2895
2896   CASE (ex, FMT_COPLD) :
2897   {
2898     CGEN_INSN_INT insn = base_insn;
2899 #define FLD(f) abuf->fields.fmt_copld.f
2900   EXTRACT_IFMT_COPLD_VARS /* f-op1 f-ccc f-op2 f-op3 f-Rjc f-u4c f-CRi */
2901
2902   EXTRACT_IFMT_COPLD_CODE
2903
2904   /* Record the fields for the semantic handler.  */
2905   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copld", (char *) 0));
2906
2907 #undef FLD
2908   BREAK (ex);
2909   }
2910
2911   CASE (ex, FMT_COPST) :
2912   {
2913     CGEN_INSN_INT insn = base_insn;
2914 #define FLD(f) abuf->fields.fmt_copst.f
2915   EXTRACT_IFMT_COPST_VARS /* f-op1 f-ccc f-op2 f-op3 f-CRj f-u4c f-Ric */
2916
2917   EXTRACT_IFMT_COPST_CODE
2918
2919   /* Record the fields for the semantic handler.  */
2920   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_copst", (char *) 0));
2921
2922 #undef FLD
2923   BREAK (ex);
2924   }
2925
2926   CASE (ex, FMT_NOP) :
2927   {
2928     CGEN_INSN_INT insn = base_insn;
2929 #define FLD(f) abuf->fields.fmt_nop.f
2930   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
2931
2932   EXTRACT_IFMT_DIV3_CODE
2933
2934   /* Record the fields for the semantic handler.  */
2935   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_nop", (char *) 0));
2936
2937 #undef FLD
2938   BREAK (ex);
2939   }
2940
2941   CASE (ex, FMT_ANDCCR) :
2942   {
2943     CGEN_INSN_INT insn = base_insn;
2944 #define FLD(f) abuf->fields.fmt_andccr.f
2945   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
2946
2947   EXTRACT_IFMT_INT_CODE
2948
2949   /* Record the fields for the semantic handler.  */
2950   FLD (f_u8) = f_u8;
2951   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_andccr", "f_u8 0x%x", 'x', f_u8, (char *) 0));
2952
2953 #undef FLD
2954   BREAK (ex);
2955   }
2956
2957   CASE (ex, FMT_STILM) :
2958   {
2959     CGEN_INSN_INT insn = base_insn;
2960 #define FLD(f) abuf->fields.fmt_stilm.f
2961   EXTRACT_IFMT_INT_VARS /* f-op1 f-op2 f-u8 */
2962
2963   EXTRACT_IFMT_INT_CODE
2964
2965   /* Record the fields for the semantic handler.  */
2966   FLD (f_u8) = f_u8;
2967   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_stilm", "f_u8 0x%x", 'x', f_u8, (char *) 0));
2968
2969 #undef FLD
2970   BREAK (ex);
2971   }
2972
2973   CASE (ex, FMT_ADDSP) :
2974   {
2975     CGEN_INSN_INT insn = base_insn;
2976 #define FLD(f) abuf->fields.fmt_addsp.f
2977   EXTRACT_IFMT_ADDSP_VARS /* f-op1 f-op2 f-s10 */
2978
2979   EXTRACT_IFMT_ADDSP_CODE
2980
2981   /* Record the fields for the semantic handler.  */
2982   FLD (f_s10) = f_s10;
2983   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_addsp", "f_s10 0x%x", 'x', f_s10, (char *) 0));
2984
2985 #if WITH_PROFILE_MODEL_P
2986   /* Record the fields for profiling.  */
2987   if (PROFILE_MODEL_P (current_cpu))
2988     {
2989       FLD (in_h_gr_15) = 15;
2990       FLD (out_h_gr_15) = 15;
2991     }
2992 #endif
2993 #undef FLD
2994   BREAK (ex);
2995   }
2996
2997   CASE (ex, FMT_EXTSB) :
2998   {
2999     CGEN_INSN_INT insn = base_insn;
3000 #define FLD(f) abuf->fields.fmt_extsb.f
3001   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
3002
3003   EXTRACT_IFMT_DIV0S_CODE
3004
3005   /* Record the fields for the semantic handler.  */
3006   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
3007   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_extsb", "Ri 0x%x", 'x', f_Ri, (char *) 0));
3008
3009 #if WITH_PROFILE_MODEL_P
3010   /* Record the fields for profiling.  */
3011   if (PROFILE_MODEL_P (current_cpu))
3012     {
3013       FLD (in_Ri) = f_Ri;
3014       FLD (out_Ri) = f_Ri;
3015     }
3016 #endif
3017 #undef FLD
3018   BREAK (ex);
3019   }
3020
3021   CASE (ex, FMT_EXTUB) :
3022   {
3023     CGEN_INSN_INT insn = base_insn;
3024 #define FLD(f) abuf->fields.fmt_extub.f
3025   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
3026
3027   EXTRACT_IFMT_DIV0S_CODE
3028
3029   /* Record the fields for the semantic handler.  */
3030   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
3031   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_extub", "Ri 0x%x", 'x', f_Ri, (char *) 0));
3032
3033 #if WITH_PROFILE_MODEL_P
3034   /* Record the fields for profiling.  */
3035   if (PROFILE_MODEL_P (current_cpu))
3036     {
3037       FLD (in_Ri) = f_Ri;
3038       FLD (out_Ri) = f_Ri;
3039     }
3040 #endif
3041 #undef FLD
3042   BREAK (ex);
3043   }
3044
3045   CASE (ex, FMT_EXTSH) :
3046   {
3047     CGEN_INSN_INT insn = base_insn;
3048 #define FLD(f) abuf->fields.fmt_extsh.f
3049   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
3050
3051   EXTRACT_IFMT_DIV0S_CODE
3052
3053   /* Record the fields for the semantic handler.  */
3054   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
3055   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_extsh", "Ri 0x%x", 'x', f_Ri, (char *) 0));
3056
3057 #if WITH_PROFILE_MODEL_P
3058   /* Record the fields for profiling.  */
3059   if (PROFILE_MODEL_P (current_cpu))
3060     {
3061       FLD (in_Ri) = f_Ri;
3062       FLD (out_Ri) = f_Ri;
3063     }
3064 #endif
3065 #undef FLD
3066   BREAK (ex);
3067   }
3068
3069   CASE (ex, FMT_EXTUH) :
3070   {
3071     CGEN_INSN_INT insn = base_insn;
3072 #define FLD(f) abuf->fields.fmt_extuh.f
3073   EXTRACT_IFMT_DIV0S_VARS /* f-op1 f-op2 f-op3 f-Ri */
3074
3075   EXTRACT_IFMT_DIV0S_CODE
3076
3077   /* Record the fields for the semantic handler.  */
3078   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
3079   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_extuh", "Ri 0x%x", 'x', f_Ri, (char *) 0));
3080
3081 #if WITH_PROFILE_MODEL_P
3082   /* Record the fields for profiling.  */
3083   if (PROFILE_MODEL_P (current_cpu))
3084     {
3085       FLD (in_Ri) = f_Ri;
3086       FLD (out_Ri) = f_Ri;
3087     }
3088 #endif
3089 #undef FLD
3090   BREAK (ex);
3091   }
3092
3093   CASE (ex, FMT_LDM0) :
3094   {
3095     CGEN_INSN_INT insn = base_insn;
3096 #define FLD(f) abuf->fields.fmt_ldm0.f
3097   EXTRACT_IFMT_LDM0_VARS /* f-op1 f-op2 f-reglist_low_ld */
3098
3099   EXTRACT_IFMT_LDM0_CODE
3100
3101   /* Record the fields for the semantic handler.  */
3102   FLD (f_reglist_low_ld) = f_reglist_low_ld;
3103   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldm0", "f_reglist_low_ld 0x%x", 'x', f_reglist_low_ld, (char *) 0));
3104
3105 #if WITH_PROFILE_MODEL_P
3106   /* Record the fields for profiling.  */
3107   if (PROFILE_MODEL_P (current_cpu))
3108     {
3109       FLD (in_h_gr_15) = 15;
3110       FLD (out_h_gr_0) = 0;
3111       FLD (out_h_gr_1) = 1;
3112       FLD (out_h_gr_15) = 15;
3113       FLD (out_h_gr_2) = 2;
3114       FLD (out_h_gr_3) = 3;
3115       FLD (out_h_gr_4) = 4;
3116       FLD (out_h_gr_5) = 5;
3117       FLD (out_h_gr_6) = 6;
3118       FLD (out_h_gr_7) = 7;
3119     }
3120 #endif
3121 #undef FLD
3122   BREAK (ex);
3123   }
3124
3125   CASE (ex, FMT_LDM1) :
3126   {
3127     CGEN_INSN_INT insn = base_insn;
3128 #define FLD(f) abuf->fields.fmt_ldm1.f
3129   EXTRACT_IFMT_LDM1_VARS /* f-op1 f-op2 f-reglist_hi_ld */
3130
3131   EXTRACT_IFMT_LDM1_CODE
3132
3133   /* Record the fields for the semantic handler.  */
3134   FLD (f_reglist_hi_ld) = f_reglist_hi_ld;
3135   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_ldm1", "f_reglist_hi_ld 0x%x", 'x', f_reglist_hi_ld, (char *) 0));
3136
3137 #if WITH_PROFILE_MODEL_P
3138   /* Record the fields for profiling.  */
3139   if (PROFILE_MODEL_P (current_cpu))
3140     {
3141       FLD (in_h_gr_15) = 15;
3142       FLD (out_h_gr_10) = 10;
3143       FLD (out_h_gr_11) = 11;
3144       FLD (out_h_gr_12) = 12;
3145       FLD (out_h_gr_13) = 13;
3146       FLD (out_h_gr_14) = 14;
3147       FLD (out_h_gr_15) = 15;
3148       FLD (out_h_gr_8) = 8;
3149       FLD (out_h_gr_9) = 9;
3150     }
3151 #endif
3152 #undef FLD
3153   BREAK (ex);
3154   }
3155
3156   CASE (ex, FMT_STM0) :
3157   {
3158     CGEN_INSN_INT insn = base_insn;
3159 #define FLD(f) abuf->fields.fmt_stm0.f
3160   EXTRACT_IFMT_STM0_VARS /* f-op1 f-op2 f-reglist_low_st */
3161
3162   EXTRACT_IFMT_STM0_CODE
3163
3164   /* Record the fields for the semantic handler.  */
3165   FLD (f_reglist_low_st) = f_reglist_low_st;
3166   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_stm0", "f_reglist_low_st 0x%x", 'x', f_reglist_low_st, (char *) 0));
3167
3168 #if WITH_PROFILE_MODEL_P
3169   /* Record the fields for profiling.  */
3170   if (PROFILE_MODEL_P (current_cpu))
3171     {
3172       FLD (in_h_gr_0) = 0;
3173       FLD (in_h_gr_1) = 1;
3174       FLD (in_h_gr_15) = 15;
3175       FLD (in_h_gr_2) = 2;
3176       FLD (in_h_gr_3) = 3;
3177       FLD (in_h_gr_4) = 4;
3178       FLD (in_h_gr_5) = 5;
3179       FLD (in_h_gr_6) = 6;
3180       FLD (in_h_gr_7) = 7;
3181       FLD (out_h_gr_15) = 15;
3182     }
3183 #endif
3184 #undef FLD
3185   BREAK (ex);
3186   }
3187
3188   CASE (ex, FMT_STM1) :
3189   {
3190     CGEN_INSN_INT insn = base_insn;
3191 #define FLD(f) abuf->fields.fmt_stm1.f
3192   EXTRACT_IFMT_STM1_VARS /* f-op1 f-op2 f-reglist_hi_st */
3193
3194   EXTRACT_IFMT_STM1_CODE
3195
3196   /* Record the fields for the semantic handler.  */
3197   FLD (f_reglist_hi_st) = f_reglist_hi_st;
3198   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_stm1", "f_reglist_hi_st 0x%x", 'x', f_reglist_hi_st, (char *) 0));
3199
3200 #if WITH_PROFILE_MODEL_P
3201   /* Record the fields for profiling.  */
3202   if (PROFILE_MODEL_P (current_cpu))
3203     {
3204       FLD (in_h_gr_10) = 10;
3205       FLD (in_h_gr_11) = 11;
3206       FLD (in_h_gr_12) = 12;
3207       FLD (in_h_gr_13) = 13;
3208       FLD (in_h_gr_14) = 14;
3209       FLD (in_h_gr_15) = 15;
3210       FLD (in_h_gr_8) = 8;
3211       FLD (in_h_gr_9) = 9;
3212       FLD (out_h_gr_15) = 15;
3213     }
3214 #endif
3215 #undef FLD
3216   BREAK (ex);
3217   }
3218
3219   CASE (ex, FMT_ENTER) :
3220   {
3221     CGEN_INSN_INT insn = base_insn;
3222 #define FLD(f) abuf->fields.fmt_enter.f
3223   EXTRACT_IFMT_ENTER_VARS /* f-op1 f-op2 f-u10 */
3224
3225   EXTRACT_IFMT_ENTER_CODE
3226
3227   /* Record the fields for the semantic handler.  */
3228   FLD (f_u10) = f_u10;
3229   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_enter", "f_u10 0x%x", 'x', f_u10, (char *) 0));
3230
3231 #if WITH_PROFILE_MODEL_P
3232   /* Record the fields for profiling.  */
3233   if (PROFILE_MODEL_P (current_cpu))
3234     {
3235       FLD (in_h_gr_14) = 14;
3236       FLD (in_h_gr_15) = 15;
3237       FLD (out_h_gr_14) = 14;
3238       FLD (out_h_gr_15) = 15;
3239     }
3240 #endif
3241 #undef FLD
3242   BREAK (ex);
3243   }
3244
3245   CASE (ex, FMT_LEAVE) :
3246   {
3247     CGEN_INSN_INT insn = base_insn;
3248 #define FLD(f) abuf->fields.fmt_leave.f
3249   EXTRACT_IFMT_DIV3_VARS /* f-op1 f-op2 f-op3 f-op4 */
3250
3251   EXTRACT_IFMT_DIV3_CODE
3252
3253   /* Record the fields for the semantic handler.  */
3254   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_leave", (char *) 0));
3255
3256 #if WITH_PROFILE_MODEL_P
3257   /* Record the fields for profiling.  */
3258   if (PROFILE_MODEL_P (current_cpu))
3259     {
3260       FLD (in_h_gr_14) = 14;
3261       FLD (in_h_gr_15) = 15;
3262       FLD (out_h_gr_14) = 14;
3263       FLD (out_h_gr_15) = 15;
3264     }
3265 #endif
3266 #undef FLD
3267   BREAK (ex);
3268   }
3269
3270   CASE (ex, FMT_XCHB) :
3271   {
3272     CGEN_INSN_INT insn = base_insn;
3273 #define FLD(f) abuf->fields.fmt_xchb.f
3274   EXTRACT_IFMT_ADD_VARS /* f-op1 f-op2 f-Rj f-Ri */
3275
3276   EXTRACT_IFMT_ADD_CODE
3277
3278   /* Record the fields for the semantic handler.  */
3279   FLD (i_Ri) = & CPU (h_gr)[f_Ri];
3280   FLD (i_Rj) = & CPU (h_gr)[f_Rj];
3281   TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "fmt_xchb", "Ri 0x%x", 'x', f_Ri, "Rj 0x%x", 'x', f_Rj, (char *) 0));
3282
3283 #if WITH_PROFILE_MODEL_P
3284   /* Record the fields for profiling.  */
3285   if (PROFILE_MODEL_P (current_cpu))
3286     {
3287       FLD (in_Ri) = f_Ri;
3288       FLD (in_Rj) = f_Rj;
3289       FLD (out_Ri) = f_Ri;
3290     }
3291 #endif
3292 #undef FLD
3293   BREAK (ex);
3294   }
3295
3296
3297       }
3298     ENDSWITCH (ex)
3299
3300   }
3301
3302   return idecode->idesc;
3303 }