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