opcodes/m32r-opc.c

   1 /* Instruction opcode table for m32r.
   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 "ansidecl.h"
  27 #include "bfd.h"
  28 #include "symcat.h"
  29 #include "m32r-desc.h"
  30 #include "m32r-opc.h"
  31 #include "libiberty.h"
  32
  33 /* -- opc.c */
  34 unsigned int
  35 m32r_cgen_dis_hash (const char * buf ATTRIBUTE_UNUSED, CGEN_INSN_INT value)
  36 {
  37   unsigned int x;
  38
  39   if (value & 0xffff0000) /* 32bit instructions.  */
  40     value = (value >> 16) & 0xffff;
  41
  42   x = (value >> 8) & 0xf0;
  43   if (x == 0x40 || x == 0xe0 || x == 0x60 || x == 0x50)
  44     return x;
  45
  46   if (x == 0x70 || x == 0xf0)
  47     return x | ((value >> 8) & 0x0f);
  48
  49   if (x == 0x30)
  50     return x | ((value & 0x70) >> 4);
  51   else
  52     return x | ((value & 0xf0) >> 4);
  53 }
  54
  55 /* -- */
  56 /* The hash functions are recorded here to help keep assembler code out of
  57    the disassembler and vice versa.  */
  58
  59 static int asm_hash_insn_p        (const CGEN_INSN *);
  60 static unsigned int asm_hash_insn (const char *);
  61 static int dis_hash_insn_p        (const CGEN_INSN *);
  62 static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
  63
  64 /* Instruction formats.  */
  65
  66 #define F(f) & m32r_cgen_ifld_table[M32R_##f]
  67 static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
  68   0, 0, 0x0, { { 0 } }
  69 };
  70
  71 static const CGEN_IFMT ifmt_add ATTRIBUTE_UNUSED = {
  72   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
  73 };
  74
  75 static const CGEN_IFMT ifmt_add3 ATTRIBUTE_UNUSED = {
  76   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
  77 };
  78
  79 static const CGEN_IFMT ifmt_and3 ATTRIBUTE_UNUSED = {
  80   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_UIMM16) }, { 0 } }
  81 };
  82
  83 static const CGEN_IFMT ifmt_or3 ATTRIBUTE_UNUSED = {
  84   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_UIMM16) }, { 0 } }
  85 };
  86
  87 static const CGEN_IFMT ifmt_addi ATTRIBUTE_UNUSED = {
  88   16, 16, 0xf000, { { F (F_OP1) }, { F (F_R1) }, { F (F_SIMM8) }, { 0 } }
  89 };
  90
  91 static const CGEN_IFMT ifmt_addv3 ATTRIBUTE_UNUSED = {
  92   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
  93 };
  94
  95 static const CGEN_IFMT ifmt_bc8 ATTRIBUTE_UNUSED = {
  96   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
  97 };
  98
  99 static const CGEN_IFMT ifmt_bc24 ATTRIBUTE_UNUSED = {
 100   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
 101 };
 102
 103 static const CGEN_IFMT ifmt_beq ATTRIBUTE_UNUSED = {
 104   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_DISP16) }, { 0 } }
 105 };
 106
 107 static const CGEN_IFMT ifmt_beqz ATTRIBUTE_UNUSED = {
 108   32, 32, 0xfff00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_DISP16) }, { 0 } }
 109 };
 110
 111 static const CGEN_IFMT ifmt_cmp ATTRIBUTE_UNUSED = {
 112   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 113 };
 114
 115 static const CGEN_IFMT ifmt_cmpi ATTRIBUTE_UNUSED = {
 116   32, 32, 0xfff00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
 117 };
 118
 119 static const CGEN_IFMT ifmt_cmpz ATTRIBUTE_UNUSED = {
 120   16, 16, 0xfff0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 121 };
 122
 123 static const CGEN_IFMT ifmt_div ATTRIBUTE_UNUSED = {
 124   32, 32, 0xf0f0ffff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
 125 };
 126
 127 static const CGEN_IFMT ifmt_jc ATTRIBUTE_UNUSED = {
 128   16, 16, 0xfff0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 129 };
 130
 131 static const CGEN_IFMT ifmt_ld24 ATTRIBUTE_UNUSED = {
 132   32, 32, 0xf0000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_UIMM24) }, { 0 } }
 133 };
 134
 135 static const CGEN_IFMT ifmt_ldi16 ATTRIBUTE_UNUSED = {
 136   32, 32, 0xf0ff0000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
 137 };
 138
 139 static const CGEN_IFMT ifmt_machi_a ATTRIBUTE_UNUSED = {
 140   16, 16, 0xf070, { { F (F_OP1) }, { F (F_R1) }, { F (F_ACC) }, { F (F_OP23) }, { F (F_R2) }, { 0 } }
 141 };
 142
 143 static const CGEN_IFMT ifmt_mvfachi ATTRIBUTE_UNUSED = {
 144   16, 16, 0xf0ff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 145 };
 146
 147 static const CGEN_IFMT ifmt_mvfachi_a ATTRIBUTE_UNUSED = {
 148   16, 16, 0xf0f3, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_OP3) }, { 0 } }
 149 };
 150
 151 static const CGEN_IFMT ifmt_mvfc ATTRIBUTE_UNUSED = {
 152   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 153 };
 154
 155 static const CGEN_IFMT ifmt_mvtachi ATTRIBUTE_UNUSED = {
 156   16, 16, 0xf0ff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 157 };
 158
 159 static const CGEN_IFMT ifmt_mvtachi_a ATTRIBUTE_UNUSED = {
 160   16, 16, 0xf0f3, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_OP3) }, { 0 } }
 161 };
 162
 163 static const CGEN_IFMT ifmt_mvtc ATTRIBUTE_UNUSED = {
 164   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 165 };
 166
 167 static const CGEN_IFMT ifmt_nop ATTRIBUTE_UNUSED = {
 168   16, 16, 0xffff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 169 };
 170
 171 static const CGEN_IFMT ifmt_rac_dsi ATTRIBUTE_UNUSED = {
 172   16, 16, 0xf3f2, { { F (F_OP1) }, { F (F_ACCD) }, { F (F_BITS67) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_BIT14) }, { F (F_IMM1) }, { 0 } }
 173 };
 174
 175 static const CGEN_IFMT ifmt_seth ATTRIBUTE_UNUSED = {
 176   32, 32, 0xf0ff0000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_HI16) }, { 0 } }
 177 };
 178
 179 static const CGEN_IFMT ifmt_slli ATTRIBUTE_UNUSED = {
 180   16, 16, 0xf0e0, { { F (F_OP1) }, { F (F_R1) }, { F (F_SHIFT_OP2) }, { F (F_UIMM5) }, { 0 } }
 181 };
 182
 183 static const CGEN_IFMT ifmt_st_d ATTRIBUTE_UNUSED = {
 184   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
 185 };
 186
 187 static const CGEN_IFMT ifmt_trap ATTRIBUTE_UNUSED = {
 188   16, 16, 0xfff0, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_UIMM4) }, { 0 } }
 189 };
 190
 191 static const CGEN_IFMT ifmt_satb ATTRIBUTE_UNUSED = {
 192   32, 32, 0xf0f0ffff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_UIMM16) }, { 0 } }
 193 };
 194
 195 static const CGEN_IFMT ifmt_clrpsw ATTRIBUTE_UNUSED = {
 196   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_UIMM8) }, { 0 } }
 197 };
 198
 199 static const CGEN_IFMT ifmt_bset ATTRIBUTE_UNUSED = {
 200   32, 32, 0xf8f00000, { { F (F_OP1) }, { F (F_BIT4) }, { F (F_UIMM3) }, { F (F_OP2) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
 201 };
 202
 203 static const CGEN_IFMT ifmt_btst ATTRIBUTE_UNUSED = {
 204   16, 16, 0xf8f0, { { F (F_OP1) }, { F (F_BIT4) }, { F (F_UIMM3) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
 205 };
 206
 207 #undef F
 208
 209 #define A(a) (1 << CGEN_INSN_##a)
 210 #define OPERAND(op) M32R_OPERAND_##op
 211 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
 212 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 213
 214 /* The instruction table.  */
 215
 216 static const CGEN_OPCODE m32r_cgen_insn_opcode_table[MAX_INSNS] =
 217 {
 218   /* Special null first entry.
 219      A `num' value of zero is thus invalid.
 220      Also, the special `invalid' insn resides here.  */
 221   { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
 222 /* add $dr,$sr */
 223   {
 224     { 0, 0, 0, 0 },
 225     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 226     & ifmt_add, { 0xa0 }
 227   },
 228 /* add3 $dr,$sr,$hash$slo16 */
 229   {
 230     { 0, 0, 0, 0 },
 231     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (HASH), OP (SLO16), 0 } },
 232     & ifmt_add3, { 0x80a00000 }
 233   },
 234 /* and $dr,$sr */
 235   {
 236     { 0, 0, 0, 0 },
 237     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 238     & ifmt_add, { 0xc0 }
 239   },
 240 /* and3 $dr,$sr,$uimm16 */
 241   {
 242     { 0, 0, 0, 0 },
 243     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (UIMM16), 0 } },
 244     & ifmt_and3, { 0x80c00000 }
 245   },
 246 /* or $dr,$sr */
 247   {
 248     { 0, 0, 0, 0 },
 249     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 250     & ifmt_add, { 0xe0 }
 251   },
 252 /* or3 $dr,$sr,$hash$ulo16 */
 253   {
 254     { 0, 0, 0, 0 },
 255     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (HASH), OP (ULO16), 0 } },
 256     & ifmt_or3, { 0x80e00000 }
 257   },
 258 /* xor $dr,$sr */
 259   {
 260     { 0, 0, 0, 0 },
 261     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 262     & ifmt_add, { 0xd0 }
 263   },
 264 /* xor3 $dr,$sr,$uimm16 */
 265   {
 266     { 0, 0, 0, 0 },
 267     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (UIMM16), 0 } },
 268     & ifmt_and3, { 0x80d00000 }
 269   },
 270 /* addi $dr,$simm8 */
 271   {
 272     { 0, 0, 0, 0 },
 273     { { MNEM, ' ', OP (DR), ',', OP (SIMM8), 0 } },
 274     & ifmt_addi, { 0x4000 }
 275   },
 276 /* addv $dr,$sr */
 277   {
 278     { 0, 0, 0, 0 },
 279     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 280     & ifmt_add, { 0x80 }
 281   },
 282 /* addv3 $dr,$sr,$simm16 */
 283   {
 284     { 0, 0, 0, 0 },
 285     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (SIMM16), 0 } },
 286     & ifmt_addv3, { 0x80800000 }
 287   },
 288 /* addx $dr,$sr */
 289   {
 290     { 0, 0, 0, 0 },
 291     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 292     & ifmt_add, { 0x90 }
 293   },
 294 /* bc.s $disp8 */
 295   {
 296     { 0, 0, 0, 0 },
 297     { { MNEM, ' ', OP (DISP8), 0 } },
 298     & ifmt_bc8, { 0x7c00 }
 299   },
 300 /* bc.l $disp24 */
 301   {
 302     { 0, 0, 0, 0 },
 303     { { MNEM, ' ', OP (DISP24), 0 } },
 304     & ifmt_bc24, { 0xfc000000 }
 305   },
 306 /* beq $src1,$src2,$disp16 */
 307   {
 308     { 0, 0, 0, 0 },
 309     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (DISP16), 0 } },
 310     & ifmt_beq, { 0xb0000000 }
 311   },
 312 /* beqz $src2,$disp16 */
 313   {
 314     { 0, 0, 0, 0 },
 315     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 316     & ifmt_beqz, { 0xb0800000 }
 317   },
 318 /* bgez $src2,$disp16 */
 319   {
 320     { 0, 0, 0, 0 },
 321     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 322     & ifmt_beqz, { 0xb0b00000 }
 323   },
 324 /* bgtz $src2,$disp16 */
 325   {
 326     { 0, 0, 0, 0 },
 327     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 328     & ifmt_beqz, { 0xb0d00000 }
 329   },
 330 /* blez $src2,$disp16 */
 331   {
 332     { 0, 0, 0, 0 },
 333     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 334     & ifmt_beqz, { 0xb0c00000 }
 335   },
 336 /* bltz $src2,$disp16 */
 337   {
 338     { 0, 0, 0, 0 },
 339     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 340     & ifmt_beqz, { 0xb0a00000 }
 341   },
 342 /* bnez $src2,$disp16 */
 343   {
 344     { 0, 0, 0, 0 },
 345     { { MNEM, ' ', OP (SRC2), ',', OP (DISP16), 0 } },
 346     & ifmt_beqz, { 0xb0900000 }
 347   },
 348 /* bl.s $disp8 */
 349   {
 350     { 0, 0, 0, 0 },
 351     { { MNEM, ' ', OP (DISP8), 0 } },
 352     & ifmt_bc8, { 0x7e00 }
 353   },
 354 /* bl.l $disp24 */
 355   {
 356     { 0, 0, 0, 0 },
 357     { { MNEM, ' ', OP (DISP24), 0 } },
 358     & ifmt_bc24, { 0xfe000000 }
 359   },
 360 /* bcl.s $disp8 */
 361   {
 362     { 0, 0, 0, 0 },
 363     { { MNEM, ' ', OP (DISP8), 0 } },
 364     & ifmt_bc8, { 0x7800 }
 365   },
 366 /* bcl.l $disp24 */
 367   {
 368     { 0, 0, 0, 0 },
 369     { { MNEM, ' ', OP (DISP24), 0 } },
 370     & ifmt_bc24, { 0xf8000000 }
 371   },
 372 /* bnc.s $disp8 */
 373   {
 374     { 0, 0, 0, 0 },
 375     { { MNEM, ' ', OP (DISP8), 0 } },
 376     & ifmt_bc8, { 0x7d00 }
 377   },
 378 /* bnc.l $disp24 */
 379   {
 380     { 0, 0, 0, 0 },
 381     { { MNEM, ' ', OP (DISP24), 0 } },
 382     & ifmt_bc24, { 0xfd000000 }
 383   },
 384 /* bne $src1,$src2,$disp16 */
 385   {
 386     { 0, 0, 0, 0 },
 387     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (DISP16), 0 } },
 388     & ifmt_beq, { 0xb0100000 }
 389   },
 390 /* bra.s $disp8 */
 391   {
 392     { 0, 0, 0, 0 },
 393     { { MNEM, ' ', OP (DISP8), 0 } },
 394     & ifmt_bc8, { 0x7f00 }
 395   },
 396 /* bra.l $disp24 */
 397   {
 398     { 0, 0, 0, 0 },
 399     { { MNEM, ' ', OP (DISP24), 0 } },
 400     & ifmt_bc24, { 0xff000000 }
 401   },
 402 /* bncl.s $disp8 */
 403   {
 404     { 0, 0, 0, 0 },
 405     { { MNEM, ' ', OP (DISP8), 0 } },
 406     & ifmt_bc8, { 0x7900 }
 407   },
 408 /* bncl.l $disp24 */
 409   {
 410     { 0, 0, 0, 0 },
 411     { { MNEM, ' ', OP (DISP24), 0 } },
 412     & ifmt_bc24, { 0xf9000000 }
 413   },
 414 /* cmp $src1,$src2 */
 415   {
 416     { 0, 0, 0, 0 },
 417     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 418     & ifmt_cmp, { 0x40 }
 419   },
 420 /* cmpi $src2,$simm16 */
 421   {
 422     { 0, 0, 0, 0 },
 423     { { MNEM, ' ', OP (SRC2), ',', OP (SIMM16), 0 } },
 424     & ifmt_cmpi, { 0x80400000 }
 425   },
 426 /* cmpu $src1,$src2 */
 427   {
 428     { 0, 0, 0, 0 },
 429     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 430     & ifmt_cmp, { 0x50 }
 431   },
 432 /* cmpui $src2,$simm16 */
 433   {
 434     { 0, 0, 0, 0 },
 435     { { MNEM, ' ', OP (SRC2), ',', OP (SIMM16), 0 } },
 436     & ifmt_cmpi, { 0x80500000 }
 437   },
 438 /* cmpeq $src1,$src2 */
 439   {
 440     { 0, 0, 0, 0 },
 441     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 442     & ifmt_cmp, { 0x60 }
 443   },
 444 /* cmpz $src2 */
 445   {
 446     { 0, 0, 0, 0 },
 447     { { MNEM, ' ', OP (SRC2), 0 } },
 448     & ifmt_cmpz, { 0x70 }
 449   },
 450 /* div $dr,$sr */
 451   {
 452     { 0, 0, 0, 0 },
 453     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 454     & ifmt_div, { 0x90000000 }
 455   },
 456 /* divu $dr,$sr */
 457   {
 458     { 0, 0, 0, 0 },
 459     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 460     & ifmt_div, { 0x90100000 }
 461   },
 462 /* rem $dr,$sr */
 463   {
 464     { 0, 0, 0, 0 },
 465     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 466     & ifmt_div, { 0x90200000 }
 467   },
 468 /* remu $dr,$sr */
 469   {
 470     { 0, 0, 0, 0 },
 471     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 472     & ifmt_div, { 0x90300000 }
 473   },
 474 /* remh $dr,$sr */
 475   {
 476     { 0, 0, 0, 0 },
 477     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 478     & ifmt_div, { 0x90200010 }
 479   },
 480 /* remuh $dr,$sr */
 481   {
 482     { 0, 0, 0, 0 },
 483     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 484     & ifmt_div, { 0x90300010 }
 485   },
 486 /* remb $dr,$sr */
 487   {
 488     { 0, 0, 0, 0 },
 489     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 490     & ifmt_div, { 0x90200018 }
 491   },
 492 /* remub $dr,$sr */
 493   {
 494     { 0, 0, 0, 0 },
 495     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 496     & ifmt_div, { 0x90300018 }
 497   },
 498 /* divuh $dr,$sr */
 499   {
 500     { 0, 0, 0, 0 },
 501     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 502     & ifmt_div, { 0x90100010 }
 503   },
 504 /* divb $dr,$sr */
 505   {
 506     { 0, 0, 0, 0 },
 507     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 508     & ifmt_div, { 0x90000018 }
 509   },
 510 /* divub $dr,$sr */
 511   {
 512     { 0, 0, 0, 0 },
 513     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 514     & ifmt_div, { 0x90100018 }
 515   },
 516 /* divh $dr,$sr */
 517   {
 518     { 0, 0, 0, 0 },
 519     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 520     & ifmt_div, { 0x90000010 }
 521   },
 522 /* jc $sr */
 523   {
 524     { 0, 0, 0, 0 },
 525     { { MNEM, ' ', OP (SR), 0 } },
 526     & ifmt_jc, { 0x1cc0 }
 527   },
 528 /* jnc $sr */
 529   {
 530     { 0, 0, 0, 0 },
 531     { { MNEM, ' ', OP (SR), 0 } },
 532     & ifmt_jc, { 0x1dc0 }
 533   },
 534 /* jl $sr */
 535   {
 536     { 0, 0, 0, 0 },
 537     { { MNEM, ' ', OP (SR), 0 } },
 538     & ifmt_jc, { 0x1ec0 }
 539   },
 540 /* jmp $sr */
 541   {
 542     { 0, 0, 0, 0 },
 543     { { MNEM, ' ', OP (SR), 0 } },
 544     & ifmt_jc, { 0x1fc0 }
 545   },
 546 /* ld $dr,@$sr */
 547   {
 548     { 0, 0, 0, 0 },
 549     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 550     & ifmt_add, { 0x20c0 }
 551   },
 552 /* ld $dr,@($slo16,$sr) */
 553   {
 554     { 0, 0, 0, 0 },
 555     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
 556     & ifmt_add3, { 0xa0c00000 }
 557   },
 558 /* ldb $dr,@$sr */
 559   {
 560     { 0, 0, 0, 0 },
 561     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 562     & ifmt_add, { 0x2080 }
 563   },
 564 /* ldb $dr,@($slo16,$sr) */
 565   {
 566     { 0, 0, 0, 0 },
 567     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
 568     & ifmt_add3, { 0xa0800000 }
 569   },
 570 /* ldh $dr,@$sr */
 571   {
 572     { 0, 0, 0, 0 },
 573     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 574     & ifmt_add, { 0x20a0 }
 575   },
 576 /* ldh $dr,@($slo16,$sr) */
 577   {
 578     { 0, 0, 0, 0 },
 579     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
 580     & ifmt_add3, { 0xa0a00000 }
 581   },
 582 /* ldub $dr,@$sr */
 583   {
 584     { 0, 0, 0, 0 },
 585     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 586     & ifmt_add, { 0x2090 }
 587   },
 588 /* ldub $dr,@($slo16,$sr) */
 589   {
 590     { 0, 0, 0, 0 },
 591     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
 592     & ifmt_add3, { 0xa0900000 }
 593   },
 594 /* lduh $dr,@$sr */
 595   {
 596     { 0, 0, 0, 0 },
 597     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 598     & ifmt_add, { 0x20b0 }
 599   },
 600 /* lduh $dr,@($slo16,$sr) */
 601   {
 602     { 0, 0, 0, 0 },
 603     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
 604     & ifmt_add3, { 0xa0b00000 }
 605   },
 606 /* ld $dr,@$sr+ */
 607   {
 608     { 0, 0, 0, 0 },
 609     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), '+', 0 } },
 610     & ifmt_add, { 0x20e0 }
 611   },
 612 /* ld24 $dr,$uimm24 */
 613   {
 614     { 0, 0, 0, 0 },
 615     { { MNEM, ' ', OP (DR), ',', OP (UIMM24), 0 } },
 616     & ifmt_ld24, { 0xe0000000 }
 617   },
 618 /* ldi8 $dr,$simm8 */
 619   {
 620     { 0, 0, 0, 0 },
 621     { { MNEM, ' ', OP (DR), ',', OP (SIMM8), 0 } },
 622     & ifmt_addi, { 0x6000 }
 623   },
 624 /* ldi16 $dr,$hash$slo16 */
 625   {
 626     { 0, 0, 0, 0 },
 627     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (SLO16), 0 } },
 628     & ifmt_ldi16, { 0x90f00000 }
 629   },
 630 /* lock $dr,@$sr */
 631   {
 632     { 0, 0, 0, 0 },
 633     { { MNEM, ' ', OP (DR), ',', '@', OP (SR), 0 } },
 634     & ifmt_add, { 0x20d0 }
 635   },
 636 /* machi $src1,$src2 */
 637   {
 638     { 0, 0, 0, 0 },
 639     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 640     & ifmt_cmp, { 0x3040 }
 641   },
 642 /* machi $src1,$src2,$acc */
 643   {
 644     { 0, 0, 0, 0 },
 645     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 646     & ifmt_machi_a, { 0x3040 }
 647   },
 648 /* maclo $src1,$src2 */
 649   {
 650     { 0, 0, 0, 0 },
 651     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 652     & ifmt_cmp, { 0x3050 }
 653   },
 654 /* maclo $src1,$src2,$acc */
 655   {
 656     { 0, 0, 0, 0 },
 657     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 658     & ifmt_machi_a, { 0x3050 }
 659   },
 660 /* macwhi $src1,$src2 */
 661   {
 662     { 0, 0, 0, 0 },
 663     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 664     & ifmt_cmp, { 0x3060 }
 665   },
 666 /* macwhi $src1,$src2,$acc */
 667   {
 668     { 0, 0, 0, 0 },
 669     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 670     & ifmt_machi_a, { 0x3060 }
 671   },
 672 /* macwlo $src1,$src2 */
 673   {
 674     { 0, 0, 0, 0 },
 675     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 676     & ifmt_cmp, { 0x3070 }
 677   },
 678 /* macwlo $src1,$src2,$acc */
 679   {
 680     { 0, 0, 0, 0 },
 681     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 682     & ifmt_machi_a, { 0x3070 }
 683   },
 684 /* mul $dr,$sr */
 685   {
 686     { 0, 0, 0, 0 },
 687     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 688     & ifmt_add, { 0x1060 }
 689   },
 690 /* mulhi $src1,$src2 */
 691   {
 692     { 0, 0, 0, 0 },
 693     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 694     & ifmt_cmp, { 0x3000 }
 695   },
 696 /* mulhi $src1,$src2,$acc */
 697   {
 698     { 0, 0, 0, 0 },
 699     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 700     & ifmt_machi_a, { 0x3000 }
 701   },
 702 /* mullo $src1,$src2 */
 703   {
 704     { 0, 0, 0, 0 },
 705     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 706     & ifmt_cmp, { 0x3010 }
 707   },
 708 /* mullo $src1,$src2,$acc */
 709   {
 710     { 0, 0, 0, 0 },
 711     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 712     & ifmt_machi_a, { 0x3010 }
 713   },
 714 /* mulwhi $src1,$src2 */
 715   {
 716     { 0, 0, 0, 0 },
 717     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 718     & ifmt_cmp, { 0x3020 }
 719   },
 720 /* mulwhi $src1,$src2,$acc */
 721   {
 722     { 0, 0, 0, 0 },
 723     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 724     & ifmt_machi_a, { 0x3020 }
 725   },
 726 /* mulwlo $src1,$src2 */
 727   {
 728     { 0, 0, 0, 0 },
 729     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
 730     & ifmt_cmp, { 0x3030 }
 731   },
 732 /* mulwlo $src1,$src2,$acc */
 733   {
 734     { 0, 0, 0, 0 },
 735     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), ',', OP (ACC), 0 } },
 736     & ifmt_machi_a, { 0x3030 }
 737   },
 738 /* mv $dr,$sr */
 739   {
 740     { 0, 0, 0, 0 },
 741     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 742     & ifmt_add, { 0x1080 }
 743   },
 744 /* mvfachi $dr */
 745   {
 746     { 0, 0, 0, 0 },
 747     { { MNEM, ' ', OP (DR), 0 } },
 748     & ifmt_mvfachi, { 0x50f0 }
 749   },
 750 /* mvfachi $dr,$accs */
 751   {
 752     { 0, 0, 0, 0 },
 753     { { MNEM, ' ', OP (DR), ',', OP (ACCS), 0 } },
 754     & ifmt_mvfachi_a, { 0x50f0 }
 755   },
 756 /* mvfaclo $dr */
 757   {
 758     { 0, 0, 0, 0 },
 759     { { MNEM, ' ', OP (DR), 0 } },
 760     & ifmt_mvfachi, { 0x50f1 }
 761   },
 762 /* mvfaclo $dr,$accs */
 763   {
 764     { 0, 0, 0, 0 },
 765     { { MNEM, ' ', OP (DR), ',', OP (ACCS), 0 } },
 766     & ifmt_mvfachi_a, { 0x50f1 }
 767   },
 768 /* mvfacmi $dr */
 769   {
 770     { 0, 0, 0, 0 },
 771     { { MNEM, ' ', OP (DR), 0 } },
 772     & ifmt_mvfachi, { 0x50f2 }
 773   },
 774 /* mvfacmi $dr,$accs */
 775   {
 776     { 0, 0, 0, 0 },
 777     { { MNEM, ' ', OP (DR), ',', OP (ACCS), 0 } },
 778     & ifmt_mvfachi_a, { 0x50f2 }
 779   },
 780 /* mvfc $dr,$scr */
 781   {
 782     { 0, 0, 0, 0 },
 783     { { MNEM, ' ', OP (DR), ',', OP (SCR), 0 } },
 784     & ifmt_mvfc, { 0x1090 }
 785   },
 786 /* mvtachi $src1 */
 787   {
 788     { 0, 0, 0, 0 },
 789     { { MNEM, ' ', OP (SRC1), 0 } },
 790     & ifmt_mvtachi, { 0x5070 }
 791   },
 792 /* mvtachi $src1,$accs */
 793   {
 794     { 0, 0, 0, 0 },
 795     { { MNEM, ' ', OP (SRC1), ',', OP (ACCS), 0 } },
 796     & ifmt_mvtachi_a, { 0x5070 }
 797   },
 798 /* mvtaclo $src1 */
 799   {
 800     { 0, 0, 0, 0 },
 801     { { MNEM, ' ', OP (SRC1), 0 } },
 802     & ifmt_mvtachi, { 0x5071 }
 803   },
 804 /* mvtaclo $src1,$accs */
 805   {
 806     { 0, 0, 0, 0 },
 807     { { MNEM, ' ', OP (SRC1), ',', OP (ACCS), 0 } },
 808     & ifmt_mvtachi_a, { 0x5071 }
 809   },
 810 /* mvtc $sr,$dcr */
 811   {
 812     { 0, 0, 0, 0 },
 813     { { MNEM, ' ', OP (SR), ',', OP (DCR), 0 } },
 814     & ifmt_mvtc, { 0x10a0 }
 815   },
 816 /* neg $dr,$sr */
 817   {
 818     { 0, 0, 0, 0 },
 819     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 820     & ifmt_add, { 0x30 }
 821   },
 822 /* nop */
 823   {
 824     { 0, 0, 0, 0 },
 825     { { MNEM, 0 } },
 826     & ifmt_nop, { 0x7000 }
 827   },
 828 /* not $dr,$sr */
 829   {
 830     { 0, 0, 0, 0 },
 831     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 832     & ifmt_add, { 0xb0 }
 833   },
 834 /* rac */
 835   {
 836     { 0, 0, 0, 0 },
 837     { { MNEM, 0 } },
 838     & ifmt_nop, { 0x5090 }
 839   },
 840 /* rac $accd,$accs,$imm1 */
 841   {
 842     { 0, 0, 0, 0 },
 843     { { MNEM, ' ', OP (ACCD), ',', OP (ACCS), ',', OP (IMM1), 0 } },
 844     & ifmt_rac_dsi, { 0x5090 }
 845   },
 846 /* rach */
 847   {
 848     { 0, 0, 0, 0 },
 849     { { MNEM, 0 } },
 850     & ifmt_nop, { 0x5080 }
 851   },
 852 /* rach $accd,$accs,$imm1 */
 853   {
 854     { 0, 0, 0, 0 },
 855     { { MNEM, ' ', OP (ACCD), ',', OP (ACCS), ',', OP (IMM1), 0 } },
 856     & ifmt_rac_dsi, { 0x5080 }
 857   },
 858 /* rte */
 859   {
 860     { 0, 0, 0, 0 },
 861     { { MNEM, 0 } },
 862     & ifmt_nop, { 0x10d6 }
 863   },
 864 /* seth $dr,$hash$hi16 */
 865   {
 866     { 0, 0, 0, 0 },
 867     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (HI16), 0 } },
 868     & ifmt_seth, { 0xd0c00000 }
 869   },
 870 /* sll $dr,$sr */
 871   {
 872     { 0, 0, 0, 0 },
 873     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 874     & ifmt_add, { 0x1040 }
 875   },
 876 /* sll3 $dr,$sr,$simm16 */
 877   {
 878     { 0, 0, 0, 0 },
 879     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (SIMM16), 0 } },
 880     & ifmt_addv3, { 0x90c00000 }
 881   },
 882 /* slli $dr,$uimm5 */
 883   {
 884     { 0, 0, 0, 0 },
 885     { { MNEM, ' ', OP (DR), ',', OP (UIMM5), 0 } },
 886     & ifmt_slli, { 0x5040 }
 887   },
 888 /* sra $dr,$sr */
 889   {
 890     { 0, 0, 0, 0 },
 891     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 892     & ifmt_add, { 0x1020 }
 893   },
 894 /* sra3 $dr,$sr,$simm16 */
 895   {
 896     { 0, 0, 0, 0 },
 897     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (SIMM16), 0 } },
 898     & ifmt_addv3, { 0x90a00000 }
 899   },
 900 /* srai $dr,$uimm5 */
 901   {
 902     { 0, 0, 0, 0 },
 903     { { MNEM, ' ', OP (DR), ',', OP (UIMM5), 0 } },
 904     & ifmt_slli, { 0x5020 }
 905   },
 906 /* srl $dr,$sr */
 907   {
 908     { 0, 0, 0, 0 },
 909     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 910     & ifmt_add, { 0x1000 }
 911   },
 912 /* srl3 $dr,$sr,$simm16 */
 913   {
 914     { 0, 0, 0, 0 },
 915     { { MNEM, ' ', OP (DR), ',', OP (SR), ',', OP (SIMM16), 0 } },
 916     & ifmt_addv3, { 0x90800000 }
 917   },
 918 /* srli $dr,$uimm5 */
 919   {
 920     { 0, 0, 0, 0 },
 921     { { MNEM, ' ', OP (DR), ',', OP (UIMM5), 0 } },
 922     & ifmt_slli, { 0x5000 }
 923   },
 924 /* st $src1,@$src2 */
 925   {
 926     { 0, 0, 0, 0 },
 927     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), 0 } },
 928     & ifmt_cmp, { 0x2040 }
 929   },
 930 /* st $src1,@($slo16,$src2) */
 931   {
 932     { 0, 0, 0, 0 },
 933     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SLO16), ',', OP (SRC2), ')', 0 } },
 934     & ifmt_st_d, { 0xa0400000 }
 935   },
 936 /* stb $src1,@$src2 */
 937   {
 938     { 0, 0, 0, 0 },
 939     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), 0 } },
 940     & ifmt_cmp, { 0x2000 }
 941   },
 942 /* stb $src1,@($slo16,$src2) */
 943   {
 944     { 0, 0, 0, 0 },
 945     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SLO16), ',', OP (SRC2), ')', 0 } },
 946     & ifmt_st_d, { 0xa0000000 }
 947   },
 948 /* sth $src1,@$src2 */
 949   {
 950     { 0, 0, 0, 0 },
 951     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), 0 } },
 952     & ifmt_cmp, { 0x2020 }
 953   },
 954 /* sth $src1,@($slo16,$src2) */
 955   {
 956     { 0, 0, 0, 0 },
 957     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SLO16), ',', OP (SRC2), ')', 0 } },
 958     & ifmt_st_d, { 0xa0200000 }
 959   },
 960 /* st $src1,@+$src2 */
 961   {
 962     { 0, 0, 0, 0 },
 963     { { MNEM, ' ', OP (SRC1), ',', '@', '+', OP (SRC2), 0 } },
 964     & ifmt_cmp, { 0x2060 }
 965   },
 966 /* sth $src1,@$src2+ */
 967   {
 968     { 0, 0, 0, 0 },
 969     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), '+', 0 } },
 970     & ifmt_cmp, { 0x2030 }
 971   },
 972 /* stb $src1,@$src2+ */
 973   {
 974     { 0, 0, 0, 0 },
 975     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), '+', 0 } },
 976     & ifmt_cmp, { 0x2010 }
 977   },
 978 /* st $src1,@-$src2 */
 979   {
 980     { 0, 0, 0, 0 },
 981     { { MNEM, ' ', OP (SRC1), ',', '@', '-', OP (SRC2), 0 } },
 982     & ifmt_cmp, { 0x2070 }
 983   },
 984 /* sub $dr,$sr */
 985   {
 986     { 0, 0, 0, 0 },
 987     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 988     & ifmt_add, { 0x20 }
 989   },
 990 /* subv $dr,$sr */
 991   {
 992     { 0, 0, 0, 0 },
 993     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 994     & ifmt_add, { 0x0 }
 995   },
 996 /* subx $dr,$sr */
 997   {
 998     { 0, 0, 0, 0 },
 999     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1000     & ifmt_add, { 0x10 }
1001   },
1002 /* trap $uimm4 */
1003   {
1004     { 0, 0, 0, 0 },
1005     { { MNEM, ' ', OP (UIMM4), 0 } },
1006     & ifmt_trap, { 0x10f0 }
1007   },
1008 /* unlock $src1,@$src2 */
1009   {
1010     { 0, 0, 0, 0 },
1011     { { MNEM, ' ', OP (SRC1), ',', '@', OP (SRC2), 0 } },
1012     & ifmt_cmp, { 0x2050 }
1013   },
1014 /* satb $dr,$sr */
1015   {
1016     { 0, 0, 0, 0 },
1017     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1018     & ifmt_satb, { 0x80600300 }
1019   },
1020 /* sath $dr,$sr */
1021   {
1022     { 0, 0, 0, 0 },
1023     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1024     & ifmt_satb, { 0x80600200 }
1025   },
1026 /* sat $dr,$sr */
1027   {
1028     { 0, 0, 0, 0 },
1029     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1030     & ifmt_satb, { 0x80600000 }
1031   },
1032 /* pcmpbz $src2 */
1033   {
1034     { 0, 0, 0, 0 },
1035     { { MNEM, ' ', OP (SRC2), 0 } },
1036     & ifmt_cmpz, { 0x370 }
1037   },
1038 /* sadd */
1039   {
1040     { 0, 0, 0, 0 },
1041     { { MNEM, 0 } },
1042     & ifmt_nop, { 0x50e4 }
1043   },
1044 /* macwu1 $src1,$src2 */
1045   {
1046     { 0, 0, 0, 0 },
1047     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1048     & ifmt_cmp, { 0x50b0 }
1049   },
1050 /* msblo $src1,$src2 */
1051   {
1052     { 0, 0, 0, 0 },
1053     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1054     & ifmt_cmp, { 0x50d0 }
1055   },
1056 /* mulwu1 $src1,$src2 */
1057   {
1058     { 0, 0, 0, 0 },
1059     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1060     & ifmt_cmp, { 0x50a0 }
1061   },
1062 /* maclh1 $src1,$src2 */
1063   {
1064     { 0, 0, 0, 0 },
1065     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1066     & ifmt_cmp, { 0x50c0 }
1067   },
1068 /* sc */
1069   {
1070     { 0, 0, 0, 0 },
1071     { { MNEM, 0 } },
1072     & ifmt_nop, { 0x7401 }
1073   },
1074 /* snc */
1075   {
1076     { 0, 0, 0, 0 },
1077     { { MNEM, 0 } },
1078     & ifmt_nop, { 0x7501 }
1079   },
1080 /* clrpsw $uimm8 */
1081   {
1082     { 0, 0, 0, 0 },
1083     { { MNEM, ' ', OP (UIMM8), 0 } },
1084     & ifmt_clrpsw, { 0x7200 }
1085   },
1086 /* setpsw $uimm8 */
1087   {
1088     { 0, 0, 0, 0 },
1089     { { MNEM, ' ', OP (UIMM8), 0 } },
1090     & ifmt_clrpsw, { 0x7100 }
1091   },
1092 /* bset $uimm3,@($slo16,$sr) */
1093   {
1094     { 0, 0, 0, 0 },
1095     { { MNEM, ' ', OP (UIMM3), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
1096     & ifmt_bset, { 0xa0600000 }
1097   },
1098 /* bclr $uimm3,@($slo16,$sr) */
1099   {
1100     { 0, 0, 0, 0 },
1101     { { MNEM, ' ', OP (UIMM3), ',', '@', '(', OP (SLO16), ',', OP (SR), ')', 0 } },
1102     & ifmt_bset, { 0xa0700000 }
1103   },
1104 /* btst $uimm3,$sr */
1105   {
1106     { 0, 0, 0, 0 },
1107     { { MNEM, ' ', OP (UIMM3), ',', OP (SR), 0 } },
1108     & ifmt_btst, { 0xf0 }
1109   },
1110 };
1111
1112 #undef A
1113 #undef OPERAND
1114 #undef MNEM
1115 #undef OP
1116
1117 /* Formats for ALIAS macro-insns.  */
1118
1119 #define F(f) & m32r_cgen_ifld_table[M32R_##f]
1120 static const CGEN_IFMT ifmt_bc8r ATTRIBUTE_UNUSED = {
1121   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1122 };
1123
1124 static const CGEN_IFMT ifmt_bc24r ATTRIBUTE_UNUSED = {
1125   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1126 };
1127
1128 static const CGEN_IFMT ifmt_bl8r ATTRIBUTE_UNUSED = {
1129   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1130 };
1131
1132 static const CGEN_IFMT ifmt_bl24r ATTRIBUTE_UNUSED = {
1133   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1134 };
1135
1136 static const CGEN_IFMT ifmt_bcl8r ATTRIBUTE_UNUSED = {
1137   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1138 };
1139
1140 static const CGEN_IFMT ifmt_bcl24r ATTRIBUTE_UNUSED = {
1141   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1142 };
1143
1144 static const CGEN_IFMT ifmt_bnc8r ATTRIBUTE_UNUSED = {
1145   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1146 };
1147
1148 static const CGEN_IFMT ifmt_bnc24r ATTRIBUTE_UNUSED = {
1149   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1150 };
1151
1152 static const CGEN_IFMT ifmt_bra8r ATTRIBUTE_UNUSED = {
1153   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1154 };
1155
1156 static const CGEN_IFMT ifmt_bra24r ATTRIBUTE_UNUSED = {
1157   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1158 };
1159
1160 static const CGEN_IFMT ifmt_bncl8r ATTRIBUTE_UNUSED = {
1161   16, 16, 0xff00, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP8) }, { 0 } }
1162 };
1163
1164 static const CGEN_IFMT ifmt_bncl24r ATTRIBUTE_UNUSED = {
1165   32, 32, 0xff000000, { { F (F_OP1) }, { F (F_R1) }, { F (F_DISP24) }, { 0 } }
1166 };
1167
1168 static const CGEN_IFMT ifmt_ld_2 ATTRIBUTE_UNUSED = {
1169   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1170 };
1171
1172 static const CGEN_IFMT ifmt_ld_d2 ATTRIBUTE_UNUSED = {
1173   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1174 };
1175
1176 static const CGEN_IFMT ifmt_ldb_2 ATTRIBUTE_UNUSED = {
1177   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1178 };
1179
1180 static const CGEN_IFMT ifmt_ldb_d2 ATTRIBUTE_UNUSED = {
1181   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1182 };
1183
1184 static const CGEN_IFMT ifmt_ldh_2 ATTRIBUTE_UNUSED = {
1185   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1186 };
1187
1188 static const CGEN_IFMT ifmt_ldh_d2 ATTRIBUTE_UNUSED = {
1189   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1190 };
1191
1192 static const CGEN_IFMT ifmt_ldub_2 ATTRIBUTE_UNUSED = {
1193   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1194 };
1195
1196 static const CGEN_IFMT ifmt_ldub_d2 ATTRIBUTE_UNUSED = {
1197   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1198 };
1199
1200 static const CGEN_IFMT ifmt_lduh_2 ATTRIBUTE_UNUSED = {
1201   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1202 };
1203
1204 static const CGEN_IFMT ifmt_lduh_d2 ATTRIBUTE_UNUSED = {
1205   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1206 };
1207
1208 static const CGEN_IFMT ifmt_pop ATTRIBUTE_UNUSED = {
1209   16, 16, 0xf0ff, { { F (F_OP1) }, { F (F_R1) }, { F (F_OP2) }, { F (F_R2) }, { 0 } }
1210 };
1211
1212 static const CGEN_IFMT ifmt_ldi8a ATTRIBUTE_UNUSED = {
1213   16, 16, 0xf000, { { F (F_OP1) }, { F (F_R1) }, { F (F_SIMM8) }, { 0 } }
1214 };
1215
1216 static const CGEN_IFMT ifmt_ldi16a ATTRIBUTE_UNUSED = {
1217   32, 32, 0xf0ff0000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R2) }, { F (F_R1) }, { F (F_SIMM16) }, { 0 } }
1218 };
1219
1220 static const CGEN_IFMT ifmt_rac_d ATTRIBUTE_UNUSED = {
1221   16, 16, 0xf3ff, { { F (F_OP1) }, { F (F_ACCD) }, { F (F_BITS67) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_BIT14) }, { F (F_IMM1) }, { 0 } }
1222 };
1223
1224 static const CGEN_IFMT ifmt_rac_ds ATTRIBUTE_UNUSED = {
1225   16, 16, 0xf3f3, { { F (F_OP1) }, { F (F_ACCD) }, { F (F_BITS67) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_BIT14) }, { F (F_IMM1) }, { 0 } }
1226 };
1227
1228 static const CGEN_IFMT ifmt_rach_d ATTRIBUTE_UNUSED = {
1229   16, 16, 0xf3ff, { { F (F_OP1) }, { F (F_ACCD) }, { F (F_BITS67) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_BIT14) }, { F (F_IMM1) }, { 0 } }
1230 };
1231
1232 static const CGEN_IFMT ifmt_rach_ds ATTRIBUTE_UNUSED = {
1233   16, 16, 0xf3f3, { { F (F_OP1) }, { F (F_ACCD) }, { F (F_BITS67) }, { F (F_OP2) }, { F (F_ACCS) }, { F (F_BIT14) }, { F (F_IMM1) }, { 0 } }
1234 };
1235
1236 static const CGEN_IFMT ifmt_st_2 ATTRIBUTE_UNUSED = {
1237   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1238 };
1239
1240 static const CGEN_IFMT ifmt_st_d2 ATTRIBUTE_UNUSED = {
1241   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1242 };
1243
1244 static const CGEN_IFMT ifmt_stb_2 ATTRIBUTE_UNUSED = {
1245   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1246 };
1247
1248 static const CGEN_IFMT ifmt_stb_d2 ATTRIBUTE_UNUSED = {
1249   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1250 };
1251
1252 static const CGEN_IFMT ifmt_sth_2 ATTRIBUTE_UNUSED = {
1253   16, 16, 0xf0f0, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1254 };
1255
1256 static const CGEN_IFMT ifmt_sth_d2 ATTRIBUTE_UNUSED = {
1257   32, 32, 0xf0f00000, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { F (F_SIMM16) }, { 0 } }
1258 };
1259
1260 static const CGEN_IFMT ifmt_push ATTRIBUTE_UNUSED = {
1261   16, 16, 0xf0ff, { { F (F_OP1) }, { F (F_OP2) }, { F (F_R1) }, { F (F_R2) }, { 0 } }
1262 };
1263
1264 #undef F
1265
1266 /* Each non-simple macro entry points to an array of expansion possibilities.  */
1267
1268 #define A(a) (1 << CGEN_INSN_##a)
1269 #define OPERAND(op) M32R_OPERAND_##op
1270 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
1271 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
1272
1273 /* The macro instruction table.  */
1274
1275 static const CGEN_IBASE m32r_cgen_macro_insn_table[] =
1276 {
1277 /* bc $disp8 */
1278   {
1279     -1, "bc8r", "bc", 16,
1280     { 0|A(RELAXABLE)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1281   },
1282 /* bc $disp24 */
1283   {
1284     -1, "bc24r", "bc", 32,
1285     { 0|A(RELAXED)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1286   },
1287 /* bl $disp8 */
1288   {
1289     -1, "bl8r", "bl", 16,
1290     { 0|A(RELAXABLE)|A(FILL_SLOT)|A(UNCOND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1291   },
1292 /* bl $disp24 */
1293   {
1294     -1, "bl24r", "bl", 32,
1295     { 0|A(RELAXED)|A(UNCOND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1296   },
1297 /* bcl $disp8 */
1298   {
1299     -1, "bcl8r", "bcl", 16,
1300     { 0|A(RELAXABLE)|A(FILL_SLOT)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
1301   },
1302 /* bcl $disp24 */
1303   {
1304     -1, "bcl24r", "bcl", 32,
1305     { 0|A(RELAXED)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
1306   },
1307 /* bnc $disp8 */
1308   {
1309     -1, "bnc8r", "bnc", 16,
1310     { 0|A(RELAXABLE)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1311   },
1312 /* bnc $disp24 */
1313   {
1314     -1, "bnc24r", "bnc", 32,
1315     { 0|A(RELAXED)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1316   },
1317 /* bra $disp8 */
1318   {
1319     -1, "bra8r", "bra", 16,
1320     { 0|A(RELAXABLE)|A(FILL_SLOT)|A(UNCOND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1321   },
1322 /* bra $disp24 */
1323   {
1324     -1, "bra24r", "bra", 32,
1325     { 0|A(RELAXED)|A(UNCOND_CTI)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1326   },
1327 /* bncl $disp8 */
1328   {
1329     -1, "bncl8r", "bncl", 16,
1330     { 0|A(RELAXABLE)|A(FILL_SLOT)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_O, 0 } } } }
1331   },
1332 /* bncl $disp24 */
1333   {
1334     -1, "bncl24r", "bncl", 32,
1335     { 0|A(RELAXED)|A(COND_CTI)|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_NONE, 0 } } } }
1336   },
1337 /* ld $dr,@($sr) */
1338   {
1339     -1, "ld-2", "ld", 16,
1340     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1341   },
1342 /* ld $dr,@($sr,$slo16) */
1343   {
1344     -1, "ld-d2", "ld", 32,
1345     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1346   },
1347 /* ldb $dr,@($sr) */
1348   {
1349     -1, "ldb-2", "ldb", 16,
1350     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1351   },
1352 /* ldb $dr,@($sr,$slo16) */
1353   {
1354     -1, "ldb-d2", "ldb", 32,
1355     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1356   },
1357 /* ldh $dr,@($sr) */
1358   {
1359     -1, "ldh-2", "ldh", 16,
1360     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1361   },
1362 /* ldh $dr,@($sr,$slo16) */
1363   {
1364     -1, "ldh-d2", "ldh", 32,
1365     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1366   },
1367 /* ldub $dr,@($sr) */
1368   {
1369     -1, "ldub-2", "ldub", 16,
1370     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1371   },
1372 /* ldub $dr,@($sr,$slo16) */
1373   {
1374     -1, "ldub-d2", "ldub", 32,
1375     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1376   },
1377 /* lduh $dr,@($sr) */
1378   {
1379     -1, "lduh-2", "lduh", 16,
1380     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1381   },
1382 /* lduh $dr,@($sr,$slo16) */
1383   {
1384     -1, "lduh-d2", "lduh", 32,
1385     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1386   },
1387 /* pop $dr */
1388   {
1389     -1, "pop", "pop", 16,
1390     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1391   },
1392 /* ldi $dr,$simm8 */
1393   {
1394     -1, "ldi8a", "ldi", 16,
1395     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_OS, 0 } } } }
1396   },
1397 /* ldi $dr,$hash$slo16 */
1398   {
1399     -1, "ldi16a", "ldi", 32,
1400     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1401   },
1402 /* rac $accd */
1403   {
1404     -1, "rac-d", "rac", 16,
1405     { 0|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
1406   },
1407 /* rac $accd,$accs */
1408   {
1409     -1, "rac-ds", "rac", 16,
1410     { 0|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
1411   },
1412 /* rach $accd */
1413   {
1414     -1, "rach-d", "rach", 16,
1415     { 0|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
1416   },
1417 /* rach $accd,$accs */
1418   {
1419     -1, "rach-ds", "rach", 16,
1420     { 0|A(ALIAS), { { { (1<<MACH_M32RX)|(1<<MACH_M32R2), 0 } }, { { PIPE_S, 0 } } } }
1421   },
1422 /* st $src1,@($src2) */
1423   {
1424     -1, "st-2", "st", 16,
1425     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1426   },
1427 /* st $src1,@($src2,$slo16) */
1428   {
1429     -1, "st-d2", "st", 32,
1430     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1431   },
1432 /* stb $src1,@($src2) */
1433   {
1434     -1, "stb-2", "stb", 16,
1435     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1436   },
1437 /* stb $src1,@($src2,$slo16) */
1438   {
1439     -1, "stb-d2", "stb", 32,
1440     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1441   },
1442 /* sth $src1,@($src2) */
1443   {
1444     -1, "sth-2", "sth", 16,
1445     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1446   },
1447 /* sth $src1,@($src2,$slo16) */
1448   {
1449     -1, "sth-d2", "sth", 32,
1450     { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_NONE, 0 } } } }
1451   },
1452 /* push $src1 */
1453   {
1454     -1, "push", "push", 16,
1455     { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { PIPE_O, 0 } } } }
1456   },
1457 };
1458
1459 /* The macro instruction opcode table.  */
1460
1461 static const CGEN_OPCODE m32r_cgen_macro_insn_opcode_table[] =
1462 {
1463 /* bc $disp8 */
1464   {
1465     { 0, 0, 0, 0 },
1466     { { MNEM, ' ', OP (DISP8), 0 } },
1467     & ifmt_bc8r, { 0x7c00 }
1468   },
1469 /* bc $disp24 */
1470   {
1471     { 0, 0, 0, 0 },
1472     { { MNEM, ' ', OP (DISP24), 0 } },
1473     & ifmt_bc24r, { 0xfc000000 }
1474   },
1475 /* bl $disp8 */
1476   {
1477     { 0, 0, 0, 0 },
1478     { { MNEM, ' ', OP (DISP8), 0 } },
1479     & ifmt_bl8r, { 0x7e00 }
1480   },
1481 /* bl $disp24 */
1482   {
1483     { 0, 0, 0, 0 },
1484     { { MNEM, ' ', OP (DISP24), 0 } },
1485     & ifmt_bl24r, { 0xfe000000 }
1486   },
1487 /* bcl $disp8 */
1488   {
1489     { 0, 0, 0, 0 },
1490     { { MNEM, ' ', OP (DISP8), 0 } },
1491     & ifmt_bcl8r, { 0x7800 }
1492   },
1493 /* bcl $disp24 */
1494   {
1495     { 0, 0, 0, 0 },
1496     { { MNEM, ' ', OP (DISP24), 0 } },
1497     & ifmt_bcl24r, { 0xf8000000 }
1498   },
1499 /* bnc $disp8 */
1500   {
1501     { 0, 0, 0, 0 },
1502     { { MNEM, ' ', OP (DISP8), 0 } },
1503     & ifmt_bnc8r, { 0x7d00 }
1504   },
1505 /* bnc $disp24 */
1506   {
1507     { 0, 0, 0, 0 },
1508     { { MNEM, ' ', OP (DISP24), 0 } },
1509     & ifmt_bnc24r, { 0xfd000000 }
1510   },
1511 /* bra $disp8 */
1512   {
1513     { 0, 0, 0, 0 },
1514     { { MNEM, ' ', OP (DISP8), 0 } },
1515     & ifmt_bra8r, { 0x7f00 }
1516   },
1517 /* bra $disp24 */
1518   {
1519     { 0, 0, 0, 0 },
1520     { { MNEM, ' ', OP (DISP24), 0 } },
1521     & ifmt_bra24r, { 0xff000000 }
1522   },
1523 /* bncl $disp8 */
1524   {
1525     { 0, 0, 0, 0 },
1526     { { MNEM, ' ', OP (DISP8), 0 } },
1527     & ifmt_bncl8r, { 0x7900 }
1528   },
1529 /* bncl $disp24 */
1530   {
1531     { 0, 0, 0, 0 },
1532     { { MNEM, ' ', OP (DISP24), 0 } },
1533     & ifmt_bncl24r, { 0xf9000000 }
1534   },
1535 /* ld $dr,@($sr) */
1536   {
1537     { 0, 0, 0, 0 },
1538     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ')', 0 } },
1539     & ifmt_ld_2, { 0x20c0 }
1540   },
1541 /* ld $dr,@($sr,$slo16) */
1542   {
1543     { 0, 0, 0, 0 },
1544     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ',', OP (SLO16), ')', 0 } },
1545     & ifmt_ld_d2, { 0xa0c00000 }
1546   },
1547 /* ldb $dr,@($sr) */
1548   {
1549     { 0, 0, 0, 0 },
1550     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ')', 0 } },
1551     & ifmt_ldb_2, { 0x2080 }
1552   },
1553 /* ldb $dr,@($sr,$slo16) */
1554   {
1555     { 0, 0, 0, 0 },
1556     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ',', OP (SLO16), ')', 0 } },
1557     & ifmt_ldb_d2, { 0xa0800000 }
1558   },
1559 /* ldh $dr,@($sr) */
1560   {
1561     { 0, 0, 0, 0 },
1562     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ')', 0 } },
1563     & ifmt_ldh_2, { 0x20a0 }
1564   },
1565 /* ldh $dr,@($sr,$slo16) */
1566   {
1567     { 0, 0, 0, 0 },
1568     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ',', OP (SLO16), ')', 0 } },
1569     & ifmt_ldh_d2, { 0xa0a00000 }
1570   },
1571 /* ldub $dr,@($sr) */
1572   {
1573     { 0, 0, 0, 0 },
1574     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ')', 0 } },
1575     & ifmt_ldub_2, { 0x2090 }
1576   },
1577 /* ldub $dr,@($sr,$slo16) */
1578   {
1579     { 0, 0, 0, 0 },
1580     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ',', OP (SLO16), ')', 0 } },
1581     & ifmt_ldub_d2, { 0xa0900000 }
1582   },
1583 /* lduh $dr,@($sr) */
1584   {
1585     { 0, 0, 0, 0 },
1586     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ')', 0 } },
1587     & ifmt_lduh_2, { 0x20b0 }
1588   },
1589 /* lduh $dr,@($sr,$slo16) */
1590   {
1591     { 0, 0, 0, 0 },
1592     { { MNEM, ' ', OP (DR), ',', '@', '(', OP (SR), ',', OP (SLO16), ')', 0 } },
1593     & ifmt_lduh_d2, { 0xa0b00000 }
1594   },
1595 /* pop $dr */
1596   {
1597     { 0, 0, 0, 0 },
1598     { { MNEM, ' ', OP (DR), 0 } },
1599     & ifmt_pop, { 0x20ef }
1600   },
1601 /* ldi $dr,$simm8 */
1602   {
1603     { 0, 0, 0, 0 },
1604     { { MNEM, ' ', OP (DR), ',', OP (SIMM8), 0 } },
1605     & ifmt_ldi8a, { 0x6000 }
1606   },
1607 /* ldi $dr,$hash$slo16 */
1608   {
1609     { 0, 0, 0, 0 },
1610     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (SLO16), 0 } },
1611     & ifmt_ldi16a, { 0x90f00000 }
1612   },
1613 /* rac $accd */
1614   {
1615     { 0, 0, 0, 0 },
1616     { { MNEM, ' ', OP (ACCD), 0 } },
1617     & ifmt_rac_d, { 0x5090 }
1618   },
1619 /* rac $accd,$accs */
1620   {
1621     { 0, 0, 0, 0 },
1622     { { MNEM, ' ', OP (ACCD), ',', OP (ACCS), 0 } },
1623     & ifmt_rac_ds, { 0x5090 }
1624   },
1625 /* rach $accd */
1626   {
1627     { 0, 0, 0, 0 },
1628     { { MNEM, ' ', OP (ACCD), 0 } },
1629     & ifmt_rach_d, { 0x5080 }
1630   },
1631 /* rach $accd,$accs */
1632   {
1633     { 0, 0, 0, 0 },
1634     { { MNEM, ' ', OP (ACCD), ',', OP (ACCS), 0 } },
1635     & ifmt_rach_ds, { 0x5080 }
1636   },
1637 /* st $src1,@($src2) */
1638   {
1639     { 0, 0, 0, 0 },
1640     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ')', 0 } },
1641     & ifmt_st_2, { 0x2040 }
1642   },
1643 /* st $src1,@($src2,$slo16) */
1644   {
1645     { 0, 0, 0, 0 },
1646     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ',', OP (SLO16), ')', 0 } },
1647     & ifmt_st_d2, { 0xa0400000 }
1648   },
1649 /* stb $src1,@($src2) */
1650   {
1651     { 0, 0, 0, 0 },
1652     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ')', 0 } },
1653     & ifmt_stb_2, { 0x2000 }
1654   },
1655 /* stb $src1,@($src2,$slo16) */
1656   {
1657     { 0, 0, 0, 0 },
1658     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ',', OP (SLO16), ')', 0 } },
1659     & ifmt_stb_d2, { 0xa0000000 }
1660   },
1661 /* sth $src1,@($src2) */
1662   {
1663     { 0, 0, 0, 0 },
1664     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ')', 0 } },
1665     & ifmt_sth_2, { 0x2020 }
1666   },
1667 /* sth $src1,@($src2,$slo16) */
1668   {
1669     { 0, 0, 0, 0 },
1670     { { MNEM, ' ', OP (SRC1), ',', '@', '(', OP (SRC2), ',', OP (SLO16), ')', 0 } },
1671     & ifmt_sth_d2, { 0xa0200000 }
1672   },
1673 /* push $src1 */
1674   {
1675     { 0, 0, 0, 0 },
1676     { { MNEM, ' ', OP (SRC1), 0 } },
1677     & ifmt_push, { 0x207f }
1678   },
1679 };
1680
1681 #undef A
1682 #undef OPERAND
1683 #undef MNEM
1684 #undef OP
1685
1686 #ifndef CGEN_ASM_HASH_P
1687 #define CGEN_ASM_HASH_P(insn) 1
1688 #endif
1689
1690 #ifndef CGEN_DIS_HASH_P
1691 #define CGEN_DIS_HASH_P(insn) 1
1692 #endif
1693
1694 /* Return non-zero if INSN is to be added to the hash table.
1695    Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
1696
1697 static int
1698 asm_hash_insn_p (insn)
1699      const CGEN_INSN *insn ATTRIBUTE_UNUSED;
1700 {
1701   return CGEN_ASM_HASH_P (insn);
1702 }
1703
1704 static int
1705 dis_hash_insn_p (insn)
1706      const CGEN_INSN *insn;
1707 {
1708   /* If building the hash table and the NO-DIS attribute is present,
1709      ignore.  */
1710   if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
1711     return 0;
1712   return CGEN_DIS_HASH_P (insn);
1713 }
1714
1715 #ifndef CGEN_ASM_HASH
1716 #define CGEN_ASM_HASH_SIZE 127
1717 #ifdef CGEN_MNEMONIC_OPERANDS
1718 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
1719 #else
1720 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
1721 #endif
1722 #endif
1723
1724 /* It doesn't make much sense to provide a default here,
1725    but while this is under development we do.
1726    BUFFER is a pointer to the bytes of the insn, target order.
1727    VALUE is the first base_insn_bitsize bits as an int in host order.  */
1728
1729 #ifndef CGEN_DIS_HASH
1730 #define CGEN_DIS_HASH_SIZE 256
1731 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
1732 #endif
1733
1734 /* The result is the hash value of the insn.
1735    Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
1736
1737 static unsigned int
1738 asm_hash_insn (mnem)
1739      const char * mnem;
1740 {
1741   return CGEN_ASM_HASH (mnem);
1742 }
1743
1744 /* BUF is a pointer to the bytes of the insn, target order.
1745    VALUE is the first base_insn_bitsize bits as an int in host order.  */
1746
1747 static unsigned int
1748 dis_hash_insn (buf, value)
1749      const char * buf ATTRIBUTE_UNUSED;
1750      CGEN_INSN_INT value ATTRIBUTE_UNUSED;
1751 {
1752   return CGEN_DIS_HASH (buf, value);
1753 }
1754
1755 /* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
1756
1757 static void
1758 set_fields_bitsize (CGEN_FIELDS *fields, int size)
1759 {
1760   CGEN_FIELDS_BITSIZE (fields) = size;
1761 }
1762
1763 /* Function to call before using the operand instance table.
1764    This plugs the opcode entries and macro instructions into the cpu table.  */
1765
1766 void
1767 m32r_cgen_init_opcode_table (CGEN_CPU_DESC cd)
1768 {
1769   int i;
1770   int num_macros = (sizeof (m32r_cgen_macro_insn_table) /
1771                     sizeof (m32r_cgen_macro_insn_table[0]));
1772   const CGEN_IBASE *ib = & m32r_cgen_macro_insn_table[0];
1773   const CGEN_OPCODE *oc = & m32r_cgen_macro_insn_opcode_table[0];
1774   CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
1775
1776   /* This test has been added to avoid a warning generated
1777      if memset is called with a third argument of value zero.  */
1778   if (num_macros >= 1)
1779     memset (insns, 0, num_macros * sizeof (CGEN_INSN));
1780   for (i = 0; i < num_macros; ++i)
1781     {
1782       insns[i].base = &ib[i];
1783       insns[i].opcode = &oc[i];
1784       m32r_cgen_build_insn_regex (& insns[i]);
1785     }
1786   cd->macro_insn_table.init_entries = insns;
1787   cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
1788   cd->macro_insn_table.num_init_entries = num_macros;
1789
1790   oc = & m32r_cgen_insn_opcode_table[0];
1791   insns = (CGEN_INSN *) cd->insn_table.init_entries;
1792   for (i = 0; i < MAX_INSNS; ++i)
1793     {
1794       insns[i].opcode = &oc[i];
1795       m32r_cgen_build_insn_regex (& insns[i]);
1796     }
1797
1798   cd->sizeof_fields = sizeof (CGEN_FIELDS);
1799   cd->set_fields_bitsize = set_fields_bitsize;
1800
1801   cd->asm_hash_p = asm_hash_insn_p;
1802   cd->asm_hash = asm_hash_insn;
1803   cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
1804
1805   cd->dis_hash_p = dis_hash_insn_p;
1806   cd->dis_hash = dis_hash_insn;
1807   cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
1808 }