opcodes/xc16x-opc.c

   1 /* DO NOT EDIT!  -*- buffer-read-only: t -*- vi:set ro:  */
   2 /* Instruction opcode table for xc16x.
   3
   4 THIS FILE IS MACHINE GENERATED WITH CGEN.
   5
   6 Copyright (C) 1996-2020 Free Software Foundation, Inc.
   7
   8 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
   9
  10    This file is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3, or (at your option)
  13    any later version.
  14
  15    It is distributed in the hope that it will be useful, but WITHOUT
  16    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  17    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  18    License for more details.
  19
  20    You should have received a copy of the GNU General Public License along
  21    with this program; if not, write to the Free Software Foundation, Inc.,
  22    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  23
  24 */
  25
  26 #include "sysdep.h"
  27 #include "ansidecl.h"
  28 #include "bfd.h"
  29 #include "symcat.h"
  30 #include "xc16x-desc.h"
  31 #include "xc16x-opc.h"
  32 #include "libiberty.h"
  33
  34 /* -- opc.c */
  35
  36 /* -- */
  37 /* The hash functions are recorded here to help keep assembler code out of
  38    the disassembler and vice versa.  */
  39
  40 static int asm_hash_insn_p        (const CGEN_INSN *);
  41 static unsigned int asm_hash_insn (const char *);
  42 static int dis_hash_insn_p        (const CGEN_INSN *);
  43 static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
  44
  45 /* Instruction formats.  */
  46
  47 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
  48 static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
  49   0, 0, 0x0, { { 0 } }
  50 };
  51
  52 static const CGEN_IFMT ifmt_addrpof ATTRIBUTE_UNUSED = {
  53   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  54 };
  55
  56 static const CGEN_IFMT ifmt_addbrpof ATTRIBUTE_UNUSED = {
  57   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  58 };
  59
  60 static const CGEN_IFMT ifmt_addrpag ATTRIBUTE_UNUSED = {
  61   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  62 };
  63
  64 static const CGEN_IFMT ifmt_addbrpag ATTRIBUTE_UNUSED = {
  65   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  66 };
  67
  68 static const CGEN_IFMT ifmt_addrhpof ATTRIBUTE_UNUSED = {
  69   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  70 };
  71
  72 static const CGEN_IFMT ifmt_addrhpof3 ATTRIBUTE_UNUSED = {
  73   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  74 };
  75
  76 static const CGEN_IFMT ifmt_addbrhpag3 ATTRIBUTE_UNUSED = {
  77   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  78 };
  79
  80 static const CGEN_IFMT ifmt_addrbhpof ATTRIBUTE_UNUSED = {
  81   32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  82 };
  83
  84 static const CGEN_IFMT ifmt_addr ATTRIBUTE_UNUSED = {
  85   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  86 };
  87
  88 static const CGEN_IFMT ifmt_addbr ATTRIBUTE_UNUSED = {
  89   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  90 };
  91
  92 static const CGEN_IFMT ifmt_add2 ATTRIBUTE_UNUSED = {
  93   16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  94 };
  95
  96 static const CGEN_IFMT ifmt_addb2 ATTRIBUTE_UNUSED = {
  97   16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
  98 };
  99
 100 static const CGEN_IFMT ifmt_addrm2 ATTRIBUTE_UNUSED = {
 101   32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 102 };
 103
 104 static const CGEN_IFMT ifmt_addrm ATTRIBUTE_UNUSED = {
 105   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 106 };
 107
 108 static const CGEN_IFMT ifmt_addbrm2 ATTRIBUTE_UNUSED = {
 109   32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 110 };
 111
 112 static const CGEN_IFMT ifmt_addbrm ATTRIBUTE_UNUSED = {
 113   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 114 };
 115
 116 static const CGEN_IFMT ifmt_muls ATTRIBUTE_UNUSED = {
 117   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 118 };
 119
 120 static const CGEN_IFMT ifmt_div ATTRIBUTE_UNUSED = {
 121   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 122 };
 123
 124 static const CGEN_IFMT ifmt_cpl ATTRIBUTE_UNUSED = {
 125   16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 126 };
 127
 128 static const CGEN_IFMT ifmt_cplb ATTRIBUTE_UNUSED = {
 129   16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 130 };
 131
 132 static const CGEN_IFMT ifmt_movri ATTRIBUTE_UNUSED = {
 133   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 134 };
 135
 136 static const CGEN_IFMT ifmt_movbri ATTRIBUTE_UNUSED = {
 137   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 138 };
 139
 140 static const CGEN_IFMT ifmt_movbr2 ATTRIBUTE_UNUSED = {
 141   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 142 };
 143
 144 static const CGEN_IFMT ifmt_mov9i ATTRIBUTE_UNUSED = {
 145   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 146 };
 147
 148 static const CGEN_IFMT ifmt_movb9i ATTRIBUTE_UNUSED = {
 149   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 150 };
 151
 152 static const CGEN_IFMT ifmt_movri11 ATTRIBUTE_UNUSED = {
 153   32, 32, 0xf0ff, { { F (F_MEMORY) }, { F (F_OP_LBIT4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 154 };
 155
 156 static const CGEN_IFMT ifmt_movehm5 ATTRIBUTE_UNUSED = {
 157   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 158 };
 159
 160 static const CGEN_IFMT ifmt_movehm6 ATTRIBUTE_UNUSED = {
 161   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 162 };
 163
 164 static const CGEN_IFMT ifmt_movehm7 ATTRIBUTE_UNUSED = {
 165   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 166 };
 167
 168 static const CGEN_IFMT ifmt_movehm8 ATTRIBUTE_UNUSED = {
 169   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 170 };
 171
 172 static const CGEN_IFMT ifmt_movehm10 ATTRIBUTE_UNUSED = {
 173   32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 174 };
 175
 176 static const CGEN_IFMT ifmt_movbsrpofm ATTRIBUTE_UNUSED = {
 177   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 178 };
 179
 180 static const CGEN_IFMT ifmt_movbspofmr ATTRIBUTE_UNUSED = {
 181   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 182 };
 183
 184 static const CGEN_IFMT ifmt_jmpa0 ATTRIBUTE_UNUSED = {
 185   32, 32, 0x4ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BITONE) }, { F (F_OP_ONEBIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 186 };
 187
 188 static const CGEN_IFMT ifmt_jmpa_ ATTRIBUTE_UNUSED = {
 189   32, 32, 0x5ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BITONE) }, { F (F_OP_ONEBIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 190 };
 191
 192 static const CGEN_IFMT ifmt_jmpi ATTRIBUTE_UNUSED = {
 193   16, 16, 0xff, { { F (F_ICONDCODE) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 194 };
 195
 196 static const CGEN_IFMT ifmt_jmpr_nenz ATTRIBUTE_UNUSED = {
 197   16, 16, 0xff, { { F (F_REL8) }, { F (F_RCOND) }, { F (F_OP2) }, { 0 } }
 198 };
 199
 200 static const CGEN_IFMT ifmt_jmpseg ATTRIBUTE_UNUSED = {
 201   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 202 };
 203
 204 static const CGEN_IFMT ifmt_jmps ATTRIBUTE_UNUSED = {
 205   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 206 };
 207
 208 static const CGEN_IFMT ifmt_jb ATTRIBUTE_UNUSED = {
 209   32, 32, 0xf0000ff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_RELHI8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 210 };
 211
 212 static const CGEN_IFMT ifmt_calla0 ATTRIBUTE_UNUSED = {
 213   32, 32, 0x6ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_2BIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 214 };
 215
 216 static const CGEN_IFMT ifmt_calla_ ATTRIBUTE_UNUSED = {
 217   32, 32, 0x7ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BIT3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 218 };
 219
 220 static const CGEN_IFMT ifmt_callr ATTRIBUTE_UNUSED = {
 221   16, 16, 0xff, { { F (F_REL8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 222 };
 223
 224 static const CGEN_IFMT ifmt_callseg ATTRIBUTE_UNUSED = {
 225   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 226 };
 227
 228 static const CGEN_IFMT ifmt_pcall ATTRIBUTE_UNUSED = {
 229   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 230 };
 231
 232 static const CGEN_IFMT ifmt_trap ATTRIBUTE_UNUSED = {
 233   16, 16, 0x1ff, { { F (F_UIMM7) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 234 };
 235
 236 static const CGEN_IFMT ifmt_ret ATTRIBUTE_UNUSED = {
 237   16, 16, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 238 };
 239
 240 static const CGEN_IFMT ifmt_retp ATTRIBUTE_UNUSED = {
 241   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 242 };
 243
 244 static const CGEN_IFMT ifmt_reti ATTRIBUTE_UNUSED = {
 245   16, 16, 0xffff, { { F (F_OP_LBIT4) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 246 };
 247
 248 static const CGEN_IFMT ifmt_srstm ATTRIBUTE_UNUSED = {
 249   32, 32, 0xffffffff, { { F (F_OP_BIT8) }, { F (F_DATA8) }, { F (F_OP_LBIT4) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 250 };
 251
 252 static const CGEN_IFMT ifmt_atomic ATTRIBUTE_UNUSED = {
 253   16, 16, 0xcfff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 254 };
 255
 256 static const CGEN_IFMT ifmt_extp ATTRIBUTE_UNUSED = {
 257   16, 16, 0xc0ff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 258 };
 259
 260 static const CGEN_IFMT ifmt_extp1 ATTRIBUTE_UNUSED = {
 261   32, 32, 0xfc00cfff, { { F (F_QLOBIT) }, { F (F_QLOBIT2) }, { F (F_PAGENUM) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 262 };
 263
 264 static const CGEN_IFMT ifmt_extpg1 ATTRIBUTE_UNUSED = {
 265   32, 32, 0xcfff, { { F (F_UIMM16) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 266 };
 267
 268 static const CGEN_IFMT ifmt_exts1 ATTRIBUTE_UNUSED = {
 269   32, 32, 0xff00cfff, { { F (F_OP_BIT8) }, { F (F_SEGNUM8) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 270 };
 271
 272 static const CGEN_IFMT ifmt_bclr18 ATTRIBUTE_UNUSED = {
 273   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 274 };
 275
 276 static const CGEN_IFMT ifmt_bclr0 ATTRIBUTE_UNUSED = {
 277   16, 16, 0xff, { { F (F_REG8) }, { F (F_QCOND) }, { F (F_OP2) }, { 0 } }
 278 };
 279
 280 static const CGEN_IFMT ifmt_bmov ATTRIBUTE_UNUSED = {
 281   32, 32, 0xff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_REGHI8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 282 };
 283
 284 static const CGEN_IFMT ifmt_bfldl ATTRIBUTE_UNUSED = {
 285   32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_MASK8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 286 };
 287
 288 static const CGEN_IFMT ifmt_bfldh ATTRIBUTE_UNUSED = {
 289   32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_DATA8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 290 };
 291
 292 static const CGEN_IFMT ifmt_cmpri ATTRIBUTE_UNUSED = {
 293   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 294 };
 295
 296 static const CGEN_IFMT ifmt_cmpd1ri ATTRIBUTE_UNUSED = {
 297   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
 298 };
 299
 300 #undef F
 301
 302 #define A(a) (1 << CGEN_INSN_##a)
 303 #define OPERAND(op) XC16X_OPERAND_##op
 304 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
 305 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
 306
 307 /* The instruction table.  */
 308
 309 static const CGEN_OPCODE xc16x_cgen_insn_opcode_table[MAX_INSNS] =
 310 {
 311   /* Special null first entry.
 312      A `num' value of zero is thus invalid.
 313      Also, the special `invalid' insn resides here.  */
 314   { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
 315 /* add $reg8,$pof$upof16 */
 316   {
 317     { 0, 0, 0, 0 },
 318     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
 319     & ifmt_addrpof, { 0x2 }
 320   },
 321 /* sub $reg8,$pof$upof16 */
 322   {
 323     { 0, 0, 0, 0 },
 324     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
 325     & ifmt_addrpof, { 0x22 }
 326   },
 327 /* addb $regb8,$pof$upof16 */
 328   {
 329     { 0, 0, 0, 0 },
 330     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
 331     & ifmt_addbrpof, { 0x3 }
 332   },
 333 /* subb $regb8,$pof$upof16 */
 334   {
 335     { 0, 0, 0, 0 },
 336     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
 337     & ifmt_addbrpof, { 0x23 }
 338   },
 339 /* add $reg8,$pag$upag16 */
 340   {
 341     { 0, 0, 0, 0 },
 342     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
 343     & ifmt_addrpag, { 0x2 }
 344   },
 345 /* sub $reg8,$pag$upag16 */
 346   {
 347     { 0, 0, 0, 0 },
 348     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
 349     & ifmt_addrpag, { 0x22 }
 350   },
 351 /* addb $regb8,$pag$upag16 */
 352   {
 353     { 0, 0, 0, 0 },
 354     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
 355     & ifmt_addbrpag, { 0x3 }
 356   },
 357 /* subb $regb8,$pag$upag16 */
 358   {
 359     { 0, 0, 0, 0 },
 360     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
 361     & ifmt_addbrpag, { 0x23 }
 362   },
 363 /* addc $reg8,$pof$upof16 */
 364   {
 365     { 0, 0, 0, 0 },
 366     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
 367     & ifmt_addrpof, { 0x12 }
 368   },
 369 /* subc $reg8,$pof$upof16 */
 370   {
 371     { 0, 0, 0, 0 },
 372     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
 373     & ifmt_addrpof, { 0x32 }
 374   },
 375 /* addcb $regb8,$pof$upof16 */
 376   {
 377     { 0, 0, 0, 0 },
 378     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
 379     & ifmt_addbrpof, { 0x13 }
 380   },
 381 /* subcb $regb8,$pof$upof16 */
 382   {
 383     { 0, 0, 0, 0 },
 384     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
 385     & ifmt_addbrpof, { 0x33 }
 386   },
 387 /* addc $reg8,$pag$upag16 */
 388   {
 389     { 0, 0, 0, 0 },
 390     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
 391     & ifmt_addrpag, { 0x12 }
 392   },
 393 /* subc $reg8,$pag$upag16 */
 394   {
 395     { 0, 0, 0, 0 },
 396     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
 397     & ifmt_addrpag, { 0x32 }
 398   },
 399 /* addcb $regb8,$pag$upag16 */
 400   {
 401     { 0, 0, 0, 0 },
 402     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
 403     & ifmt_addbrpag, { 0x13 }
 404   },
 405 /* subcb $regb8,$pag$upag16 */
 406   {
 407     { 0, 0, 0, 0 },
 408     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
 409     & ifmt_addbrpag, { 0x33 }
 410   },
 411 /* add $pof$upof16,$reg8 */
 412   {
 413     { 0, 0, 0, 0 },
 414     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
 415     & ifmt_addrpof, { 0x4 }
 416   },
 417 /* sub $pof$upof16,$reg8 */
 418   {
 419     { 0, 0, 0, 0 },
 420     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
 421     & ifmt_addrpof, { 0x24 }
 422   },
 423 /* addb $pof$upof16,$regb8 */
 424   {
 425     { 0, 0, 0, 0 },
 426     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
 427     & ifmt_addbrpof, { 0x5 }
 428   },
 429 /* subb $pof$upof16,$regb8 */
 430   {
 431     { 0, 0, 0, 0 },
 432     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
 433     & ifmt_addbrpof, { 0x25 }
 434   },
 435 /* addc $pof$upof16,$reg8 */
 436   {
 437     { 0, 0, 0, 0 },
 438     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
 439     & ifmt_addrpof, { 0x14 }
 440   },
 441 /* subc $pof$upof16,$reg8 */
 442   {
 443     { 0, 0, 0, 0 },
 444     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
 445     & ifmt_addrpof, { 0x34 }
 446   },
 447 /* addcb $pof$upof16,$regb8 */
 448   {
 449     { 0, 0, 0, 0 },
 450     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
 451     & ifmt_addbrpof, { 0x15 }
 452   },
 453 /* subcb $pof$upof16,$regb8 */
 454   {
 455     { 0, 0, 0, 0 },
 456     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
 457     & ifmt_addbrpof, { 0x35 }
 458   },
 459 /* add $reg8,$hash$pof$uimm16 */
 460   {
 461     { 0, 0, 0, 0 },
 462     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
 463     & ifmt_addrhpof, { 0x6 }
 464   },
 465 /* sub $reg8,$hash$pof$uimm16 */
 466   {
 467     { 0, 0, 0, 0 },
 468     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
 469     & ifmt_addrhpof, { 0x26 }
 470   },
 471 /* add $reg8,$hash$pag$uimm16 */
 472   {
 473     { 0, 0, 0, 0 },
 474     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
 475     & ifmt_addrhpof, { 0x6 }
 476   },
 477 /* sub $reg8,$hash$pag$uimm16 */
 478   {
 479     { 0, 0, 0, 0 },
 480     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
 481     & ifmt_addrhpof, { 0x26 }
 482   },
 483 /* add $dr,$hash$pof$uimm3 */
 484   {
 485     { 0, 0, 0, 0 },
 486     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 487     & ifmt_addrhpof3, { 0x8 }
 488   },
 489 /* sub $dr,$hash$pof$uimm3 */
 490   {
 491     { 0, 0, 0, 0 },
 492     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 493     & ifmt_addrhpof3, { 0x28 }
 494   },
 495 /* addb $drb,$hash$pag$uimm3 */
 496   {
 497     { 0, 0, 0, 0 },
 498     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 499     & ifmt_addbrhpag3, { 0x9 }
 500   },
 501 /* subb $drb,$hash$pag$uimm3 */
 502   {
 503     { 0, 0, 0, 0 },
 504     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 505     & ifmt_addbrhpag3, { 0x29 }
 506   },
 507 /* add $dr,$hash$pag$uimm3 */
 508   {
 509     { 0, 0, 0, 0 },
 510     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 511     & ifmt_addrhpof3, { 0x8 }
 512   },
 513 /* sub $dr,$hash$pag$uimm3 */
 514   {
 515     { 0, 0, 0, 0 },
 516     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 517     & ifmt_addrhpof3, { 0x28 }
 518   },
 519 /* addb $drb,$hash$pof$uimm3 */
 520   {
 521     { 0, 0, 0, 0 },
 522     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 523     & ifmt_addbrhpag3, { 0x9 }
 524   },
 525 /* subb $drb,$hash$pof$uimm3 */
 526   {
 527     { 0, 0, 0, 0 },
 528     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 529     & ifmt_addbrhpag3, { 0x29 }
 530   },
 531 /* addb $regb8,$hash$pof$uimm8 */
 532   {
 533     { 0, 0, 0, 0 },
 534     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
 535     & ifmt_addrbhpof, { 0x7 }
 536   },
 537 /* subb $regb8,$hash$pof$uimm8 */
 538   {
 539     { 0, 0, 0, 0 },
 540     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
 541     & ifmt_addrbhpof, { 0x27 }
 542   },
 543 /* addb $regb8,$hash$pag$uimm8 */
 544   {
 545     { 0, 0, 0, 0 },
 546     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
 547     & ifmt_addrbhpof, { 0x7 }
 548   },
 549 /* subb $regb8,$hash$pag$uimm8 */
 550   {
 551     { 0, 0, 0, 0 },
 552     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
 553     & ifmt_addrbhpof, { 0x27 }
 554   },
 555 /* addc $reg8,$hash$pof$uimm16 */
 556   {
 557     { 0, 0, 0, 0 },
 558     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
 559     & ifmt_addrhpof, { 0x16 }
 560   },
 561 /* subc $reg8,$hash$pof$uimm16 */
 562   {
 563     { 0, 0, 0, 0 },
 564     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
 565     & ifmt_addrhpof, { 0x36 }
 566   },
 567 /* addc $reg8,$hash$pag$uimm16 */
 568   {
 569     { 0, 0, 0, 0 },
 570     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
 571     & ifmt_addrhpof, { 0x16 }
 572   },
 573 /* subc $reg8,$hash$pag$uimm16 */
 574   {
 575     { 0, 0, 0, 0 },
 576     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
 577     & ifmt_addrhpof, { 0x36 }
 578   },
 579 /* addc $dr,$hash$pof$uimm3 */
 580   {
 581     { 0, 0, 0, 0 },
 582     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 583     & ifmt_addrhpof3, { 0x18 }
 584   },
 585 /* subc $dr,$hash$pof$uimm3 */
 586   {
 587     { 0, 0, 0, 0 },
 588     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 589     & ifmt_addrhpof3, { 0x38 }
 590   },
 591 /* addcb $drb,$hash$pag$uimm3 */
 592   {
 593     { 0, 0, 0, 0 },
 594     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 595     & ifmt_addbrhpag3, { 0x19 }
 596   },
 597 /* subcb $drb,$hash$pag$uimm3 */
 598   {
 599     { 0, 0, 0, 0 },
 600     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 601     & ifmt_addbrhpag3, { 0x39 }
 602   },
 603 /* addc $dr,$hash$pag$uimm3 */
 604   {
 605     { 0, 0, 0, 0 },
 606     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 607     & ifmt_addrhpof3, { 0x18 }
 608   },
 609 /* subc $dr,$hash$pag$uimm3 */
 610   {
 611     { 0, 0, 0, 0 },
 612     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
 613     & ifmt_addrhpof3, { 0x38 }
 614   },
 615 /* addcb $drb,$hash$pof$uimm3 */
 616   {
 617     { 0, 0, 0, 0 },
 618     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 619     & ifmt_addbrhpag3, { 0x19 }
 620   },
 621 /* subcb $drb,$hash$pof$uimm3 */
 622   {
 623     { 0, 0, 0, 0 },
 624     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
 625     & ifmt_addbrhpag3, { 0x39 }
 626   },
 627 /* addcb $regb8,$hash$pof$uimm8 */
 628   {
 629     { 0, 0, 0, 0 },
 630     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
 631     & ifmt_addrbhpof, { 0x17 }
 632   },
 633 /* subcb $regb8,$hash$pof$uimm8 */
 634   {
 635     { 0, 0, 0, 0 },
 636     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
 637     & ifmt_addrbhpof, { 0x37 }
 638   },
 639 /* addcb $regb8,$hash$pag$uimm8 */
 640   {
 641     { 0, 0, 0, 0 },
 642     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
 643     & ifmt_addrbhpof, { 0x17 }
 644   },
 645 /* subcb $regb8,$hash$pag$uimm8 */
 646   {
 647     { 0, 0, 0, 0 },
 648     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
 649     & ifmt_addrbhpof, { 0x37 }
 650   },
 651 /* add $dr,$hash$uimm3 */
 652   {
 653     { 0, 0, 0, 0 },
 654     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
 655     & ifmt_addrhpof3, { 0x8 }
 656   },
 657 /* sub $dr,$hash$uimm3 */
 658   {
 659     { 0, 0, 0, 0 },
 660     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
 661     & ifmt_addrhpof3, { 0x28 }
 662   },
 663 /* addb $drb,$hash$uimm3 */
 664   {
 665     { 0, 0, 0, 0 },
 666     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
 667     & ifmt_addbrhpag3, { 0x9 }
 668   },
 669 /* subb $drb,$hash$uimm3 */
 670   {
 671     { 0, 0, 0, 0 },
 672     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
 673     & ifmt_addbrhpag3, { 0x29 }
 674   },
 675 /* add $reg8,$hash$uimm16 */
 676   {
 677     { 0, 0, 0, 0 },
 678     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
 679     & ifmt_addrhpof, { 0x6 }
 680   },
 681 /* sub $reg8,$hash$uimm16 */
 682   {
 683     { 0, 0, 0, 0 },
 684     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
 685     & ifmt_addrhpof, { 0x26 }
 686   },
 687 /* addb $regb8,$hash$uimm8 */
 688   {
 689     { 0, 0, 0, 0 },
 690     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
 691     & ifmt_addrbhpof, { 0x7 }
 692   },
 693 /* subb $regb8,$hash$uimm8 */
 694   {
 695     { 0, 0, 0, 0 },
 696     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
 697     & ifmt_addrbhpof, { 0x27 }
 698   },
 699 /* addc $dr,$hash$uimm3 */
 700   {
 701     { 0, 0, 0, 0 },
 702     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
 703     & ifmt_addrhpof3, { 0x18 }
 704   },
 705 /* subc $dr,$hash$uimm3 */
 706   {
 707     { 0, 0, 0, 0 },
 708     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
 709     & ifmt_addrhpof3, { 0x38 }
 710   },
 711 /* addcb $drb,$hash$uimm3 */
 712   {
 713     { 0, 0, 0, 0 },
 714     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
 715     & ifmt_addbrhpag3, { 0x19 }
 716   },
 717 /* subcb $drb,$hash$uimm3 */
 718   {
 719     { 0, 0, 0, 0 },
 720     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
 721     & ifmt_addbrhpag3, { 0x39 }
 722   },
 723 /* addc $reg8,$hash$uimm16 */
 724   {
 725     { 0, 0, 0, 0 },
 726     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
 727     & ifmt_addrhpof, { 0x16 }
 728   },
 729 /* subc $reg8,$hash$uimm16 */
 730   {
 731     { 0, 0, 0, 0 },
 732     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
 733     & ifmt_addrhpof, { 0x36 }
 734   },
 735 /* addcb $regb8,$hash$uimm8 */
 736   {
 737     { 0, 0, 0, 0 },
 738     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
 739     & ifmt_addrbhpof, { 0x17 }
 740   },
 741 /* subcb $regb8,$hash$uimm8 */
 742   {
 743     { 0, 0, 0, 0 },
 744     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
 745     & ifmt_addrbhpof, { 0x37 }
 746   },
 747 /* add $dr,$sr */
 748   {
 749     { 0, 0, 0, 0 },
 750     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 751     & ifmt_addr, { 0x0 }
 752   },
 753 /* sub $dr,$sr */
 754   {
 755     { 0, 0, 0, 0 },
 756     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 757     & ifmt_addr, { 0x20 }
 758   },
 759 /* addb $drb,$srb */
 760   {
 761     { 0, 0, 0, 0 },
 762     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
 763     & ifmt_addbr, { 0x1 }
 764   },
 765 /* subb $drb,$srb */
 766   {
 767     { 0, 0, 0, 0 },
 768     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
 769     & ifmt_addbr, { 0x21 }
 770   },
 771 /* add $dr,[$sr2] */
 772   {
 773     { 0, 0, 0, 0 },
 774     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
 775     & ifmt_add2, { 0x808 }
 776   },
 777 /* sub $dr,[$sr2] */
 778   {
 779     { 0, 0, 0, 0 },
 780     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
 781     & ifmt_add2, { 0x828 }
 782   },
 783 /* addb $drb,[$sr2] */
 784   {
 785     { 0, 0, 0, 0 },
 786     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
 787     & ifmt_addb2, { 0x809 }
 788   },
 789 /* subb $drb,[$sr2] */
 790   {
 791     { 0, 0, 0, 0 },
 792     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
 793     & ifmt_addb2, { 0x829 }
 794   },
 795 /* add $dr,[$sr2+] */
 796   {
 797     { 0, 0, 0, 0 },
 798     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
 799     & ifmt_add2, { 0xc08 }
 800   },
 801 /* sub $dr,[$sr2+] */
 802   {
 803     { 0, 0, 0, 0 },
 804     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
 805     & ifmt_add2, { 0xc28 }
 806   },
 807 /* addb $drb,[$sr2+] */
 808   {
 809     { 0, 0, 0, 0 },
 810     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
 811     & ifmt_addb2, { 0xc09 }
 812   },
 813 /* subb $drb,[$sr2+] */
 814   {
 815     { 0, 0, 0, 0 },
 816     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
 817     & ifmt_addb2, { 0xc29 }
 818   },
 819 /* addc $dr,$sr */
 820   {
 821     { 0, 0, 0, 0 },
 822     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 823     & ifmt_addr, { 0x10 }
 824   },
 825 /* subc $dr,$sr */
 826   {
 827     { 0, 0, 0, 0 },
 828     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
 829     & ifmt_addr, { 0x30 }
 830   },
 831 /* addcb $drb,$srb */
 832   {
 833     { 0, 0, 0, 0 },
 834     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
 835     & ifmt_addbr, { 0x11 }
 836   },
 837 /* subcb $drb,$srb */
 838   {
 839     { 0, 0, 0, 0 },
 840     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
 841     & ifmt_addbr, { 0x31 }
 842   },
 843 /* addc $dr,[$sr2] */
 844   {
 845     { 0, 0, 0, 0 },
 846     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
 847     & ifmt_add2, { 0x818 }
 848   },
 849 /* subc $dr,[$sr2] */
 850   {
 851     { 0, 0, 0, 0 },
 852     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
 853     & ifmt_add2, { 0x838 }
 854   },
 855 /* addcb $drb,[$sr2] */
 856   {
 857     { 0, 0, 0, 0 },
 858     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
 859     & ifmt_addb2, { 0x819 }
 860   },
 861 /* subcb $drb,[$sr2] */
 862   {
 863     { 0, 0, 0, 0 },
 864     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
 865     & ifmt_addb2, { 0x839 }
 866   },
 867 /* addc $dr,[$sr2+] */
 868   {
 869     { 0, 0, 0, 0 },
 870     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
 871     & ifmt_add2, { 0xc18 }
 872   },
 873 /* subc $dr,[$sr2+] */
 874   {
 875     { 0, 0, 0, 0 },
 876     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
 877     & ifmt_add2, { 0xc38 }
 878   },
 879 /* addcb $drb,[$sr2+] */
 880   {
 881     { 0, 0, 0, 0 },
 882     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
 883     & ifmt_addb2, { 0xc19 }
 884   },
 885 /* subcb $drb,[$sr2+] */
 886   {
 887     { 0, 0, 0, 0 },
 888     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
 889     & ifmt_addb2, { 0xc39 }
 890   },
 891 /* add $regmem8,$memgr8 */
 892   {
 893     { 0, 0, 0, 0 },
 894     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
 895     & ifmt_addrm2, { 0x2 }
 896   },
 897 /* add $memgr8,$regmem8 */
 898   {
 899     { 0, 0, 0, 0 },
 900     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
 901     & ifmt_addrm2, { 0x4 }
 902   },
 903 /* add $reg8,$memory */
 904   {
 905     { 0, 0, 0, 0 },
 906     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
 907     & ifmt_addrm, { 0x2 }
 908   },
 909 /* add $memory,$reg8 */
 910   {
 911     { 0, 0, 0, 0 },
 912     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
 913     & ifmt_addrm, { 0x4 }
 914   },
 915 /* sub $regmem8,$memgr8 */
 916   {
 917     { 0, 0, 0, 0 },
 918     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
 919     & ifmt_addrm2, { 0x22 }
 920   },
 921 /* sub $memgr8,$regmem8 */
 922   {
 923     { 0, 0, 0, 0 },
 924     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
 925     & ifmt_addrm2, { 0x24 }
 926   },
 927 /* sub $reg8,$memory */
 928   {
 929     { 0, 0, 0, 0 },
 930     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
 931     & ifmt_addrm, { 0x22 }
 932   },
 933 /* sub $memory,$reg8 */
 934   {
 935     { 0, 0, 0, 0 },
 936     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
 937     & ifmt_addrm, { 0x24 }
 938   },
 939 /* addb $regbmem8,$memgr8 */
 940   {
 941     { 0, 0, 0, 0 },
 942     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
 943     & ifmt_addbrm2, { 0x3 }
 944   },
 945 /* addb $memgr8,$regbmem8 */
 946   {
 947     { 0, 0, 0, 0 },
 948     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
 949     & ifmt_addbrm2, { 0x5 }
 950   },
 951 /* addb $regb8,$memory */
 952   {
 953     { 0, 0, 0, 0 },
 954     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
 955     & ifmt_addbrm, { 0x3 }
 956   },
 957 /* addb $memory,$regb8 */
 958   {
 959     { 0, 0, 0, 0 },
 960     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
 961     & ifmt_addbrm, { 0x5 }
 962   },
 963 /* subb $regbmem8,$memgr8 */
 964   {
 965     { 0, 0, 0, 0 },
 966     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
 967     & ifmt_addbrm2, { 0x23 }
 968   },
 969 /* subb $memgr8,$regbmem8 */
 970   {
 971     { 0, 0, 0, 0 },
 972     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
 973     & ifmt_addbrm2, { 0x25 }
 974   },
 975 /* subb $regb8,$memory */
 976   {
 977     { 0, 0, 0, 0 },
 978     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
 979     & ifmt_addbrm, { 0x23 }
 980   },
 981 /* subb $memory,$regb8 */
 982   {
 983     { 0, 0, 0, 0 },
 984     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
 985     & ifmt_addbrm, { 0x25 }
 986   },
 987 /* addc $regmem8,$memgr8 */
 988   {
 989     { 0, 0, 0, 0 },
 990     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
 991     & ifmt_addrm2, { 0x12 }
 992   },
 993 /* addc $memgr8,$regmem8 */
 994   {
 995     { 0, 0, 0, 0 },
 996     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
 997     & ifmt_addrm2, { 0x14 }
 998   },
 999 /* addc $reg8,$memory */
1000   {
1001     { 0, 0, 0, 0 },
1002     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1003     & ifmt_addrm, { 0x12 }
1004   },
1005 /* addc $memory,$reg8 */
1006   {
1007     { 0, 0, 0, 0 },
1008     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1009     & ifmt_addrm, { 0x14 }
1010   },
1011 /* subc $regmem8,$memgr8 */
1012   {
1013     { 0, 0, 0, 0 },
1014     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1015     & ifmt_addrm2, { 0x32 }
1016   },
1017 /* subc $memgr8,$regmem8 */
1018   {
1019     { 0, 0, 0, 0 },
1020     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1021     & ifmt_addrm2, { 0x34 }
1022   },
1023 /* subc $reg8,$memory */
1024   {
1025     { 0, 0, 0, 0 },
1026     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1027     & ifmt_addrm, { 0x32 }
1028   },
1029 /* subc $memory,$reg8 */
1030   {
1031     { 0, 0, 0, 0 },
1032     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1033     & ifmt_addrm, { 0x34 }
1034   },
1035 /* addcb $regbmem8,$memgr8 */
1036   {
1037     { 0, 0, 0, 0 },
1038     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1039     & ifmt_addbrm2, { 0x13 }
1040   },
1041 /* addcb $memgr8,$regbmem8 */
1042   {
1043     { 0, 0, 0, 0 },
1044     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1045     & ifmt_addbrm2, { 0x15 }
1046   },
1047 /* addcb $regb8,$memory */
1048   {
1049     { 0, 0, 0, 0 },
1050     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1051     & ifmt_addbrm, { 0x13 }
1052   },
1053 /* addcb $memory,$regb8 */
1054   {
1055     { 0, 0, 0, 0 },
1056     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1057     & ifmt_addbrm, { 0x15 }
1058   },
1059 /* subcb $regbmem8,$memgr8 */
1060   {
1061     { 0, 0, 0, 0 },
1062     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1063     & ifmt_addbrm2, { 0x33 }
1064   },
1065 /* subcb $memgr8,$regbmem8 */
1066   {
1067     { 0, 0, 0, 0 },
1068     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1069     & ifmt_addbrm2, { 0x35 }
1070   },
1071 /* subcb $regb8,$memory */
1072   {
1073     { 0, 0, 0, 0 },
1074     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1075     & ifmt_addbrm, { 0x33 }
1076   },
1077 /* subcb $memory,$regb8 */
1078   {
1079     { 0, 0, 0, 0 },
1080     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1081     & ifmt_addbrm, { 0x35 }
1082   },
1083 /* mul $src1,$src2 */
1084   {
1085     { 0, 0, 0, 0 },
1086     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1087     & ifmt_muls, { 0xb }
1088   },
1089 /* mulu $src1,$src2 */
1090   {
1091     { 0, 0, 0, 0 },
1092     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1093     & ifmt_muls, { 0x1b }
1094   },
1095 /* div $srdiv */
1096   {
1097     { 0, 0, 0, 0 },
1098     { { MNEM, ' ', OP (SRDIV), 0 } },
1099     & ifmt_div, { 0x4b }
1100   },
1101 /* divl $srdiv */
1102   {
1103     { 0, 0, 0, 0 },
1104     { { MNEM, ' ', OP (SRDIV), 0 } },
1105     & ifmt_div, { 0x6b }
1106   },
1107 /* divlu $srdiv */
1108   {
1109     { 0, 0, 0, 0 },
1110     { { MNEM, ' ', OP (SRDIV), 0 } },
1111     & ifmt_div, { 0x7b }
1112   },
1113 /* divu $srdiv */
1114   {
1115     { 0, 0, 0, 0 },
1116     { { MNEM, ' ', OP (SRDIV), 0 } },
1117     & ifmt_div, { 0x5b }
1118   },
1119 /* cpl $dr */
1120   {
1121     { 0, 0, 0, 0 },
1122     { { MNEM, ' ', OP (DR), 0 } },
1123     & ifmt_cpl, { 0x91 }
1124   },
1125 /* cplb $drb */
1126   {
1127     { 0, 0, 0, 0 },
1128     { { MNEM, ' ', OP (DRB), 0 } },
1129     & ifmt_cplb, { 0xb1 }
1130   },
1131 /* neg $dr */
1132   {
1133     { 0, 0, 0, 0 },
1134     { { MNEM, ' ', OP (DR), 0 } },
1135     & ifmt_cpl, { 0x81 }
1136   },
1137 /* negb $drb */
1138   {
1139     { 0, 0, 0, 0 },
1140     { { MNEM, ' ', OP (DRB), 0 } },
1141     & ifmt_cplb, { 0xa1 }
1142   },
1143 /* and $dr,$sr */
1144   {
1145     { 0, 0, 0, 0 },
1146     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1147     & ifmt_addr, { 0x60 }
1148   },
1149 /* or $dr,$sr */
1150   {
1151     { 0, 0, 0, 0 },
1152     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1153     & ifmt_addr, { 0x70 }
1154   },
1155 /* xor $dr,$sr */
1156   {
1157     { 0, 0, 0, 0 },
1158     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1159     & ifmt_addr, { 0x50 }
1160   },
1161 /* andb $drb,$srb */
1162   {
1163     { 0, 0, 0, 0 },
1164     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1165     & ifmt_addbr, { 0x61 }
1166   },
1167 /* orb $drb,$srb */
1168   {
1169     { 0, 0, 0, 0 },
1170     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1171     & ifmt_addbr, { 0x71 }
1172   },
1173 /* xorb $drb,$srb */
1174   {
1175     { 0, 0, 0, 0 },
1176     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1177     & ifmt_addbr, { 0x51 }
1178   },
1179 /* and $dr,$hash$uimm3 */
1180   {
1181     { 0, 0, 0, 0 },
1182     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1183     & ifmt_addrhpof3, { 0x68 }
1184   },
1185 /* or $dr,$hash$uimm3 */
1186   {
1187     { 0, 0, 0, 0 },
1188     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1189     & ifmt_addrhpof3, { 0x78 }
1190   },
1191 /* xor $dr,$hash$uimm3 */
1192   {
1193     { 0, 0, 0, 0 },
1194     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1195     & ifmt_addrhpof3, { 0x58 }
1196   },
1197 /* andb $drb,$hash$uimm3 */
1198   {
1199     { 0, 0, 0, 0 },
1200     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1201     & ifmt_addbrhpag3, { 0x69 }
1202   },
1203 /* orb $drb,$hash$uimm3 */
1204   {
1205     { 0, 0, 0, 0 },
1206     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1207     & ifmt_addbrhpag3, { 0x79 }
1208   },
1209 /* xorb $drb,$hash$uimm3 */
1210   {
1211     { 0, 0, 0, 0 },
1212     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1213     & ifmt_addbrhpag3, { 0x59 }
1214   },
1215 /* and $reg8,$hash$uimm16 */
1216   {
1217     { 0, 0, 0, 0 },
1218     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1219     & ifmt_addrhpof, { 0x66 }
1220   },
1221 /* or $reg8,$hash$uimm16 */
1222   {
1223     { 0, 0, 0, 0 },
1224     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1225     & ifmt_addrhpof, { 0x76 }
1226   },
1227 /* xor $reg8,$hash$uimm16 */
1228   {
1229     { 0, 0, 0, 0 },
1230     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1231     & ifmt_addrhpof, { 0x56 }
1232   },
1233 /* andb $regb8,$hash$uimm8 */
1234   {
1235     { 0, 0, 0, 0 },
1236     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1237     & ifmt_addrbhpof, { 0x67 }
1238   },
1239 /* orb $regb8,$hash$uimm8 */
1240   {
1241     { 0, 0, 0, 0 },
1242     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1243     & ifmt_addrbhpof, { 0x77 }
1244   },
1245 /* xorb $regb8,$hash$uimm8 */
1246   {
1247     { 0, 0, 0, 0 },
1248     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1249     & ifmt_addrbhpof, { 0x57 }
1250   },
1251 /* and $dr,[$sr2] */
1252   {
1253     { 0, 0, 0, 0 },
1254     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1255     & ifmt_add2, { 0x868 }
1256   },
1257 /* or $dr,[$sr2] */
1258   {
1259     { 0, 0, 0, 0 },
1260     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1261     & ifmt_add2, { 0x878 }
1262   },
1263 /* xor $dr,[$sr2] */
1264   {
1265     { 0, 0, 0, 0 },
1266     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1267     & ifmt_add2, { 0x858 }
1268   },
1269 /* andb $drb,[$sr2] */
1270   {
1271     { 0, 0, 0, 0 },
1272     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1273     & ifmt_addb2, { 0x869 }
1274   },
1275 /* orb $drb,[$sr2] */
1276   {
1277     { 0, 0, 0, 0 },
1278     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1279     & ifmt_addb2, { 0x879 }
1280   },
1281 /* xorb $drb,[$sr2] */
1282   {
1283     { 0, 0, 0, 0 },
1284     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1285     & ifmt_addb2, { 0x859 }
1286   },
1287 /* and $dr,[$sr2+] */
1288   {
1289     { 0, 0, 0, 0 },
1290     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1291     & ifmt_add2, { 0xc68 }
1292   },
1293 /* or $dr,[$sr2+] */
1294   {
1295     { 0, 0, 0, 0 },
1296     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1297     & ifmt_add2, { 0xc78 }
1298   },
1299 /* xor $dr,[$sr2+] */
1300   {
1301     { 0, 0, 0, 0 },
1302     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1303     & ifmt_add2, { 0xc58 }
1304   },
1305 /* andb $drb,[$sr2+] */
1306   {
1307     { 0, 0, 0, 0 },
1308     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1309     & ifmt_addb2, { 0xc69 }
1310   },
1311 /* orb $drb,[$sr2+] */
1312   {
1313     { 0, 0, 0, 0 },
1314     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1315     & ifmt_addb2, { 0xc79 }
1316   },
1317 /* xorb $drb,[$sr2+] */
1318   {
1319     { 0, 0, 0, 0 },
1320     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1321     & ifmt_addb2, { 0xc59 }
1322   },
1323 /* and $pof$reg8,$upof16 */
1324   {
1325     { 0, 0, 0, 0 },
1326     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1327     & ifmt_addrpof, { 0x62 }
1328   },
1329 /* or $pof$reg8,$upof16 */
1330   {
1331     { 0, 0, 0, 0 },
1332     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1333     & ifmt_addrpof, { 0x72 }
1334   },
1335 /* xor $pof$reg8,$upof16 */
1336   {
1337     { 0, 0, 0, 0 },
1338     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1339     & ifmt_addrpof, { 0x52 }
1340   },
1341 /* andb $pof$regb8,$upof16 */
1342   {
1343     { 0, 0, 0, 0 },
1344     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1345     & ifmt_addbrpof, { 0x63 }
1346   },
1347 /* orb $pof$regb8,$upof16 */
1348   {
1349     { 0, 0, 0, 0 },
1350     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1351     & ifmt_addbrpof, { 0x73 }
1352   },
1353 /* xorb $pof$regb8,$upof16 */
1354   {
1355     { 0, 0, 0, 0 },
1356     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1357     & ifmt_addbrpof, { 0x53 }
1358   },
1359 /* and $pof$upof16,$reg8 */
1360   {
1361     { 0, 0, 0, 0 },
1362     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1363     & ifmt_addrpof, { 0x64 }
1364   },
1365 /* or $pof$upof16,$reg8 */
1366   {
1367     { 0, 0, 0, 0 },
1368     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1369     & ifmt_addrpof, { 0x74 }
1370   },
1371 /* xor $pof$upof16,$reg8 */
1372   {
1373     { 0, 0, 0, 0 },
1374     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1375     & ifmt_addrpof, { 0x54 }
1376   },
1377 /* andb $pof$upof16,$regb8 */
1378   {
1379     { 0, 0, 0, 0 },
1380     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1381     & ifmt_addbrpof, { 0x65 }
1382   },
1383 /* orb $pof$upof16,$regb8 */
1384   {
1385     { 0, 0, 0, 0 },
1386     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1387     & ifmt_addbrpof, { 0x75 }
1388   },
1389 /* xorb $pof$upof16,$regb8 */
1390   {
1391     { 0, 0, 0, 0 },
1392     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1393     & ifmt_addbrpof, { 0x55 }
1394   },
1395 /* and $regmem8,$memgr8 */
1396   {
1397     { 0, 0, 0, 0 },
1398     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1399     & ifmt_addrm2, { 0x62 }
1400   },
1401 /* and $memgr8,$regmem8 */
1402   {
1403     { 0, 0, 0, 0 },
1404     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1405     & ifmt_addrm2, { 0x64 }
1406   },
1407 /* and $reg8,$memory */
1408   {
1409     { 0, 0, 0, 0 },
1410     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1411     & ifmt_addrm, { 0x62 }
1412   },
1413 /* and $memory,$reg8 */
1414   {
1415     { 0, 0, 0, 0 },
1416     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1417     & ifmt_addrm, { 0x64 }
1418   },
1419 /* or $regmem8,$memgr8 */
1420   {
1421     { 0, 0, 0, 0 },
1422     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1423     & ifmt_addrm2, { 0x72 }
1424   },
1425 /* or $memgr8,$regmem8 */
1426   {
1427     { 0, 0, 0, 0 },
1428     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1429     & ifmt_addrm2, { 0x74 }
1430   },
1431 /* or $reg8,$memory */
1432   {
1433     { 0, 0, 0, 0 },
1434     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1435     & ifmt_addrm, { 0x72 }
1436   },
1437 /* or $memory,$reg8 */
1438   {
1439     { 0, 0, 0, 0 },
1440     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1441     & ifmt_addrm, { 0x74 }
1442   },
1443 /* xor $regmem8,$memgr8 */
1444   {
1445     { 0, 0, 0, 0 },
1446     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1447     & ifmt_addrm2, { 0x52 }
1448   },
1449 /* xor $memgr8,$regmem8 */
1450   {
1451     { 0, 0, 0, 0 },
1452     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1453     & ifmt_addrm2, { 0x54 }
1454   },
1455 /* xor $reg8,$memory */
1456   {
1457     { 0, 0, 0, 0 },
1458     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1459     & ifmt_addrm, { 0x52 }
1460   },
1461 /* xor $memory,$reg8 */
1462   {
1463     { 0, 0, 0, 0 },
1464     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1465     & ifmt_addrm, { 0x54 }
1466   },
1467 /* andb $regbmem8,$memgr8 */
1468   {
1469     { 0, 0, 0, 0 },
1470     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1471     & ifmt_addbrm2, { 0x63 }
1472   },
1473 /* andb $memgr8,$regbmem8 */
1474   {
1475     { 0, 0, 0, 0 },
1476     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1477     & ifmt_addbrm2, { 0x65 }
1478   },
1479 /* andb $regb8,$memory */
1480   {
1481     { 0, 0, 0, 0 },
1482     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1483     & ifmt_addbrm, { 0x63 }
1484   },
1485 /* andb $memory,$regb8 */
1486   {
1487     { 0, 0, 0, 0 },
1488     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1489     & ifmt_addbrm, { 0x65 }
1490   },
1491 /* orb $regbmem8,$memgr8 */
1492   {
1493     { 0, 0, 0, 0 },
1494     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1495     & ifmt_addbrm2, { 0x73 }
1496   },
1497 /* orb $memgr8,$regbmem8 */
1498   {
1499     { 0, 0, 0, 0 },
1500     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1501     & ifmt_addbrm2, { 0x75 }
1502   },
1503 /* orb $regb8,$memory */
1504   {
1505     { 0, 0, 0, 0 },
1506     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1507     & ifmt_addbrm, { 0x73 }
1508   },
1509 /* orb $memory,$regb8 */
1510   {
1511     { 0, 0, 0, 0 },
1512     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1513     & ifmt_addbrm, { 0x75 }
1514   },
1515 /* xorb $regbmem8,$memgr8 */
1516   {
1517     { 0, 0, 0, 0 },
1518     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1519     & ifmt_addbrm2, { 0x53 }
1520   },
1521 /* xorb $memgr8,$regbmem8 */
1522   {
1523     { 0, 0, 0, 0 },
1524     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1525     & ifmt_addbrm2, { 0x55 }
1526   },
1527 /* xorb $regb8,$memory */
1528   {
1529     { 0, 0, 0, 0 },
1530     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1531     & ifmt_addbrm, { 0x53 }
1532   },
1533 /* xorb $memory,$regb8 */
1534   {
1535     { 0, 0, 0, 0 },
1536     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1537     & ifmt_addbrm, { 0x55 }
1538   },
1539 /* mov $dr,$sr */
1540   {
1541     { 0, 0, 0, 0 },
1542     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1543     & ifmt_addr, { 0xf0 }
1544   },
1545 /* movb $drb,$srb */
1546   {
1547     { 0, 0, 0, 0 },
1548     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1549     & ifmt_addbr, { 0xf1 }
1550   },
1551 /* mov $dri,$hash$u4 */
1552   {
1553     { 0, 0, 0, 0 },
1554     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (U4), 0 } },
1555     & ifmt_movri, { 0xe0 }
1556   },
1557 /* movb $srb,$hash$u4 */
1558   {
1559     { 0, 0, 0, 0 },
1560     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (U4), 0 } },
1561     & ifmt_movbri, { 0xe1 }
1562   },
1563 /* mov $reg8,$hash$uimm16 */
1564   {
1565     { 0, 0, 0, 0 },
1566     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1567     & ifmt_addrhpof, { 0xe6 }
1568   },
1569 /* movb $regb8,$hash$uimm8 */
1570   {
1571     { 0, 0, 0, 0 },
1572     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1573     & ifmt_addrbhpof, { 0xe7 }
1574   },
1575 /* mov $dr,[$sr] */
1576   {
1577     { 0, 0, 0, 0 },
1578     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), ']', 0 } },
1579     & ifmt_addr, { 0xa8 }
1580   },
1581 /* movb $drb,[$sr] */
1582   {
1583     { 0, 0, 0, 0 },
1584     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), ']', 0 } },
1585     & ifmt_movbr2, { 0xa9 }
1586   },
1587 /* mov [$sr],$dr */
1588   {
1589     { 0, 0, 0, 0 },
1590     { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DR), 0 } },
1591     & ifmt_addr, { 0xb8 }
1592   },
1593 /* movb [$sr],$drb */
1594   {
1595     { 0, 0, 0, 0 },
1596     { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DRB), 0 } },
1597     & ifmt_movbr2, { 0xb9 }
1598   },
1599 /* mov [-$sr],$dr */
1600   {
1601     { 0, 0, 0, 0 },
1602     { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DR), 0 } },
1603     & ifmt_addr, { 0x88 }
1604   },
1605 /* movb [-$sr],$drb */
1606   {
1607     { 0, 0, 0, 0 },
1608     { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DRB), 0 } },
1609     & ifmt_movbr2, { 0x89 }
1610   },
1611 /* mov $dr,[$sr+] */
1612   {
1613     { 0, 0, 0, 0 },
1614     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', ']', 0 } },
1615     & ifmt_addr, { 0x98 }
1616   },
1617 /* movb $drb,[$sr+] */
1618   {
1619     { 0, 0, 0, 0 },
1620     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', ']', 0 } },
1621     & ifmt_movbr2, { 0x99 }
1622   },
1623 /* mov [$dr],[$sr] */
1624   {
1625     { 0, 0, 0, 0 },
1626     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
1627     & ifmt_addr, { 0xc8 }
1628   },
1629 /* movb [$dr],[$sr] */
1630   {
1631     { 0, 0, 0, 0 },
1632     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
1633     & ifmt_addr, { 0xc9 }
1634   },
1635 /* mov [$dr+],[$sr] */
1636   {
1637     { 0, 0, 0, 0 },
1638     { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
1639     & ifmt_addr, { 0xd8 }
1640   },
1641 /* movb [$dr+],[$sr] */
1642   {
1643     { 0, 0, 0, 0 },
1644     { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
1645     & ifmt_addr, { 0xd9 }
1646   },
1647 /* mov [$dr],[$sr+] */
1648   {
1649     { 0, 0, 0, 0 },
1650     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
1651     & ifmt_addr, { 0xe8 }
1652   },
1653 /* movb [$dr],[$sr+] */
1654   {
1655     { 0, 0, 0, 0 },
1656     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
1657     & ifmt_addr, { 0xe9 }
1658   },
1659 /* mov $dr,[$sr+$hash$uimm16] */
1660   {
1661     { 0, 0, 0, 0 },
1662     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
1663     & ifmt_mov9i, { 0xd4 }
1664   },
1665 /* movb $drb,[$sr+$hash$uimm16] */
1666   {
1667     { 0, 0, 0, 0 },
1668     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
1669     & ifmt_movb9i, { 0xf4 }
1670   },
1671 /* mov [$sr+$hash$uimm16],$dr */
1672   {
1673     { 0, 0, 0, 0 },
1674     { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DR), 0 } },
1675     & ifmt_mov9i, { 0xc4 }
1676   },
1677 /* movb [$sr+$hash$uimm16],$drb */
1678   {
1679     { 0, 0, 0, 0 },
1680     { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DRB), 0 } },
1681     & ifmt_movb9i, { 0xe4 }
1682   },
1683 /* mov [$src2],$memory */
1684   {
1685     { 0, 0, 0, 0 },
1686     { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
1687     & ifmt_movri11, { 0x84 }
1688   },
1689 /* movb [$src2],$memory */
1690   {
1691     { 0, 0, 0, 0 },
1692     { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
1693     & ifmt_movri11, { 0xa4 }
1694   },
1695 /* mov $memory,[$src2] */
1696   {
1697     { 0, 0, 0, 0 },
1698     { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
1699     & ifmt_movri11, { 0x94 }
1700   },
1701 /* movb $memory,[$src2] */
1702   {
1703     { 0, 0, 0, 0 },
1704     { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
1705     & ifmt_movri11, { 0xb4 }
1706   },
1707 /* mov $regoff8,$hash$pof$upof16 */
1708   {
1709     { 0, 0, 0, 0 },
1710     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (POF), OP (UPOF16), 0 } },
1711     & ifmt_movehm5, { 0xe6 }
1712   },
1713 /* mov $regoff8,$hash$pag$upag16 */
1714   {
1715     { 0, 0, 0, 0 },
1716     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UPAG16), 0 } },
1717     & ifmt_movehm6, { 0xe6 }
1718   },
1719 /* mov $regoff8,$hash$segm$useg16 */
1720   {
1721     { 0, 0, 0, 0 },
1722     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SEGM), OP (USEG16), 0 } },
1723     & ifmt_movehm7, { 0xe6 }
1724   },
1725 /* mov $regoff8,$hash$sof$usof16 */
1726   {
1727     { 0, 0, 0, 0 },
1728     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
1729     & ifmt_movehm8, { 0xe6 }
1730   },
1731 /* movb $regb8,$hash$pof$uimm8 */
1732   {
1733     { 0, 0, 0, 0 },
1734     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
1735     & ifmt_addrbhpof, { 0xe7 }
1736   },
1737 /* movb $regoff8,$hash$pag$uimm8 */
1738   {
1739     { 0, 0, 0, 0 },
1740     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
1741     & ifmt_movehm10, { 0xe7 }
1742   },
1743 /* mov $regoff8,$pof$upof16 */
1744   {
1745     { 0, 0, 0, 0 },
1746     { { MNEM, ' ', OP (REGOFF8), ',', OP (POF), OP (UPOF16), 0 } },
1747     & ifmt_movehm5, { 0xf2 }
1748   },
1749 /* movb $regb8,$pof$upof16 */
1750   {
1751     { 0, 0, 0, 0 },
1752     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
1753     & ifmt_addbrpof, { 0xf3 }
1754   },
1755 /* mov $regoff8,$pag$upag16 */
1756   {
1757     { 0, 0, 0, 0 },
1758     { { MNEM, ' ', OP (REGOFF8), ',', OP (PAG), OP (UPAG16), 0 } },
1759     & ifmt_movehm6, { 0xf2 }
1760   },
1761 /* movb $regb8,$pag$upag16 */
1762   {
1763     { 0, 0, 0, 0 },
1764     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
1765     & ifmt_addbrpag, { 0xf3 }
1766   },
1767 /* mov $pof$upof16,$regoff8 */
1768   {
1769     { 0, 0, 0, 0 },
1770     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGOFF8), 0 } },
1771     & ifmt_movehm5, { 0xf6 }
1772   },
1773 /* movb $pof$upof16,$regb8 */
1774   {
1775     { 0, 0, 0, 0 },
1776     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1777     & ifmt_addbrpof, { 0xf7 }
1778   },
1779 /* mov $dri,$hash$pof$u4 */
1780   {
1781     { 0, 0, 0, 0 },
1782     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (POF), OP (U4), 0 } },
1783     & ifmt_movri, { 0xe0 }
1784   },
1785 /* movb $srb,$hash$pof$u4 */
1786   {
1787     { 0, 0, 0, 0 },
1788     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (POF), OP (U4), 0 } },
1789     & ifmt_movbri, { 0xe1 }
1790   },
1791 /* mov $dri,$hash$pag$u4 */
1792   {
1793     { 0, 0, 0, 0 },
1794     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
1795     & ifmt_movri, { 0xe0 }
1796   },
1797 /* movb $srb,$hash$pag$u4 */
1798   {
1799     { 0, 0, 0, 0 },
1800     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
1801     & ifmt_movbri, { 0xe1 }
1802   },
1803 /* mov $regmem8,$memgr8 */
1804   {
1805     { 0, 0, 0, 0 },
1806     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1807     & ifmt_addrm2, { 0xf2 }
1808   },
1809 /* mov $memgr8,$regmem8 */
1810   {
1811     { 0, 0, 0, 0 },
1812     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1813     & ifmt_addrm2, { 0xf6 }
1814   },
1815 /* mov $reg8,$memory */
1816   {
1817     { 0, 0, 0, 0 },
1818     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1819     & ifmt_addrm, { 0xf2 }
1820   },
1821 /* mov $memory,$reg8 */
1822   {
1823     { 0, 0, 0, 0 },
1824     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1825     & ifmt_addrm, { 0xf6 }
1826   },
1827 /* movb $regbmem8,$memgr8 */
1828   {
1829     { 0, 0, 0, 0 },
1830     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1831     & ifmt_addbrm2, { 0xf3 }
1832   },
1833 /* movb $memgr8,$regbmem8 */
1834   {
1835     { 0, 0, 0, 0 },
1836     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1837     & ifmt_addbrm2, { 0xf7 }
1838   },
1839 /* movb $regb8,$memory */
1840   {
1841     { 0, 0, 0, 0 },
1842     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1843     & ifmt_addbrm, { 0xf3 }
1844   },
1845 /* movb $memory,$regb8 */
1846   {
1847     { 0, 0, 0, 0 },
1848     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1849     & ifmt_addbrm, { 0xf7 }
1850   },
1851 /* movbs $sr,$drb */
1852   {
1853     { 0, 0, 0, 0 },
1854     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1855     & ifmt_movbr2, { 0xd0 }
1856   },
1857 /* movbz $sr,$drb */
1858   {
1859     { 0, 0, 0, 0 },
1860     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1861     & ifmt_movbr2, { 0xc0 }
1862   },
1863 /* movbs $regmem8,$pof$upof16 */
1864   {
1865     { 0, 0, 0, 0 },
1866     { { MNEM, ' ', OP (REGMEM8), ',', OP (POF), OP (UPOF16), 0 } },
1867     & ifmt_movbsrpofm, { 0xd2 }
1868   },
1869 /* movbs $pof$upof16,$regbmem8 */
1870   {
1871     { 0, 0, 0, 0 },
1872     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGBMEM8), 0 } },
1873     & ifmt_movbspofmr, { 0xd5 }
1874   },
1875 /* movbz $reg8,$pof$upof16 */
1876   {
1877     { 0, 0, 0, 0 },
1878     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
1879     & ifmt_addrpof, { 0xc2 }
1880   },
1881 /* movbz $pof$upof16,$regb8 */
1882   {
1883     { 0, 0, 0, 0 },
1884     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1885     & ifmt_addbrpof, { 0xc5 }
1886   },
1887 /* movbs $regmem8,$memgr8 */
1888   {
1889     { 0, 0, 0, 0 },
1890     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1891     & ifmt_addrm2, { 0xd2 }
1892   },
1893 /* movbs $memgr8,$regbmem8 */
1894   {
1895     { 0, 0, 0, 0 },
1896     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1897     & ifmt_addbrm2, { 0xd5 }
1898   },
1899 /* movbs $reg8,$memory */
1900   {
1901     { 0, 0, 0, 0 },
1902     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1903     & ifmt_addrm, { 0xd2 }
1904   },
1905 /* movbs $memory,$regb8 */
1906   {
1907     { 0, 0, 0, 0 },
1908     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1909     & ifmt_addbrm, { 0xd5 }
1910   },
1911 /* movbz $regmem8,$memgr8 */
1912   {
1913     { 0, 0, 0, 0 },
1914     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1915     & ifmt_addrm2, { 0xc2 }
1916   },
1917 /* movbz $memgr8,$regbmem8 */
1918   {
1919     { 0, 0, 0, 0 },
1920     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1921     & ifmt_addbrm2, { 0xc5 }
1922   },
1923 /* movbz $reg8,$memory */
1924   {
1925     { 0, 0, 0, 0 },
1926     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1927     & ifmt_addrm, { 0xc2 }
1928   },
1929 /* movbz $memory,$regb8 */
1930   {
1931     { 0, 0, 0, 0 },
1932     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1933     & ifmt_addbrm, { 0xc5 }
1934   },
1935 /* movbs $sr,$drb */
1936   {
1937     { 0, 0, 0, 0 },
1938     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1939     & ifmt_movbr2, { 0xd0 }
1940   },
1941 /* movbz $sr,$drb */
1942   {
1943     { 0, 0, 0, 0 },
1944     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1945     & ifmt_movbr2, { 0xc0 }
1946   },
1947 /* jmpa+ $extcond,$caddr */
1948   {
1949     { 0, 0, 0, 0 },
1950     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1951     & ifmt_jmpa0, { 0xea }
1952   },
1953 /* jmpa $extcond,$caddr */
1954   {
1955     { 0, 0, 0, 0 },
1956     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1957     & ifmt_jmpa0, { 0xea }
1958   },
1959 /* jmpa- $extcond,$caddr */
1960   {
1961     { 0, 0, 0, 0 },
1962     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1963     & ifmt_jmpa_, { 0x1ea }
1964   },
1965 /* jmpi $icond,[$sr] */
1966   {
1967     { 0, 0, 0, 0 },
1968     { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
1969     & ifmt_jmpi, { 0x9c }
1970   },
1971 /* jmpr $cond,$rel */
1972   {
1973     { 0, 0, 0, 0 },
1974     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1975     & ifmt_jmpr_nenz, { 0x3d }
1976   },
1977 /* jmpr $cond,$rel */
1978   {
1979     { 0, 0, 0, 0 },
1980     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1981     & ifmt_jmpr_nenz, { 0xad }
1982   },
1983 /* jmpr $cond,$rel */
1984   {
1985     { 0, 0, 0, 0 },
1986     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1987     & ifmt_jmpr_nenz, { 0x2d }
1988   },
1989 /* jmpr $cond,$rel */
1990   {
1991     { 0, 0, 0, 0 },
1992     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1993     & ifmt_jmpr_nenz, { 0x4d }
1994   },
1995 /* jmpr $cond,$rel */
1996   {
1997     { 0, 0, 0, 0 },
1998     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1999     & ifmt_jmpr_nenz, { 0x5d }
2000   },
2001 /* jmpr $cond,$rel */
2002   {
2003     { 0, 0, 0, 0 },
2004     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2005     & ifmt_jmpr_nenz, { 0x6d }
2006   },
2007 /* jmpr $cond,$rel */
2008   {
2009     { 0, 0, 0, 0 },
2010     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2011     & ifmt_jmpr_nenz, { 0x7d }
2012   },
2013 /* jmpr $cond,$rel */
2014   {
2015     { 0, 0, 0, 0 },
2016     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2017     & ifmt_jmpr_nenz, { 0x8d }
2018   },
2019 /* jmpr $cond,$rel */
2020   {
2021     { 0, 0, 0, 0 },
2022     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2023     & ifmt_jmpr_nenz, { 0x9d }
2024   },
2025 /* jmpr $cond,$rel */
2026   {
2027     { 0, 0, 0, 0 },
2028     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2029     & ifmt_jmpr_nenz, { 0x2d }
2030   },
2031 /* jmpr $cond,$rel */
2032   {
2033     { 0, 0, 0, 0 },
2034     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2035     & ifmt_jmpr_nenz, { 0x3d }
2036   },
2037 /* jmpr $cond,$rel */
2038   {
2039     { 0, 0, 0, 0 },
2040     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2041     & ifmt_jmpr_nenz, { 0x8d }
2042   },
2043 /* jmpr $cond,$rel */
2044   {
2045     { 0, 0, 0, 0 },
2046     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2047     & ifmt_jmpr_nenz, { 0xfd }
2048   },
2049 /* jmpr $cond,$rel */
2050   {
2051     { 0, 0, 0, 0 },
2052     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2053     & ifmt_jmpr_nenz, { 0x9d }
2054   },
2055 /* jmpr $cond,$rel */
2056   {
2057     { 0, 0, 0, 0 },
2058     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2059     & ifmt_jmpr_nenz, { 0xed }
2060   },
2061 /* jmpr $cond,$rel */
2062   {
2063     { 0, 0, 0, 0 },
2064     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2065     & ifmt_jmpr_nenz, { 0xbd }
2066   },
2067 /* jmpr $cond,$rel */
2068   {
2069     { 0, 0, 0, 0 },
2070     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2071     & ifmt_jmpr_nenz, { 0xdd }
2072   },
2073 /* jmpr $cond,$rel */
2074   {
2075     { 0, 0, 0, 0 },
2076     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2077     & ifmt_jmpr_nenz, { 0x1d }
2078   },
2079 /* jmpr $cond,$rel */
2080   {
2081     { 0, 0, 0, 0 },
2082     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2083     & ifmt_jmpr_nenz, { 0xd }
2084   },
2085 /* jmpr $cond,$rel */
2086   {
2087     { 0, 0, 0, 0 },
2088     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2089     & ifmt_jmpr_nenz, { 0xcd }
2090   },
2091 /* jmps $hash$segm$useg8,$hash$sof$usof16 */
2092   {
2093     { 0, 0, 0, 0 },
2094     { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
2095     & ifmt_jmpseg, { 0xfa }
2096   },
2097 /* jmps $seg,$caddr */
2098   {
2099     { 0, 0, 0, 0 },
2100     { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
2101     & ifmt_jmps, { 0xfa }
2102   },
2103 /* jb $genreg$dot$qlobit,$relhi */
2104   {
2105     { 0, 0, 0, 0 },
2106     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2107     & ifmt_jb, { 0x8a }
2108   },
2109 /* jbc $genreg$dot$qlobit,$relhi */
2110   {
2111     { 0, 0, 0, 0 },
2112     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2113     & ifmt_jb, { 0xaa }
2114   },
2115 /* jnb $genreg$dot$qlobit,$relhi */
2116   {
2117     { 0, 0, 0, 0 },
2118     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2119     & ifmt_jb, { 0x9a }
2120   },
2121 /* jnbs $genreg$dot$qlobit,$relhi */
2122   {
2123     { 0, 0, 0, 0 },
2124     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2125     & ifmt_jb, { 0xba }
2126   },
2127 /* calla+ $extcond,$caddr */
2128   {
2129     { 0, 0, 0, 0 },
2130     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2131     & ifmt_calla0, { 0xca }
2132   },
2133 /* calla $extcond,$caddr */
2134   {
2135     { 0, 0, 0, 0 },
2136     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2137     & ifmt_calla0, { 0xca }
2138   },
2139 /* calla- $extcond,$caddr */
2140   {
2141     { 0, 0, 0, 0 },
2142     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2143     & ifmt_calla_, { 0x1ca }
2144   },
2145 /* calli $icond,[$sr] */
2146   {
2147     { 0, 0, 0, 0 },
2148     { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
2149     & ifmt_jmpi, { 0xab }
2150   },
2151 /* callr $rel */
2152   {
2153     { 0, 0, 0, 0 },
2154     { { MNEM, ' ', OP (REL), 0 } },
2155     & ifmt_callr, { 0xbb }
2156   },
2157 /* calls $hash$segm$useg8,$hash$sof$usof16 */
2158   {
2159     { 0, 0, 0, 0 },
2160     { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
2161     & ifmt_callseg, { 0xda }
2162   },
2163 /* calls $seg,$caddr */
2164   {
2165     { 0, 0, 0, 0 },
2166     { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
2167     & ifmt_jmps, { 0xda }
2168   },
2169 /* pcall $reg8,$caddr */
2170   {
2171     { 0, 0, 0, 0 },
2172     { { MNEM, ' ', OP (REG8), ',', OP (CADDR), 0 } },
2173     & ifmt_pcall, { 0xe2 }
2174   },
2175 /* trap $hash$uimm7 */
2176   {
2177     { 0, 0, 0, 0 },
2178     { { MNEM, ' ', OP (HASH), OP (UIMM7), 0 } },
2179     & ifmt_trap, { 0x9b }
2180   },
2181 /* ret */
2182   {
2183     { 0, 0, 0, 0 },
2184     { { MNEM, 0 } },
2185     & ifmt_ret, { 0xcb }
2186   },
2187 /* rets */
2188   {
2189     { 0, 0, 0, 0 },
2190     { { MNEM, 0 } },
2191     & ifmt_ret, { 0xdb }
2192   },
2193 /* retp $reg8 */
2194   {
2195     { 0, 0, 0, 0 },
2196     { { MNEM, ' ', OP (REG8), 0 } },
2197     & ifmt_retp, { 0xeb }
2198   },
2199 /* reti */
2200   {
2201     { 0, 0, 0, 0 },
2202     { { MNEM, 0 } },
2203     & ifmt_reti, { 0x88fb }
2204   },
2205 /* pop $reg8 */
2206   {
2207     { 0, 0, 0, 0 },
2208     { { MNEM, ' ', OP (REG8), 0 } },
2209     & ifmt_retp, { 0xfc }
2210   },
2211 /* push $reg8 */
2212   {
2213     { 0, 0, 0, 0 },
2214     { { MNEM, ' ', OP (REG8), 0 } },
2215     & ifmt_retp, { 0xec }
2216   },
2217 /* scxt $reg8,$hash$uimm16 */
2218   {
2219     { 0, 0, 0, 0 },
2220     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2221     & ifmt_addrhpof, { 0xc6 }
2222   },
2223 /* scxt $reg8,$pof$upof16 */
2224   {
2225     { 0, 0, 0, 0 },
2226     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2227     & ifmt_addrpof, { 0xd6 }
2228   },
2229 /* scxt $regmem8,$memgr8 */
2230   {
2231     { 0, 0, 0, 0 },
2232     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2233     & ifmt_addrm2, { 0xd6 }
2234   },
2235 /* scxt $reg8,$memory */
2236   {
2237     { 0, 0, 0, 0 },
2238     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2239     & ifmt_addrm, { 0xd6 }
2240   },
2241 /* nop */
2242   {
2243     { 0, 0, 0, 0 },
2244     { { MNEM, 0 } },
2245     & ifmt_ret, { 0xcc }
2246   },
2247 /* srst */
2248   {
2249     { 0, 0, 0, 0 },
2250     { { MNEM, 0 } },
2251     & ifmt_srstm, { 0xb7b748b7 }
2252   },
2253 /* idle */
2254   {
2255     { 0, 0, 0, 0 },
2256     { { MNEM, 0 } },
2257     & ifmt_srstm, { 0x87877887 }
2258   },
2259 /* pwrdn */
2260   {
2261     { 0, 0, 0, 0 },
2262     { { MNEM, 0 } },
2263     & ifmt_srstm, { 0x97976897 }
2264   },
2265 /* diswdt */
2266   {
2267     { 0, 0, 0, 0 },
2268     { { MNEM, 0 } },
2269     & ifmt_srstm, { 0xa5a55aa5 }
2270   },
2271 /* enwdt */
2272   {
2273     { 0, 0, 0, 0 },
2274     { { MNEM, 0 } },
2275     & ifmt_srstm, { 0x85857a85 }
2276   },
2277 /* einit */
2278   {
2279     { 0, 0, 0, 0 },
2280     { { MNEM, 0 } },
2281     & ifmt_srstm, { 0xb5b54ab5 }
2282   },
2283 /* srvwdt */
2284   {
2285     { 0, 0, 0, 0 },
2286     { { MNEM, 0 } },
2287     & ifmt_srstm, { 0xa7a758a7 }
2288   },
2289 /* sbrk */
2290   {
2291     { 0, 0, 0, 0 },
2292     { { MNEM, 0 } },
2293     & ifmt_ret, { 0x8c }
2294   },
2295 /* atomic $hash$uimm2 */
2296   {
2297     { 0, 0, 0, 0 },
2298     { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
2299     & ifmt_atomic, { 0xd1 }
2300   },
2301 /* extr $hash$uimm2 */
2302   {
2303     { 0, 0, 0, 0 },
2304     { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
2305     & ifmt_atomic, { 0x80d1 }
2306   },
2307 /* extp $sr,$hash$uimm2 */
2308   {
2309     { 0, 0, 0, 0 },
2310     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2311     & ifmt_extp, { 0x40dc }
2312   },
2313 /* extp $hash$pagenum,$hash$uimm2 */
2314   {
2315     { 0, 0, 0, 0 },
2316     { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
2317     & ifmt_extp1, { 0x40d7 }
2318   },
2319 /* extp $hash$pag$upag16,$hash$uimm2 */
2320   {
2321     { 0, 0, 0, 0 },
2322     { { MNEM, ' ', OP (HASH), OP (PAG), OP (UPAG16), ',', OP (HASH), OP (UIMM2), 0 } },
2323     & ifmt_extpg1, { 0x40d7 }
2324   },
2325 /* extpr $sr,$hash$uimm2 */
2326   {
2327     { 0, 0, 0, 0 },
2328     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2329     & ifmt_extp, { 0xc0dc }
2330   },
2331 /* extpr $hash$pagenum,$hash$uimm2 */
2332   {
2333     { 0, 0, 0, 0 },
2334     { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
2335     & ifmt_extp1, { 0xc0d7 }
2336   },
2337 /* exts $sr,$hash$uimm2 */
2338   {
2339     { 0, 0, 0, 0 },
2340     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2341     & ifmt_extp, { 0xdc }
2342   },
2343 /* exts $hash$seghi8,$hash$uimm2 */
2344   {
2345     { 0, 0, 0, 0 },
2346     { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
2347     & ifmt_exts1, { 0xd7 }
2348   },
2349 /* extsr $sr,$hash$uimm2 */
2350   {
2351     { 0, 0, 0, 0 },
2352     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2353     & ifmt_extp, { 0x80dc }
2354   },
2355 /* extsr $hash$seghi8,$hash$uimm2 */
2356   {
2357     { 0, 0, 0, 0 },
2358     { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
2359     & ifmt_exts1, { 0x80d7 }
2360   },
2361 /* prior $dr,$sr */
2362   {
2363     { 0, 0, 0, 0 },
2364     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2365     & ifmt_addr, { 0x2b }
2366   },
2367 /* bclr $RegNam */
2368   {
2369     { 0, 0, 0, 0 },
2370     { { MNEM, ' ', OP (REGNAM), 0 } },
2371     & ifmt_bclr18, { 0xbe }
2372   },
2373 /* bclr $reg8$dot$qbit */
2374   {
2375     { 0, 0, 0, 0 },
2376     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2377     & ifmt_bclr0, { 0xe }
2378   },
2379 /* bclr $reg8$dot$qbit */
2380   {
2381     { 0, 0, 0, 0 },
2382     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2383     & ifmt_bclr0, { 0x1e }
2384   },
2385 /* bclr $reg8$dot$qbit */
2386   {
2387     { 0, 0, 0, 0 },
2388     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2389     & ifmt_bclr0, { 0x2e }
2390   },
2391 /* bclr $reg8$dot$qbit */
2392   {
2393     { 0, 0, 0, 0 },
2394     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2395     & ifmt_bclr0, { 0x3e }
2396   },
2397 /* bclr $reg8$dot$qbit */
2398   {
2399     { 0, 0, 0, 0 },
2400     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2401     & ifmt_bclr0, { 0x4e }
2402   },
2403 /* bclr $reg8$dot$qbit */
2404   {
2405     { 0, 0, 0, 0 },
2406     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2407     & ifmt_bclr0, { 0x5e }
2408   },
2409 /* bclr $reg8$dot$qbit */
2410   {
2411     { 0, 0, 0, 0 },
2412     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2413     & ifmt_bclr0, { 0x6e }
2414   },
2415 /* bclr $reg8$dot$qbit */
2416   {
2417     { 0, 0, 0, 0 },
2418     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2419     & ifmt_bclr0, { 0x7e }
2420   },
2421 /* bclr $reg8$dot$qbit */
2422   {
2423     { 0, 0, 0, 0 },
2424     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2425     & ifmt_bclr0, { 0x8e }
2426   },
2427 /* bclr $reg8$dot$qbit */
2428   {
2429     { 0, 0, 0, 0 },
2430     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2431     & ifmt_bclr0, { 0x9e }
2432   },
2433 /* bclr $reg8$dot$qbit */
2434   {
2435     { 0, 0, 0, 0 },
2436     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2437     & ifmt_bclr0, { 0xae }
2438   },
2439 /* bclr $reg8$dot$qbit */
2440   {
2441     { 0, 0, 0, 0 },
2442     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2443     & ifmt_bclr0, { 0xbe }
2444   },
2445 /* bclr $reg8$dot$qbit */
2446   {
2447     { 0, 0, 0, 0 },
2448     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2449     & ifmt_bclr0, { 0xce }
2450   },
2451 /* bclr $reg8$dot$qbit */
2452   {
2453     { 0, 0, 0, 0 },
2454     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2455     & ifmt_bclr0, { 0xde }
2456   },
2457 /* bclr $reg8$dot$qbit */
2458   {
2459     { 0, 0, 0, 0 },
2460     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2461     & ifmt_bclr0, { 0xee }
2462   },
2463 /* bclr $reg8$dot$qbit */
2464   {
2465     { 0, 0, 0, 0 },
2466     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2467     & ifmt_bclr0, { 0xfe }
2468   },
2469 /* bset $RegNam */
2470   {
2471     { 0, 0, 0, 0 },
2472     { { MNEM, ' ', OP (REGNAM), 0 } },
2473     & ifmt_bclr18, { 0xbf }
2474   },
2475 /* bset $reg8$dot$qbit */
2476   {
2477     { 0, 0, 0, 0 },
2478     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2479     & ifmt_bclr0, { 0xf }
2480   },
2481 /* bset $reg8$dot$qbit */
2482   {
2483     { 0, 0, 0, 0 },
2484     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2485     & ifmt_bclr0, { 0x1f }
2486   },
2487 /* bset $reg8$dot$qbit */
2488   {
2489     { 0, 0, 0, 0 },
2490     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2491     & ifmt_bclr0, { 0x2f }
2492   },
2493 /* bset $reg8$dot$qbit */
2494   {
2495     { 0, 0, 0, 0 },
2496     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2497     & ifmt_bclr0, { 0x3f }
2498   },
2499 /* bset $reg8$dot$qbit */
2500   {
2501     { 0, 0, 0, 0 },
2502     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2503     & ifmt_bclr0, { 0x4f }
2504   },
2505 /* bset $reg8$dot$qbit */
2506   {
2507     { 0, 0, 0, 0 },
2508     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2509     & ifmt_bclr0, { 0x5f }
2510   },
2511 /* bset $reg8$dot$qbit */
2512   {
2513     { 0, 0, 0, 0 },
2514     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2515     & ifmt_bclr0, { 0x6f }
2516   },
2517 /* bset $reg8$dot$qbit */
2518   {
2519     { 0, 0, 0, 0 },
2520     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2521     & ifmt_bclr0, { 0x7f }
2522   },
2523 /* bset $reg8$dot$qbit */
2524   {
2525     { 0, 0, 0, 0 },
2526     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2527     & ifmt_bclr0, { 0x8f }
2528   },
2529 /* bset $reg8$dot$qbit */
2530   {
2531     { 0, 0, 0, 0 },
2532     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2533     & ifmt_bclr0, { 0x9f }
2534   },
2535 /* bset $reg8$dot$qbit */
2536   {
2537     { 0, 0, 0, 0 },
2538     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2539     & ifmt_bclr0, { 0xaf }
2540   },
2541 /* bset $reg8$dot$qbit */
2542   {
2543     { 0, 0, 0, 0 },
2544     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2545     & ifmt_bclr0, { 0xbf }
2546   },
2547 /* bset $reg8$dot$qbit */
2548   {
2549     { 0, 0, 0, 0 },
2550     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2551     & ifmt_bclr0, { 0xcf }
2552   },
2553 /* bset $reg8$dot$qbit */
2554   {
2555     { 0, 0, 0, 0 },
2556     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2557     & ifmt_bclr0, { 0xdf }
2558   },
2559 /* bset $reg8$dot$qbit */
2560   {
2561     { 0, 0, 0, 0 },
2562     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2563     & ifmt_bclr0, { 0xef }
2564   },
2565 /* bset $reg8$dot$qbit */
2566   {
2567     { 0, 0, 0, 0 },
2568     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2569     & ifmt_bclr0, { 0xff }
2570   },
2571 /* bmov $reghi8$dot$qhibit,$reg8$dot$qlobit */
2572   {
2573     { 0, 0, 0, 0 },
2574     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2575     & ifmt_bmov, { 0x4a }
2576   },
2577 /* bmovn $reghi8$dot$qhibit,$reg8$dot$qlobit */
2578   {
2579     { 0, 0, 0, 0 },
2580     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2581     & ifmt_bmov, { 0x3a }
2582   },
2583 /* band $reghi8$dot$qhibit,$reg8$dot$qlobit */
2584   {
2585     { 0, 0, 0, 0 },
2586     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2587     & ifmt_bmov, { 0x6a }
2588   },
2589 /* bor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2590   {
2591     { 0, 0, 0, 0 },
2592     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2593     & ifmt_bmov, { 0x5a }
2594   },
2595 /* bxor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2596   {
2597     { 0, 0, 0, 0 },
2598     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2599     & ifmt_bmov, { 0x7a }
2600   },
2601 /* bcmp $reghi8$dot$qhibit,$reg8$dot$qlobit */
2602   {
2603     { 0, 0, 0, 0 },
2604     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2605     & ifmt_bmov, { 0x2a }
2606   },
2607 /* bfldl $reg8,$hash$mask8,$hash$datahi8 */
2608   {
2609     { 0, 0, 0, 0 },
2610     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASK8), ',', OP (HASH), OP (DATAHI8), 0 } },
2611     & ifmt_bfldl, { 0xa }
2612   },
2613 /* bfldh $reg8,$hash$masklo8,$hash$data8 */
2614   {
2615     { 0, 0, 0, 0 },
2616     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASKLO8), ',', OP (HASH), OP (DATA8), 0 } },
2617     & ifmt_bfldh, { 0x1a }
2618   },
2619 /* cmp $src1,$src2 */
2620   {
2621     { 0, 0, 0, 0 },
2622     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
2623     & ifmt_muls, { 0x40 }
2624   },
2625 /* cmpb $drb,$srb */
2626   {
2627     { 0, 0, 0, 0 },
2628     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
2629     & ifmt_addbr, { 0x41 }
2630   },
2631 /* cmp $src1,$hash$uimm3 */
2632   {
2633     { 0, 0, 0, 0 },
2634     { { MNEM, ' ', OP (SRC1), ',', OP (HASH), OP (UIMM3), 0 } },
2635     & ifmt_cmpri, { 0x48 }
2636   },
2637 /* cmpb $drb,$hash$uimm3 */
2638   {
2639     { 0, 0, 0, 0 },
2640     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
2641     & ifmt_addbrhpag3, { 0x49 }
2642   },
2643 /* cmp $reg8,$hash$uimm16 */
2644   {
2645     { 0, 0, 0, 0 },
2646     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2647     & ifmt_addrhpof, { 0x46 }
2648   },
2649 /* cmpb $regb8,$hash$uimm8 */
2650   {
2651     { 0, 0, 0, 0 },
2652     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
2653     & ifmt_addrbhpof, { 0x47 }
2654   },
2655 /* cmp $dr,[$sr2] */
2656   {
2657     { 0, 0, 0, 0 },
2658     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
2659     & ifmt_add2, { 0x848 }
2660   },
2661 /* cmpb $drb,[$sr2] */
2662   {
2663     { 0, 0, 0, 0 },
2664     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
2665     & ifmt_addb2, { 0x849 }
2666   },
2667 /* cmp $dr,[$sr2+] */
2668   {
2669     { 0, 0, 0, 0 },
2670     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
2671     & ifmt_add2, { 0xc48 }
2672   },
2673 /* cmpb $drb,[$sr2+] */
2674   {
2675     { 0, 0, 0, 0 },
2676     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
2677     & ifmt_addb2, { 0xc49 }
2678   },
2679 /* cmp $reg8,$pof$upof16 */
2680   {
2681     { 0, 0, 0, 0 },
2682     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2683     & ifmt_addrpof, { 0x42 }
2684   },
2685 /* cmpb $regb8,$pof$upof16 */
2686   {
2687     { 0, 0, 0, 0 },
2688     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
2689     & ifmt_addbrpof, { 0x43 }
2690   },
2691 /* cmp $regmem8,$memgr8 */
2692   {
2693     { 0, 0, 0, 0 },
2694     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2695     & ifmt_addrm2, { 0x42 }
2696   },
2697 /* cmp $reg8,$memory */
2698   {
2699     { 0, 0, 0, 0 },
2700     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2701     & ifmt_addrm, { 0x42 }
2702   },
2703 /* cmpb $regbmem8,$memgr8 */
2704   {
2705     { 0, 0, 0, 0 },
2706     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
2707     & ifmt_addbrm2, { 0x43 }
2708   },
2709 /* cmpb $regb8,$memory */
2710   {
2711     { 0, 0, 0, 0 },
2712     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
2713     & ifmt_addbrm, { 0x43 }
2714   },
2715 /* cmpd1 $sr,$hash$uimm4 */
2716   {
2717     { 0, 0, 0, 0 },
2718     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2719     & ifmt_cmpd1ri, { 0xa0 }
2720   },
2721 /* cmpd2 $sr,$hash$uimm4 */
2722   {
2723     { 0, 0, 0, 0 },
2724     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2725     & ifmt_cmpd1ri, { 0xb0 }
2726   },
2727 /* cmpi1 $sr,$hash$uimm4 */
2728   {
2729     { 0, 0, 0, 0 },
2730     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2731     & ifmt_cmpd1ri, { 0x80 }
2732   },
2733 /* cmpi2 $sr,$hash$uimm4 */
2734   {
2735     { 0, 0, 0, 0 },
2736     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2737     & ifmt_cmpd1ri, { 0x90 }
2738   },
2739 /* cmpd1 $reg8,$hash$uimm16 */
2740   {
2741     { 0, 0, 0, 0 },
2742     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2743     & ifmt_addrhpof, { 0xa6 }
2744   },
2745 /* cmpd2 $reg8,$hash$uimm16 */
2746   {
2747     { 0, 0, 0, 0 },
2748     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2749     & ifmt_addrhpof, { 0xb6 }
2750   },
2751 /* cmpi1 $reg8,$hash$uimm16 */
2752   {
2753     { 0, 0, 0, 0 },
2754     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2755     & ifmt_addrhpof, { 0x86 }
2756   },
2757 /* cmpi2 $reg8,$hash$uimm16 */
2758   {
2759     { 0, 0, 0, 0 },
2760     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2761     & ifmt_addrhpof, { 0x96 }
2762   },
2763 /* cmpd1 $reg8,$pof$upof16 */
2764   {
2765     { 0, 0, 0, 0 },
2766     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2767     & ifmt_addrpof, { 0xa2 }
2768   },
2769 /* cmpd2 $reg8,$pof$upof16 */
2770   {
2771     { 0, 0, 0, 0 },
2772     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2773     & ifmt_addrpof, { 0xb2 }
2774   },
2775 /* cmpi1 $reg8,$pof$upof16 */
2776   {
2777     { 0, 0, 0, 0 },
2778     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2779     & ifmt_addrpof, { 0x82 }
2780   },
2781 /* cmpi2 $reg8,$pof$upof16 */
2782   {
2783     { 0, 0, 0, 0 },
2784     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2785     & ifmt_addrpof, { 0x92 }
2786   },
2787 /* cmpd1 $regmem8,$memgr8 */
2788   {
2789     { 0, 0, 0, 0 },
2790     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2791     & ifmt_addrm2, { 0xa2 }
2792   },
2793 /* cmpd2 $regmem8,$memgr8 */
2794   {
2795     { 0, 0, 0, 0 },
2796     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2797     & ifmt_addrm2, { 0xb2 }
2798   },
2799 /* cmpi1 $regmem8,$memgr8 */
2800   {
2801     { 0, 0, 0, 0 },
2802     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2803     & ifmt_addrm2, { 0x82 }
2804   },
2805 /* cmpi2 $regmem8,$memgr8 */
2806   {
2807     { 0, 0, 0, 0 },
2808     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2809     & ifmt_addrm2, { 0x92 }
2810   },
2811 /* cmpd1 $reg8,$memory */
2812   {
2813     { 0, 0, 0, 0 },
2814     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2815     & ifmt_addrm, { 0xa2 }
2816   },
2817 /* cmpd2 $reg8,$memory */
2818   {
2819     { 0, 0, 0, 0 },
2820     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2821     & ifmt_addrm, { 0xb2 }
2822   },
2823 /* cmpi1 $reg8,$memory */
2824   {
2825     { 0, 0, 0, 0 },
2826     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2827     & ifmt_addrm, { 0x82 }
2828   },
2829 /* cmpi2 $reg8,$memory */
2830   {
2831     { 0, 0, 0, 0 },
2832     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2833     & ifmt_addrm, { 0x92 }
2834   },
2835 /* shl $dr,$sr */
2836   {
2837     { 0, 0, 0, 0 },
2838     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2839     & ifmt_addr, { 0x4c }
2840   },
2841 /* shr $dr,$sr */
2842   {
2843     { 0, 0, 0, 0 },
2844     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2845     & ifmt_addr, { 0x6c }
2846   },
2847 /* rol $dr,$sr */
2848   {
2849     { 0, 0, 0, 0 },
2850     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2851     & ifmt_addr, { 0xc }
2852   },
2853 /* ror $dr,$sr */
2854   {
2855     { 0, 0, 0, 0 },
2856     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2857     & ifmt_addr, { 0x2c }
2858   },
2859 /* ashr $dr,$sr */
2860   {
2861     { 0, 0, 0, 0 },
2862     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2863     & ifmt_addr, { 0xac }
2864   },
2865 /* shl $sr,$hash$uimm4 */
2866   {
2867     { 0, 0, 0, 0 },
2868     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2869     & ifmt_cmpd1ri, { 0x5c }
2870   },
2871 /* shr $sr,$hash$uimm4 */
2872   {
2873     { 0, 0, 0, 0 },
2874     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2875     & ifmt_cmpd1ri, { 0x7c }
2876   },
2877 /* rol $sr,$hash$uimm4 */
2878   {
2879     { 0, 0, 0, 0 },
2880     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2881     & ifmt_cmpd1ri, { 0x1c }
2882   },
2883 /* ror $sr,$hash$uimm4 */
2884   {
2885     { 0, 0, 0, 0 },
2886     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2887     & ifmt_cmpd1ri, { 0x3c }
2888   },
2889 /* ashr $sr,$hash$uimm4 */
2890   {
2891     { 0, 0, 0, 0 },
2892     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2893     & ifmt_cmpd1ri, { 0xbc }
2894   },
2895 };
2896
2897 #undef A
2898 #undef OPERAND
2899 #undef MNEM
2900 #undef OP
2901
2902 /* Formats for ALIAS macro-insns.  */
2903
2904 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
2905 #undef F
2906
2907 /* Each non-simple macro entry points to an array of expansion possibilities.  */
2908
2909 #define A(a) (1 << CGEN_INSN_##a)
2910 #define OPERAND(op) XC16X_OPERAND_##op
2911 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
2912 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
2913
2914 /* The macro instruction table.  */
2915
2916 static const CGEN_IBASE xc16x_cgen_macro_insn_table[] =
2917 {
2918 };
2919
2920 /* The macro instruction opcode table.  */
2921
2922 static const CGEN_OPCODE xc16x_cgen_macro_insn_opcode_table[] =
2923 {
2924 };
2925
2926 #undef A
2927 #undef OPERAND
2928 #undef MNEM
2929 #undef OP
2930
2931 #ifndef CGEN_ASM_HASH_P
2932 #define CGEN_ASM_HASH_P(insn) 1
2933 #endif
2934
2935 #ifndef CGEN_DIS_HASH_P
2936 #define CGEN_DIS_HASH_P(insn) 1
2937 #endif
2938
2939 /* Return non-zero if INSN is to be added to the hash table.
2940    Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
2941
2942 static int
2943 asm_hash_insn_p (const CGEN_INSN *insn ATTRIBUTE_UNUSED)
2944 {
2945   return CGEN_ASM_HASH_P (insn);
2946 }
2947
2948 static int
2949 dis_hash_insn_p (const CGEN_INSN *insn)
2950 {
2951   /* If building the hash table and the NO-DIS attribute is present,
2952      ignore.  */
2953   if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
2954     return 0;
2955   return CGEN_DIS_HASH_P (insn);
2956 }
2957
2958 #ifndef CGEN_ASM_HASH
2959 #define CGEN_ASM_HASH_SIZE 127
2960 #ifdef CGEN_MNEMONIC_OPERANDS
2961 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
2962 #else
2963 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
2964 #endif
2965 #endif
2966
2967 /* It doesn't make much sense to provide a default here,
2968    but while this is under development we do.
2969    BUFFER is a pointer to the bytes of the insn, target order.
2970    VALUE is the first base_insn_bitsize bits as an int in host order.  */
2971
2972 #ifndef CGEN_DIS_HASH
2973 #define CGEN_DIS_HASH_SIZE 256
2974 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
2975 #endif
2976
2977 /* The result is the hash value of the insn.
2978    Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
2979
2980 static unsigned int
2981 asm_hash_insn (const char *mnem)
2982 {
2983   return CGEN_ASM_HASH (mnem);
2984 }
2985
2986 /* BUF is a pointer to the bytes of the insn, target order.
2987    VALUE is the first base_insn_bitsize bits as an int in host order.  */
2988
2989 static unsigned int
2990 dis_hash_insn (const char *buf ATTRIBUTE_UNUSED,
2991                      CGEN_INSN_INT value ATTRIBUTE_UNUSED)
2992 {
2993   return CGEN_DIS_HASH (buf, value);
2994 }
2995
2996 /* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
2997
2998 static void
2999 set_fields_bitsize (CGEN_FIELDS *fields, int size)
3000 {
3001   CGEN_FIELDS_BITSIZE (fields) = size;
3002 }
3003
3004 /* Function to call before using the operand instance table.
3005    This plugs the opcode entries and macro instructions into the cpu table.  */
3006
3007 void
3008 xc16x_cgen_init_opcode_table (CGEN_CPU_DESC cd)
3009 {
3010   int i;
3011   int num_macros = (sizeof (xc16x_cgen_macro_insn_table) /
3012                     sizeof (xc16x_cgen_macro_insn_table[0]));
3013   const CGEN_IBASE *ib = & xc16x_cgen_macro_insn_table[0];
3014   const CGEN_OPCODE *oc = & xc16x_cgen_macro_insn_opcode_table[0];
3015   CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
3016
3017   /* This test has been added to avoid a warning generated
3018      if memset is called with a third argument of value zero.  */
3019   if (num_macros >= 1)
3020     memset (insns, 0, num_macros * sizeof (CGEN_INSN));
3021   for (i = 0; i < num_macros; ++i)
3022     {
3023       insns[i].base = &ib[i];
3024       insns[i].opcode = &oc[i];
3025       xc16x_cgen_build_insn_regex (& insns[i]);
3026     }
3027   cd->macro_insn_table.init_entries = insns;
3028   cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
3029   cd->macro_insn_table.num_init_entries = num_macros;
3030
3031   oc = & xc16x_cgen_insn_opcode_table[0];
3032   insns = (CGEN_INSN *) cd->insn_table.init_entries;
3033   for (i = 0; i < MAX_INSNS; ++i)
3034     {
3035       insns[i].opcode = &oc[i];
3036       xc16x_cgen_build_insn_regex (& insns[i]);
3037     }
3038
3039   cd->sizeof_fields = sizeof (CGEN_FIELDS);
3040   cd->set_fields_bitsize = set_fields_bitsize;
3041
3042   cd->asm_hash_p = asm_hash_insn_p;
3043   cd->asm_hash = asm_hash_insn;
3044   cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
3045
3046   cd->dis_hash_p = dis_hash_insn_p;
3047   cd->dis_hash = dis_hash_insn;
3048   cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
3049 }