opcodes/iq2000-desc.c

   1 /* CPU data for iq2000.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996-2010 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
   8
   9    This file is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3, or (at your option)
  12    any later version.
  13
  14    It is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    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    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  22
  23 */
  24
  25 #include "sysdep.h"
  26 #include <stdio.h>
  27 #include <stdarg.h>
  28 #include "ansidecl.h"
  29 #include "bfd.h"
  30 #include "symcat.h"
  31 #include "iq2000-desc.h"
  32 #include "iq2000-opc.h"
  33 #include "opintl.h"
  34 #include "libiberty.h"
  35 #include "xregex.h"
  36
  37 /* Attributes.  */
  38
  39 static const CGEN_ATTR_ENTRY bool_attr[] =
  40 {
  41   { "#f", 0 },
  42   { "#t", 1 },
  43   { 0, 0 }
  44 };
  45
  46 static const CGEN_ATTR_ENTRY MACH_attr[] ATTRIBUTE_UNUSED =
  47 {
  48   { "base", MACH_BASE },
  49   { "iq2000", MACH_IQ2000 },
  50   { "iq10", MACH_IQ10 },
  51   { "max", MACH_MAX },
  52   { 0, 0 }
  53 };
  54
  55 static const CGEN_ATTR_ENTRY ISA_attr[] ATTRIBUTE_UNUSED =
  56 {
  57   { "iq2000", ISA_IQ2000 },
  58   { "max", ISA_MAX },
  59   { 0, 0 }
  60 };
  61
  62 const CGEN_ATTR_TABLE iq2000_cgen_ifield_attr_table[] =
  63 {
  64   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  65   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  66   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  67   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  68   { "RESERVED", &bool_attr[0], &bool_attr[0] },
  69   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  70   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  71   { 0, 0, 0 }
  72 };
  73
  74 const CGEN_ATTR_TABLE iq2000_cgen_hardware_attr_table[] =
  75 {
  76   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  77   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  78   { "CACHE-ADDR", &bool_attr[0], &bool_attr[0] },
  79   { "PC", &bool_attr[0], &bool_attr[0] },
  80   { "PROFILE", &bool_attr[0], &bool_attr[0] },
  81   { 0, 0, 0 }
  82 };
  83
  84 const CGEN_ATTR_TABLE iq2000_cgen_operand_attr_table[] =
  85 {
  86   { "MACH", & MACH_attr[0], & MACH_attr[0] },
  87   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
  88   { "PCREL-ADDR", &bool_attr[0], &bool_attr[0] },
  89   { "ABS-ADDR", &bool_attr[0], &bool_attr[0] },
  90   { "SIGN-OPT", &bool_attr[0], &bool_attr[0] },
  91   { "SIGNED", &bool_attr[0], &bool_attr[0] },
  92   { "NEGATIVE", &bool_attr[0], &bool_attr[0] },
  93   { "RELAX", &bool_attr[0], &bool_attr[0] },
  94   { "SEM-ONLY", &bool_attr[0], &bool_attr[0] },
  95   { 0, 0, 0 }
  96 };
  97
  98 const CGEN_ATTR_TABLE iq2000_cgen_insn_attr_table[] =
  99 {
 100   { "MACH", & MACH_attr[0], & MACH_attr[0] },
 101   { "ALIAS", &bool_attr[0], &bool_attr[0] },
 102   { "VIRTUAL", &bool_attr[0], &bool_attr[0] },
 103   { "UNCOND-CTI", &bool_attr[0], &bool_attr[0] },
 104   { "COND-CTI", &bool_attr[0], &bool_attr[0] },
 105   { "SKIP-CTI", &bool_attr[0], &bool_attr[0] },
 106   { "DELAY-SLOT", &bool_attr[0], &bool_attr[0] },
 107   { "RELAXABLE", &bool_attr[0], &bool_attr[0] },
 108   { "RELAXED", &bool_attr[0], &bool_attr[0] },
 109   { "NO-DIS", &bool_attr[0], &bool_attr[0] },
 110   { "PBB", &bool_attr[0], &bool_attr[0] },
 111   { "YIELD-INSN", &bool_attr[0], &bool_attr[0] },
 112   { "LOAD-DELAY", &bool_attr[0], &bool_attr[0] },
 113   { "EVEN-REG-NUM", &bool_attr[0], &bool_attr[0] },
 114   { "UNSUPPORTED", &bool_attr[0], &bool_attr[0] },
 115   { "USES-RD", &bool_attr[0], &bool_attr[0] },
 116   { "USES-RS", &bool_attr[0], &bool_attr[0] },
 117   { "USES-RT", &bool_attr[0], &bool_attr[0] },
 118   { "USES-R31", &bool_attr[0], &bool_attr[0] },
 119   { 0, 0, 0 }
 120 };
 121
 122 /* Instruction set variants.  */
 123
 124 static const CGEN_ISA iq2000_cgen_isa_table[] = {
 125   { "iq2000", 32, 32, 32, 32 },
 126   { 0, 0, 0, 0, 0 }
 127 };
 128
 129 /* Machine variants.  */
 130
 131 static const CGEN_MACH iq2000_cgen_mach_table[] = {
 132   { "iq2000", "iq2000", MACH_IQ2000, 0 },
 133   { "iq10", "iq10", MACH_IQ10, 0 },
 134   { 0, 0, 0, 0 }
 135 };
 136
 137 static CGEN_KEYWORD_ENTRY iq2000_cgen_opval_gr_names_entries[] =
 138 {
 139   { "r0", 0, {0, {{{0, 0}}}}, 0, 0 },
 140   { "%0", 0, {0, {{{0, 0}}}}, 0, 0 },
 141   { "r1", 1, {0, {{{0, 0}}}}, 0, 0 },
 142   { "%1", 1, {0, {{{0, 0}}}}, 0, 0 },
 143   { "r2", 2, {0, {{{0, 0}}}}, 0, 0 },
 144   { "%2", 2, {0, {{{0, 0}}}}, 0, 0 },
 145   { "r3", 3, {0, {{{0, 0}}}}, 0, 0 },
 146   { "%3", 3, {0, {{{0, 0}}}}, 0, 0 },
 147   { "r4", 4, {0, {{{0, 0}}}}, 0, 0 },
 148   { "%4", 4, {0, {{{0, 0}}}}, 0, 0 },
 149   { "r5", 5, {0, {{{0, 0}}}}, 0, 0 },
 150   { "%5", 5, {0, {{{0, 0}}}}, 0, 0 },
 151   { "r6", 6, {0, {{{0, 0}}}}, 0, 0 },
 152   { "%6", 6, {0, {{{0, 0}}}}, 0, 0 },
 153   { "r7", 7, {0, {{{0, 0}}}}, 0, 0 },
 154   { "%7", 7, {0, {{{0, 0}}}}, 0, 0 },
 155   { "r8", 8, {0, {{{0, 0}}}}, 0, 0 },
 156   { "%8", 8, {0, {{{0, 0}}}}, 0, 0 },
 157   { "r9", 9, {0, {{{0, 0}}}}, 0, 0 },
 158   { "%9", 9, {0, {{{0, 0}}}}, 0, 0 },
 159   { "r10", 10, {0, {{{0, 0}}}}, 0, 0 },
 160   { "%10", 10, {0, {{{0, 0}}}}, 0, 0 },
 161   { "r11", 11, {0, {{{0, 0}}}}, 0, 0 },
 162   { "%11", 11, {0, {{{0, 0}}}}, 0, 0 },
 163   { "r12", 12, {0, {{{0, 0}}}}, 0, 0 },
 164   { "%12", 12, {0, {{{0, 0}}}}, 0, 0 },
 165   { "r13", 13, {0, {{{0, 0}}}}, 0, 0 },
 166   { "%13", 13, {0, {{{0, 0}}}}, 0, 0 },
 167   { "r14", 14, {0, {{{0, 0}}}}, 0, 0 },
 168   { "%14", 14, {0, {{{0, 0}}}}, 0, 0 },
 169   { "r15", 15, {0, {{{0, 0}}}}, 0, 0 },
 170   { "%15", 15, {0, {{{0, 0}}}}, 0, 0 },
 171   { "r16", 16, {0, {{{0, 0}}}}, 0, 0 },
 172   { "%16", 16, {0, {{{0, 0}}}}, 0, 0 },
 173   { "r17", 17, {0, {{{0, 0}}}}, 0, 0 },
 174   { "%17", 17, {0, {{{0, 0}}}}, 0, 0 },
 175   { "r18", 18, {0, {{{0, 0}}}}, 0, 0 },
 176   { "%18", 18, {0, {{{0, 0}}}}, 0, 0 },
 177   { "r19", 19, {0, {{{0, 0}}}}, 0, 0 },
 178   { "%19", 19, {0, {{{0, 0}}}}, 0, 0 },
 179   { "r20", 20, {0, {{{0, 0}}}}, 0, 0 },
 180   { "%20", 20, {0, {{{0, 0}}}}, 0, 0 },
 181   { "r21", 21, {0, {{{0, 0}}}}, 0, 0 },
 182   { "%21", 21, {0, {{{0, 0}}}}, 0, 0 },
 183   { "r22", 22, {0, {{{0, 0}}}}, 0, 0 },
 184   { "%22", 22, {0, {{{0, 0}}}}, 0, 0 },
 185   { "r23", 23, {0, {{{0, 0}}}}, 0, 0 },
 186   { "%23", 23, {0, {{{0, 0}}}}, 0, 0 },
 187   { "r24", 24, {0, {{{0, 0}}}}, 0, 0 },
 188   { "%24", 24, {0, {{{0, 0}}}}, 0, 0 },
 189   { "r25", 25, {0, {{{0, 0}}}}, 0, 0 },
 190   { "%25", 25, {0, {{{0, 0}}}}, 0, 0 },
 191   { "r26", 26, {0, {{{0, 0}}}}, 0, 0 },
 192   { "%26", 26, {0, {{{0, 0}}}}, 0, 0 },
 193   { "r27", 27, {0, {{{0, 0}}}}, 0, 0 },
 194   { "%27", 27, {0, {{{0, 0}}}}, 0, 0 },
 195   { "r28", 28, {0, {{{0, 0}}}}, 0, 0 },
 196   { "%28", 28, {0, {{{0, 0}}}}, 0, 0 },
 197   { "r29", 29, {0, {{{0, 0}}}}, 0, 0 },
 198   { "%29", 29, {0, {{{0, 0}}}}, 0, 0 },
 199   { "r30", 30, {0, {{{0, 0}}}}, 0, 0 },
 200   { "%30", 30, {0, {{{0, 0}}}}, 0, 0 },
 201   { "r31", 31, {0, {{{0, 0}}}}, 0, 0 },
 202   { "%31", 31, {0, {{{0, 0}}}}, 0, 0 }
 203 };
 204
 205 CGEN_KEYWORD iq2000_cgen_opval_gr_names =
 206 {
 207   & iq2000_cgen_opval_gr_names_entries[0],
 208   64,
 209   0, 0, 0, 0, ""
 210 };
 211
 212
 213 /* The hardware table.  */
 214
 215 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 216 #define A(a) (1 << CGEN_HW_##a)
 217 #else
 218 #define A(a) (1 << CGEN_HW_/**/a)
 219 #endif
 220
 221 const CGEN_HW_ENTRY iq2000_cgen_hw_table[] =
 222 {
 223   { "h-memory", HW_H_MEMORY, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 224   { "h-sint", HW_H_SINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 225   { "h-uint", HW_H_UINT, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 226   { "h-addr", HW_H_ADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 227   { "h-iaddr", HW_H_IADDR, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 228   { "h-pc", HW_H_PC, CGEN_ASM_NONE, 0, { 0|A(PROFILE)|A(PC), { { { (1<<MACH_BASE), 0 } } } } },
 229   { "h-gr", HW_H_GR, CGEN_ASM_KEYWORD, (PTR) & iq2000_cgen_opval_gr_names, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 230   { 0, 0, CGEN_ASM_NONE, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
 231 };
 232
 233 #undef A
 234
 235
 236 /* The instruction field table.  */
 237
 238 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 239 #define A(a) (1 << CGEN_IFLD_##a)
 240 #else
 241 #define A(a) (1 << CGEN_IFLD_/**/a)
 242 #endif
 243
 244 const CGEN_IFLD iq2000_cgen_ifld_table[] =
 245 {
 246   { IQ2000_F_NIL, "f-nil", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 247   { IQ2000_F_ANYOF, "f-anyof", 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 248   { IQ2000_F_OPCODE, "f-opcode", 0, 32, 31, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 249   { IQ2000_F_RS, "f-rs", 0, 32, 25, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 250   { IQ2000_F_RT, "f-rt", 0, 32, 20, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 251   { IQ2000_F_RD, "f-rd", 0, 32, 15, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 252   { IQ2000_F_SHAMT, "f-shamt", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 253   { IQ2000_F_CP_OP, "f-cp-op", 0, 32, 10, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 254   { IQ2000_F_CP_OP_10, "f-cp-op-10", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 255   { IQ2000_F_CP_GRP, "f-cp-grp", 0, 32, 7, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 256   { IQ2000_F_FUNC, "f-func", 0, 32, 5, 6, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 257   { IQ2000_F_IMM, "f-imm", 0, 32, 15, 16, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 258   { IQ2000_F_RD_RS, "f-rd-rs", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 259   { IQ2000_F_RD_RT, "f-rd-rt", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 260   { IQ2000_F_RT_RS, "f-rt-rs", 0, 0, 0, 0,{ 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 261   { IQ2000_F_JTARG, "f-jtarg", 0, 32, 15, 16, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 262   { IQ2000_F_JTARGQ10, "f-jtargq10", 0, 32, 20, 21, { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 263   { IQ2000_F_OFFSET, "f-offset", 0, 32, 15, 16, { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 264   { IQ2000_F_COUNT, "f-count", 0, 32, 15, 7, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 265   { IQ2000_F_BYTECOUNT, "f-bytecount", 0, 32, 7, 8, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 266   { IQ2000_F_INDEX, "f-index", 0, 32, 8, 9, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 267   { IQ2000_F_MASK, "f-mask", 0, 32, 9, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 268   { IQ2000_F_MASKQ10, "f-maskq10", 0, 32, 10, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 269   { IQ2000_F_MASKL, "f-maskl", 0, 32, 4, 5, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 270   { IQ2000_F_EXCODE, "f-excode", 0, 32, 25, 20, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 271   { IQ2000_F_RSRVD, "f-rsrvd", 0, 32, 25, 10, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 272   { IQ2000_F_10_11, "f-10-11", 0, 32, 10, 11, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 273   { IQ2000_F_24_19, "f-24-19", 0, 32, 24, 19, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 274   { IQ2000_F_5, "f-5", 0, 32, 5, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 275   { IQ2000_F_10, "f-10", 0, 32, 10, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 276   { IQ2000_F_25, "f-25", 0, 32, 25, 1, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 277   { IQ2000_F_CAM_Z, "f-cam-z", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 278   { IQ2000_F_CAM_Y, "f-cam-y", 0, 32, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 279   { IQ2000_F_CM_3FUNC, "f-cm-3func", 0, 32, 5, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 280   { IQ2000_F_CM_4FUNC, "f-cm-4func", 0, 32, 5, 4, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 281   { IQ2000_F_CM_3Z, "f-cm-3z", 0, 32, 1, 2, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 282   { IQ2000_F_CM_4Z, "f-cm-4z", 0, 32, 2, 3, { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 283   { 0, 0, 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } }
 284 };
 285
 286 #undef A
 287
 288
 289
 290 /* multi ifield declarations */
 291
 292 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RS_MULTI_IFIELD [];
 293 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RT_MULTI_IFIELD [];
 294 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RT_RS_MULTI_IFIELD [];
 295
 296
 297 /* multi ifield definitions */
 298
 299 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RS_MULTI_IFIELD [] =
 300 {
 301     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
 302     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
 303     { 0, { (const PTR) 0 } }
 304 };
 305 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RD_RT_MULTI_IFIELD [] =
 306 {
 307     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
 308     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
 309     { 0, { (const PTR) 0 } }
 310 };
 311 const CGEN_MAYBE_MULTI_IFLD IQ2000_F_RT_RS_MULTI_IFIELD [] =
 312 {
 313     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
 314     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
 315     { 0, { (const PTR) 0 } }
 316 };
 317
 318 /* The operand table.  */
 319
 320 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 321 #define A(a) (1 << CGEN_OPERAND_##a)
 322 #else
 323 #define A(a) (1 << CGEN_OPERAND_/**/a)
 324 #endif
 325 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 326 #define OPERAND(op) IQ2000_OPERAND_##op
 327 #else
 328 #define OPERAND(op) IQ2000_OPERAND_/**/op
 329 #endif
 330
 331 const CGEN_OPERAND iq2000_cgen_operand_table[] =
 332 {
 333 /* pc: program counter */
 334   { "pc", IQ2000_OPERAND_PC, HW_H_PC, 0, 0,
 335     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_NIL] } },
 336     { 0|A(SEM_ONLY), { { { (1<<MACH_BASE), 0 } } } }  },
 337 /* rs: register Rs */
 338   { "rs", IQ2000_OPERAND_RS, HW_H_GR, 25, 5,
 339     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
 340     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 341 /* rt: register Rt */
 342   { "rt", IQ2000_OPERAND_RT, HW_H_GR, 20, 5,
 343     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
 344     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 345 /* rd: register Rd */
 346   { "rd", IQ2000_OPERAND_RD, HW_H_GR, 15, 5,
 347     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RD] } },
 348     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 349 /* rd-rs: register Rd from Rs */
 350   { "rd-rs", IQ2000_OPERAND_RD_RS, HW_H_GR, 15, 10,
 351     { 2, { (const PTR) &IQ2000_F_RD_RS_MULTI_IFIELD[0] } },
 352     { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 353 /* rd-rt: register Rd from Rt */
 354   { "rd-rt", IQ2000_OPERAND_RD_RT, HW_H_GR, 15, 10,
 355     { 2, { (const PTR) &IQ2000_F_RD_RT_MULTI_IFIELD[0] } },
 356     { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 357 /* rt-rs: register Rt from Rs */
 358   { "rt-rs", IQ2000_OPERAND_RT_RS, HW_H_GR, 20, 10,
 359     { 2, { (const PTR) &IQ2000_F_RT_RS_MULTI_IFIELD[0] } },
 360     { 0|A(VIRTUAL), { { { (1<<MACH_BASE), 0 } } } }  },
 361 /* shamt: shift amount */
 362   { "shamt", IQ2000_OPERAND_SHAMT, HW_H_UINT, 10, 5,
 363     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_SHAMT] } },
 364     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 365 /* imm: immediate */
 366   { "imm", IQ2000_OPERAND_IMM, HW_H_UINT, 15, 16,
 367     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
 368     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 369 /* offset: pc-relative offset */
 370   { "offset", IQ2000_OPERAND_OFFSET, HW_H_IADDR, 15, 16,
 371     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_OFFSET] } },
 372     { 0|A(PCREL_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 373 /* baseoff: base register offset */
 374   { "baseoff", IQ2000_OPERAND_BASEOFF, HW_H_IADDR, 15, 16,
 375     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
 376     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 377 /* jmptarg: jump target */
 378   { "jmptarg", IQ2000_OPERAND_JMPTARG, HW_H_IADDR, 15, 16,
 379     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_JTARG] } },
 380     { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 381 /* mask: mask */
 382   { "mask", IQ2000_OPERAND_MASK, HW_H_UINT, 9, 4,
 383     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASK] } },
 384     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 385 /* maskq10: iq10 mask */
 386   { "maskq10", IQ2000_OPERAND_MASKQ10, HW_H_UINT, 10, 5,
 387     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASKQ10] } },
 388     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 389 /* maskl: mask left */
 390   { "maskl", IQ2000_OPERAND_MASKL, HW_H_UINT, 4, 5,
 391     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_MASKL] } },
 392     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 393 /* count: count */
 394   { "count", IQ2000_OPERAND_COUNT, HW_H_UINT, 15, 7,
 395     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_COUNT] } },
 396     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 397 /* _index: index */
 398   { "_index", IQ2000_OPERAND__INDEX, HW_H_UINT, 8, 9,
 399     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_INDEX] } },
 400     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 401 /* execode: execcode */
 402   { "execode", IQ2000_OPERAND_EXECODE, HW_H_UINT, 25, 20,
 403     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_EXCODE] } },
 404     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 405 /* bytecount: byte count */
 406   { "bytecount", IQ2000_OPERAND_BYTECOUNT, HW_H_UINT, 7, 8,
 407     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_BYTECOUNT] } },
 408     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 409 /* cam-y: cam global opn y */
 410   { "cam-y", IQ2000_OPERAND_CAM_Y, HW_H_UINT, 2, 3,
 411     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CAM_Y] } },
 412     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 413 /* cam-z: cam global mask z */
 414   { "cam-z", IQ2000_OPERAND_CAM_Z, HW_H_UINT, 5, 3,
 415     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CAM_Z] } },
 416     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 417 /* cm-3func: CM 3 bit fn field */
 418   { "cm-3func", IQ2000_OPERAND_CM_3FUNC, HW_H_UINT, 5, 3,
 419     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_3FUNC] } },
 420     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 421 /* cm-4func: CM 4 bit fn field */
 422   { "cm-4func", IQ2000_OPERAND_CM_4FUNC, HW_H_UINT, 5, 4,
 423     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_4FUNC] } },
 424     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 425 /* cm-3z: CM 3 bit Z field */
 426   { "cm-3z", IQ2000_OPERAND_CM_3Z, HW_H_UINT, 1, 2,
 427     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_3Z] } },
 428     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 429 /* cm-4z: CM 4 bit Z field */
 430   { "cm-4z", IQ2000_OPERAND_CM_4Z, HW_H_UINT, 2, 3,
 431     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_CM_4Z] } },
 432     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 433 /* base: base register */
 434   { "base", IQ2000_OPERAND_BASE, HW_H_GR, 25, 5,
 435     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
 436     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 437 /* maskr: mask right */
 438   { "maskr", IQ2000_OPERAND_MASKR, HW_H_UINT, 25, 5,
 439     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RS] } },
 440     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 441 /* bitnum: bit number */
 442   { "bitnum", IQ2000_OPERAND_BITNUM, HW_H_UINT, 20, 5,
 443     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_RT] } },
 444     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 445 /* hi16: high 16 bit immediate */
 446   { "hi16", IQ2000_OPERAND_HI16, HW_H_UINT, 15, 16,
 447     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
 448     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 449 /* lo16: 16 bit signed immediate, for low */
 450   { "lo16", IQ2000_OPERAND_LO16, HW_H_UINT, 15, 16,
 451     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
 452     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 453 /* mlo16: negated 16 bit signed immediate */
 454   { "mlo16", IQ2000_OPERAND_MLO16, HW_H_UINT, 15, 16,
 455     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_IMM] } },
 456     { 0, { { { (1<<MACH_BASE), 0 } } } }  },
 457 /* jmptargq10: iq10 21-bit jump offset */
 458   { "jmptargq10", IQ2000_OPERAND_JMPTARGQ10, HW_H_IADDR, 20, 21,
 459     { 0, { (const PTR) &iq2000_cgen_ifld_table[IQ2000_F_JTARGQ10] } },
 460     { 0|A(ABS_ADDR), { { { (1<<MACH_BASE), 0 } } } }  },
 461 /* sentinel */
 462   { 0, 0, 0, 0, 0,
 463     { 0, { (const PTR) 0 } },
 464     { 0, { { { (1<<MACH_BASE), 0 } } } } }
 465 };
 466
 467 #undef A
 468
 469
 470 /* The instruction table.  */
 471
 472 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 473 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 474 #define A(a) (1 << CGEN_INSN_##a)
 475 #else
 476 #define A(a) (1 << CGEN_INSN_/**/a)
 477 #endif
 478
 479 static const CGEN_IBASE iq2000_cgen_insn_table[MAX_INSNS] =
 480 {
 481   /* Special null first entry.
 482      A `num' value of zero is thus invalid.
 483      Also, the special `invalid' insn resides here.  */
 484   { 0, 0, 0, 0, { 0, { { { (1<<MACH_BASE), 0 } } } } },
 485 /* add ${rd-rs},$rt */
 486   {
 487     -1, "add2", "add", 32,
 488     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 489   },
 490 /* add $rd,$rs,$rt */
 491   {
 492     IQ2000_INSN_ADD, "add", "add", 32,
 493     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 494   },
 495 /* addi ${rt-rs},$lo16 */
 496   {
 497     -1, "addi2", "addi", 32,
 498     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 499   },
 500 /* addi $rt,$rs,$lo16 */
 501   {
 502     IQ2000_INSN_ADDI, "addi", "addi", 32,
 503     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 504   },
 505 /* addiu ${rt-rs},$lo16 */
 506   {
 507     -1, "addiu2", "addiu", 32,
 508     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 509   },
 510 /* addiu $rt,$rs,$lo16 */
 511   {
 512     IQ2000_INSN_ADDIU, "addiu", "addiu", 32,
 513     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 514   },
 515 /* addu ${rd-rs},$rt */
 516   {
 517     -1, "addu2", "addu", 32,
 518     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 519   },
 520 /* addu $rd,$rs,$rt */
 521   {
 522     IQ2000_INSN_ADDU, "addu", "addu", 32,
 523     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 524   },
 525 /* ado16 ${rd-rs},$rt */
 526   {
 527     -1, "ado162", "ado16", 32,
 528     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 529   },
 530 /* ado16 $rd,$rs,$rt */
 531   {
 532     IQ2000_INSN_ADO16, "ado16", "ado16", 32,
 533     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 534   },
 535 /* and ${rd-rs},$rt */
 536   {
 537     -1, "and2", "and", 32,
 538     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 539   },
 540 /* and $rd,$rs,$rt */
 541   {
 542     IQ2000_INSN_AND, "and", "and", 32,
 543     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 544   },
 545 /* andi ${rt-rs},$lo16 */
 546   {
 547     -1, "andi2", "andi", 32,
 548     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 549   },
 550 /* andi $rt,$rs,$lo16 */
 551   {
 552     IQ2000_INSN_ANDI, "andi", "andi", 32,
 553     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 554   },
 555 /* andoi ${rt-rs},$lo16 */
 556   {
 557     -1, "andoi2", "andoi", 32,
 558     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 559   },
 560 /* andoi $rt,$rs,$lo16 */
 561   {
 562     IQ2000_INSN_ANDOI, "andoi", "andoi", 32,
 563     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 564   },
 565 /* nor ${rd-rs},$rt */
 566   {
 567     -1, "nor2", "nor", 32,
 568     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 569   },
 570 /* nor $rd,$rs,$rt */
 571   {
 572     IQ2000_INSN_NOR, "nor", "nor", 32,
 573     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 574   },
 575 /* or ${rd-rs},$rt */
 576   {
 577     -1, "or2", "or", 32,
 578     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 579   },
 580 /* or $rd,$rs,$rt */
 581   {
 582     IQ2000_INSN_OR, "or", "or", 32,
 583     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 584   },
 585 /* ori ${rt-rs},$lo16 */
 586   {
 587     -1, "ori2", "ori", 32,
 588     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 589   },
 590 /* ori $rt,$rs,$lo16 */
 591   {
 592     IQ2000_INSN_ORI, "ori", "ori", 32,
 593     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 594   },
 595 /* ram $rd,$rt,$shamt,$maskl,$maskr */
 596   {
 597     IQ2000_INSN_RAM, "ram", "ram", 32,
 598     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 599   },
 600 /* sll $rd,$rt,$shamt */
 601   {
 602     IQ2000_INSN_SLL, "sll", "sll", 32,
 603     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 604   },
 605 /* sllv ${rd-rt},$rs */
 606   {
 607     -1, "sllv2", "sllv", 32,
 608     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 609   },
 610 /* sllv $rd,$rt,$rs */
 611   {
 612     IQ2000_INSN_SLLV, "sllv", "sllv", 32,
 613     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 614   },
 615 /* slmv ${rd-rt},$rs,$shamt */
 616   {
 617     -1, "slmv2", "slmv", 32,
 618     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 619   },
 620 /* slmv $rd,$rt,$rs,$shamt */
 621   {
 622     IQ2000_INSN_SLMV, "slmv", "slmv", 32,
 623     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 624   },
 625 /* slt ${rd-rs},$rt */
 626   {
 627     -1, "slt2", "slt", 32,
 628     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 629   },
 630 /* slt $rd,$rs,$rt */
 631   {
 632     IQ2000_INSN_SLT, "slt", "slt", 32,
 633     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 634   },
 635 /* slti ${rt-rs},$imm */
 636   {
 637     -1, "slti2", "slti", 32,
 638     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 639   },
 640 /* slti $rt,$rs,$imm */
 641   {
 642     IQ2000_INSN_SLTI, "slti", "slti", 32,
 643     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 644   },
 645 /* sltiu ${rt-rs},$imm */
 646   {
 647     -1, "sltiu2", "sltiu", 32,
 648     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 649   },
 650 /* sltiu $rt,$rs,$imm */
 651   {
 652     IQ2000_INSN_SLTIU, "sltiu", "sltiu", 32,
 653     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 654   },
 655 /* sltu ${rd-rs},$rt */
 656   {
 657     -1, "sltu2", "sltu", 32,
 658     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 659   },
 660 /* sltu $rd,$rs,$rt */
 661   {
 662     IQ2000_INSN_SLTU, "sltu", "sltu", 32,
 663     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 664   },
 665 /* sra ${rd-rt},$shamt */
 666   {
 667     -1, "sra2", "sra", 32,
 668     { 0|A(USES_RT)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 669   },
 670 /* sra $rd,$rt,$shamt */
 671   {
 672     IQ2000_INSN_SRA, "sra", "sra", 32,
 673     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 674   },
 675 /* srav ${rd-rt},$rs */
 676   {
 677     -1, "srav2", "srav", 32,
 678     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 679   },
 680 /* srav $rd,$rt,$rs */
 681   {
 682     IQ2000_INSN_SRAV, "srav", "srav", 32,
 683     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 684   },
 685 /* srl $rd,$rt,$shamt */
 686   {
 687     IQ2000_INSN_SRL, "srl", "srl", 32,
 688     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 689   },
 690 /* srlv ${rd-rt},$rs */
 691   {
 692     -1, "srlv2", "srlv", 32,
 693     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 694   },
 695 /* srlv $rd,$rt,$rs */
 696   {
 697     IQ2000_INSN_SRLV, "srlv", "srlv", 32,
 698     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 699   },
 700 /* srmv ${rd-rt},$rs,$shamt */
 701   {
 702     -1, "srmv2", "srmv", 32,
 703     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 704   },
 705 /* srmv $rd,$rt,$rs,$shamt */
 706   {
 707     IQ2000_INSN_SRMV, "srmv", "srmv", 32,
 708     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 709   },
 710 /* sub ${rd-rs},$rt */
 711   {
 712     -1, "sub2", "sub", 32,
 713     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 714   },
 715 /* sub $rd,$rs,$rt */
 716   {
 717     IQ2000_INSN_SUB, "sub", "sub", 32,
 718     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 719   },
 720 /* subu ${rd-rs},$rt */
 721   {
 722     -1, "subu2", "subu", 32,
 723     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 724   },
 725 /* subu $rd,$rs,$rt */
 726   {
 727     IQ2000_INSN_SUBU, "subu", "subu", 32,
 728     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 729   },
 730 /* xor ${rd-rs},$rt */
 731   {
 732     -1, "xor2", "xor", 32,
 733     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 734   },
 735 /* xor $rd,$rs,$rt */
 736   {
 737     IQ2000_INSN_XOR, "xor", "xor", 32,
 738     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_BASE), 0 } } } }
 739   },
 740 /* xori ${rt-rs},$lo16 */
 741   {
 742     -1, "xori2", "xori", 32,
 743     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } } } }
 744   },
 745 /* xori $rt,$rs,$lo16 */
 746   {
 747     IQ2000_INSN_XORI, "xori", "xori", 32,
 748     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 749   },
 750 /* bbi $rs($bitnum),$offset */
 751   {
 752     IQ2000_INSN_BBI, "bbi", "bbi", 32,
 753     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 754   },
 755 /* bbin $rs($bitnum),$offset */
 756   {
 757     IQ2000_INSN_BBIN, "bbin", "bbin", 32,
 758     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 759   },
 760 /* bbv $rs,$rt,$offset */
 761   {
 762     IQ2000_INSN_BBV, "bbv", "bbv", 32,
 763     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 764   },
 765 /* bbvn $rs,$rt,$offset */
 766   {
 767     IQ2000_INSN_BBVN, "bbvn", "bbvn", 32,
 768     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 769   },
 770 /* beq $rs,$rt,$offset */
 771   {
 772     IQ2000_INSN_BEQ, "beq", "beq", 32,
 773     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 774   },
 775 /* beql $rs,$rt,$offset */
 776   {
 777     IQ2000_INSN_BEQL, "beql", "beql", 32,
 778     { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 779   },
 780 /* bgez $rs,$offset */
 781   {
 782     IQ2000_INSN_BGEZ, "bgez", "bgez", 32,
 783     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 784   },
 785 /* bgezal $rs,$offset */
 786   {
 787     IQ2000_INSN_BGEZAL, "bgezal", "bgezal", 32,
 788     { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 789   },
 790 /* bgezall $rs,$offset */
 791   {
 792     IQ2000_INSN_BGEZALL, "bgezall", "bgezall", 32,
 793     { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 794   },
 795 /* bgezl $rs,$offset */
 796   {
 797     IQ2000_INSN_BGEZL, "bgezl", "bgezl", 32,
 798     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 799   },
 800 /* bltz $rs,$offset */
 801   {
 802     IQ2000_INSN_BLTZ, "bltz", "bltz", 32,
 803     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 804   },
 805 /* bltzl $rs,$offset */
 806   {
 807     IQ2000_INSN_BLTZL, "bltzl", "bltzl", 32,
 808     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 809   },
 810 /* bltzal $rs,$offset */
 811   {
 812     IQ2000_INSN_BLTZAL, "bltzal", "bltzal", 32,
 813     { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 814   },
 815 /* bltzall $rs,$offset */
 816   {
 817     IQ2000_INSN_BLTZALL, "bltzall", "bltzall", 32,
 818     { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 819   },
 820 /* bmb0 $rs,$rt,$offset */
 821   {
 822     IQ2000_INSN_BMB0, "bmb0", "bmb0", 32,
 823     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 824   },
 825 /* bmb1 $rs,$rt,$offset */
 826   {
 827     IQ2000_INSN_BMB1, "bmb1", "bmb1", 32,
 828     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 829   },
 830 /* bmb2 $rs,$rt,$offset */
 831   {
 832     IQ2000_INSN_BMB2, "bmb2", "bmb2", 32,
 833     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 834   },
 835 /* bmb3 $rs,$rt,$offset */
 836   {
 837     IQ2000_INSN_BMB3, "bmb3", "bmb3", 32,
 838     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 839   },
 840 /* bne $rs,$rt,$offset */
 841   {
 842     IQ2000_INSN_BNE, "bne", "bne", 32,
 843     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 844   },
 845 /* bnel $rs,$rt,$offset */
 846   {
 847     IQ2000_INSN_BNEL, "bnel", "bnel", 32,
 848     { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 849   },
 850 /* jalr $rd,$rs */
 851   {
 852     IQ2000_INSN_JALR, "jalr", "jalr", 32,
 853     { 0|A(USES_RS)|A(USES_RD)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 854   },
 855 /* jr $rs */
 856   {
 857     IQ2000_INSN_JR, "jr", "jr", 32,
 858     { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_BASE), 0 } } } }
 859   },
 860 /* lb $rt,$lo16($base) */
 861   {
 862     IQ2000_INSN_LB, "lb", "lb", 32,
 863     { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
 864   },
 865 /* lbu $rt,$lo16($base) */
 866   {
 867     IQ2000_INSN_LBU, "lbu", "lbu", 32,
 868     { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
 869   },
 870 /* lh $rt,$lo16($base) */
 871   {
 872     IQ2000_INSN_LH, "lh", "lh", 32,
 873     { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
 874   },
 875 /* lhu $rt,$lo16($base) */
 876   {
 877     IQ2000_INSN_LHU, "lhu", "lhu", 32,
 878     { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
 879   },
 880 /* lui $rt,$hi16 */
 881   {
 882     IQ2000_INSN_LUI, "lui", "lui", 32,
 883     { 0|A(USES_RT), { { { (1<<MACH_BASE), 0 } } } }
 884   },
 885 /* lw $rt,$lo16($base) */
 886   {
 887     IQ2000_INSN_LW, "lw", "lw", 32,
 888     { 0|A(USES_RT)|A(USES_RS)|A(LOAD_DELAY), { { { (1<<MACH_BASE), 0 } } } }
 889   },
 890 /* sb $rt,$lo16($base) */
 891   {
 892     IQ2000_INSN_SB, "sb", "sb", 32,
 893     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 894   },
 895 /* sh $rt,$lo16($base) */
 896   {
 897     IQ2000_INSN_SH, "sh", "sh", 32,
 898     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 899   },
 900 /* sw $rt,$lo16($base) */
 901   {
 902     IQ2000_INSN_SW, "sw", "sw", 32,
 903     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_BASE), 0 } } } }
 904   },
 905 /* break */
 906   {
 907     IQ2000_INSN_BREAK, "break", "break", 32,
 908     { 0, { { { (1<<MACH_BASE), 0 } } } }
 909   },
 910 /* syscall */
 911   {
 912     IQ2000_INSN_SYSCALL, "syscall", "syscall", 32,
 913     { 0|A(YIELD_INSN), { { { (1<<MACH_BASE), 0 } } } }
 914   },
 915 /* andoui $rt,$rs,$hi16 */
 916   {
 917     IQ2000_INSN_ANDOUI, "andoui", "andoui", 32,
 918     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ2000), 0 } } } }
 919   },
 920 /* andoui ${rt-rs},$hi16 */
 921   {
 922     -1, "andoui2", "andoui", 32,
 923     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
 924   },
 925 /* orui ${rt-rs},$hi16 */
 926   {
 927     -1, "orui2", "orui", 32,
 928     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
 929   },
 930 /* orui $rt,$rs,$hi16 */
 931   {
 932     IQ2000_INSN_ORUI, "orui", "orui", 32,
 933     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ2000), 0 } } } }
 934   },
 935 /* bgtz $rs,$offset */
 936   {
 937     IQ2000_INSN_BGTZ, "bgtz", "bgtz", 32,
 938     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 939   },
 940 /* bgtzl $rs,$offset */
 941   {
 942     IQ2000_INSN_BGTZL, "bgtzl", "bgtzl", 32,
 943     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 944   },
 945 /* blez $rs,$offset */
 946   {
 947     IQ2000_INSN_BLEZ, "blez", "blez", 32,
 948     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 949   },
 950 /* blezl $rs,$offset */
 951   {
 952     IQ2000_INSN_BLEZL, "blezl", "blezl", 32,
 953     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 954   },
 955 /* mrgb $rd,$rs,$rt,$mask */
 956   {
 957     IQ2000_INSN_MRGB, "mrgb", "mrgb", 32,
 958     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
 959   },
 960 /* mrgb ${rd-rs},$rt,$mask */
 961   {
 962     -1, "mrgb2", "mrgb", 32,
 963     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ2000), 0 } } } }
 964   },
 965 /* bctxt $rs,$offset */
 966   {
 967     IQ2000_INSN_BCTXT, "bctxt", "bctxt", 32,
 968     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 969   },
 970 /* bc0f $offset */
 971   {
 972     IQ2000_INSN_BC0F, "bc0f", "bc0f", 32,
 973     { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 974   },
 975 /* bc0fl $offset */
 976   {
 977     IQ2000_INSN_BC0FL, "bc0fl", "bc0fl", 32,
 978     { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 979   },
 980 /* bc3f $offset */
 981   {
 982     IQ2000_INSN_BC3F, "bc3f", "bc3f", 32,
 983     { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 984   },
 985 /* bc3fl $offset */
 986   {
 987     IQ2000_INSN_BC3FL, "bc3fl", "bc3fl", 32,
 988     { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 989   },
 990 /* bc0t $offset */
 991   {
 992     IQ2000_INSN_BC0T, "bc0t", "bc0t", 32,
 993     { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 994   },
 995 /* bc0tl $offset */
 996   {
 997     IQ2000_INSN_BC0TL, "bc0tl", "bc0tl", 32,
 998     { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
 999   },
1000 /* bc3t $offset */
1001   {
1002     IQ2000_INSN_BC3T, "bc3t", "bc3t", 32,
1003     { 0|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1004   },
1005 /* bc3tl $offset */
1006   {
1007     IQ2000_INSN_BC3TL, "bc3tl", "bc3tl", 32,
1008     { 0|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1009   },
1010 /* cfc0 $rt,$rd */
1011   {
1012     IQ2000_INSN_CFC0, "cfc0", "cfc0", 32,
1013     { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1014   },
1015 /* cfc1 $rt,$rd */
1016   {
1017     IQ2000_INSN_CFC1, "cfc1", "cfc1", 32,
1018     { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1019   },
1020 /* cfc2 $rt,$rd */
1021   {
1022     IQ2000_INSN_CFC2, "cfc2", "cfc2", 32,
1023     { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1024   },
1025 /* cfc3 $rt,$rd */
1026   {
1027     IQ2000_INSN_CFC3, "cfc3", "cfc3", 32,
1028     { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1029   },
1030 /* chkhdr $rd,$rt */
1031   {
1032     IQ2000_INSN_CHKHDR, "chkhdr", "chkhdr", 32,
1033     { 0|A(YIELD_INSN)|A(USES_RD)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1034   },
1035 /* ctc0 $rt,$rd */
1036   {
1037     IQ2000_INSN_CTC0, "ctc0", "ctc0", 32,
1038     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1039   },
1040 /* ctc1 $rt,$rd */
1041   {
1042     IQ2000_INSN_CTC1, "ctc1", "ctc1", 32,
1043     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1044   },
1045 /* ctc2 $rt,$rd */
1046   {
1047     IQ2000_INSN_CTC2, "ctc2", "ctc2", 32,
1048     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1049   },
1050 /* ctc3 $rt,$rd */
1051   {
1052     IQ2000_INSN_CTC3, "ctc3", "ctc3", 32,
1053     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1054   },
1055 /* jcr $rs */
1056   {
1057     IQ2000_INSN_JCR, "jcr", "jcr", 32,
1058     { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1059   },
1060 /* luc32 $rt,$rd */
1061   {
1062     IQ2000_INSN_LUC32, "luc32", "luc32", 32,
1063     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1064   },
1065 /* luc32l $rt,$rd */
1066   {
1067     IQ2000_INSN_LUC32L, "luc32l", "luc32l", 32,
1068     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1069   },
1070 /* luc64 $rt,$rd */
1071   {
1072     IQ2000_INSN_LUC64, "luc64", "luc64", 32,
1073     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1074   },
1075 /* luc64l $rt,$rd */
1076   {
1077     IQ2000_INSN_LUC64L, "luc64l", "luc64l", 32,
1078     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1079   },
1080 /* luk $rt,$rd */
1081   {
1082     IQ2000_INSN_LUK, "luk", "luk", 32,
1083     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1084   },
1085 /* lulck $rt */
1086   {
1087     IQ2000_INSN_LULCK, "lulck", "lulck", 32,
1088     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1089   },
1090 /* lum32 $rt,$rd */
1091   {
1092     IQ2000_INSN_LUM32, "lum32", "lum32", 32,
1093     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1094   },
1095 /* lum32l $rt,$rd */
1096   {
1097     IQ2000_INSN_LUM32L, "lum32l", "lum32l", 32,
1098     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1099   },
1100 /* lum64 $rt,$rd */
1101   {
1102     IQ2000_INSN_LUM64, "lum64", "lum64", 32,
1103     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1104   },
1105 /* lum64l $rt,$rd */
1106   {
1107     IQ2000_INSN_LUM64L, "lum64l", "lum64l", 32,
1108     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1109   },
1110 /* lur $rt,$rd */
1111   {
1112     IQ2000_INSN_LUR, "lur", "lur", 32,
1113     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1114   },
1115 /* lurl $rt,$rd */
1116   {
1117     IQ2000_INSN_LURL, "lurl", "lurl", 32,
1118     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1119   },
1120 /* luulck $rt */
1121   {
1122     IQ2000_INSN_LUULCK, "luulck", "luulck", 32,
1123     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1124   },
1125 /* mfc0 $rt,$rd */
1126   {
1127     IQ2000_INSN_MFC0, "mfc0", "mfc0", 32,
1128     { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1129   },
1130 /* mfc1 $rt,$rd */
1131   {
1132     IQ2000_INSN_MFC1, "mfc1", "mfc1", 32,
1133     { 0|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1134   },
1135 /* mfc2 $rt,$rd */
1136   {
1137     IQ2000_INSN_MFC2, "mfc2", "mfc2", 32,
1138     { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1139   },
1140 /* mfc3 $rt,$rd */
1141   {
1142     IQ2000_INSN_MFC3, "mfc3", "mfc3", 32,
1143     { 0|A(YIELD_INSN)|A(USES_RT)|A(LOAD_DELAY), { { { (1<<MACH_IQ2000), 0 } } } }
1144   },
1145 /* mtc0 $rt,$rd */
1146   {
1147     IQ2000_INSN_MTC0, "mtc0", "mtc0", 32,
1148     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1149   },
1150 /* mtc1 $rt,$rd */
1151   {
1152     IQ2000_INSN_MTC1, "mtc1", "mtc1", 32,
1153     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1154   },
1155 /* mtc2 $rt,$rd */
1156   {
1157     IQ2000_INSN_MTC2, "mtc2", "mtc2", 32,
1158     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1159   },
1160 /* mtc3 $rt,$rd */
1161   {
1162     IQ2000_INSN_MTC3, "mtc3", "mtc3", 32,
1163     { 0|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1164   },
1165 /* pkrl $rd,$rt */
1166   {
1167     IQ2000_INSN_PKRL, "pkrl", "pkrl", 32,
1168     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1169   },
1170 /* pkrlr1 $rt,$_index,$count */
1171   {
1172     IQ2000_INSN_PKRLR1, "pkrlr1", "pkrlr1", 32,
1173     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1174   },
1175 /* pkrlr30 $rt,$_index,$count */
1176   {
1177     IQ2000_INSN_PKRLR30, "pkrlr30", "pkrlr30", 32,
1178     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1179   },
1180 /* rb $rd,$rt */
1181   {
1182     IQ2000_INSN_RB, "rb", "rb", 32,
1183     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1184   },
1185 /* rbr1 $rt,$_index,$count */
1186   {
1187     IQ2000_INSN_RBR1, "rbr1", "rbr1", 32,
1188     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1189   },
1190 /* rbr30 $rt,$_index,$count */
1191   {
1192     IQ2000_INSN_RBR30, "rbr30", "rbr30", 32,
1193     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1194   },
1195 /* rfe */
1196   {
1197     IQ2000_INSN_RFE, "rfe", "rfe", 32,
1198     { 0, { { { (1<<MACH_IQ2000), 0 } } } }
1199   },
1200 /* rx $rd,$rt */
1201   {
1202     IQ2000_INSN_RX, "rx", "rx", 32,
1203     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1204   },
1205 /* rxr1 $rt,$_index,$count */
1206   {
1207     IQ2000_INSN_RXR1, "rxr1", "rxr1", 32,
1208     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1209   },
1210 /* rxr30 $rt,$_index,$count */
1211   {
1212     IQ2000_INSN_RXR30, "rxr30", "rxr30", 32,
1213     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1214   },
1215 /* sleep */
1216   {
1217     IQ2000_INSN_SLEEP, "sleep", "sleep", 32,
1218     { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1219   },
1220 /* srrd $rt */
1221   {
1222     IQ2000_INSN_SRRD, "srrd", "srrd", 32,
1223     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1224   },
1225 /* srrdl $rt */
1226   {
1227     IQ2000_INSN_SRRDL, "srrdl", "srrdl", 32,
1228     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1229   },
1230 /* srulck $rt */
1231   {
1232     IQ2000_INSN_SRULCK, "srulck", "srulck", 32,
1233     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1234   },
1235 /* srwr $rt,$rd */
1236   {
1237     IQ2000_INSN_SRWR, "srwr", "srwr", 32,
1238     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1239   },
1240 /* srwru $rt,$rd */
1241   {
1242     IQ2000_INSN_SRWRU, "srwru", "srwru", 32,
1243     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1244   },
1245 /* trapqfl */
1246   {
1247     IQ2000_INSN_TRAPQFL, "trapqfl", "trapqfl", 32,
1248     { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1249   },
1250 /* trapqne */
1251   {
1252     IQ2000_INSN_TRAPQNE, "trapqne", "trapqne", 32,
1253     { 0|A(YIELD_INSN), { { { (1<<MACH_IQ2000), 0 } } } }
1254   },
1255 /* traprel $rt */
1256   {
1257     IQ2000_INSN_TRAPREL, "traprel", "traprel", 32,
1258     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1259   },
1260 /* wb $rd,$rt */
1261   {
1262     IQ2000_INSN_WB, "wb", "wb", 32,
1263     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1264   },
1265 /* wbu $rd,$rt */
1266   {
1267     IQ2000_INSN_WBU, "wbu", "wbu", 32,
1268     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1269   },
1270 /* wbr1 $rt,$_index,$count */
1271   {
1272     IQ2000_INSN_WBR1, "wbr1", "wbr1", 32,
1273     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1274   },
1275 /* wbr1u $rt,$_index,$count */
1276   {
1277     IQ2000_INSN_WBR1U, "wbr1u", "wbr1u", 32,
1278     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1279   },
1280 /* wbr30 $rt,$_index,$count */
1281   {
1282     IQ2000_INSN_WBR30, "wbr30", "wbr30", 32,
1283     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1284   },
1285 /* wbr30u $rt,$_index,$count */
1286   {
1287     IQ2000_INSN_WBR30U, "wbr30u", "wbr30u", 32,
1288     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1289   },
1290 /* wx $rd,$rt */
1291   {
1292     IQ2000_INSN_WX, "wx", "wx", 32,
1293     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1294   },
1295 /* wxu $rd,$rt */
1296   {
1297     IQ2000_INSN_WXU, "wxu", "wxu", 32,
1298     { 0|A(YIELD_INSN)|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ2000), 0 } } } }
1299   },
1300 /* wxr1 $rt,$_index,$count */
1301   {
1302     IQ2000_INSN_WXR1, "wxr1", "wxr1", 32,
1303     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1304   },
1305 /* wxr1u $rt,$_index,$count */
1306   {
1307     IQ2000_INSN_WXR1U, "wxr1u", "wxr1u", 32,
1308     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1309   },
1310 /* wxr30 $rt,$_index,$count */
1311   {
1312     IQ2000_INSN_WXR30, "wxr30", "wxr30", 32,
1313     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1314   },
1315 /* wxr30u $rt,$_index,$count */
1316   {
1317     IQ2000_INSN_WXR30U, "wxr30u", "wxr30u", 32,
1318     { 0|A(YIELD_INSN)|A(USES_RT), { { { (1<<MACH_IQ2000), 0 } } } }
1319   },
1320 /* ldw $rt,$lo16($base) */
1321   {
1322     IQ2000_INSN_LDW, "ldw", "ldw", 32,
1323     { 0|A(USES_RT)|A(LOAD_DELAY)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ2000), 0 } } } }
1324   },
1325 /* sdw $rt,$lo16($base) */
1326   {
1327     IQ2000_INSN_SDW, "sdw", "sdw", 32,
1328     { 0|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ2000), 0 } } } }
1329   },
1330 /* j $jmptarg */
1331   {
1332     IQ2000_INSN_J, "j", "j", 32,
1333     { 0|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1334   },
1335 /* jal $jmptarg */
1336   {
1337     IQ2000_INSN_JAL, "jal", "jal", 32,
1338     { 0|A(USES_R31)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1339   },
1340 /* bmb $rs,$rt,$offset */
1341   {
1342     IQ2000_INSN_BMB, "bmb", "bmb", 32,
1343     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ2000), 0 } } } }
1344   },
1345 /* andoui $rt,$rs,$hi16 */
1346   {
1347     IQ2000_INSN_ANDOUI_Q10, "andoui-q10", "andoui", 32,
1348     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1349   },
1350 /* andoui ${rt-rs},$hi16 */
1351   {
1352     -1, "andoui2-q10", "andoui", 32,
1353     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1354   },
1355 /* orui $rt,$rs,$hi16 */
1356   {
1357     IQ2000_INSN_ORUI_Q10, "orui-q10", "orui", 32,
1358     { 0|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1359   },
1360 /* orui ${rt-rs},$hi16 */
1361   {
1362     -1, "orui2-q10", "orui", 32,
1363     { 0|A(USES_RT)|A(USES_RS)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1364   },
1365 /* mrgb $rd,$rs,$rt,$maskq10 */
1366   {
1367     IQ2000_INSN_MRGBQ10, "mrgbq10", "mrgb", 32,
1368     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1369   },
1370 /* mrgb ${rd-rs},$rt,$maskq10 */
1371   {
1372     -1, "mrgbq102", "mrgb", 32,
1373     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD)|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_IQ10), 0 } } } }
1374   },
1375 /* j $jmptarg */
1376   {
1377     IQ2000_INSN_JQ10, "jq10", "j", 32,
1378     { 0|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1379   },
1380 /* jal $rt,$jmptarg */
1381   {
1382     IQ2000_INSN_JALQ10, "jalq10", "jal", 32,
1383     { 0|A(USES_RT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1384   },
1385 /* jal $jmptarg */
1386   {
1387     IQ2000_INSN_JALQ10_2, "jalq10-2", "jal", 32,
1388     { 0|A(USES_RT)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1389   },
1390 /* bbil $rs($bitnum),$offset */
1391   {
1392     IQ2000_INSN_BBIL, "bbil", "bbil", 32,
1393     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1394   },
1395 /* bbinl $rs($bitnum),$offset */
1396   {
1397     IQ2000_INSN_BBINL, "bbinl", "bbinl", 32,
1398     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1399   },
1400 /* bbvl $rs,$rt,$offset */
1401   {
1402     IQ2000_INSN_BBVL, "bbvl", "bbvl", 32,
1403     { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1404   },
1405 /* bbvnl $rs,$rt,$offset */
1406   {
1407     IQ2000_INSN_BBVNL, "bbvnl", "bbvnl", 32,
1408     { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1409   },
1410 /* bgtzal $rs,$offset */
1411   {
1412     IQ2000_INSN_BGTZAL, "bgtzal", "bgtzal", 32,
1413     { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1414   },
1415 /* bgtzall $rs,$offset */
1416   {
1417     IQ2000_INSN_BGTZALL, "bgtzall", "bgtzall", 32,
1418     { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1419   },
1420 /* blezal $rs,$offset */
1421   {
1422     IQ2000_INSN_BLEZAL, "blezal", "blezal", 32,
1423     { 0|A(USES_R31)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1424   },
1425 /* blezall $rs,$offset */
1426   {
1427     IQ2000_INSN_BLEZALL, "blezall", "blezall", 32,
1428     { 0|A(USES_R31)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1429   },
1430 /* bgtz $rs,$offset */
1431   {
1432     IQ2000_INSN_BGTZ_Q10, "bgtz-q10", "bgtz", 32,
1433     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1434   },
1435 /* bgtzl $rs,$offset */
1436   {
1437     IQ2000_INSN_BGTZL_Q10, "bgtzl-q10", "bgtzl", 32,
1438     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1439   },
1440 /* blez $rs,$offset */
1441   {
1442     IQ2000_INSN_BLEZ_Q10, "blez-q10", "blez", 32,
1443     { 0|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1444   },
1445 /* blezl $rs,$offset */
1446   {
1447     IQ2000_INSN_BLEZL_Q10, "blezl-q10", "blezl", 32,
1448     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1449   },
1450 /* bmb $rs,$rt,$offset */
1451   {
1452     IQ2000_INSN_BMB_Q10, "bmb-q10", "bmb", 32,
1453     { 0|A(USES_RT)|A(USES_RS)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1454   },
1455 /* bmbl $rs,$rt,$offset */
1456   {
1457     IQ2000_INSN_BMBL, "bmbl", "bmbl", 32,
1458     { 0|A(USES_RT)|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1459   },
1460 /* bri $rs,$offset */
1461   {
1462     IQ2000_INSN_BRI, "bri", "bri", 32,
1463     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1464   },
1465 /* brv $rs,$offset */
1466   {
1467     IQ2000_INSN_BRV, "brv", "brv", 32,
1468     { 0|A(USES_RS)|A(SKIP_CTI)|A(COND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1469   },
1470 /* bctx $rs,$offset */
1471   {
1472     IQ2000_INSN_BCTX, "bctx", "bctx", 32,
1473     { 0|A(USES_RS)|A(UNCOND_CTI)|A(DELAY_SLOT), { { { (1<<MACH_IQ10), 0 } } } }
1474   },
1475 /* yield */
1476   {
1477     IQ2000_INSN_YIELD, "yield", "yield", 32,
1478     { 0, { { { (1<<MACH_IQ10), 0 } } } }
1479   },
1480 /* crc32 $rd,$rs,$rt */
1481   {
1482     IQ2000_INSN_CRC32, "crc32", "crc32", 32,
1483     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1484   },
1485 /* crc32b $rd,$rs,$rt */
1486   {
1487     IQ2000_INSN_CRC32B, "crc32b", "crc32b", 32,
1488     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1489   },
1490 /* cnt1s $rd,$rs */
1491   {
1492     IQ2000_INSN_CNT1S, "cnt1s", "cnt1s", 32,
1493     { 0|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1494   },
1495 /* avail $rd */
1496   {
1497     IQ2000_INSN_AVAIL, "avail", "avail", 32,
1498     { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1499   },
1500 /* free $rd,$rs */
1501   {
1502     IQ2000_INSN_FREE, "free", "free", 32,
1503     { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1504   },
1505 /* tstod $rd,$rs */
1506   {
1507     IQ2000_INSN_TSTOD, "tstod", "tstod", 32,
1508     { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1509   },
1510 /* cmphdr $rd */
1511   {
1512     IQ2000_INSN_CMPHDR, "cmphdr", "cmphdr", 32,
1513     { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1514   },
1515 /* mcid $rd,$rt */
1516   {
1517     IQ2000_INSN_MCID, "mcid", "mcid", 32,
1518     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1519   },
1520 /* dba $rd */
1521   {
1522     IQ2000_INSN_DBA, "dba", "dba", 32,
1523     { 0|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1524   },
1525 /* dbd $rd,$rs,$rt */
1526   {
1527     IQ2000_INSN_DBD, "dbd", "dbd", 32,
1528     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1529   },
1530 /* dpwt $rd,$rs */
1531   {
1532     IQ2000_INSN_DPWT, "dpwt", "dpwt", 32,
1533     { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1534   },
1535 /* chkhdr $rd,$rs */
1536   {
1537     IQ2000_INSN_CHKHDRQ10, "chkhdrq10", "chkhdr", 32,
1538     { 0|A(USES_RD)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1539   },
1540 /* rba $rd,$rs,$rt */
1541   {
1542     IQ2000_INSN_RBA, "rba", "rba", 32,
1543     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1544   },
1545 /* rbal $rd,$rs,$rt */
1546   {
1547     IQ2000_INSN_RBAL, "rbal", "rbal", 32,
1548     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1549   },
1550 /* rbar $rd,$rs,$rt */
1551   {
1552     IQ2000_INSN_RBAR, "rbar", "rbar", 32,
1553     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1554   },
1555 /* wba $rd,$rs,$rt */
1556   {
1557     IQ2000_INSN_WBA, "wba", "wba", 32,
1558     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1559   },
1560 /* wbau $rd,$rs,$rt */
1561   {
1562     IQ2000_INSN_WBAU, "wbau", "wbau", 32,
1563     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1564   },
1565 /* wbac $rd,$rs,$rt */
1566   {
1567     IQ2000_INSN_WBAC, "wbac", "wbac", 32,
1568     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1569   },
1570 /* rbi $rd,$rs,$rt,$bytecount */
1571   {
1572     IQ2000_INSN_RBI, "rbi", "rbi", 32,
1573     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1574   },
1575 /* rbil $rd,$rs,$rt,$bytecount */
1576   {
1577     IQ2000_INSN_RBIL, "rbil", "rbil", 32,
1578     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1579   },
1580 /* rbir $rd,$rs,$rt,$bytecount */
1581   {
1582     IQ2000_INSN_RBIR, "rbir", "rbir", 32,
1583     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1584   },
1585 /* wbi $rd,$rs,$rt,$bytecount */
1586   {
1587     IQ2000_INSN_WBI, "wbi", "wbi", 32,
1588     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1589   },
1590 /* wbic $rd,$rs,$rt,$bytecount */
1591   {
1592     IQ2000_INSN_WBIC, "wbic", "wbic", 32,
1593     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1594   },
1595 /* wbiu $rd,$rs,$rt,$bytecount */
1596   {
1597     IQ2000_INSN_WBIU, "wbiu", "wbiu", 32,
1598     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1599   },
1600 /* pkrli $rd,$rs,$rt,$bytecount */
1601   {
1602     IQ2000_INSN_PKRLI, "pkrli", "pkrli", 32,
1603     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1604   },
1605 /* pkrlih $rd,$rs,$rt,$bytecount */
1606   {
1607     IQ2000_INSN_PKRLIH, "pkrlih", "pkrlih", 32,
1608     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1609   },
1610 /* pkrliu $rd,$rs,$rt,$bytecount */
1611   {
1612     IQ2000_INSN_PKRLIU, "pkrliu", "pkrliu", 32,
1613     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1614   },
1615 /* pkrlic $rd,$rs,$rt,$bytecount */
1616   {
1617     IQ2000_INSN_PKRLIC, "pkrlic", "pkrlic", 32,
1618     { 0|A(USES_RT)|A(USES_RS)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1619   },
1620 /* pkrla $rd,$rs,$rt */
1621   {
1622     IQ2000_INSN_PKRLA, "pkrla", "pkrla", 32,
1623     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1624   },
1625 /* pkrlau $rd,$rs,$rt */
1626   {
1627     IQ2000_INSN_PKRLAU, "pkrlau", "pkrlau", 32,
1628     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1629   },
1630 /* pkrlah $rd,$rs,$rt */
1631   {
1632     IQ2000_INSN_PKRLAH, "pkrlah", "pkrlah", 32,
1633     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1634   },
1635 /* pkrlac $rd,$rs,$rt */
1636   {
1637     IQ2000_INSN_PKRLAC, "pkrlac", "pkrlac", 32,
1638     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1639   },
1640 /* lock $rd,$rt */
1641   {
1642     IQ2000_INSN_LOCK, "lock", "lock", 32,
1643     { 0|A(USES_RT)|A(USES_RD), { { { (1<<MACH_IQ10), 0 } } } }
1644   },
1645 /* unlk $rd,$rt */
1646   {
1647     IQ2000_INSN_UNLK, "unlk", "unlk", 32,
1648     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1649   },
1650 /* swrd $rd,$rt */
1651   {
1652     IQ2000_INSN_SWRD, "swrd", "swrd", 32,
1653     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1654   },
1655 /* swrdl $rd,$rt */
1656   {
1657     IQ2000_INSN_SWRDL, "swrdl", "swrdl", 32,
1658     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1659   },
1660 /* swwr $rd,$rs,$rt */
1661   {
1662     IQ2000_INSN_SWWR, "swwr", "swwr", 32,
1663     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1664   },
1665 /* swwru $rd,$rs,$rt */
1666   {
1667     IQ2000_INSN_SWWRU, "swwru", "swwru", 32,
1668     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1669   },
1670 /* dwrd $rd,$rt */
1671   {
1672     IQ2000_INSN_DWRD, "dwrd", "dwrd", 32,
1673     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1674   },
1675 /* dwrdl $rd,$rt */
1676   {
1677     IQ2000_INSN_DWRDL, "dwrdl", "dwrdl", 32,
1678     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1679   },
1680 /* cam36 $rd,$rt,${cam-z},${cam-y} */
1681   {
1682     IQ2000_INSN_CAM36, "cam36", "cam36", 32,
1683     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1684   },
1685 /* cam72 $rd,$rt,${cam-y},${cam-z} */
1686   {
1687     IQ2000_INSN_CAM72, "cam72", "cam72", 32,
1688     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1689   },
1690 /* cam144 $rd,$rt,${cam-y},${cam-z} */
1691   {
1692     IQ2000_INSN_CAM144, "cam144", "cam144", 32,
1693     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1694   },
1695 /* cam288 $rd,$rt,${cam-y},${cam-z} */
1696   {
1697     IQ2000_INSN_CAM288, "cam288", "cam288", 32,
1698     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1699   },
1700 /* cm32and $rd,$rs,$rt */
1701   {
1702     IQ2000_INSN_CM32AND, "cm32and", "cm32and", 32,
1703     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1704   },
1705 /* cm32andn $rd,$rs,$rt */
1706   {
1707     IQ2000_INSN_CM32ANDN, "cm32andn", "cm32andn", 32,
1708     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1709   },
1710 /* cm32or $rd,$rs,$rt */
1711   {
1712     IQ2000_INSN_CM32OR, "cm32or", "cm32or", 32,
1713     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1714   },
1715 /* cm32ra $rd,$rs,$rt */
1716   {
1717     IQ2000_INSN_CM32RA, "cm32ra", "cm32ra", 32,
1718     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1719   },
1720 /* cm32rd $rd,$rt */
1721   {
1722     IQ2000_INSN_CM32RD, "cm32rd", "cm32rd", 32,
1723     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1724   },
1725 /* cm32ri $rd,$rt */
1726   {
1727     IQ2000_INSN_CM32RI, "cm32ri", "cm32ri", 32,
1728     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1729   },
1730 /* cm32rs $rd,$rs,$rt */
1731   {
1732     IQ2000_INSN_CM32RS, "cm32rs", "cm32rs", 32,
1733     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1734   },
1735 /* cm32sa $rd,$rs,$rt */
1736   {
1737     IQ2000_INSN_CM32SA, "cm32sa", "cm32sa", 32,
1738     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1739   },
1740 /* cm32sd $rd,$rt */
1741   {
1742     IQ2000_INSN_CM32SD, "cm32sd", "cm32sd", 32,
1743     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1744   },
1745 /* cm32si $rd,$rt */
1746   {
1747     IQ2000_INSN_CM32SI, "cm32si", "cm32si", 32,
1748     { 0|A(USES_RD)|A(USES_RT), { { { (1<<MACH_IQ10), 0 } } } }
1749   },
1750 /* cm32ss $rd,$rs,$rt */
1751   {
1752     IQ2000_INSN_CM32SS, "cm32ss", "cm32ss", 32,
1753     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1754   },
1755 /* cm32xor $rd,$rs,$rt */
1756   {
1757     IQ2000_INSN_CM32XOR, "cm32xor", "cm32xor", 32,
1758     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1759   },
1760 /* cm64clr $rd,$rt */
1761   {
1762     IQ2000_INSN_CM64CLR, "cm64clr", "cm64clr", 32,
1763     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1764   },
1765 /* cm64ra $rd,$rs,$rt */
1766   {
1767     IQ2000_INSN_CM64RA, "cm64ra", "cm64ra", 32,
1768     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1769   },
1770 /* cm64rd $rd,$rt */
1771   {
1772     IQ2000_INSN_CM64RD, "cm64rd", "cm64rd", 32,
1773     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1774   },
1775 /* cm64ri $rd,$rt */
1776   {
1777     IQ2000_INSN_CM64RI, "cm64ri", "cm64ri", 32,
1778     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1779   },
1780 /* cm64ria2 $rd,$rs,$rt */
1781   {
1782     IQ2000_INSN_CM64RIA2, "cm64ria2", "cm64ria2", 32,
1783     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1784   },
1785 /* cm64rs $rd,$rs,$rt */
1786   {
1787     IQ2000_INSN_CM64RS, "cm64rs", "cm64rs", 32,
1788     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1789   },
1790 /* cm64sa $rd,$rs,$rt */
1791   {
1792     IQ2000_INSN_CM64SA, "cm64sa", "cm64sa", 32,
1793     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1794   },
1795 /* cm64sd $rd,$rt */
1796   {
1797     IQ2000_INSN_CM64SD, "cm64sd", "cm64sd", 32,
1798     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1799   },
1800 /* cm64si $rd,$rt */
1801   {
1802     IQ2000_INSN_CM64SI, "cm64si", "cm64si", 32,
1803     { 0|A(USES_RD)|A(USES_RT)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1804   },
1805 /* cm64sia2 $rd,$rs,$rt */
1806   {
1807     IQ2000_INSN_CM64SIA2, "cm64sia2", "cm64sia2", 32,
1808     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1809   },
1810 /* cm64ss $rd,$rs,$rt */
1811   {
1812     IQ2000_INSN_CM64SS, "cm64ss", "cm64ss", 32,
1813     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1814   },
1815 /* cm128ria2 $rd,$rs,$rt */
1816   {
1817     IQ2000_INSN_CM128RIA2, "cm128ria2", "cm128ria2", 32,
1818     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1819   },
1820 /* cm128ria3 $rd,$rs,$rt,${cm-3z} */
1821   {
1822     IQ2000_INSN_CM128RIA3, "cm128ria3", "cm128ria3", 32,
1823     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1824   },
1825 /* cm128ria4 $rd,$rs,$rt,${cm-4z} */
1826   {
1827     IQ2000_INSN_CM128RIA4, "cm128ria4", "cm128ria4", 32,
1828     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1829   },
1830 /* cm128sia2 $rd,$rs,$rt */
1831   {
1832     IQ2000_INSN_CM128SIA2, "cm128sia2", "cm128sia2", 32,
1833     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1834   },
1835 /* cm128sia3 $rd,$rs,$rt,${cm-3z} */
1836   {
1837     IQ2000_INSN_CM128SIA3, "cm128sia3", "cm128sia3", 32,
1838     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS)|A(EVEN_REG_NUM), { { { (1<<MACH_IQ10), 0 } } } }
1839   },
1840 /* cm128sia4 $rd,$rs,$rt,${cm-4z} */
1841   {
1842     IQ2000_INSN_CM128SIA4, "cm128sia4", "cm128sia4", 32,
1843     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1844   },
1845 /* cm128vsa $rd,$rs,$rt */
1846   {
1847     IQ2000_INSN_CM128VSA, "cm128vsa", "cm128vsa", 32,
1848     { 0|A(USES_RD)|A(USES_RT)|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1849   },
1850 /* cfc $rd,$rt */
1851   {
1852     IQ2000_INSN_CFC, "cfc", "cfc", 32,
1853     { 0|A(YIELD_INSN)|A(USES_RD)|A(LOAD_DELAY), { { { (1<<MACH_IQ10), 0 } } } }
1854   },
1855 /* ctc $rs,$rt */
1856   {
1857     IQ2000_INSN_CTC, "ctc", "ctc", 32,
1858     { 0|A(USES_RS), { { { (1<<MACH_IQ10), 0 } } } }
1859   },
1860 };
1861
1862 #undef OP
1863 #undef A
1864
1865 /* Initialize anything needed to be done once, before any cpu_open call.  */
1866
1867 static void
1868 init_tables (void)
1869 {
1870 }
1871
1872 static const CGEN_MACH * lookup_mach_via_bfd_name (const CGEN_MACH *, const char *);
1873 static void build_hw_table      (CGEN_CPU_TABLE *);
1874 static void build_ifield_table  (CGEN_CPU_TABLE *);
1875 static void build_operand_table (CGEN_CPU_TABLE *);
1876 static void build_insn_table    (CGEN_CPU_TABLE *);
1877 static void iq2000_cgen_rebuild_tables (CGEN_CPU_TABLE *);
1878
1879 /* Subroutine of iq2000_cgen_cpu_open to look up a mach via its bfd name.  */
1880
1881 static const CGEN_MACH *
1882 lookup_mach_via_bfd_name (const CGEN_MACH *table, const char *name)
1883 {
1884   while (table->name)
1885     {
1886       if (strcmp (name, table->bfd_name) == 0)
1887         return table;
1888       ++table;
1889     }
1890   abort ();
1891 }
1892
1893 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table.  */
1894
1895 static void
1896 build_hw_table (CGEN_CPU_TABLE *cd)
1897 {
1898   int i;
1899   int machs = cd->machs;
1900   const CGEN_HW_ENTRY *init = & iq2000_cgen_hw_table[0];
1901   /* MAX_HW is only an upper bound on the number of selected entries.
1902      However each entry is indexed by it's enum so there can be holes in
1903      the table.  */
1904   const CGEN_HW_ENTRY **selected =
1905     (const CGEN_HW_ENTRY **) xmalloc (MAX_HW * sizeof (CGEN_HW_ENTRY *));
1906
1907   cd->hw_table.init_entries = init;
1908   cd->hw_table.entry_size = sizeof (CGEN_HW_ENTRY);
1909   memset (selected, 0, MAX_HW * sizeof (CGEN_HW_ENTRY *));
1910   /* ??? For now we just use machs to determine which ones we want.  */
1911   for (i = 0; init[i].name != NULL; ++i)
1912     if (CGEN_HW_ATTR_VALUE (&init[i], CGEN_HW_MACH)
1913         & machs)
1914       selected[init[i].type] = &init[i];
1915   cd->hw_table.entries = selected;
1916   cd->hw_table.num_entries = MAX_HW;
1917 }
1918
1919 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table.  */
1920
1921 static void
1922 build_ifield_table (CGEN_CPU_TABLE *cd)
1923 {
1924   cd->ifld_table = & iq2000_cgen_ifld_table[0];
1925 }
1926
1927 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table.  */
1928
1929 static void
1930 build_operand_table (CGEN_CPU_TABLE *cd)
1931 {
1932   int i;
1933   int machs = cd->machs;
1934   const CGEN_OPERAND *init = & iq2000_cgen_operand_table[0];
1935   /* MAX_OPERANDS is only an upper bound on the number of selected entries.
1936      However each entry is indexed by it's enum so there can be holes in
1937      the table.  */
1938   const CGEN_OPERAND **selected = xmalloc (MAX_OPERANDS * sizeof (* selected));
1939
1940   cd->operand_table.init_entries = init;
1941   cd->operand_table.entry_size = sizeof (CGEN_OPERAND);
1942   memset (selected, 0, MAX_OPERANDS * sizeof (CGEN_OPERAND *));
1943   /* ??? For now we just use mach to determine which ones we want.  */
1944   for (i = 0; init[i].name != NULL; ++i)
1945     if (CGEN_OPERAND_ATTR_VALUE (&init[i], CGEN_OPERAND_MACH)
1946         & machs)
1947       selected[init[i].type] = &init[i];
1948   cd->operand_table.entries = selected;
1949   cd->operand_table.num_entries = MAX_OPERANDS;
1950 }
1951
1952 /* Subroutine of iq2000_cgen_cpu_open to build the hardware table.
1953    ??? This could leave out insns not supported by the specified mach/isa,
1954    but that would cause errors like "foo only supported by bar" to become
1955    "unknown insn", so for now we include all insns and require the app to
1956    do the checking later.
1957    ??? On the other hand, parsing of such insns may require their hardware or
1958    operand elements to be in the table [which they mightn't be].  */
1959
1960 static void
1961 build_insn_table (CGEN_CPU_TABLE *cd)
1962 {
1963   int i;
1964   const CGEN_IBASE *ib = & iq2000_cgen_insn_table[0];
1965   CGEN_INSN *insns = xmalloc (MAX_INSNS * sizeof (CGEN_INSN));
1966
1967   memset (insns, 0, MAX_INSNS * sizeof (CGEN_INSN));
1968   for (i = 0; i < MAX_INSNS; ++i)
1969     insns[i].base = &ib[i];
1970   cd->insn_table.init_entries = insns;
1971   cd->insn_table.entry_size = sizeof (CGEN_IBASE);
1972   cd->insn_table.num_init_entries = MAX_INSNS;
1973 }
1974
1975 /* Subroutine of iq2000_cgen_cpu_open to rebuild the tables.  */
1976
1977 static void
1978 iq2000_cgen_rebuild_tables (CGEN_CPU_TABLE *cd)
1979 {
1980   int i;
1981   CGEN_BITSET *isas = cd->isas;
1982   unsigned int machs = cd->machs;
1983
1984   cd->int_insn_p = CGEN_INT_INSN_P;
1985
1986   /* Data derived from the isa spec.  */
1987 #define UNSET (CGEN_SIZE_UNKNOWN + 1)
1988   cd->default_insn_bitsize = UNSET;
1989   cd->base_insn_bitsize = UNSET;
1990   cd->min_insn_bitsize = 65535; /* Some ridiculously big number.  */
1991   cd->max_insn_bitsize = 0;
1992   for (i = 0; i < MAX_ISAS; ++i)
1993     if (cgen_bitset_contains (isas, i))
1994       {
1995         const CGEN_ISA *isa = & iq2000_cgen_isa_table[i];
1996
1997         /* Default insn sizes of all selected isas must be
1998            equal or we set the result to 0, meaning "unknown".  */
1999         if (cd->default_insn_bitsize == UNSET)
2000           cd->default_insn_bitsize = isa->default_insn_bitsize;
2001         else if (isa->default_insn_bitsize == cd->default_insn_bitsize)
2002           ; /* This is ok.  */
2003         else
2004           cd->default_insn_bitsize = CGEN_SIZE_UNKNOWN;
2005
2006         /* Base insn sizes of all selected isas must be equal
2007            or we set the result to 0, meaning "unknown".  */
2008         if (cd->base_insn_bitsize == UNSET)
2009           cd->base_insn_bitsize = isa->base_insn_bitsize;
2010         else if (isa->base_insn_bitsize == cd->base_insn_bitsize)
2011           ; /* This is ok.  */
2012         else
2013           cd->base_insn_bitsize = CGEN_SIZE_UNKNOWN;
2014
2015         /* Set min,max insn sizes.  */
2016         if (isa->min_insn_bitsize < cd->min_insn_bitsize)
2017           cd->min_insn_bitsize = isa->min_insn_bitsize;
2018         if (isa->max_insn_bitsize > cd->max_insn_bitsize)
2019           cd->max_insn_bitsize = isa->max_insn_bitsize;
2020       }
2021
2022   /* Data derived from the mach spec.  */
2023   for (i = 0; i < MAX_MACHS; ++i)
2024     if (((1 << i) & machs) != 0)
2025       {
2026         const CGEN_MACH *mach = & iq2000_cgen_mach_table[i];
2027
2028         if (mach->insn_chunk_bitsize != 0)
2029         {
2030           if (cd->insn_chunk_bitsize != 0 && cd->insn_chunk_bitsize != mach->insn_chunk_bitsize)
2031             {
2032               fprintf (stderr, "iq2000_cgen_rebuild_tables: conflicting insn-chunk-bitsize values: `%d' vs. `%d'\n",
2033                        cd->insn_chunk_bitsize, mach->insn_chunk_bitsize);
2034               abort ();
2035             }
2036
2037           cd->insn_chunk_bitsize = mach->insn_chunk_bitsize;
2038         }
2039       }
2040
2041   /* Determine which hw elements are used by MACH.  */
2042   build_hw_table (cd);
2043
2044   /* Build the ifield table.  */
2045   build_ifield_table (cd);
2046
2047   /* Determine which operands are used by MACH/ISA.  */
2048   build_operand_table (cd);
2049
2050   /* Build the instruction table.  */
2051   build_insn_table (cd);
2052 }
2053
2054 /* Initialize a cpu table and return a descriptor.
2055    It's much like opening a file, and must be the first function called.
2056    The arguments are a set of (type/value) pairs, terminated with
2057    CGEN_CPU_OPEN_END.
2058
2059    Currently supported values:
2060    CGEN_CPU_OPEN_ISAS:    bitmap of values in enum isa_attr
2061    CGEN_CPU_OPEN_MACHS:   bitmap of values in enum mach_attr
2062    CGEN_CPU_OPEN_BFDMACH: specify 1 mach using bfd name
2063    CGEN_CPU_OPEN_ENDIAN:  specify endian choice
2064    CGEN_CPU_OPEN_END:     terminates arguments
2065
2066    ??? Simultaneous multiple isas might not make sense, but it's not (yet)
2067    precluded.
2068
2069    ??? We only support ISO C stdargs here, not K&R.
2070    Laziness, plus experiment to see if anything requires K&R - eventually
2071    K&R will no longer be supported - e.g. GDB is currently trying this.  */
2072
2073 CGEN_CPU_DESC
2074 iq2000_cgen_cpu_open (enum cgen_cpu_open_arg arg_type, ...)
2075 {
2076   CGEN_CPU_TABLE *cd = (CGEN_CPU_TABLE *) xmalloc (sizeof (CGEN_CPU_TABLE));
2077   static int init_p;
2078   CGEN_BITSET *isas = 0;  /* 0 = "unspecified" */
2079   unsigned int machs = 0; /* 0 = "unspecified" */
2080   enum cgen_endian endian = CGEN_ENDIAN_UNKNOWN;
2081   va_list ap;
2082
2083   if (! init_p)
2084     {
2085       init_tables ();
2086       init_p = 1;
2087     }
2088
2089   memset (cd, 0, sizeof (*cd));
2090
2091   va_start (ap, arg_type);
2092   while (arg_type != CGEN_CPU_OPEN_END)
2093     {
2094       switch (arg_type)
2095         {
2096         case CGEN_CPU_OPEN_ISAS :
2097           isas = va_arg (ap, CGEN_BITSET *);
2098           break;
2099         case CGEN_CPU_OPEN_MACHS :
2100           machs = va_arg (ap, unsigned int);
2101           break;
2102         case CGEN_CPU_OPEN_BFDMACH :
2103           {
2104             const char *name = va_arg (ap, const char *);
2105             const CGEN_MACH *mach =
2106               lookup_mach_via_bfd_name (iq2000_cgen_mach_table, name);
2107
2108             machs |= 1 << mach->num;
2109             break;
2110           }
2111         case CGEN_CPU_OPEN_ENDIAN :
2112           endian = va_arg (ap, enum cgen_endian);
2113           break;
2114         default :
2115           fprintf (stderr, "iq2000_cgen_cpu_open: unsupported argument `%d'\n",
2116                    arg_type);
2117           abort (); /* ??? return NULL? */
2118         }
2119       arg_type = va_arg (ap, enum cgen_cpu_open_arg);
2120     }
2121   va_end (ap);
2122
2123   /* Mach unspecified means "all".  */
2124   if (machs == 0)
2125     machs = (1 << MAX_MACHS) - 1;
2126   /* Base mach is always selected.  */
2127   machs |= 1;
2128   if (endian == CGEN_ENDIAN_UNKNOWN)
2129     {
2130       /* ??? If target has only one, could have a default.  */
2131       fprintf (stderr, "iq2000_cgen_cpu_open: no endianness specified\n");
2132       abort ();
2133     }
2134
2135   cd->isas = cgen_bitset_copy (isas);
2136   cd->machs = machs;
2137   cd->endian = endian;
2138   /* FIXME: for the sparc case we can determine insn-endianness statically.
2139      The worry here is where both data and insn endian can be independently
2140      chosen, in which case this function will need another argument.
2141      Actually, will want to allow for more arguments in the future anyway.  */
2142   cd->insn_endian = endian;
2143
2144   /* Table (re)builder.  */
2145   cd->rebuild_tables = iq2000_cgen_rebuild_tables;
2146   iq2000_cgen_rebuild_tables (cd);
2147
2148   /* Default to not allowing signed overflow.  */
2149   cd->signed_overflow_ok_p = 0;
2150
2151   return (CGEN_CPU_DESC) cd;
2152 }
2153
2154 /* Cover fn to iq2000_cgen_cpu_open to handle the simple case of 1 isa, 1 mach.
2155    MACH_NAME is the bfd name of the mach.  */
2156
2157 CGEN_CPU_DESC
2158 iq2000_cgen_cpu_open_1 (const char *mach_name, enum cgen_endian endian)
2159 {
2160   return iq2000_cgen_cpu_open (CGEN_CPU_OPEN_BFDMACH, mach_name,
2161                                CGEN_CPU_OPEN_ENDIAN, endian,
2162                                CGEN_CPU_OPEN_END);
2163 }
2164
2165 /* Close a cpu table.
2166    ??? This can live in a machine independent file, but there's currently
2167    no place to put this file (there's no libcgen).  libopcodes is the wrong
2168    place as some simulator ports use this but they don't use libopcodes.  */
2169
2170 void
2171 iq2000_cgen_cpu_close (CGEN_CPU_DESC cd)
2172 {
2173   unsigned int i;
2174   const CGEN_INSN *insns;
2175
2176   if (cd->macro_insn_table.init_entries)
2177     {
2178       insns = cd->macro_insn_table.init_entries;
2179       for (i = 0; i < cd->macro_insn_table.num_init_entries; ++i, ++insns)
2180         if (CGEN_INSN_RX ((insns)))
2181           regfree (CGEN_INSN_RX (insns));
2182     }
2183
2184   if (cd->insn_table.init_entries)
2185     {
2186       insns = cd->insn_table.init_entries;
2187       for (i = 0; i < cd->insn_table.num_init_entries; ++i, ++insns)
2188         if (CGEN_INSN_RX (insns))
2189           regfree (CGEN_INSN_RX (insns));
2190     }
2191
2192   if (cd->macro_insn_table.init_entries)
2193     free ((CGEN_INSN *) cd->macro_insn_table.init_entries);
2194
2195   if (cd->insn_table.init_entries)
2196     free ((CGEN_INSN *) cd->insn_table.init_entries);
2197
2198   if (cd->hw_table.entries)
2199     free ((CGEN_HW_ENTRY *) cd->hw_table.entries);
2200
2201   if (cd->operand_table.entries)
2202     free ((CGEN_HW_ENTRY *) cd->operand_table.entries);
2203
2204   free (cd);
2205 }
2206