OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [xc16x-opc.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.