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