opcodes/xc16x-opc.c

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