Back to index

cell-binutils  2.17cvs20070401
xc16x-opc.c
Go to the documentation of this file.
00001 /* Instruction opcode table for xc16x.
00002 
00003 THIS FILE IS MACHINE GENERATED WITH CGEN.
00004 
00005 Copyright 1996-2005 Free Software Foundation, Inc.
00006 
00007 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
00008 
00009 This program is free software; you can redistribute it and/or modify
00010 it under the terms of the GNU General Public License as published by
00011 the Free Software Foundation; either version 2, or (at your option)
00012 any later version.
00013 
00014 This program is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017 GNU General Public License for more details.
00018 
00019 You should have received a copy of the GNU General Public License along
00020 with this program; if not, write to the Free Software Foundation, Inc.,
00021 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
00022 
00023 */
00024 
00025 #include "sysdep.h"
00026 #include "ansidecl.h"
00027 #include "bfd.h"
00028 #include "symcat.h"
00029 #include "xc16x-desc.h"
00030 #include "xc16x-opc.h"
00031 #include "libiberty.h"
00032 
00033 /* -- opc.c */
00034                                                                                 
00035 /* -- */
00036 /* The hash functions are recorded here to help keep assembler code out of
00037    the disassembler and vice versa.  */
00038 
00039 static int asm_hash_insn_p        (const CGEN_INSN *);
00040 static unsigned int asm_hash_insn (const char *);
00041 static int dis_hash_insn_p        (const CGEN_INSN *);
00042 static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
00043 
00044 /* Instruction formats.  */
00045 
00046 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
00047 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
00048 #else
00049 #define F(f) & xc16x_cgen_ifld_table[XC16X_f]
00050 #endif
00051 static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
00052   0, 0, 0x0, { { 0 } }
00053 };
00054 
00055 static const CGEN_IFMT ifmt_addrpof ATTRIBUTE_UNUSED = {
00056   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00057 };
00058 
00059 static const CGEN_IFMT ifmt_addbrpof ATTRIBUTE_UNUSED = {
00060   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00061 };
00062 
00063 static const CGEN_IFMT ifmt_addrpag ATTRIBUTE_UNUSED = {
00064   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00065 };
00066 
00067 static const CGEN_IFMT ifmt_addbrpag ATTRIBUTE_UNUSED = {
00068   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00069 };
00070 
00071 static const CGEN_IFMT ifmt_addrhpof ATTRIBUTE_UNUSED = {
00072   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00073 };
00074 
00075 static const CGEN_IFMT ifmt_addrhpof3 ATTRIBUTE_UNUSED = {
00076   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00077 };
00078 
00079 static const CGEN_IFMT ifmt_addbrhpag3 ATTRIBUTE_UNUSED = {
00080   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00081 };
00082 
00083 static const CGEN_IFMT ifmt_addrbhpof ATTRIBUTE_UNUSED = {
00084   32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00085 };
00086 
00087 static const CGEN_IFMT ifmt_addr ATTRIBUTE_UNUSED = {
00088   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00089 };
00090 
00091 static const CGEN_IFMT ifmt_addbr ATTRIBUTE_UNUSED = {
00092   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00093 };
00094 
00095 static const CGEN_IFMT ifmt_add2 ATTRIBUTE_UNUSED = {
00096   16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00097 };
00098 
00099 static const CGEN_IFMT ifmt_addb2 ATTRIBUTE_UNUSED = {
00100   16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00101 };
00102 
00103 static const CGEN_IFMT ifmt_addrm2 ATTRIBUTE_UNUSED = {
00104   32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00105 };
00106 
00107 static const CGEN_IFMT ifmt_addrm ATTRIBUTE_UNUSED = {
00108   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00109 };
00110 
00111 static const CGEN_IFMT ifmt_addbrm2 ATTRIBUTE_UNUSED = {
00112   32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00113 };
00114 
00115 static const CGEN_IFMT ifmt_addbrm ATTRIBUTE_UNUSED = {
00116   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00117 };
00118 
00119 static const CGEN_IFMT ifmt_muls ATTRIBUTE_UNUSED = {
00120   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00121 };
00122 
00123 static const CGEN_IFMT ifmt_div ATTRIBUTE_UNUSED = {
00124   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00125 };
00126 
00127 static const CGEN_IFMT ifmt_cpl ATTRIBUTE_UNUSED = {
00128   16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00129 };
00130 
00131 static const CGEN_IFMT ifmt_cplb ATTRIBUTE_UNUSED = {
00132   16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00133 };
00134 
00135 static const CGEN_IFMT ifmt_movri ATTRIBUTE_UNUSED = {
00136   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00137 };
00138 
00139 static const CGEN_IFMT ifmt_movbri ATTRIBUTE_UNUSED = {
00140   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00141 };
00142 
00143 static const CGEN_IFMT ifmt_movbr2 ATTRIBUTE_UNUSED = {
00144   16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00145 };
00146 
00147 static const CGEN_IFMT ifmt_mov9i ATTRIBUTE_UNUSED = {
00148   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00149 };
00150 
00151 static const CGEN_IFMT ifmt_movb9i ATTRIBUTE_UNUSED = {
00152   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00153 };
00154 
00155 static const CGEN_IFMT ifmt_movri11 ATTRIBUTE_UNUSED = {
00156   32, 32, 0xf0ff, { { F (F_MEMORY) }, { F (F_OP_LBIT4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00157 };
00158 
00159 static const CGEN_IFMT ifmt_movehm5 ATTRIBUTE_UNUSED = {
00160   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00161 };
00162 
00163 static const CGEN_IFMT ifmt_movehm6 ATTRIBUTE_UNUSED = {
00164   32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00165 };
00166 
00167 static const CGEN_IFMT ifmt_movehm7 ATTRIBUTE_UNUSED = {
00168   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00169 };
00170 
00171 static const CGEN_IFMT ifmt_movehm8 ATTRIBUTE_UNUSED = {
00172   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00173 };
00174 
00175 static const CGEN_IFMT ifmt_movehm10 ATTRIBUTE_UNUSED = {
00176   32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00177 };
00178 
00179 static const CGEN_IFMT ifmt_movbsrpofm ATTRIBUTE_UNUSED = {
00180   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00181 };
00182 
00183 static const CGEN_IFMT ifmt_movbspofmr ATTRIBUTE_UNUSED = {
00184   32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00185 };
00186 
00187 static const CGEN_IFMT ifmt_jmpa0 ATTRIBUTE_UNUSED = {
00188   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 } }
00189 };
00190 
00191 static const CGEN_IFMT ifmt_jmpa_ ATTRIBUTE_UNUSED = {
00192   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 } }
00193 };
00194 
00195 static const CGEN_IFMT ifmt_jmpi ATTRIBUTE_UNUSED = {
00196   16, 16, 0xff, { { F (F_ICONDCODE) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00197 };
00198 
00199 static const CGEN_IFMT ifmt_jmpr_nenz ATTRIBUTE_UNUSED = {
00200   16, 16, 0xff, { { F (F_REL8) }, { F (F_RCOND) }, { F (F_OP2) }, { 0 } }
00201 };
00202 
00203 static const CGEN_IFMT ifmt_jmpseg ATTRIBUTE_UNUSED = {
00204   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00205 };
00206 
00207 static const CGEN_IFMT ifmt_jmps ATTRIBUTE_UNUSED = {
00208   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00209 };
00210 
00211 static const CGEN_IFMT ifmt_jb ATTRIBUTE_UNUSED = {
00212   32, 32, 0xf0000ff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_RELHI8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00213 };
00214 
00215 static const CGEN_IFMT ifmt_calla0 ATTRIBUTE_UNUSED = {
00216   32, 32, 0x6ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_2BIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00217 };
00218 
00219 static const CGEN_IFMT ifmt_calla_ ATTRIBUTE_UNUSED = {
00220   32, 32, 0x7ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BIT3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00221 };
00222 
00223 static const CGEN_IFMT ifmt_callr ATTRIBUTE_UNUSED = {
00224   16, 16, 0xff, { { F (F_REL8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00225 };
00226 
00227 static const CGEN_IFMT ifmt_callseg ATTRIBUTE_UNUSED = {
00228   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00229 };
00230 
00231 static const CGEN_IFMT ifmt_pcall ATTRIBUTE_UNUSED = {
00232   32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00233 };
00234 
00235 static const CGEN_IFMT ifmt_trap ATTRIBUTE_UNUSED = {
00236   16, 16, 0x1ff, { { F (F_UIMM7) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00237 };
00238 
00239 static const CGEN_IFMT ifmt_ret ATTRIBUTE_UNUSED = {
00240   16, 16, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00241 };
00242 
00243 static const CGEN_IFMT ifmt_retp ATTRIBUTE_UNUSED = {
00244   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00245 };
00246 
00247 static const CGEN_IFMT ifmt_reti ATTRIBUTE_UNUSED = {
00248   16, 16, 0xffff, { { F (F_OP_LBIT4) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00249 };
00250 
00251 static const CGEN_IFMT ifmt_srstm ATTRIBUTE_UNUSED = {
00252   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 } }
00253 };
00254 
00255 static const CGEN_IFMT ifmt_atomic ATTRIBUTE_UNUSED = {
00256   16, 16, 0xcfff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00257 };
00258 
00259 static const CGEN_IFMT ifmt_extp ATTRIBUTE_UNUSED = {
00260   16, 16, 0xc0ff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00261 };
00262 
00263 static const CGEN_IFMT ifmt_extp1 ATTRIBUTE_UNUSED = {
00264   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 } }
00265 };
00266 
00267 static const CGEN_IFMT ifmt_extpg1 ATTRIBUTE_UNUSED = {
00268   32, 32, 0xcfff, { { F (F_UIMM16) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00269 };
00270 
00271 static const CGEN_IFMT ifmt_exts1 ATTRIBUTE_UNUSED = {
00272   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 } }
00273 };
00274 
00275 static const CGEN_IFMT ifmt_bclr18 ATTRIBUTE_UNUSED = {
00276   16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00277 };
00278 
00279 static const CGEN_IFMT ifmt_bclr0 ATTRIBUTE_UNUSED = {
00280   16, 16, 0xff, { { F (F_REG8) }, { F (F_QCOND) }, { F (F_OP2) }, { 0 } }
00281 };
00282 
00283 static const CGEN_IFMT ifmt_bmov ATTRIBUTE_UNUSED = {
00284   32, 32, 0xff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_REGHI8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00285 };
00286 
00287 static const CGEN_IFMT ifmt_bfldl ATTRIBUTE_UNUSED = {
00288   32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_MASK8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00289 };
00290 
00291 static const CGEN_IFMT ifmt_bfldh ATTRIBUTE_UNUSED = {
00292   32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_DATA8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00293 };
00294 
00295 static const CGEN_IFMT ifmt_cmpri ATTRIBUTE_UNUSED = {
00296   16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00297 };
00298 
00299 static const CGEN_IFMT ifmt_cmpd1ri ATTRIBUTE_UNUSED = {
00300   16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
00301 };
00302 
00303 #undef F
00304 
00305 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
00306 #define A(a) (1 << CGEN_INSN_##a)
00307 #else
00308 #define A(a) (1 << CGEN_INSN_a)
00309 #endif
00310 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
00311 #define OPERAND(op) XC16X_OPERAND_##op
00312 #else
00313 #define OPERAND(op) XC16X_OPERAND_op
00314 #endif
00315 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
00316 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
00317 
00318 /* The instruction table.  */
00319 
00320 static const CGEN_OPCODE xc16x_cgen_insn_opcode_table[MAX_INSNS] =
00321 {
00322   /* Special null first entry.
00323      A `num' value of zero is thus invalid.
00324      Also, the special `invalid' insn resides here.  */
00325   { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
00326 /* add $reg8,$pof$upof16 */
00327   {
00328     { 0, 0, 0, 0 },
00329     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
00330     & ifmt_addrpof, { 0x2 }
00331   },
00332 /* sub $reg8,$pof$upof16 */
00333   {
00334     { 0, 0, 0, 0 },
00335     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
00336     & ifmt_addrpof, { 0x22 }
00337   },
00338 /* addb $regb8,$pof$upof16 */
00339   {
00340     { 0, 0, 0, 0 },
00341     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
00342     & ifmt_addbrpof, { 0x3 }
00343   },
00344 /* subb $regb8,$pof$upof16 */
00345   {
00346     { 0, 0, 0, 0 },
00347     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
00348     & ifmt_addbrpof, { 0x23 }
00349   },
00350 /* add $reg8,$pag$upag16 */
00351   {
00352     { 0, 0, 0, 0 },
00353     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
00354     & ifmt_addrpag, { 0x2 }
00355   },
00356 /* sub $reg8,$pag$upag16 */
00357   {
00358     { 0, 0, 0, 0 },
00359     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
00360     & ifmt_addrpag, { 0x22 }
00361   },
00362 /* addb $regb8,$pag$upag16 */
00363   {
00364     { 0, 0, 0, 0 },
00365     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
00366     & ifmt_addbrpag, { 0x3 }
00367   },
00368 /* subb $regb8,$pag$upag16 */
00369   {
00370     { 0, 0, 0, 0 },
00371     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
00372     & ifmt_addbrpag, { 0x23 }
00373   },
00374 /* addc $reg8,$pof$upof16 */
00375   {
00376     { 0, 0, 0, 0 },
00377     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
00378     & ifmt_addrpof, { 0x12 }
00379   },
00380 /* subc $reg8,$pof$upof16 */
00381   {
00382     { 0, 0, 0, 0 },
00383     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
00384     & ifmt_addrpof, { 0x32 }
00385   },
00386 /* addcb $regb8,$pof$upof16 */
00387   {
00388     { 0, 0, 0, 0 },
00389     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
00390     & ifmt_addbrpof, { 0x13 }
00391   },
00392 /* subcb $regb8,$pof$upof16 */
00393   {
00394     { 0, 0, 0, 0 },
00395     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
00396     & ifmt_addbrpof, { 0x33 }
00397   },
00398 /* addc $reg8,$pag$upag16 */
00399   {
00400     { 0, 0, 0, 0 },
00401     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
00402     & ifmt_addrpag, { 0x12 }
00403   },
00404 /* subc $reg8,$pag$upag16 */
00405   {
00406     { 0, 0, 0, 0 },
00407     { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
00408     & ifmt_addrpag, { 0x32 }
00409   },
00410 /* addcb $regb8,$pag$upag16 */
00411   {
00412     { 0, 0, 0, 0 },
00413     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
00414     & ifmt_addbrpag, { 0x13 }
00415   },
00416 /* subcb $regb8,$pag$upag16 */
00417   {
00418     { 0, 0, 0, 0 },
00419     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
00420     & ifmt_addbrpag, { 0x33 }
00421   },
00422 /* add $pof$upof16,$reg8 */
00423   {
00424     { 0, 0, 0, 0 },
00425     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
00426     & ifmt_addrpof, { 0x4 }
00427   },
00428 /* sub $pof$upof16,$reg8 */
00429   {
00430     { 0, 0, 0, 0 },
00431     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
00432     & ifmt_addrpof, { 0x24 }
00433   },
00434 /* addb $pof$upof16,$regb8 */
00435   {
00436     { 0, 0, 0, 0 },
00437     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
00438     & ifmt_addbrpof, { 0x5 }
00439   },
00440 /* subb $pof$upof16,$regb8 */
00441   {
00442     { 0, 0, 0, 0 },
00443     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
00444     & ifmt_addbrpof, { 0x25 }
00445   },
00446 /* addc $pof$upof16,$reg8 */
00447   {
00448     { 0, 0, 0, 0 },
00449     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
00450     & ifmt_addrpof, { 0x14 }
00451   },
00452 /* subc $pof$upof16,$reg8 */
00453   {
00454     { 0, 0, 0, 0 },
00455     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
00456     & ifmt_addrpof, { 0x34 }
00457   },
00458 /* addcb $pof$upof16,$regb8 */
00459   {
00460     { 0, 0, 0, 0 },
00461     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
00462     & ifmt_addbrpof, { 0x15 }
00463   },
00464 /* subcb $pof$upof16,$regb8 */
00465   {
00466     { 0, 0, 0, 0 },
00467     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
00468     & ifmt_addbrpof, { 0x35 }
00469   },
00470 /* add $reg8,$hash$pof$uimm16 */
00471   {
00472     { 0, 0, 0, 0 },
00473     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
00474     & ifmt_addrhpof, { 0x6 }
00475   },
00476 /* sub $reg8,$hash$pof$uimm16 */
00477   {
00478     { 0, 0, 0, 0 },
00479     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
00480     & ifmt_addrhpof, { 0x26 }
00481   },
00482 /* add $reg8,$hash$pag$uimm16 */
00483   {
00484     { 0, 0, 0, 0 },
00485     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
00486     & ifmt_addrhpof, { 0x6 }
00487   },
00488 /* sub $reg8,$hash$pag$uimm16 */
00489   {
00490     { 0, 0, 0, 0 },
00491     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
00492     & ifmt_addrhpof, { 0x26 }
00493   },
00494 /* add $dr,$hash$pof$uimm3 */
00495   {
00496     { 0, 0, 0, 0 },
00497     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00498     & ifmt_addrhpof3, { 0x8 }
00499   },
00500 /* sub $dr,$hash$pof$uimm3 */
00501   {
00502     { 0, 0, 0, 0 },
00503     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00504     & ifmt_addrhpof3, { 0x28 }
00505   },
00506 /* addb $drb,$hash$pag$uimm3 */
00507   {
00508     { 0, 0, 0, 0 },
00509     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00510     & ifmt_addbrhpag3, { 0x9 }
00511   },
00512 /* subb $drb,$hash$pag$uimm3 */
00513   {
00514     { 0, 0, 0, 0 },
00515     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00516     & ifmt_addbrhpag3, { 0x29 }
00517   },
00518 /* add $dr,$hash$pag$uimm3 */
00519   {
00520     { 0, 0, 0, 0 },
00521     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00522     & ifmt_addrhpof3, { 0x8 }
00523   },
00524 /* sub $dr,$hash$pag$uimm3 */
00525   {
00526     { 0, 0, 0, 0 },
00527     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00528     & ifmt_addrhpof3, { 0x28 }
00529   },
00530 /* addb $drb,$hash$pof$uimm3 */
00531   {
00532     { 0, 0, 0, 0 },
00533     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00534     & ifmt_addbrhpag3, { 0x9 }
00535   },
00536 /* subb $drb,$hash$pof$uimm3 */
00537   {
00538     { 0, 0, 0, 0 },
00539     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00540     & ifmt_addbrhpag3, { 0x29 }
00541   },
00542 /* addb $regb8,$hash$pof$uimm8 */
00543   {
00544     { 0, 0, 0, 0 },
00545     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
00546     & ifmt_addrbhpof, { 0x7 }
00547   },
00548 /* subb $regb8,$hash$pof$uimm8 */
00549   {
00550     { 0, 0, 0, 0 },
00551     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
00552     & ifmt_addrbhpof, { 0x27 }
00553   },
00554 /* addb $regb8,$hash$pag$uimm8 */
00555   {
00556     { 0, 0, 0, 0 },
00557     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
00558     & ifmt_addrbhpof, { 0x7 }
00559   },
00560 /* subb $regb8,$hash$pag$uimm8 */
00561   {
00562     { 0, 0, 0, 0 },
00563     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
00564     & ifmt_addrbhpof, { 0x27 }
00565   },
00566 /* addc $reg8,$hash$pof$uimm16 */
00567   {
00568     { 0, 0, 0, 0 },
00569     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
00570     & ifmt_addrhpof, { 0x16 }
00571   },
00572 /* subc $reg8,$hash$pof$uimm16 */
00573   {
00574     { 0, 0, 0, 0 },
00575     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
00576     & ifmt_addrhpof, { 0x36 }
00577   },
00578 /* addc $reg8,$hash$pag$uimm16 */
00579   {
00580     { 0, 0, 0, 0 },
00581     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
00582     & ifmt_addrhpof, { 0x16 }
00583   },
00584 /* subc $reg8,$hash$pag$uimm16 */
00585   {
00586     { 0, 0, 0, 0 },
00587     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
00588     & ifmt_addrhpof, { 0x36 }
00589   },
00590 /* addc $dr,$hash$pof$uimm3 */
00591   {
00592     { 0, 0, 0, 0 },
00593     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00594     & ifmt_addrhpof3, { 0x18 }
00595   },
00596 /* subc $dr,$hash$pof$uimm3 */
00597   {
00598     { 0, 0, 0, 0 },
00599     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00600     & ifmt_addrhpof3, { 0x38 }
00601   },
00602 /* addcb $drb,$hash$pag$uimm3 */
00603   {
00604     { 0, 0, 0, 0 },
00605     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00606     & ifmt_addbrhpag3, { 0x19 }
00607   },
00608 /* subcb $drb,$hash$pag$uimm3 */
00609   {
00610     { 0, 0, 0, 0 },
00611     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00612     & ifmt_addbrhpag3, { 0x39 }
00613   },
00614 /* addc $dr,$hash$pag$uimm3 */
00615   {
00616     { 0, 0, 0, 0 },
00617     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00618     & ifmt_addrhpof3, { 0x18 }
00619   },
00620 /* subc $dr,$hash$pag$uimm3 */
00621   {
00622     { 0, 0, 0, 0 },
00623     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
00624     & ifmt_addrhpof3, { 0x38 }
00625   },
00626 /* addcb $drb,$hash$pof$uimm3 */
00627   {
00628     { 0, 0, 0, 0 },
00629     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00630     & ifmt_addbrhpag3, { 0x19 }
00631   },
00632 /* subcb $drb,$hash$pof$uimm3 */
00633   {
00634     { 0, 0, 0, 0 },
00635     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
00636     & ifmt_addbrhpag3, { 0x39 }
00637   },
00638 /* addcb $regb8,$hash$pof$uimm8 */
00639   {
00640     { 0, 0, 0, 0 },
00641     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
00642     & ifmt_addrbhpof, { 0x17 }
00643   },
00644 /* subcb $regb8,$hash$pof$uimm8 */
00645   {
00646     { 0, 0, 0, 0 },
00647     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
00648     & ifmt_addrbhpof, { 0x37 }
00649   },
00650 /* addcb $regb8,$hash$pag$uimm8 */
00651   {
00652     { 0, 0, 0, 0 },
00653     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
00654     & ifmt_addrbhpof, { 0x17 }
00655   },
00656 /* subcb $regb8,$hash$pag$uimm8 */
00657   {
00658     { 0, 0, 0, 0 },
00659     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
00660     & ifmt_addrbhpof, { 0x37 }
00661   },
00662 /* add $dr,$hash$uimm3 */
00663   {
00664     { 0, 0, 0, 0 },
00665     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
00666     & ifmt_addrhpof3, { 0x8 }
00667   },
00668 /* sub $dr,$hash$uimm3 */
00669   {
00670     { 0, 0, 0, 0 },
00671     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
00672     & ifmt_addrhpof3, { 0x28 }
00673   },
00674 /* addb $drb,$hash$uimm3 */
00675   {
00676     { 0, 0, 0, 0 },
00677     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
00678     & ifmt_addbrhpag3, { 0x9 }
00679   },
00680 /* subb $drb,$hash$uimm3 */
00681   {
00682     { 0, 0, 0, 0 },
00683     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
00684     & ifmt_addbrhpag3, { 0x29 }
00685   },
00686 /* add $reg8,$hash$uimm16 */
00687   {
00688     { 0, 0, 0, 0 },
00689     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
00690     & ifmt_addrhpof, { 0x6 }
00691   },
00692 /* sub $reg8,$hash$uimm16 */
00693   {
00694     { 0, 0, 0, 0 },
00695     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
00696     & ifmt_addrhpof, { 0x26 }
00697   },
00698 /* addb $regb8,$hash$uimm8 */
00699   {
00700     { 0, 0, 0, 0 },
00701     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
00702     & ifmt_addrbhpof, { 0x7 }
00703   },
00704 /* subb $regb8,$hash$uimm8 */
00705   {
00706     { 0, 0, 0, 0 },
00707     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
00708     & ifmt_addrbhpof, { 0x27 }
00709   },
00710 /* addc $dr,$hash$uimm3 */
00711   {
00712     { 0, 0, 0, 0 },
00713     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
00714     & ifmt_addrhpof3, { 0x18 }
00715   },
00716 /* subc $dr,$hash$uimm3 */
00717   {
00718     { 0, 0, 0, 0 },
00719     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
00720     & ifmt_addrhpof3, { 0x38 }
00721   },
00722 /* addcb $drb,$hash$uimm3 */
00723   {
00724     { 0, 0, 0, 0 },
00725     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
00726     & ifmt_addbrhpag3, { 0x19 }
00727   },
00728 /* subcb $drb,$hash$uimm3 */
00729   {
00730     { 0, 0, 0, 0 },
00731     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
00732     & ifmt_addbrhpag3, { 0x39 }
00733   },
00734 /* addc $reg8,$hash$uimm16 */
00735   {
00736     { 0, 0, 0, 0 },
00737     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
00738     & ifmt_addrhpof, { 0x16 }
00739   },
00740 /* subc $reg8,$hash$uimm16 */
00741   {
00742     { 0, 0, 0, 0 },
00743     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
00744     & ifmt_addrhpof, { 0x36 }
00745   },
00746 /* addcb $regb8,$hash$uimm8 */
00747   {
00748     { 0, 0, 0, 0 },
00749     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
00750     & ifmt_addrbhpof, { 0x17 }
00751   },
00752 /* subcb $regb8,$hash$uimm8 */
00753   {
00754     { 0, 0, 0, 0 },
00755     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
00756     & ifmt_addrbhpof, { 0x37 }
00757   },
00758 /* add $dr,$sr */
00759   {
00760     { 0, 0, 0, 0 },
00761     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
00762     & ifmt_addr, { 0x0 }
00763   },
00764 /* sub $dr,$sr */
00765   {
00766     { 0, 0, 0, 0 },
00767     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
00768     & ifmt_addr, { 0x20 }
00769   },
00770 /* addb $drb,$srb */
00771   {
00772     { 0, 0, 0, 0 },
00773     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
00774     & ifmt_addbr, { 0x1 }
00775   },
00776 /* subb $drb,$srb */
00777   {
00778     { 0, 0, 0, 0 },
00779     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
00780     & ifmt_addbr, { 0x21 }
00781   },
00782 /* add $dr,[$sr2] */
00783   {
00784     { 0, 0, 0, 0 },
00785     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
00786     & ifmt_add2, { 0x808 }
00787   },
00788 /* sub $dr,[$sr2] */
00789   {
00790     { 0, 0, 0, 0 },
00791     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
00792     & ifmt_add2, { 0x828 }
00793   },
00794 /* addb $drb,[$sr2] */
00795   {
00796     { 0, 0, 0, 0 },
00797     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
00798     & ifmt_addb2, { 0x809 }
00799   },
00800 /* subb $drb,[$sr2] */
00801   {
00802     { 0, 0, 0, 0 },
00803     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
00804     & ifmt_addb2, { 0x829 }
00805   },
00806 /* add $dr,[$sr2+] */
00807   {
00808     { 0, 0, 0, 0 },
00809     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
00810     & ifmt_add2, { 0xc08 }
00811   },
00812 /* sub $dr,[$sr2+] */
00813   {
00814     { 0, 0, 0, 0 },
00815     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
00816     & ifmt_add2, { 0xc28 }
00817   },
00818 /* addb $drb,[$sr2+] */
00819   {
00820     { 0, 0, 0, 0 },
00821     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
00822     & ifmt_addb2, { 0xc09 }
00823   },
00824 /* subb $drb,[$sr2+] */
00825   {
00826     { 0, 0, 0, 0 },
00827     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
00828     & ifmt_addb2, { 0xc29 }
00829   },
00830 /* addc $dr,$sr */
00831   {
00832     { 0, 0, 0, 0 },
00833     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
00834     & ifmt_addr, { 0x10 }
00835   },
00836 /* subc $dr,$sr */
00837   {
00838     { 0, 0, 0, 0 },
00839     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
00840     & ifmt_addr, { 0x30 }
00841   },
00842 /* addcb $drb,$srb */
00843   {
00844     { 0, 0, 0, 0 },
00845     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
00846     & ifmt_addbr, { 0x11 }
00847   },
00848 /* subcb $drb,$srb */
00849   {
00850     { 0, 0, 0, 0 },
00851     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
00852     & ifmt_addbr, { 0x31 }
00853   },
00854 /* addc $dr,[$sr2] */
00855   {
00856     { 0, 0, 0, 0 },
00857     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
00858     & ifmt_add2, { 0x818 }
00859   },
00860 /* subc $dr,[$sr2] */
00861   {
00862     { 0, 0, 0, 0 },
00863     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
00864     & ifmt_add2, { 0x838 }
00865   },
00866 /* addcb $drb,[$sr2] */
00867   {
00868     { 0, 0, 0, 0 },
00869     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
00870     & ifmt_addb2, { 0x819 }
00871   },
00872 /* subcb $drb,[$sr2] */
00873   {
00874     { 0, 0, 0, 0 },
00875     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
00876     & ifmt_addb2, { 0x839 }
00877   },
00878 /* addc $dr,[$sr2+] */
00879   {
00880     { 0, 0, 0, 0 },
00881     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
00882     & ifmt_add2, { 0xc18 }
00883   },
00884 /* subc $dr,[$sr2+] */
00885   {
00886     { 0, 0, 0, 0 },
00887     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
00888     & ifmt_add2, { 0xc38 }
00889   },
00890 /* addcb $drb,[$sr2+] */
00891   {
00892     { 0, 0, 0, 0 },
00893     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
00894     & ifmt_addb2, { 0xc19 }
00895   },
00896 /* subcb $drb,[$sr2+] */
00897   {
00898     { 0, 0, 0, 0 },
00899     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
00900     & ifmt_addb2, { 0xc39 }
00901   },
00902 /* add $regmem8,$memgr8 */
00903   {
00904     { 0, 0, 0, 0 },
00905     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
00906     & ifmt_addrm2, { 0x2 }
00907   },
00908 /* add $memgr8,$regmem8 */
00909   {
00910     { 0, 0, 0, 0 },
00911     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
00912     & ifmt_addrm2, { 0x4 }
00913   },
00914 /* add $reg8,$memory */
00915   {
00916     { 0, 0, 0, 0 },
00917     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
00918     & ifmt_addrm, { 0x2 }
00919   },
00920 /* add $memory,$reg8 */
00921   {
00922     { 0, 0, 0, 0 },
00923     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
00924     & ifmt_addrm, { 0x4 }
00925   },
00926 /* sub $regmem8,$memgr8 */
00927   {
00928     { 0, 0, 0, 0 },
00929     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
00930     & ifmt_addrm2, { 0x22 }
00931   },
00932 /* sub $memgr8,$regmem8 */
00933   {
00934     { 0, 0, 0, 0 },
00935     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
00936     & ifmt_addrm2, { 0x24 }
00937   },
00938 /* sub $reg8,$memory */
00939   {
00940     { 0, 0, 0, 0 },
00941     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
00942     & ifmt_addrm, { 0x22 }
00943   },
00944 /* sub $memory,$reg8 */
00945   {
00946     { 0, 0, 0, 0 },
00947     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
00948     & ifmt_addrm, { 0x24 }
00949   },
00950 /* addb $regbmem8,$memgr8 */
00951   {
00952     { 0, 0, 0, 0 },
00953     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
00954     & ifmt_addbrm2, { 0x3 }
00955   },
00956 /* addb $memgr8,$regbmem8 */
00957   {
00958     { 0, 0, 0, 0 },
00959     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
00960     & ifmt_addbrm2, { 0x5 }
00961   },
00962 /* addb $regb8,$memory */
00963   {
00964     { 0, 0, 0, 0 },
00965     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
00966     & ifmt_addbrm, { 0x3 }
00967   },
00968 /* addb $memory,$regb8 */
00969   {
00970     { 0, 0, 0, 0 },
00971     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
00972     & ifmt_addbrm, { 0x5 }
00973   },
00974 /* subb $regbmem8,$memgr8 */
00975   {
00976     { 0, 0, 0, 0 },
00977     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
00978     & ifmt_addbrm2, { 0x23 }
00979   },
00980 /* subb $memgr8,$regbmem8 */
00981   {
00982     { 0, 0, 0, 0 },
00983     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
00984     & ifmt_addbrm2, { 0x25 }
00985   },
00986 /* subb $regb8,$memory */
00987   {
00988     { 0, 0, 0, 0 },
00989     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
00990     & ifmt_addbrm, { 0x23 }
00991   },
00992 /* subb $memory,$regb8 */
00993   {
00994     { 0, 0, 0, 0 },
00995     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
00996     & ifmt_addbrm, { 0x25 }
00997   },
00998 /* addc $regmem8,$memgr8 */
00999   {
01000     { 0, 0, 0, 0 },
01001     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01002     & ifmt_addrm2, { 0x12 }
01003   },
01004 /* addc $memgr8,$regmem8 */
01005   {
01006     { 0, 0, 0, 0 },
01007     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01008     & ifmt_addrm2, { 0x14 }
01009   },
01010 /* addc $reg8,$memory */
01011   {
01012     { 0, 0, 0, 0 },
01013     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01014     & ifmt_addrm, { 0x12 }
01015   },
01016 /* addc $memory,$reg8 */
01017   {
01018     { 0, 0, 0, 0 },
01019     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01020     & ifmt_addrm, { 0x14 }
01021   },
01022 /* subc $regmem8,$memgr8 */
01023   {
01024     { 0, 0, 0, 0 },
01025     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01026     & ifmt_addrm2, { 0x32 }
01027   },
01028 /* subc $memgr8,$regmem8 */
01029   {
01030     { 0, 0, 0, 0 },
01031     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01032     & ifmt_addrm2, { 0x34 }
01033   },
01034 /* subc $reg8,$memory */
01035   {
01036     { 0, 0, 0, 0 },
01037     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01038     & ifmt_addrm, { 0x32 }
01039   },
01040 /* subc $memory,$reg8 */
01041   {
01042     { 0, 0, 0, 0 },
01043     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01044     & ifmt_addrm, { 0x34 }
01045   },
01046 /* addcb $regbmem8,$memgr8 */
01047   {
01048     { 0, 0, 0, 0 },
01049     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01050     & ifmt_addbrm2, { 0x13 }
01051   },
01052 /* addcb $memgr8,$regbmem8 */
01053   {
01054     { 0, 0, 0, 0 },
01055     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01056     & ifmt_addbrm2, { 0x15 }
01057   },
01058 /* addcb $regb8,$memory */
01059   {
01060     { 0, 0, 0, 0 },
01061     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01062     & ifmt_addbrm, { 0x13 }
01063   },
01064 /* addcb $memory,$regb8 */
01065   {
01066     { 0, 0, 0, 0 },
01067     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01068     & ifmt_addbrm, { 0x15 }
01069   },
01070 /* subcb $regbmem8,$memgr8 */
01071   {
01072     { 0, 0, 0, 0 },
01073     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01074     & ifmt_addbrm2, { 0x33 }
01075   },
01076 /* subcb $memgr8,$regbmem8 */
01077   {
01078     { 0, 0, 0, 0 },
01079     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01080     & ifmt_addbrm2, { 0x35 }
01081   },
01082 /* subcb $regb8,$memory */
01083   {
01084     { 0, 0, 0, 0 },
01085     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01086     & ifmt_addbrm, { 0x33 }
01087   },
01088 /* subcb $memory,$regb8 */
01089   {
01090     { 0, 0, 0, 0 },
01091     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01092     & ifmt_addbrm, { 0x35 }
01093   },
01094 /* mul $src1,$src2 */
01095   {
01096     { 0, 0, 0, 0 },
01097     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
01098     & ifmt_muls, { 0xb }
01099   },
01100 /* mulu $src1,$src2 */
01101   {
01102     { 0, 0, 0, 0 },
01103     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
01104     & ifmt_muls, { 0x1b }
01105   },
01106 /* div $srdiv */
01107   {
01108     { 0, 0, 0, 0 },
01109     { { MNEM, ' ', OP (SRDIV), 0 } },
01110     & ifmt_div, { 0x4b }
01111   },
01112 /* divl $srdiv */
01113   {
01114     { 0, 0, 0, 0 },
01115     { { MNEM, ' ', OP (SRDIV), 0 } },
01116     & ifmt_div, { 0x6b }
01117   },
01118 /* divlu $srdiv */
01119   {
01120     { 0, 0, 0, 0 },
01121     { { MNEM, ' ', OP (SRDIV), 0 } },
01122     & ifmt_div, { 0x7b }
01123   },
01124 /* divu $srdiv */
01125   {
01126     { 0, 0, 0, 0 },
01127     { { MNEM, ' ', OP (SRDIV), 0 } },
01128     & ifmt_div, { 0x5b }
01129   },
01130 /* cpl $dr */
01131   {
01132     { 0, 0, 0, 0 },
01133     { { MNEM, ' ', OP (DR), 0 } },
01134     & ifmt_cpl, { 0x91 }
01135   },
01136 /* cplb $drb */
01137   {
01138     { 0, 0, 0, 0 },
01139     { { MNEM, ' ', OP (DRB), 0 } },
01140     & ifmt_cplb, { 0xb1 }
01141   },
01142 /* neg $dr */
01143   {
01144     { 0, 0, 0, 0 },
01145     { { MNEM, ' ', OP (DR), 0 } },
01146     & ifmt_cpl, { 0x81 }
01147   },
01148 /* negb $drb */
01149   {
01150     { 0, 0, 0, 0 },
01151     { { MNEM, ' ', OP (DRB), 0 } },
01152     & ifmt_cplb, { 0xa1 }
01153   },
01154 /* and $dr,$sr */
01155   {
01156     { 0, 0, 0, 0 },
01157     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
01158     & ifmt_addr, { 0x60 }
01159   },
01160 /* or $dr,$sr */
01161   {
01162     { 0, 0, 0, 0 },
01163     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
01164     & ifmt_addr, { 0x70 }
01165   },
01166 /* xor $dr,$sr */
01167   {
01168     { 0, 0, 0, 0 },
01169     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
01170     & ifmt_addr, { 0x50 }
01171   },
01172 /* andb $drb,$srb */
01173   {
01174     { 0, 0, 0, 0 },
01175     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
01176     & ifmt_addbr, { 0x61 }
01177   },
01178 /* orb $drb,$srb */
01179   {
01180     { 0, 0, 0, 0 },
01181     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
01182     & ifmt_addbr, { 0x71 }
01183   },
01184 /* xorb $drb,$srb */
01185   {
01186     { 0, 0, 0, 0 },
01187     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
01188     & ifmt_addbr, { 0x51 }
01189   },
01190 /* and $dr,$hash$uimm3 */
01191   {
01192     { 0, 0, 0, 0 },
01193     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
01194     & ifmt_addrhpof3, { 0x68 }
01195   },
01196 /* or $dr,$hash$uimm3 */
01197   {
01198     { 0, 0, 0, 0 },
01199     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
01200     & ifmt_addrhpof3, { 0x78 }
01201   },
01202 /* xor $dr,$hash$uimm3 */
01203   {
01204     { 0, 0, 0, 0 },
01205     { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
01206     & ifmt_addrhpof3, { 0x58 }
01207   },
01208 /* andb $drb,$hash$uimm3 */
01209   {
01210     { 0, 0, 0, 0 },
01211     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
01212     & ifmt_addbrhpag3, { 0x69 }
01213   },
01214 /* orb $drb,$hash$uimm3 */
01215   {
01216     { 0, 0, 0, 0 },
01217     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
01218     & ifmt_addbrhpag3, { 0x79 }
01219   },
01220 /* xorb $drb,$hash$uimm3 */
01221   {
01222     { 0, 0, 0, 0 },
01223     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
01224     & ifmt_addbrhpag3, { 0x59 }
01225   },
01226 /* and $reg8,$hash$uimm16 */
01227   {
01228     { 0, 0, 0, 0 },
01229     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
01230     & ifmt_addrhpof, { 0x66 }
01231   },
01232 /* or $reg8,$hash$uimm16 */
01233   {
01234     { 0, 0, 0, 0 },
01235     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
01236     & ifmt_addrhpof, { 0x76 }
01237   },
01238 /* xor $reg8,$hash$uimm16 */
01239   {
01240     { 0, 0, 0, 0 },
01241     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
01242     & ifmt_addrhpof, { 0x56 }
01243   },
01244 /* andb $regb8,$hash$uimm8 */
01245   {
01246     { 0, 0, 0, 0 },
01247     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
01248     & ifmt_addrbhpof, { 0x67 }
01249   },
01250 /* orb $regb8,$hash$uimm8 */
01251   {
01252     { 0, 0, 0, 0 },
01253     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
01254     & ifmt_addrbhpof, { 0x77 }
01255   },
01256 /* xorb $regb8,$hash$uimm8 */
01257   {
01258     { 0, 0, 0, 0 },
01259     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
01260     & ifmt_addrbhpof, { 0x57 }
01261   },
01262 /* and $dr,[$sr2] */
01263   {
01264     { 0, 0, 0, 0 },
01265     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
01266     & ifmt_add2, { 0x868 }
01267   },
01268 /* or $dr,[$sr2] */
01269   {
01270     { 0, 0, 0, 0 },
01271     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
01272     & ifmt_add2, { 0x878 }
01273   },
01274 /* xor $dr,[$sr2] */
01275   {
01276     { 0, 0, 0, 0 },
01277     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
01278     & ifmt_add2, { 0x858 }
01279   },
01280 /* andb $drb,[$sr2] */
01281   {
01282     { 0, 0, 0, 0 },
01283     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
01284     & ifmt_addb2, { 0x869 }
01285   },
01286 /* orb $drb,[$sr2] */
01287   {
01288     { 0, 0, 0, 0 },
01289     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
01290     & ifmt_addb2, { 0x879 }
01291   },
01292 /* xorb $drb,[$sr2] */
01293   {
01294     { 0, 0, 0, 0 },
01295     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
01296     & ifmt_addb2, { 0x859 }
01297   },
01298 /* and $dr,[$sr2+] */
01299   {
01300     { 0, 0, 0, 0 },
01301     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
01302     & ifmt_add2, { 0xc68 }
01303   },
01304 /* or $dr,[$sr2+] */
01305   {
01306     { 0, 0, 0, 0 },
01307     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
01308     & ifmt_add2, { 0xc78 }
01309   },
01310 /* xor $dr,[$sr2+] */
01311   {
01312     { 0, 0, 0, 0 },
01313     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
01314     & ifmt_add2, { 0xc58 }
01315   },
01316 /* andb $drb,[$sr2+] */
01317   {
01318     { 0, 0, 0, 0 },
01319     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
01320     & ifmt_addb2, { 0xc69 }
01321   },
01322 /* orb $drb,[$sr2+] */
01323   {
01324     { 0, 0, 0, 0 },
01325     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
01326     & ifmt_addb2, { 0xc79 }
01327   },
01328 /* xorb $drb,[$sr2+] */
01329   {
01330     { 0, 0, 0, 0 },
01331     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
01332     & ifmt_addb2, { 0xc59 }
01333   },
01334 /* and $pof$reg8,$upof16 */
01335   {
01336     { 0, 0, 0, 0 },
01337     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
01338     & ifmt_addrpof, { 0x62 }
01339   },
01340 /* or $pof$reg8,$upof16 */
01341   {
01342     { 0, 0, 0, 0 },
01343     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
01344     & ifmt_addrpof, { 0x72 }
01345   },
01346 /* xor $pof$reg8,$upof16 */
01347   {
01348     { 0, 0, 0, 0 },
01349     { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
01350     & ifmt_addrpof, { 0x52 }
01351   },
01352 /* andb $pof$regb8,$upof16 */
01353   {
01354     { 0, 0, 0, 0 },
01355     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
01356     & ifmt_addbrpof, { 0x63 }
01357   },
01358 /* orb $pof$regb8,$upof16 */
01359   {
01360     { 0, 0, 0, 0 },
01361     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
01362     & ifmt_addbrpof, { 0x73 }
01363   },
01364 /* xorb $pof$regb8,$upof16 */
01365   {
01366     { 0, 0, 0, 0 },
01367     { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
01368     & ifmt_addbrpof, { 0x53 }
01369   },
01370 /* and $pof$upof16,$reg8 */
01371   {
01372     { 0, 0, 0, 0 },
01373     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
01374     & ifmt_addrpof, { 0x64 }
01375   },
01376 /* or $pof$upof16,$reg8 */
01377   {
01378     { 0, 0, 0, 0 },
01379     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
01380     & ifmt_addrpof, { 0x74 }
01381   },
01382 /* xor $pof$upof16,$reg8 */
01383   {
01384     { 0, 0, 0, 0 },
01385     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
01386     & ifmt_addrpof, { 0x54 }
01387   },
01388 /* andb $pof$upof16,$regb8 */
01389   {
01390     { 0, 0, 0, 0 },
01391     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
01392     & ifmt_addbrpof, { 0x65 }
01393   },
01394 /* orb $pof$upof16,$regb8 */
01395   {
01396     { 0, 0, 0, 0 },
01397     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
01398     & ifmt_addbrpof, { 0x75 }
01399   },
01400 /* xorb $pof$upof16,$regb8 */
01401   {
01402     { 0, 0, 0, 0 },
01403     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
01404     & ifmt_addbrpof, { 0x55 }
01405   },
01406 /* and $regmem8,$memgr8 */
01407   {
01408     { 0, 0, 0, 0 },
01409     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01410     & ifmt_addrm2, { 0x62 }
01411   },
01412 /* and $memgr8,$regmem8 */
01413   {
01414     { 0, 0, 0, 0 },
01415     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01416     & ifmt_addrm2, { 0x64 }
01417   },
01418 /* and $reg8,$memory */
01419   {
01420     { 0, 0, 0, 0 },
01421     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01422     & ifmt_addrm, { 0x62 }
01423   },
01424 /* and $memory,$reg8 */
01425   {
01426     { 0, 0, 0, 0 },
01427     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01428     & ifmt_addrm, { 0x64 }
01429   },
01430 /* or $regmem8,$memgr8 */
01431   {
01432     { 0, 0, 0, 0 },
01433     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01434     & ifmt_addrm2, { 0x72 }
01435   },
01436 /* or $memgr8,$regmem8 */
01437   {
01438     { 0, 0, 0, 0 },
01439     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01440     & ifmt_addrm2, { 0x74 }
01441   },
01442 /* or $reg8,$memory */
01443   {
01444     { 0, 0, 0, 0 },
01445     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01446     & ifmt_addrm, { 0x72 }
01447   },
01448 /* or $memory,$reg8 */
01449   {
01450     { 0, 0, 0, 0 },
01451     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01452     & ifmt_addrm, { 0x74 }
01453   },
01454 /* xor $regmem8,$memgr8 */
01455   {
01456     { 0, 0, 0, 0 },
01457     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01458     & ifmt_addrm2, { 0x52 }
01459   },
01460 /* xor $memgr8,$regmem8 */
01461   {
01462     { 0, 0, 0, 0 },
01463     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01464     & ifmt_addrm2, { 0x54 }
01465   },
01466 /* xor $reg8,$memory */
01467   {
01468     { 0, 0, 0, 0 },
01469     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01470     & ifmt_addrm, { 0x52 }
01471   },
01472 /* xor $memory,$reg8 */
01473   {
01474     { 0, 0, 0, 0 },
01475     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01476     & ifmt_addrm, { 0x54 }
01477   },
01478 /* andb $regbmem8,$memgr8 */
01479   {
01480     { 0, 0, 0, 0 },
01481     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01482     & ifmt_addbrm2, { 0x63 }
01483   },
01484 /* andb $memgr8,$regbmem8 */
01485   {
01486     { 0, 0, 0, 0 },
01487     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01488     & ifmt_addbrm2, { 0x65 }
01489   },
01490 /* andb $regb8,$memory */
01491   {
01492     { 0, 0, 0, 0 },
01493     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01494     & ifmt_addbrm, { 0x63 }
01495   },
01496 /* andb $memory,$regb8 */
01497   {
01498     { 0, 0, 0, 0 },
01499     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01500     & ifmt_addbrm, { 0x65 }
01501   },
01502 /* orb $regbmem8,$memgr8 */
01503   {
01504     { 0, 0, 0, 0 },
01505     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01506     & ifmt_addbrm2, { 0x73 }
01507   },
01508 /* orb $memgr8,$regbmem8 */
01509   {
01510     { 0, 0, 0, 0 },
01511     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01512     & ifmt_addbrm2, { 0x75 }
01513   },
01514 /* orb $regb8,$memory */
01515   {
01516     { 0, 0, 0, 0 },
01517     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01518     & ifmt_addbrm, { 0x73 }
01519   },
01520 /* orb $memory,$regb8 */
01521   {
01522     { 0, 0, 0, 0 },
01523     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01524     & ifmt_addbrm, { 0x75 }
01525   },
01526 /* xorb $regbmem8,$memgr8 */
01527   {
01528     { 0, 0, 0, 0 },
01529     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01530     & ifmt_addbrm2, { 0x53 }
01531   },
01532 /* xorb $memgr8,$regbmem8 */
01533   {
01534     { 0, 0, 0, 0 },
01535     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01536     & ifmt_addbrm2, { 0x55 }
01537   },
01538 /* xorb $regb8,$memory */
01539   {
01540     { 0, 0, 0, 0 },
01541     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01542     & ifmt_addbrm, { 0x53 }
01543   },
01544 /* xorb $memory,$regb8 */
01545   {
01546     { 0, 0, 0, 0 },
01547     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01548     & ifmt_addbrm, { 0x55 }
01549   },
01550 /* mov $dr,$sr */
01551   {
01552     { 0, 0, 0, 0 },
01553     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
01554     & ifmt_addr, { 0xf0 }
01555   },
01556 /* movb $drb,$srb */
01557   {
01558     { 0, 0, 0, 0 },
01559     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
01560     & ifmt_addbr, { 0xf1 }
01561   },
01562 /* mov $dri,$hash$u4 */
01563   {
01564     { 0, 0, 0, 0 },
01565     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (U4), 0 } },
01566     & ifmt_movri, { 0xe0 }
01567   },
01568 /* movb $srb,$hash$u4 */
01569   {
01570     { 0, 0, 0, 0 },
01571     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (U4), 0 } },
01572     & ifmt_movbri, { 0xe1 }
01573   },
01574 /* mov $reg8,$hash$uimm16 */
01575   {
01576     { 0, 0, 0, 0 },
01577     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
01578     & ifmt_addrhpof, { 0xe6 }
01579   },
01580 /* movb $regb8,$hash$uimm8 */
01581   {
01582     { 0, 0, 0, 0 },
01583     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
01584     & ifmt_addrbhpof, { 0xe7 }
01585   },
01586 /* mov $dr,[$sr] */
01587   {
01588     { 0, 0, 0, 0 },
01589     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), ']', 0 } },
01590     & ifmt_addr, { 0xa8 }
01591   },
01592 /* movb $drb,[$sr] */
01593   {
01594     { 0, 0, 0, 0 },
01595     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), ']', 0 } },
01596     & ifmt_movbr2, { 0xa9 }
01597   },
01598 /* mov [$sr],$dr */
01599   {
01600     { 0, 0, 0, 0 },
01601     { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DR), 0 } },
01602     & ifmt_addr, { 0xb8 }
01603   },
01604 /* movb [$sr],$drb */
01605   {
01606     { 0, 0, 0, 0 },
01607     { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DRB), 0 } },
01608     & ifmt_movbr2, { 0xb9 }
01609   },
01610 /* mov [-$sr],$dr */
01611   {
01612     { 0, 0, 0, 0 },
01613     { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DR), 0 } },
01614     & ifmt_addr, { 0x88 }
01615   },
01616 /* movb [-$sr],$drb */
01617   {
01618     { 0, 0, 0, 0 },
01619     { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DRB), 0 } },
01620     & ifmt_movbr2, { 0x89 }
01621   },
01622 /* mov $dr,[$sr+] */
01623   {
01624     { 0, 0, 0, 0 },
01625     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', ']', 0 } },
01626     & ifmt_addr, { 0x98 }
01627   },
01628 /* movb $drb,[$sr+] */
01629   {
01630     { 0, 0, 0, 0 },
01631     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', ']', 0 } },
01632     & ifmt_movbr2, { 0x99 }
01633   },
01634 /* mov [$dr],[$sr] */
01635   {
01636     { 0, 0, 0, 0 },
01637     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
01638     & ifmt_addr, { 0xc8 }
01639   },
01640 /* movb [$dr],[$sr] */
01641   {
01642     { 0, 0, 0, 0 },
01643     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
01644     & ifmt_addr, { 0xc9 }
01645   },
01646 /* mov [$dr+],[$sr] */
01647   {
01648     { 0, 0, 0, 0 },
01649     { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
01650     & ifmt_addr, { 0xd8 }
01651   },
01652 /* movb [$dr+],[$sr] */
01653   {
01654     { 0, 0, 0, 0 },
01655     { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
01656     & ifmt_addr, { 0xd9 }
01657   },
01658 /* mov [$dr],[$sr+] */
01659   {
01660     { 0, 0, 0, 0 },
01661     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
01662     & ifmt_addr, { 0xe8 }
01663   },
01664 /* movb [$dr],[$sr+] */
01665   {
01666     { 0, 0, 0, 0 },
01667     { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
01668     & ifmt_addr, { 0xe9 }
01669   },
01670 /* mov $dr,[$sr+$hash$uimm16] */
01671   {
01672     { 0, 0, 0, 0 },
01673     { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
01674     & ifmt_mov9i, { 0xd4 }
01675   },
01676 /* movb $drb,[$sr+$hash$uimm16] */
01677   {
01678     { 0, 0, 0, 0 },
01679     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
01680     & ifmt_movb9i, { 0xf4 }
01681   },
01682 /* mov [$sr+$hash$uimm16],$dr */
01683   {
01684     { 0, 0, 0, 0 },
01685     { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DR), 0 } },
01686     & ifmt_mov9i, { 0xc4 }
01687   },
01688 /* movb [$sr+$hash$uimm16],$drb */
01689   {
01690     { 0, 0, 0, 0 },
01691     { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DRB), 0 } },
01692     & ifmt_movb9i, { 0xe4 }
01693   },
01694 /* mov [$src2],$memory */
01695   {
01696     { 0, 0, 0, 0 },
01697     { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
01698     & ifmt_movri11, { 0x84 }
01699   },
01700 /* movb [$src2],$memory */
01701   {
01702     { 0, 0, 0, 0 },
01703     { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
01704     & ifmt_movri11, { 0xa4 }
01705   },
01706 /* mov $memory,[$src2] */
01707   {
01708     { 0, 0, 0, 0 },
01709     { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
01710     & ifmt_movri11, { 0x94 }
01711   },
01712 /* movb $memory,[$src2] */
01713   {
01714     { 0, 0, 0, 0 },
01715     { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
01716     & ifmt_movri11, { 0xb4 }
01717   },
01718 /* mov $regoff8,$hash$pof$upof16 */
01719   {
01720     { 0, 0, 0, 0 },
01721     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (POF), OP (UPOF16), 0 } },
01722     & ifmt_movehm5, { 0xe6 }
01723   },
01724 /* mov $regoff8,$hash$pag$upag16 */
01725   {
01726     { 0, 0, 0, 0 },
01727     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UPAG16), 0 } },
01728     & ifmt_movehm6, { 0xe6 }
01729   },
01730 /* mov $regoff8,$hash$segm$useg16 */
01731   {
01732     { 0, 0, 0, 0 },
01733     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SEGM), OP (USEG16), 0 } },
01734     & ifmt_movehm7, { 0xe6 }
01735   },
01736 /* mov $regoff8,$hash$sof$usof16 */
01737   {
01738     { 0, 0, 0, 0 },
01739     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
01740     & ifmt_movehm8, { 0xe6 }
01741   },
01742 /* movb $regb8,$hash$pof$uimm8 */
01743   {
01744     { 0, 0, 0, 0 },
01745     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
01746     & ifmt_addrbhpof, { 0xe7 }
01747   },
01748 /* movb $regoff8,$hash$pag$uimm8 */
01749   {
01750     { 0, 0, 0, 0 },
01751     { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
01752     & ifmt_movehm10, { 0xe7 }
01753   },
01754 /* mov $regoff8,$pof$upof16 */
01755   {
01756     { 0, 0, 0, 0 },
01757     { { MNEM, ' ', OP (REGOFF8), ',', OP (POF), OP (UPOF16), 0 } },
01758     & ifmt_movehm5, { 0xf2 }
01759   },
01760 /* movb $regb8,$pof$upof16 */
01761   {
01762     { 0, 0, 0, 0 },
01763     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
01764     & ifmt_addbrpof, { 0xf3 }
01765   },
01766 /* mov $regoff8,$pag$upag16 */
01767   {
01768     { 0, 0, 0, 0 },
01769     { { MNEM, ' ', OP (REGOFF8), ',', OP (PAG), OP (UPAG16), 0 } },
01770     & ifmt_movehm6, { 0xf2 }
01771   },
01772 /* movb $regb8,$pag$upag16 */
01773   {
01774     { 0, 0, 0, 0 },
01775     { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
01776     & ifmt_addbrpag, { 0xf3 }
01777   },
01778 /* mov $pof$upof16,$regoff8 */
01779   {
01780     { 0, 0, 0, 0 },
01781     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGOFF8), 0 } },
01782     & ifmt_movehm5, { 0xf6 }
01783   },
01784 /* movb $pof$upof16,$regb8 */
01785   {
01786     { 0, 0, 0, 0 },
01787     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
01788     & ifmt_addbrpof, { 0xf7 }
01789   },
01790 /* mov $dri,$hash$pof$u4 */
01791   {
01792     { 0, 0, 0, 0 },
01793     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (POF), OP (U4), 0 } },
01794     & ifmt_movri, { 0xe0 }
01795   },
01796 /* movb $srb,$hash$pof$u4 */
01797   {
01798     { 0, 0, 0, 0 },
01799     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (POF), OP (U4), 0 } },
01800     & ifmt_movbri, { 0xe1 }
01801   },
01802 /* mov $dri,$hash$pag$u4 */
01803   {
01804     { 0, 0, 0, 0 },
01805     { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
01806     & ifmt_movri, { 0xe0 }
01807   },
01808 /* movb $srb,$hash$pag$u4 */
01809   {
01810     { 0, 0, 0, 0 },
01811     { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
01812     & ifmt_movbri, { 0xe1 }
01813   },
01814 /* mov $regmem8,$memgr8 */
01815   {
01816     { 0, 0, 0, 0 },
01817     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01818     & ifmt_addrm2, { 0xf2 }
01819   },
01820 /* mov $memgr8,$regmem8 */
01821   {
01822     { 0, 0, 0, 0 },
01823     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
01824     & ifmt_addrm2, { 0xf6 }
01825   },
01826 /* mov $reg8,$memory */
01827   {
01828     { 0, 0, 0, 0 },
01829     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01830     & ifmt_addrm, { 0xf2 }
01831   },
01832 /* mov $memory,$reg8 */
01833   {
01834     { 0, 0, 0, 0 },
01835     { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
01836     & ifmt_addrm, { 0xf6 }
01837   },
01838 /* movb $regbmem8,$memgr8 */
01839   {
01840     { 0, 0, 0, 0 },
01841     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
01842     & ifmt_addbrm2, { 0xf3 }
01843   },
01844 /* movb $memgr8,$regbmem8 */
01845   {
01846     { 0, 0, 0, 0 },
01847     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01848     & ifmt_addbrm2, { 0xf7 }
01849   },
01850 /* movb $regb8,$memory */
01851   {
01852     { 0, 0, 0, 0 },
01853     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
01854     & ifmt_addbrm, { 0xf3 }
01855   },
01856 /* movb $memory,$regb8 */
01857   {
01858     { 0, 0, 0, 0 },
01859     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01860     & ifmt_addbrm, { 0xf7 }
01861   },
01862 /* movbs $sr,$drb */
01863   {
01864     { 0, 0, 0, 0 },
01865     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
01866     & ifmt_movbr2, { 0xd0 }
01867   },
01868 /* movbz $sr,$drb */
01869   {
01870     { 0, 0, 0, 0 },
01871     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
01872     & ifmt_movbr2, { 0xc0 }
01873   },
01874 /* movbs $regmem8,$pof$upof16 */
01875   {
01876     { 0, 0, 0, 0 },
01877     { { MNEM, ' ', OP (REGMEM8), ',', OP (POF), OP (UPOF16), 0 } },
01878     & ifmt_movbsrpofm, { 0xd2 }
01879   },
01880 /* movbs $pof$upof16,$regbmem8 */
01881   {
01882     { 0, 0, 0, 0 },
01883     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGBMEM8), 0 } },
01884     & ifmt_movbspofmr, { 0xd5 }
01885   },
01886 /* movbz $reg8,$pof$upof16 */
01887   {
01888     { 0, 0, 0, 0 },
01889     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
01890     & ifmt_addrpof, { 0xc2 }
01891   },
01892 /* movbz $pof$upof16,$regb8 */
01893   {
01894     { 0, 0, 0, 0 },
01895     { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
01896     & ifmt_addbrpof, { 0xc5 }
01897   },
01898 /* movbs $regmem8,$memgr8 */
01899   {
01900     { 0, 0, 0, 0 },
01901     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01902     & ifmt_addrm2, { 0xd2 }
01903   },
01904 /* movbs $memgr8,$regbmem8 */
01905   {
01906     { 0, 0, 0, 0 },
01907     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01908     & ifmt_addbrm2, { 0xd5 }
01909   },
01910 /* movbs $reg8,$memory */
01911   {
01912     { 0, 0, 0, 0 },
01913     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01914     & ifmt_addrm, { 0xd2 }
01915   },
01916 /* movbs $memory,$regb8 */
01917   {
01918     { 0, 0, 0, 0 },
01919     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01920     & ifmt_addbrm, { 0xd5 }
01921   },
01922 /* movbz $regmem8,$memgr8 */
01923   {
01924     { 0, 0, 0, 0 },
01925     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
01926     & ifmt_addrm2, { 0xc2 }
01927   },
01928 /* movbz $memgr8,$regbmem8 */
01929   {
01930     { 0, 0, 0, 0 },
01931     { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
01932     & ifmt_addbrm2, { 0xc5 }
01933   },
01934 /* movbz $reg8,$memory */
01935   {
01936     { 0, 0, 0, 0 },
01937     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
01938     & ifmt_addrm, { 0xc2 }
01939   },
01940 /* movbz $memory,$regb8 */
01941   {
01942     { 0, 0, 0, 0 },
01943     { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
01944     & ifmt_addbrm, { 0xc5 }
01945   },
01946 /* movbs $sr,$drb */
01947   {
01948     { 0, 0, 0, 0 },
01949     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
01950     & ifmt_movbr2, { 0xd0 }
01951   },
01952 /* movbz $sr,$drb */
01953   {
01954     { 0, 0, 0, 0 },
01955     { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
01956     & ifmt_movbr2, { 0xc0 }
01957   },
01958 /* jmpa+ $extcond,$caddr */
01959   {
01960     { 0, 0, 0, 0 },
01961     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
01962     & ifmt_jmpa0, { 0xea }
01963   },
01964 /* jmpa $extcond,$caddr */
01965   {
01966     { 0, 0, 0, 0 },
01967     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
01968     & ifmt_jmpa0, { 0xea }
01969   },
01970 /* jmpa- $extcond,$caddr */
01971   {
01972     { 0, 0, 0, 0 },
01973     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
01974     & ifmt_jmpa_, { 0x1ea }
01975   },
01976 /* jmpi $icond,[$sr] */
01977   {
01978     { 0, 0, 0, 0 },
01979     { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
01980     & ifmt_jmpi, { 0x9c }
01981   },
01982 /* jmpr $cond,$rel */
01983   {
01984     { 0, 0, 0, 0 },
01985     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
01986     & ifmt_jmpr_nenz, { 0x3d }
01987   },
01988 /* jmpr $cond,$rel */
01989   {
01990     { 0, 0, 0, 0 },
01991     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
01992     & ifmt_jmpr_nenz, { 0xad }
01993   },
01994 /* jmpr $cond,$rel */
01995   {
01996     { 0, 0, 0, 0 },
01997     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
01998     & ifmt_jmpr_nenz, { 0x2d }
01999   },
02000 /* jmpr $cond,$rel */
02001   {
02002     { 0, 0, 0, 0 },
02003     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02004     & ifmt_jmpr_nenz, { 0x4d }
02005   },
02006 /* jmpr $cond,$rel */
02007   {
02008     { 0, 0, 0, 0 },
02009     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02010     & ifmt_jmpr_nenz, { 0x5d }
02011   },
02012 /* jmpr $cond,$rel */
02013   {
02014     { 0, 0, 0, 0 },
02015     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02016     & ifmt_jmpr_nenz, { 0x6d }
02017   },
02018 /* jmpr $cond,$rel */
02019   {
02020     { 0, 0, 0, 0 },
02021     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02022     & ifmt_jmpr_nenz, { 0x7d }
02023   },
02024 /* jmpr $cond,$rel */
02025   {
02026     { 0, 0, 0, 0 },
02027     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02028     & ifmt_jmpr_nenz, { 0x8d }
02029   },
02030 /* jmpr $cond,$rel */
02031   {
02032     { 0, 0, 0, 0 },
02033     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02034     & ifmt_jmpr_nenz, { 0x9d }
02035   },
02036 /* jmpr $cond,$rel */
02037   {
02038     { 0, 0, 0, 0 },
02039     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02040     & ifmt_jmpr_nenz, { 0x2d }
02041   },
02042 /* jmpr $cond,$rel */
02043   {
02044     { 0, 0, 0, 0 },
02045     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02046     & ifmt_jmpr_nenz, { 0x3d }
02047   },
02048 /* jmpr $cond,$rel */
02049   {
02050     { 0, 0, 0, 0 },
02051     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02052     & ifmt_jmpr_nenz, { 0x8d }
02053   },
02054 /* jmpr $cond,$rel */
02055   {
02056     { 0, 0, 0, 0 },
02057     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02058     & ifmt_jmpr_nenz, { 0xfd }
02059   },
02060 /* jmpr $cond,$rel */
02061   {
02062     { 0, 0, 0, 0 },
02063     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02064     & ifmt_jmpr_nenz, { 0x9d }
02065   },
02066 /* jmpr $cond,$rel */
02067   {
02068     { 0, 0, 0, 0 },
02069     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02070     & ifmt_jmpr_nenz, { 0xed }
02071   },
02072 /* jmpr $cond,$rel */
02073   {
02074     { 0, 0, 0, 0 },
02075     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02076     & ifmt_jmpr_nenz, { 0xbd }
02077   },
02078 /* jmpr $cond,$rel */
02079   {
02080     { 0, 0, 0, 0 },
02081     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02082     & ifmt_jmpr_nenz, { 0xdd }
02083   },
02084 /* jmpr $cond,$rel */
02085   {
02086     { 0, 0, 0, 0 },
02087     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02088     & ifmt_jmpr_nenz, { 0x1d }
02089   },
02090 /* jmpr $cond,$rel */
02091   {
02092     { 0, 0, 0, 0 },
02093     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02094     & ifmt_jmpr_nenz, { 0xd }
02095   },
02096 /* jmpr $cond,$rel */
02097   {
02098     { 0, 0, 0, 0 },
02099     { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
02100     & ifmt_jmpr_nenz, { 0xcd }
02101   },
02102 /* jmps $hash$segm$useg8,$hash$sof$usof16 */
02103   {
02104     { 0, 0, 0, 0 },
02105     { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
02106     & ifmt_jmpseg, { 0xfa }
02107   },
02108 /* jmps $seg,$caddr */
02109   {
02110     { 0, 0, 0, 0 },
02111     { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
02112     & ifmt_jmps, { 0xfa }
02113   },
02114 /* jb $genreg$dot$qlobit,$relhi */
02115   {
02116     { 0, 0, 0, 0 },
02117     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
02118     & ifmt_jb, { 0x8a }
02119   },
02120 /* jbc $genreg$dot$qlobit,$relhi */
02121   {
02122     { 0, 0, 0, 0 },
02123     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
02124     & ifmt_jb, { 0xaa }
02125   },
02126 /* jnb $genreg$dot$qlobit,$relhi */
02127   {
02128     { 0, 0, 0, 0 },
02129     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
02130     & ifmt_jb, { 0x9a }
02131   },
02132 /* jnbs $genreg$dot$qlobit,$relhi */
02133   {
02134     { 0, 0, 0, 0 },
02135     { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
02136     & ifmt_jb, { 0xba }
02137   },
02138 /* calla+ $extcond,$caddr */
02139   {
02140     { 0, 0, 0, 0 },
02141     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
02142     & ifmt_calla0, { 0xca }
02143   },
02144 /* calla $extcond,$caddr */
02145   {
02146     { 0, 0, 0, 0 },
02147     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
02148     & ifmt_calla0, { 0xca }
02149   },
02150 /* calla- $extcond,$caddr */
02151   {
02152     { 0, 0, 0, 0 },
02153     { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
02154     & ifmt_calla_, { 0x1ca }
02155   },
02156 /* calli $icond,[$sr] */
02157   {
02158     { 0, 0, 0, 0 },
02159     { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
02160     & ifmt_jmpi, { 0xab }
02161   },
02162 /* callr $rel */
02163   {
02164     { 0, 0, 0, 0 },
02165     { { MNEM, ' ', OP (REL), 0 } },
02166     & ifmt_callr, { 0xbb }
02167   },
02168 /* calls $hash$segm$useg8,$hash$sof$usof16 */
02169   {
02170     { 0, 0, 0, 0 },
02171     { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
02172     & ifmt_callseg, { 0xda }
02173   },
02174 /* calls $seg,$caddr */
02175   {
02176     { 0, 0, 0, 0 },
02177     { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
02178     & ifmt_jmps, { 0xda }
02179   },
02180 /* pcall $reg8,$caddr */
02181   {
02182     { 0, 0, 0, 0 },
02183     { { MNEM, ' ', OP (REG8), ',', OP (CADDR), 0 } },
02184     & ifmt_pcall, { 0xe2 }
02185   },
02186 /* trap $hash$uimm7 */
02187   {
02188     { 0, 0, 0, 0 },
02189     { { MNEM, ' ', OP (HASH), OP (UIMM7), 0 } },
02190     & ifmt_trap, { 0x9b }
02191   },
02192 /* ret */
02193   {
02194     { 0, 0, 0, 0 },
02195     { { MNEM, 0 } },
02196     & ifmt_ret, { 0xcb }
02197   },
02198 /* rets */
02199   {
02200     { 0, 0, 0, 0 },
02201     { { MNEM, 0 } },
02202     & ifmt_ret, { 0xdb }
02203   },
02204 /* retp $reg8 */
02205   {
02206     { 0, 0, 0, 0 },
02207     { { MNEM, ' ', OP (REG8), 0 } },
02208     & ifmt_retp, { 0xeb }
02209   },
02210 /* reti */
02211   {
02212     { 0, 0, 0, 0 },
02213     { { MNEM, 0 } },
02214     & ifmt_reti, { 0x88fb }
02215   },
02216 /* pop $reg8 */
02217   {
02218     { 0, 0, 0, 0 },
02219     { { MNEM, ' ', OP (REG8), 0 } },
02220     & ifmt_retp, { 0xfc }
02221   },
02222 /* push $reg8 */
02223   {
02224     { 0, 0, 0, 0 },
02225     { { MNEM, ' ', OP (REG8), 0 } },
02226     & ifmt_retp, { 0xec }
02227   },
02228 /* scxt $reg8,$hash$uimm16 */
02229   {
02230     { 0, 0, 0, 0 },
02231     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02232     & ifmt_addrhpof, { 0xc6 }
02233   },
02234 /* scxt $reg8,$pof$upof16 */
02235   {
02236     { 0, 0, 0, 0 },
02237     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02238     & ifmt_addrpof, { 0xd6 }
02239   },
02240 /* scxt $regmem8,$memgr8 */
02241   {
02242     { 0, 0, 0, 0 },
02243     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02244     & ifmt_addrm2, { 0xd6 }
02245   },
02246 /* scxt $reg8,$memory */
02247   {
02248     { 0, 0, 0, 0 },
02249     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02250     & ifmt_addrm, { 0xd6 }
02251   },
02252 /* nop */
02253   {
02254     { 0, 0, 0, 0 },
02255     { { MNEM, 0 } },
02256     & ifmt_ret, { 0xcc }
02257   },
02258 /* srst */
02259   {
02260     { 0, 0, 0, 0 },
02261     { { MNEM, 0 } },
02262     & ifmt_srstm, { 0xb7b748b7 }
02263   },
02264 /* idle */
02265   {
02266     { 0, 0, 0, 0 },
02267     { { MNEM, 0 } },
02268     & ifmt_srstm, { 0x87877887 }
02269   },
02270 /* pwrdn */
02271   {
02272     { 0, 0, 0, 0 },
02273     { { MNEM, 0 } },
02274     & ifmt_srstm, { 0x97976897 }
02275   },
02276 /* diswdt */
02277   {
02278     { 0, 0, 0, 0 },
02279     { { MNEM, 0 } },
02280     & ifmt_srstm, { 0xa5a55aa5 }
02281   },
02282 /* enwdt */
02283   {
02284     { 0, 0, 0, 0 },
02285     { { MNEM, 0 } },
02286     & ifmt_srstm, { 0x85857a85 }
02287   },
02288 /* einit */
02289   {
02290     { 0, 0, 0, 0 },
02291     { { MNEM, 0 } },
02292     & ifmt_srstm, { 0xb5b54ab5 }
02293   },
02294 /* srvwdt */
02295   {
02296     { 0, 0, 0, 0 },
02297     { { MNEM, 0 } },
02298     & ifmt_srstm, { 0xa7a758a7 }
02299   },
02300 /* sbrk */
02301   {
02302     { 0, 0, 0, 0 },
02303     { { MNEM, 0 } },
02304     & ifmt_ret, { 0x8c }
02305   },
02306 /* atomic $hash$uimm2 */
02307   {
02308     { 0, 0, 0, 0 },
02309     { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
02310     & ifmt_atomic, { 0xd1 }
02311   },
02312 /* extr $hash$uimm2 */
02313   {
02314     { 0, 0, 0, 0 },
02315     { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
02316     & ifmt_atomic, { 0x80d1 }
02317   },
02318 /* extp $sr,$hash$uimm2 */
02319   {
02320     { 0, 0, 0, 0 },
02321     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
02322     & ifmt_extp, { 0x40dc }
02323   },
02324 /* extp $hash$pagenum,$hash$uimm2 */
02325   {
02326     { 0, 0, 0, 0 },
02327     { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
02328     & ifmt_extp1, { 0x40d7 }
02329   },
02330 /* extp $hash$pag$upag16,$hash$uimm2 */
02331   {
02332     { 0, 0, 0, 0 },
02333     { { MNEM, ' ', OP (HASH), OP (PAG), OP (UPAG16), ',', OP (HASH), OP (UIMM2), 0 } },
02334     & ifmt_extpg1, { 0x40d7 }
02335   },
02336 /* extpr $sr,$hash$uimm2 */
02337   {
02338     { 0, 0, 0, 0 },
02339     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
02340     & ifmt_extp, { 0xc0dc }
02341   },
02342 /* extpr $hash$pagenum,$hash$uimm2 */
02343   {
02344     { 0, 0, 0, 0 },
02345     { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
02346     & ifmt_extp1, { 0xc0d7 }
02347   },
02348 /* exts $sr,$hash$uimm2 */
02349   {
02350     { 0, 0, 0, 0 },
02351     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
02352     & ifmt_extp, { 0xdc }
02353   },
02354 /* exts $hash$seghi8,$hash$uimm2 */
02355   {
02356     { 0, 0, 0, 0 },
02357     { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
02358     & ifmt_exts1, { 0xd7 }
02359   },
02360 /* extsr $sr,$hash$uimm2 */
02361   {
02362     { 0, 0, 0, 0 },
02363     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
02364     & ifmt_extp, { 0x80dc }
02365   },
02366 /* extsr $hash$seghi8,$hash$uimm2 */
02367   {
02368     { 0, 0, 0, 0 },
02369     { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
02370     & ifmt_exts1, { 0x80d7 }
02371   },
02372 /* prior $dr,$sr */
02373   {
02374     { 0, 0, 0, 0 },
02375     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02376     & ifmt_addr, { 0x2b }
02377   },
02378 /* bclr $RegNam */
02379   {
02380     { 0, 0, 0, 0 },
02381     { { MNEM, ' ', OP (REGNAM), 0 } },
02382     & ifmt_bclr18, { 0xbe }
02383   },
02384 /* bclr $reg8$dot$qbit */
02385   {
02386     { 0, 0, 0, 0 },
02387     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02388     & ifmt_bclr0, { 0xe }
02389   },
02390 /* bclr $reg8$dot$qbit */
02391   {
02392     { 0, 0, 0, 0 },
02393     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02394     & ifmt_bclr0, { 0x1e }
02395   },
02396 /* bclr $reg8$dot$qbit */
02397   {
02398     { 0, 0, 0, 0 },
02399     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02400     & ifmt_bclr0, { 0x2e }
02401   },
02402 /* bclr $reg8$dot$qbit */
02403   {
02404     { 0, 0, 0, 0 },
02405     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02406     & ifmt_bclr0, { 0x3e }
02407   },
02408 /* bclr $reg8$dot$qbit */
02409   {
02410     { 0, 0, 0, 0 },
02411     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02412     & ifmt_bclr0, { 0x4e }
02413   },
02414 /* bclr $reg8$dot$qbit */
02415   {
02416     { 0, 0, 0, 0 },
02417     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02418     & ifmt_bclr0, { 0x5e }
02419   },
02420 /* bclr $reg8$dot$qbit */
02421   {
02422     { 0, 0, 0, 0 },
02423     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02424     & ifmt_bclr0, { 0x6e }
02425   },
02426 /* bclr $reg8$dot$qbit */
02427   {
02428     { 0, 0, 0, 0 },
02429     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02430     & ifmt_bclr0, { 0x7e }
02431   },
02432 /* bclr $reg8$dot$qbit */
02433   {
02434     { 0, 0, 0, 0 },
02435     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02436     & ifmt_bclr0, { 0x8e }
02437   },
02438 /* bclr $reg8$dot$qbit */
02439   {
02440     { 0, 0, 0, 0 },
02441     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02442     & ifmt_bclr0, { 0x9e }
02443   },
02444 /* bclr $reg8$dot$qbit */
02445   {
02446     { 0, 0, 0, 0 },
02447     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02448     & ifmt_bclr0, { 0xae }
02449   },
02450 /* bclr $reg8$dot$qbit */
02451   {
02452     { 0, 0, 0, 0 },
02453     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02454     & ifmt_bclr0, { 0xbe }
02455   },
02456 /* bclr $reg8$dot$qbit */
02457   {
02458     { 0, 0, 0, 0 },
02459     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02460     & ifmt_bclr0, { 0xce }
02461   },
02462 /* bclr $reg8$dot$qbit */
02463   {
02464     { 0, 0, 0, 0 },
02465     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02466     & ifmt_bclr0, { 0xde }
02467   },
02468 /* bclr $reg8$dot$qbit */
02469   {
02470     { 0, 0, 0, 0 },
02471     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02472     & ifmt_bclr0, { 0xee }
02473   },
02474 /* bclr $reg8$dot$qbit */
02475   {
02476     { 0, 0, 0, 0 },
02477     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02478     & ifmt_bclr0, { 0xfe }
02479   },
02480 /* bset $RegNam */
02481   {
02482     { 0, 0, 0, 0 },
02483     { { MNEM, ' ', OP (REGNAM), 0 } },
02484     & ifmt_bclr18, { 0xbf }
02485   },
02486 /* bset $reg8$dot$qbit */
02487   {
02488     { 0, 0, 0, 0 },
02489     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02490     & ifmt_bclr0, { 0xf }
02491   },
02492 /* bset $reg8$dot$qbit */
02493   {
02494     { 0, 0, 0, 0 },
02495     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02496     & ifmt_bclr0, { 0x1f }
02497   },
02498 /* bset $reg8$dot$qbit */
02499   {
02500     { 0, 0, 0, 0 },
02501     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02502     & ifmt_bclr0, { 0x2f }
02503   },
02504 /* bset $reg8$dot$qbit */
02505   {
02506     { 0, 0, 0, 0 },
02507     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02508     & ifmt_bclr0, { 0x3f }
02509   },
02510 /* bset $reg8$dot$qbit */
02511   {
02512     { 0, 0, 0, 0 },
02513     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02514     & ifmt_bclr0, { 0x4f }
02515   },
02516 /* bset $reg8$dot$qbit */
02517   {
02518     { 0, 0, 0, 0 },
02519     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02520     & ifmt_bclr0, { 0x5f }
02521   },
02522 /* bset $reg8$dot$qbit */
02523   {
02524     { 0, 0, 0, 0 },
02525     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02526     & ifmt_bclr0, { 0x6f }
02527   },
02528 /* bset $reg8$dot$qbit */
02529   {
02530     { 0, 0, 0, 0 },
02531     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02532     & ifmt_bclr0, { 0x7f }
02533   },
02534 /* bset $reg8$dot$qbit */
02535   {
02536     { 0, 0, 0, 0 },
02537     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02538     & ifmt_bclr0, { 0x8f }
02539   },
02540 /* bset $reg8$dot$qbit */
02541   {
02542     { 0, 0, 0, 0 },
02543     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02544     & ifmt_bclr0, { 0x9f }
02545   },
02546 /* bset $reg8$dot$qbit */
02547   {
02548     { 0, 0, 0, 0 },
02549     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02550     & ifmt_bclr0, { 0xaf }
02551   },
02552 /* bset $reg8$dot$qbit */
02553   {
02554     { 0, 0, 0, 0 },
02555     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02556     & ifmt_bclr0, { 0xbf }
02557   },
02558 /* bset $reg8$dot$qbit */
02559   {
02560     { 0, 0, 0, 0 },
02561     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02562     & ifmt_bclr0, { 0xcf }
02563   },
02564 /* bset $reg8$dot$qbit */
02565   {
02566     { 0, 0, 0, 0 },
02567     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02568     & ifmt_bclr0, { 0xdf }
02569   },
02570 /* bset $reg8$dot$qbit */
02571   {
02572     { 0, 0, 0, 0 },
02573     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02574     & ifmt_bclr0, { 0xef }
02575   },
02576 /* bset $reg8$dot$qbit */
02577   {
02578     { 0, 0, 0, 0 },
02579     { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
02580     & ifmt_bclr0, { 0xff }
02581   },
02582 /* bmov $reghi8$dot$qhibit,$reg8$dot$qlobit */
02583   {
02584     { 0, 0, 0, 0 },
02585     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02586     & ifmt_bmov, { 0x4a }
02587   },
02588 /* bmovn $reghi8$dot$qhibit,$reg8$dot$qlobit */
02589   {
02590     { 0, 0, 0, 0 },
02591     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02592     & ifmt_bmov, { 0x3a }
02593   },
02594 /* band $reghi8$dot$qhibit,$reg8$dot$qlobit */
02595   {
02596     { 0, 0, 0, 0 },
02597     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02598     & ifmt_bmov, { 0x6a }
02599   },
02600 /* bor $reghi8$dot$qhibit,$reg8$dot$qlobit */
02601   {
02602     { 0, 0, 0, 0 },
02603     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02604     & ifmt_bmov, { 0x5a }
02605   },
02606 /* bxor $reghi8$dot$qhibit,$reg8$dot$qlobit */
02607   {
02608     { 0, 0, 0, 0 },
02609     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02610     & ifmt_bmov, { 0x7a }
02611   },
02612 /* bcmp $reghi8$dot$qhibit,$reg8$dot$qlobit */
02613   {
02614     { 0, 0, 0, 0 },
02615     { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
02616     & ifmt_bmov, { 0x2a }
02617   },
02618 /* bfldl $reg8,$hash$mask8,$hash$datahi8 */
02619   {
02620     { 0, 0, 0, 0 },
02621     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASK8), ',', OP (HASH), OP (DATAHI8), 0 } },
02622     & ifmt_bfldl, { 0xa }
02623   },
02624 /* bfldh $reg8,$hash$masklo8,$hash$data8 */
02625   {
02626     { 0, 0, 0, 0 },
02627     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASKLO8), ',', OP (HASH), OP (DATA8), 0 } },
02628     & ifmt_bfldh, { 0x1a }
02629   },
02630 /* cmp $src1,$src2 */
02631   {
02632     { 0, 0, 0, 0 },
02633     { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
02634     & ifmt_muls, { 0x40 }
02635   },
02636 /* cmpb $drb,$srb */
02637   {
02638     { 0, 0, 0, 0 },
02639     { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
02640     & ifmt_addbr, { 0x41 }
02641   },
02642 /* cmp $src1,$hash$uimm3 */
02643   {
02644     { 0, 0, 0, 0 },
02645     { { MNEM, ' ', OP (SRC1), ',', OP (HASH), OP (UIMM3), 0 } },
02646     & ifmt_cmpri, { 0x48 }
02647   },
02648 /* cmpb $drb,$hash$uimm3 */
02649   {
02650     { 0, 0, 0, 0 },
02651     { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
02652     & ifmt_addbrhpag3, { 0x49 }
02653   },
02654 /* cmp $reg8,$hash$uimm16 */
02655   {
02656     { 0, 0, 0, 0 },
02657     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02658     & ifmt_addrhpof, { 0x46 }
02659   },
02660 /* cmpb $regb8,$hash$uimm8 */
02661   {
02662     { 0, 0, 0, 0 },
02663     { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
02664     & ifmt_addrbhpof, { 0x47 }
02665   },
02666 /* cmp $dr,[$sr2] */
02667   {
02668     { 0, 0, 0, 0 },
02669     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
02670     & ifmt_add2, { 0x848 }
02671   },
02672 /* cmpb $drb,[$sr2] */
02673   {
02674     { 0, 0, 0, 0 },
02675     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
02676     & ifmt_addb2, { 0x849 }
02677   },
02678 /* cmp $dr,[$sr2+] */
02679   {
02680     { 0, 0, 0, 0 },
02681     { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
02682     & ifmt_add2, { 0xc48 }
02683   },
02684 /* cmpb $drb,[$sr2+] */
02685   {
02686     { 0, 0, 0, 0 },
02687     { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
02688     & ifmt_addb2, { 0xc49 }
02689   },
02690 /* cmp $reg8,$pof$upof16 */
02691   {
02692     { 0, 0, 0, 0 },
02693     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02694     & ifmt_addrpof, { 0x42 }
02695   },
02696 /* cmpb $regb8,$pof$upof16 */
02697   {
02698     { 0, 0, 0, 0 },
02699     { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
02700     & ifmt_addbrpof, { 0x43 }
02701   },
02702 /* cmp $regmem8,$memgr8 */
02703   {
02704     { 0, 0, 0, 0 },
02705     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02706     & ifmt_addrm2, { 0x42 }
02707   },
02708 /* cmp $reg8,$memory */
02709   {
02710     { 0, 0, 0, 0 },
02711     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02712     & ifmt_addrm, { 0x42 }
02713   },
02714 /* cmpb $regbmem8,$memgr8 */
02715   {
02716     { 0, 0, 0, 0 },
02717     { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
02718     & ifmt_addbrm2, { 0x43 }
02719   },
02720 /* cmpb $regb8,$memory */
02721   {
02722     { 0, 0, 0, 0 },
02723     { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
02724     & ifmt_addbrm, { 0x43 }
02725   },
02726 /* cmpd1 $sr,$hash$uimm4 */
02727   {
02728     { 0, 0, 0, 0 },
02729     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02730     & ifmt_cmpd1ri, { 0xa0 }
02731   },
02732 /* cmpd2 $sr,$hash$uimm4 */
02733   {
02734     { 0, 0, 0, 0 },
02735     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02736     & ifmt_cmpd1ri, { 0xb0 }
02737   },
02738 /* cmpi1 $sr,$hash$uimm4 */
02739   {
02740     { 0, 0, 0, 0 },
02741     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02742     & ifmt_cmpd1ri, { 0x80 }
02743   },
02744 /* cmpi2 $sr,$hash$uimm4 */
02745   {
02746     { 0, 0, 0, 0 },
02747     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02748     & ifmt_cmpd1ri, { 0x90 }
02749   },
02750 /* cmpd1 $reg8,$hash$uimm16 */
02751   {
02752     { 0, 0, 0, 0 },
02753     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02754     & ifmt_addrhpof, { 0xa6 }
02755   },
02756 /* cmpd2 $reg8,$hash$uimm16 */
02757   {
02758     { 0, 0, 0, 0 },
02759     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02760     & ifmt_addrhpof, { 0xb6 }
02761   },
02762 /* cmpi1 $reg8,$hash$uimm16 */
02763   {
02764     { 0, 0, 0, 0 },
02765     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02766     & ifmt_addrhpof, { 0x86 }
02767   },
02768 /* cmpi2 $reg8,$hash$uimm16 */
02769   {
02770     { 0, 0, 0, 0 },
02771     { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
02772     & ifmt_addrhpof, { 0x96 }
02773   },
02774 /* cmpd1 $reg8,$pof$upof16 */
02775   {
02776     { 0, 0, 0, 0 },
02777     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02778     & ifmt_addrpof, { 0xa2 }
02779   },
02780 /* cmpd2 $reg8,$pof$upof16 */
02781   {
02782     { 0, 0, 0, 0 },
02783     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02784     & ifmt_addrpof, { 0xb2 }
02785   },
02786 /* cmpi1 $reg8,$pof$upof16 */
02787   {
02788     { 0, 0, 0, 0 },
02789     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02790     & ifmt_addrpof, { 0x82 }
02791   },
02792 /* cmpi2 $reg8,$pof$upof16 */
02793   {
02794     { 0, 0, 0, 0 },
02795     { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
02796     & ifmt_addrpof, { 0x92 }
02797   },
02798 /* cmpd1 $regmem8,$memgr8 */
02799   {
02800     { 0, 0, 0, 0 },
02801     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02802     & ifmt_addrm2, { 0xa2 }
02803   },
02804 /* cmpd2 $regmem8,$memgr8 */
02805   {
02806     { 0, 0, 0, 0 },
02807     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02808     & ifmt_addrm2, { 0xb2 }
02809   },
02810 /* cmpi1 $regmem8,$memgr8 */
02811   {
02812     { 0, 0, 0, 0 },
02813     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02814     & ifmt_addrm2, { 0x82 }
02815   },
02816 /* cmpi2 $regmem8,$memgr8 */
02817   {
02818     { 0, 0, 0, 0 },
02819     { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
02820     & ifmt_addrm2, { 0x92 }
02821   },
02822 /* cmpd1 $reg8,$memory */
02823   {
02824     { 0, 0, 0, 0 },
02825     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02826     & ifmt_addrm, { 0xa2 }
02827   },
02828 /* cmpd2 $reg8,$memory */
02829   {
02830     { 0, 0, 0, 0 },
02831     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02832     & ifmt_addrm, { 0xb2 }
02833   },
02834 /* cmpi1 $reg8,$memory */
02835   {
02836     { 0, 0, 0, 0 },
02837     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02838     & ifmt_addrm, { 0x82 }
02839   },
02840 /* cmpi2 $reg8,$memory */
02841   {
02842     { 0, 0, 0, 0 },
02843     { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
02844     & ifmt_addrm, { 0x92 }
02845   },
02846 /* shl $dr,$sr */
02847   {
02848     { 0, 0, 0, 0 },
02849     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02850     & ifmt_addr, { 0x4c }
02851   },
02852 /* shr $dr,$sr */
02853   {
02854     { 0, 0, 0, 0 },
02855     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02856     & ifmt_addr, { 0x6c }
02857   },
02858 /* rol $dr,$sr */
02859   {
02860     { 0, 0, 0, 0 },
02861     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02862     & ifmt_addr, { 0xc }
02863   },
02864 /* ror $dr,$sr */
02865   {
02866     { 0, 0, 0, 0 },
02867     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02868     & ifmt_addr, { 0x2c }
02869   },
02870 /* ashr $dr,$sr */
02871   {
02872     { 0, 0, 0, 0 },
02873     { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
02874     & ifmt_addr, { 0xac }
02875   },
02876 /* shl $sr,$hash$uimm4 */
02877   {
02878     { 0, 0, 0, 0 },
02879     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02880     & ifmt_cmpd1ri, { 0x5c }
02881   },
02882 /* shr $sr,$hash$uimm4 */
02883   {
02884     { 0, 0, 0, 0 },
02885     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02886     & ifmt_cmpd1ri, { 0x7c }
02887   },
02888 /* rol $sr,$hash$uimm4 */
02889   {
02890     { 0, 0, 0, 0 },
02891     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02892     & ifmt_cmpd1ri, { 0x1c }
02893   },
02894 /* ror $sr,$hash$uimm4 */
02895   {
02896     { 0, 0, 0, 0 },
02897     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02898     & ifmt_cmpd1ri, { 0x3c }
02899   },
02900 /* ashr $sr,$hash$uimm4 */
02901   {
02902     { 0, 0, 0, 0 },
02903     { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
02904     & ifmt_cmpd1ri, { 0xbc }
02905   },
02906 };
02907 
02908 #undef A
02909 #undef OPERAND
02910 #undef MNEM
02911 #undef OP
02912 
02913 /* Formats for ALIAS macro-insns.  */
02914 
02915 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
02916 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
02917 #else
02918 #define F(f) & xc16x_cgen_ifld_table[XC16X_f]
02919 #endif
02920 #undef F
02921 
02922 /* Each non-simple macro entry points to an array of expansion possibilities.  */
02923 
02924 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
02925 #define A(a) (1 << CGEN_INSN_##a)
02926 #else
02927 #define A(a) (1 << CGEN_INSN_a)
02928 #endif
02929 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
02930 #define OPERAND(op) XC16X_OPERAND_##op
02931 #else
02932 #define OPERAND(op) XC16X_OPERAND_op
02933 #endif
02934 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
02935 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
02936 
02937 /* The macro instruction table.  */
02938 
02939 static const CGEN_IBASE xc16x_cgen_macro_insn_table[] =
02940 {
02941 };
02942 
02943 /* The macro instruction opcode table.  */
02944 
02945 static const CGEN_OPCODE xc16x_cgen_macro_insn_opcode_table[] =
02946 {
02947 };
02948 
02949 #undef A
02950 #undef OPERAND
02951 #undef MNEM
02952 #undef OP
02953 
02954 #ifndef CGEN_ASM_HASH_P
02955 #define CGEN_ASM_HASH_P(insn) 1
02956 #endif
02957 
02958 #ifndef CGEN_DIS_HASH_P
02959 #define CGEN_DIS_HASH_P(insn) 1
02960 #endif
02961 
02962 /* Return non-zero if INSN is to be added to the hash table.
02963    Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
02964 
02965 static int
02966 asm_hash_insn_p (insn)
02967      const CGEN_INSN *insn ATTRIBUTE_UNUSED;
02968 {
02969   return CGEN_ASM_HASH_P (insn);
02970 }
02971 
02972 static int
02973 dis_hash_insn_p (insn)
02974      const CGEN_INSN *insn;
02975 {
02976   /* If building the hash table and the NO-DIS attribute is present,
02977      ignore.  */
02978   if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
02979     return 0;
02980   return CGEN_DIS_HASH_P (insn);
02981 }
02982 
02983 #ifndef CGEN_ASM_HASH
02984 #define CGEN_ASM_HASH_SIZE 127
02985 #ifdef CGEN_MNEMONIC_OPERANDS
02986 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
02987 #else
02988 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
02989 #endif
02990 #endif
02991 
02992 /* It doesn't make much sense to provide a default here,
02993    but while this is under development we do.
02994    BUFFER is a pointer to the bytes of the insn, target order.
02995    VALUE is the first base_insn_bitsize bits as an int in host order.  */
02996 
02997 #ifndef CGEN_DIS_HASH
02998 #define CGEN_DIS_HASH_SIZE 256
02999 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
03000 #endif
03001 
03002 /* The result is the hash value of the insn.
03003    Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
03004 
03005 static unsigned int
03006 asm_hash_insn (mnem)
03007      const char * mnem;
03008 {
03009   return CGEN_ASM_HASH (mnem);
03010 }
03011 
03012 /* BUF is a pointer to the bytes of the insn, target order.
03013    VALUE is the first base_insn_bitsize bits as an int in host order.  */
03014 
03015 static unsigned int
03016 dis_hash_insn (buf, value)
03017      const char * buf ATTRIBUTE_UNUSED;
03018      CGEN_INSN_INT value ATTRIBUTE_UNUSED;
03019 {
03020   return CGEN_DIS_HASH (buf, value);
03021 }
03022 
03023 /* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
03024 
03025 static void
03026 set_fields_bitsize (CGEN_FIELDS *fields, int size)
03027 {
03028   CGEN_FIELDS_BITSIZE (fields) = size;
03029 }
03030 
03031 /* Function to call before using the operand instance table.
03032    This plugs the opcode entries and macro instructions into the cpu table.  */
03033 
03034 void
03035 xc16x_cgen_init_opcode_table (CGEN_CPU_DESC cd)
03036 {
03037   int i;
03038   int num_macros = (sizeof (xc16x_cgen_macro_insn_table) /
03039                   sizeof (xc16x_cgen_macro_insn_table[0]));
03040   const CGEN_IBASE *ib = & xc16x_cgen_macro_insn_table[0];
03041   const CGEN_OPCODE *oc = & xc16x_cgen_macro_insn_opcode_table[0];
03042   CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
03043 
03044   memset (insns, 0, num_macros * sizeof (CGEN_INSN));
03045   for (i = 0; i < num_macros; ++i)
03046     {
03047       insns[i].base = &ib[i];
03048       insns[i].opcode = &oc[i];
03049       xc16x_cgen_build_insn_regex (& insns[i]);
03050     }
03051   cd->macro_insn_table.init_entries = insns;
03052   cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
03053   cd->macro_insn_table.num_init_entries = num_macros;
03054 
03055   oc = & xc16x_cgen_insn_opcode_table[0];
03056   insns = (CGEN_INSN *) cd->insn_table.init_entries;
03057   for (i = 0; i < MAX_INSNS; ++i)
03058     {
03059       insns[i].opcode = &oc[i];
03060       xc16x_cgen_build_insn_regex (& insns[i]);
03061     }
03062 
03063   cd->sizeof_fields = sizeof (CGEN_FIELDS);
03064   cd->set_fields_bitsize = set_fields_bitsize;
03065 
03066   cd->asm_hash_p = asm_hash_insn_p;
03067   cd->asm_hash = asm_hash_insn;
03068   cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
03069 
03070   cd->dis_hash_p = dis_hash_insn_p;
03071   cd->dis_hash = dis_hash_insn;
03072   cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
03073 }