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