daily update
[binutils.git] / opcodes / xc16x-opc.c
blob7a5abc05343fdd92a0846f0f54c1a83c524c2169
1 /* Instruction opcode table for xc16x.
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 Copyright 1996-2010 Free Software Foundation, Inc.
7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
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.
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.
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.
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"
33 /* -- opc.c */
35 /* -- */
36 /* The hash functions are recorded here to help keep assembler code out of
37 the disassembler and vice versa. */
39 static int asm_hash_insn_p (const CGEN_INSN *);
40 static unsigned int asm_hash_insn (const char *);
41 static int dis_hash_insn_p (const CGEN_INSN *);
42 static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
44 /* Instruction formats. */
46 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
47 static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
48 0, 0, 0x0, { { 0 } }
51 static const CGEN_IFMT ifmt_addrpof ATTRIBUTE_UNUSED = {
52 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
55 static const CGEN_IFMT ifmt_addbrpof ATTRIBUTE_UNUSED = {
56 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
59 static const CGEN_IFMT ifmt_addrpag ATTRIBUTE_UNUSED = {
60 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
63 static const CGEN_IFMT ifmt_addbrpag ATTRIBUTE_UNUSED = {
64 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
67 static const CGEN_IFMT ifmt_addrhpof ATTRIBUTE_UNUSED = {
68 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
71 static const CGEN_IFMT ifmt_addrhpof3 ATTRIBUTE_UNUSED = {
72 16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
75 static const CGEN_IFMT ifmt_addbrhpag3 ATTRIBUTE_UNUSED = {
76 16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
79 static const CGEN_IFMT ifmt_addrbhpof ATTRIBUTE_UNUSED = {
80 32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
83 static const CGEN_IFMT ifmt_addr ATTRIBUTE_UNUSED = {
84 16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
87 static const CGEN_IFMT ifmt_addbr ATTRIBUTE_UNUSED = {
88 16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
91 static const CGEN_IFMT ifmt_add2 ATTRIBUTE_UNUSED = {
92 16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
95 static const CGEN_IFMT ifmt_addb2 ATTRIBUTE_UNUSED = {
96 16, 16, 0xcff, { { F (F_R1) }, { F (F_OP_BIT2) }, { F (F_R0) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
99 static const CGEN_IFMT ifmt_addrm2 ATTRIBUTE_UNUSED = {
100 32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
103 static const CGEN_IFMT ifmt_addrm ATTRIBUTE_UNUSED = {
104 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
107 static const CGEN_IFMT ifmt_addbrm2 ATTRIBUTE_UNUSED = {
108 32, 32, 0xff, { { F (F_MEMGR8) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
111 static const CGEN_IFMT ifmt_addbrm ATTRIBUTE_UNUSED = {
112 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
115 static const CGEN_IFMT ifmt_muls ATTRIBUTE_UNUSED = {
116 16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
119 static const CGEN_IFMT ifmt_div ATTRIBUTE_UNUSED = {
120 16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
123 static const CGEN_IFMT ifmt_cpl ATTRIBUTE_UNUSED = {
124 16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
127 static const CGEN_IFMT ifmt_cplb ATTRIBUTE_UNUSED = {
128 16, 16, 0xfff, { { F (F_R1) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
131 static const CGEN_IFMT ifmt_movri ATTRIBUTE_UNUSED = {
132 16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
135 static const CGEN_IFMT ifmt_movbri ATTRIBUTE_UNUSED = {
136 16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
139 static const CGEN_IFMT ifmt_movbr2 ATTRIBUTE_UNUSED = {
140 16, 16, 0xff, { { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
143 static const CGEN_IFMT ifmt_mov9i ATTRIBUTE_UNUSED = {
144 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
147 static const CGEN_IFMT ifmt_movb9i ATTRIBUTE_UNUSED = {
148 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_R1) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
151 static const CGEN_IFMT ifmt_movri11 ATTRIBUTE_UNUSED = {
152 32, 32, 0xf0ff, { { F (F_MEMORY) }, { F (F_OP_LBIT4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
155 static const CGEN_IFMT ifmt_movehm5 ATTRIBUTE_UNUSED = {
156 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
159 static const CGEN_IFMT ifmt_movehm6 ATTRIBUTE_UNUSED = {
160 32, 32, 0xff, { { F (F_UIMM16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
163 static const CGEN_IFMT ifmt_movehm7 ATTRIBUTE_UNUSED = {
164 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
167 static const CGEN_IFMT ifmt_movehm8 ATTRIBUTE_UNUSED = {
168 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
171 static const CGEN_IFMT ifmt_movehm10 ATTRIBUTE_UNUSED = {
172 32, 32, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_UIMM8) }, { F (F_REGOFF8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
175 static const CGEN_IFMT ifmt_movbsrpofm ATTRIBUTE_UNUSED = {
176 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
179 static const CGEN_IFMT ifmt_movbspofmr ATTRIBUTE_UNUSED = {
180 32, 32, 0xff, { { F (F_MEMORY) }, { F (F_REGMEM8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
183 static const CGEN_IFMT ifmt_jmpa0 ATTRIBUTE_UNUSED = {
184 32, 32, 0x4ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BITONE) }, { F (F_OP_ONEBIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
187 static const CGEN_IFMT ifmt_jmpa_ ATTRIBUTE_UNUSED = {
188 32, 32, 0x5ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BITONE) }, { F (F_OP_ONEBIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
191 static const CGEN_IFMT ifmt_jmpi ATTRIBUTE_UNUSED = {
192 16, 16, 0xff, { { F (F_ICONDCODE) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
195 static const CGEN_IFMT ifmt_jmpr_nenz ATTRIBUTE_UNUSED = {
196 16, 16, 0xff, { { F (F_REL8) }, { F (F_RCOND) }, { F (F_OP2) }, { 0 } }
199 static const CGEN_IFMT ifmt_jmpseg ATTRIBUTE_UNUSED = {
200 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
203 static const CGEN_IFMT ifmt_jmps ATTRIBUTE_UNUSED = {
204 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
207 static const CGEN_IFMT ifmt_jb ATTRIBUTE_UNUSED = {
208 32, 32, 0xf0000ff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_RELHI8) }, { F (F_REGB8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
211 static const CGEN_IFMT ifmt_calla0 ATTRIBUTE_UNUSED = {
212 32, 32, 0x6ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_2BIT) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
215 static const CGEN_IFMT ifmt_calla_ ATTRIBUTE_UNUSED = {
216 32, 32, 0x7ff, { { F (F_OFFSET16) }, { F (F_EXTCCODE) }, { F (F_OP_BIT3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
219 static const CGEN_IFMT ifmt_callr ATTRIBUTE_UNUSED = {
220 16, 16, 0xff, { { F (F_REL8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
223 static const CGEN_IFMT ifmt_callseg ATTRIBUTE_UNUSED = {
224 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_SEG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
227 static const CGEN_IFMT ifmt_pcall ATTRIBUTE_UNUSED = {
228 32, 32, 0xff, { { F (F_OFFSET16) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
231 static const CGEN_IFMT ifmt_trap ATTRIBUTE_UNUSED = {
232 16, 16, 0x1ff, { { F (F_UIMM7) }, { F (F_OP_1BIT) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
235 static const CGEN_IFMT ifmt_ret ATTRIBUTE_UNUSED = {
236 16, 16, 0xff0000ff, { { F (F_OP_BIT8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
239 static const CGEN_IFMT ifmt_retp ATTRIBUTE_UNUSED = {
240 16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
243 static const CGEN_IFMT ifmt_reti ATTRIBUTE_UNUSED = {
244 16, 16, 0xffff, { { F (F_OP_LBIT4) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
247 static const CGEN_IFMT ifmt_srstm ATTRIBUTE_UNUSED = {
248 32, 32, 0xffffffff, { { F (F_OP_BIT8) }, { F (F_DATA8) }, { F (F_OP_LBIT4) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
251 static const CGEN_IFMT ifmt_atomic ATTRIBUTE_UNUSED = {
252 16, 16, 0xcfff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
255 static const CGEN_IFMT ifmt_extp ATTRIBUTE_UNUSED = {
256 16, 16, 0xc0ff, { { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
259 static const CGEN_IFMT ifmt_extp1 ATTRIBUTE_UNUSED = {
260 32, 32, 0xfc00cfff, { { F (F_QLOBIT) }, { F (F_QLOBIT2) }, { F (F_PAGENUM) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
263 static const CGEN_IFMT ifmt_extpg1 ATTRIBUTE_UNUSED = {
264 32, 32, 0xcfff, { { F (F_UIMM16) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
267 static const CGEN_IFMT ifmt_exts1 ATTRIBUTE_UNUSED = {
268 32, 32, 0xff00cfff, { { F (F_OP_BIT8) }, { F (F_SEGNUM8) }, { F (F_OP_LBIT2) }, { F (F_UIMM2) }, { F (F_OP_BIT4) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
271 static const CGEN_IFMT ifmt_bclr18 ATTRIBUTE_UNUSED = {
272 16, 16, 0xff, { { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
275 static const CGEN_IFMT ifmt_bclr0 ATTRIBUTE_UNUSED = {
276 16, 16, 0xff, { { F (F_REG8) }, { F (F_QCOND) }, { F (F_OP2) }, { 0 } }
279 static const CGEN_IFMT ifmt_bmov ATTRIBUTE_UNUSED = {
280 32, 32, 0xff, { { F (F_QLOBIT) }, { F (F_QHIBIT) }, { F (F_REGHI8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
283 static const CGEN_IFMT ifmt_bfldl ATTRIBUTE_UNUSED = {
284 32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_MASK8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
287 static const CGEN_IFMT ifmt_bfldh ATTRIBUTE_UNUSED = {
288 32, 32, 0xff, { { F (F_DATAHI8) }, { F (F_DATA8) }, { F (F_REG8) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
291 static const CGEN_IFMT ifmt_cmpri ATTRIBUTE_UNUSED = {
292 16, 16, 0x8ff, { { F (F_R1) }, { F (F_OP_BIT1) }, { F (F_UIMM3) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
295 static const CGEN_IFMT ifmt_cmpd1ri ATTRIBUTE_UNUSED = {
296 16, 16, 0xff, { { F (F_UIMM4) }, { F (F_R2) }, { F (F_OP1) }, { F (F_OP2) }, { 0 } }
299 #undef F
301 #define A(a) (1 << CGEN_INSN_##a)
302 #define OPERAND(op) XC16X_OPERAND_##op
303 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
304 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
306 /* The instruction table. */
308 static const CGEN_OPCODE xc16x_cgen_insn_opcode_table[MAX_INSNS] =
310 /* Special null first entry.
311 A `num' value of zero is thus invalid.
312 Also, the special `invalid' insn resides here. */
313 { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
314 /* add $reg8,$pof$upof16 */
316 { 0, 0, 0, 0 },
317 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
318 & ifmt_addrpof, { 0x2 }
320 /* sub $reg8,$pof$upof16 */
322 { 0, 0, 0, 0 },
323 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
324 & ifmt_addrpof, { 0x22 }
326 /* addb $regb8,$pof$upof16 */
328 { 0, 0, 0, 0 },
329 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
330 & ifmt_addbrpof, { 0x3 }
332 /* subb $regb8,$pof$upof16 */
334 { 0, 0, 0, 0 },
335 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
336 & ifmt_addbrpof, { 0x23 }
338 /* add $reg8,$pag$upag16 */
340 { 0, 0, 0, 0 },
341 { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
342 & ifmt_addrpag, { 0x2 }
344 /* sub $reg8,$pag$upag16 */
346 { 0, 0, 0, 0 },
347 { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
348 & ifmt_addrpag, { 0x22 }
350 /* addb $regb8,$pag$upag16 */
352 { 0, 0, 0, 0 },
353 { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
354 & ifmt_addbrpag, { 0x3 }
356 /* subb $regb8,$pag$upag16 */
358 { 0, 0, 0, 0 },
359 { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
360 & ifmt_addbrpag, { 0x23 }
362 /* addc $reg8,$pof$upof16 */
364 { 0, 0, 0, 0 },
365 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
366 & ifmt_addrpof, { 0x12 }
368 /* subc $reg8,$pof$upof16 */
370 { 0, 0, 0, 0 },
371 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
372 & ifmt_addrpof, { 0x32 }
374 /* addcb $regb8,$pof$upof16 */
376 { 0, 0, 0, 0 },
377 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
378 & ifmt_addbrpof, { 0x13 }
380 /* subcb $regb8,$pof$upof16 */
382 { 0, 0, 0, 0 },
383 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
384 & ifmt_addbrpof, { 0x33 }
386 /* addc $reg8,$pag$upag16 */
388 { 0, 0, 0, 0 },
389 { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
390 & ifmt_addrpag, { 0x12 }
392 /* subc $reg8,$pag$upag16 */
394 { 0, 0, 0, 0 },
395 { { MNEM, ' ', OP (REG8), ',', OP (PAG), OP (UPAG16), 0 } },
396 & ifmt_addrpag, { 0x32 }
398 /* addcb $regb8,$pag$upag16 */
400 { 0, 0, 0, 0 },
401 { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
402 & ifmt_addbrpag, { 0x13 }
404 /* subcb $regb8,$pag$upag16 */
406 { 0, 0, 0, 0 },
407 { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
408 & ifmt_addbrpag, { 0x33 }
410 /* add $pof$upof16,$reg8 */
412 { 0, 0, 0, 0 },
413 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
414 & ifmt_addrpof, { 0x4 }
416 /* sub $pof$upof16,$reg8 */
418 { 0, 0, 0, 0 },
419 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
420 & ifmt_addrpof, { 0x24 }
422 /* addb $pof$upof16,$regb8 */
424 { 0, 0, 0, 0 },
425 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
426 & ifmt_addbrpof, { 0x5 }
428 /* subb $pof$upof16,$regb8 */
430 { 0, 0, 0, 0 },
431 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
432 & ifmt_addbrpof, { 0x25 }
434 /* addc $pof$upof16,$reg8 */
436 { 0, 0, 0, 0 },
437 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
438 & ifmt_addrpof, { 0x14 }
440 /* subc $pof$upof16,$reg8 */
442 { 0, 0, 0, 0 },
443 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
444 & ifmt_addrpof, { 0x34 }
446 /* addcb $pof$upof16,$regb8 */
448 { 0, 0, 0, 0 },
449 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
450 & ifmt_addbrpof, { 0x15 }
452 /* subcb $pof$upof16,$regb8 */
454 { 0, 0, 0, 0 },
455 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
456 & ifmt_addbrpof, { 0x35 }
458 /* add $reg8,$hash$pof$uimm16 */
460 { 0, 0, 0, 0 },
461 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
462 & ifmt_addrhpof, { 0x6 }
464 /* sub $reg8,$hash$pof$uimm16 */
466 { 0, 0, 0, 0 },
467 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
468 & ifmt_addrhpof, { 0x26 }
470 /* add $reg8,$hash$pag$uimm16 */
472 { 0, 0, 0, 0 },
473 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
474 & ifmt_addrhpof, { 0x6 }
476 /* sub $reg8,$hash$pag$uimm16 */
478 { 0, 0, 0, 0 },
479 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
480 & ifmt_addrhpof, { 0x26 }
482 /* add $dr,$hash$pof$uimm3 */
484 { 0, 0, 0, 0 },
485 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
486 & ifmt_addrhpof3, { 0x8 }
488 /* sub $dr,$hash$pof$uimm3 */
490 { 0, 0, 0, 0 },
491 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
492 & ifmt_addrhpof3, { 0x28 }
494 /* addb $drb,$hash$pag$uimm3 */
496 { 0, 0, 0, 0 },
497 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
498 & ifmt_addbrhpag3, { 0x9 }
500 /* subb $drb,$hash$pag$uimm3 */
502 { 0, 0, 0, 0 },
503 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
504 & ifmt_addbrhpag3, { 0x29 }
506 /* add $dr,$hash$pag$uimm3 */
508 { 0, 0, 0, 0 },
509 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
510 & ifmt_addrhpof3, { 0x8 }
512 /* sub $dr,$hash$pag$uimm3 */
514 { 0, 0, 0, 0 },
515 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
516 & ifmt_addrhpof3, { 0x28 }
518 /* addb $drb,$hash$pof$uimm3 */
520 { 0, 0, 0, 0 },
521 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
522 & ifmt_addbrhpag3, { 0x9 }
524 /* subb $drb,$hash$pof$uimm3 */
526 { 0, 0, 0, 0 },
527 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
528 & ifmt_addbrhpag3, { 0x29 }
530 /* addb $regb8,$hash$pof$uimm8 */
532 { 0, 0, 0, 0 },
533 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
534 & ifmt_addrbhpof, { 0x7 }
536 /* subb $regb8,$hash$pof$uimm8 */
538 { 0, 0, 0, 0 },
539 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
540 & ifmt_addrbhpof, { 0x27 }
542 /* addb $regb8,$hash$pag$uimm8 */
544 { 0, 0, 0, 0 },
545 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
546 & ifmt_addrbhpof, { 0x7 }
548 /* subb $regb8,$hash$pag$uimm8 */
550 { 0, 0, 0, 0 },
551 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
552 & ifmt_addrbhpof, { 0x27 }
554 /* addc $reg8,$hash$pof$uimm16 */
556 { 0, 0, 0, 0 },
557 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
558 & ifmt_addrhpof, { 0x16 }
560 /* subc $reg8,$hash$pof$uimm16 */
562 { 0, 0, 0, 0 },
563 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (POF), OP (UIMM16), 0 } },
564 & ifmt_addrhpof, { 0x36 }
566 /* addc $reg8,$hash$pag$uimm16 */
568 { 0, 0, 0, 0 },
569 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
570 & ifmt_addrhpof, { 0x16 }
572 /* subc $reg8,$hash$pag$uimm16 */
574 { 0, 0, 0, 0 },
575 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (PAG), OP (UIMM16), 0 } },
576 & ifmt_addrhpof, { 0x36 }
578 /* addc $dr,$hash$pof$uimm3 */
580 { 0, 0, 0, 0 },
581 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
582 & ifmt_addrhpof3, { 0x18 }
584 /* subc $dr,$hash$pof$uimm3 */
586 { 0, 0, 0, 0 },
587 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
588 & ifmt_addrhpof3, { 0x38 }
590 /* addcb $drb,$hash$pag$uimm3 */
592 { 0, 0, 0, 0 },
593 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
594 & ifmt_addbrhpag3, { 0x19 }
596 /* subcb $drb,$hash$pag$uimm3 */
598 { 0, 0, 0, 0 },
599 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
600 & ifmt_addbrhpag3, { 0x39 }
602 /* addc $dr,$hash$pag$uimm3 */
604 { 0, 0, 0, 0 },
605 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
606 & ifmt_addrhpof3, { 0x18 }
608 /* subc $dr,$hash$pag$uimm3 */
610 { 0, 0, 0, 0 },
611 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (PAG), OP (UIMM3), 0 } },
612 & ifmt_addrhpof3, { 0x38 }
614 /* addcb $drb,$hash$pof$uimm3 */
616 { 0, 0, 0, 0 },
617 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
618 & ifmt_addbrhpag3, { 0x19 }
620 /* subcb $drb,$hash$pof$uimm3 */
622 { 0, 0, 0, 0 },
623 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (POF), OP (UIMM3), 0 } },
624 & ifmt_addbrhpag3, { 0x39 }
626 /* addcb $regb8,$hash$pof$uimm8 */
628 { 0, 0, 0, 0 },
629 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
630 & ifmt_addrbhpof, { 0x17 }
632 /* subcb $regb8,$hash$pof$uimm8 */
634 { 0, 0, 0, 0 },
635 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
636 & ifmt_addrbhpof, { 0x37 }
638 /* addcb $regb8,$hash$pag$uimm8 */
640 { 0, 0, 0, 0 },
641 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
642 & ifmt_addrbhpof, { 0x17 }
644 /* subcb $regb8,$hash$pag$uimm8 */
646 { 0, 0, 0, 0 },
647 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
648 & ifmt_addrbhpof, { 0x37 }
650 /* add $dr,$hash$uimm3 */
652 { 0, 0, 0, 0 },
653 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
654 & ifmt_addrhpof3, { 0x8 }
656 /* sub $dr,$hash$uimm3 */
658 { 0, 0, 0, 0 },
659 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
660 & ifmt_addrhpof3, { 0x28 }
662 /* addb $drb,$hash$uimm3 */
664 { 0, 0, 0, 0 },
665 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
666 & ifmt_addbrhpag3, { 0x9 }
668 /* subb $drb,$hash$uimm3 */
670 { 0, 0, 0, 0 },
671 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
672 & ifmt_addbrhpag3, { 0x29 }
674 /* add $reg8,$hash$uimm16 */
676 { 0, 0, 0, 0 },
677 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
678 & ifmt_addrhpof, { 0x6 }
680 /* sub $reg8,$hash$uimm16 */
682 { 0, 0, 0, 0 },
683 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
684 & ifmt_addrhpof, { 0x26 }
686 /* addb $regb8,$hash$uimm8 */
688 { 0, 0, 0, 0 },
689 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
690 & ifmt_addrbhpof, { 0x7 }
692 /* subb $regb8,$hash$uimm8 */
694 { 0, 0, 0, 0 },
695 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
696 & ifmt_addrbhpof, { 0x27 }
698 /* addc $dr,$hash$uimm3 */
700 { 0, 0, 0, 0 },
701 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
702 & ifmt_addrhpof3, { 0x18 }
704 /* subc $dr,$hash$uimm3 */
706 { 0, 0, 0, 0 },
707 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
708 & ifmt_addrhpof3, { 0x38 }
710 /* addcb $drb,$hash$uimm3 */
712 { 0, 0, 0, 0 },
713 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
714 & ifmt_addbrhpag3, { 0x19 }
716 /* subcb $drb,$hash$uimm3 */
718 { 0, 0, 0, 0 },
719 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
720 & ifmt_addbrhpag3, { 0x39 }
722 /* addc $reg8,$hash$uimm16 */
724 { 0, 0, 0, 0 },
725 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
726 & ifmt_addrhpof, { 0x16 }
728 /* subc $reg8,$hash$uimm16 */
730 { 0, 0, 0, 0 },
731 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
732 & ifmt_addrhpof, { 0x36 }
734 /* addcb $regb8,$hash$uimm8 */
736 { 0, 0, 0, 0 },
737 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
738 & ifmt_addrbhpof, { 0x17 }
740 /* subcb $regb8,$hash$uimm8 */
742 { 0, 0, 0, 0 },
743 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
744 & ifmt_addrbhpof, { 0x37 }
746 /* add $dr,$sr */
748 { 0, 0, 0, 0 },
749 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
750 & ifmt_addr, { 0x0 }
752 /* sub $dr,$sr */
754 { 0, 0, 0, 0 },
755 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
756 & ifmt_addr, { 0x20 }
758 /* addb $drb,$srb */
760 { 0, 0, 0, 0 },
761 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
762 & ifmt_addbr, { 0x1 }
764 /* subb $drb,$srb */
766 { 0, 0, 0, 0 },
767 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
768 & ifmt_addbr, { 0x21 }
770 /* add $dr,[$sr2] */
772 { 0, 0, 0, 0 },
773 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
774 & ifmt_add2, { 0x808 }
776 /* sub $dr,[$sr2] */
778 { 0, 0, 0, 0 },
779 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
780 & ifmt_add2, { 0x828 }
782 /* addb $drb,[$sr2] */
784 { 0, 0, 0, 0 },
785 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
786 & ifmt_addb2, { 0x809 }
788 /* subb $drb,[$sr2] */
790 { 0, 0, 0, 0 },
791 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
792 & ifmt_addb2, { 0x829 }
794 /* add $dr,[$sr2+] */
796 { 0, 0, 0, 0 },
797 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
798 & ifmt_add2, { 0xc08 }
800 /* sub $dr,[$sr2+] */
802 { 0, 0, 0, 0 },
803 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
804 & ifmt_add2, { 0xc28 }
806 /* addb $drb,[$sr2+] */
808 { 0, 0, 0, 0 },
809 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
810 & ifmt_addb2, { 0xc09 }
812 /* subb $drb,[$sr2+] */
814 { 0, 0, 0, 0 },
815 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
816 & ifmt_addb2, { 0xc29 }
818 /* addc $dr,$sr */
820 { 0, 0, 0, 0 },
821 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
822 & ifmt_addr, { 0x10 }
824 /* subc $dr,$sr */
826 { 0, 0, 0, 0 },
827 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
828 & ifmt_addr, { 0x30 }
830 /* addcb $drb,$srb */
832 { 0, 0, 0, 0 },
833 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
834 & ifmt_addbr, { 0x11 }
836 /* subcb $drb,$srb */
838 { 0, 0, 0, 0 },
839 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
840 & ifmt_addbr, { 0x31 }
842 /* addc $dr,[$sr2] */
844 { 0, 0, 0, 0 },
845 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
846 & ifmt_add2, { 0x818 }
848 /* subc $dr,[$sr2] */
850 { 0, 0, 0, 0 },
851 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
852 & ifmt_add2, { 0x838 }
854 /* addcb $drb,[$sr2] */
856 { 0, 0, 0, 0 },
857 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
858 & ifmt_addb2, { 0x819 }
860 /* subcb $drb,[$sr2] */
862 { 0, 0, 0, 0 },
863 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
864 & ifmt_addb2, { 0x839 }
866 /* addc $dr,[$sr2+] */
868 { 0, 0, 0, 0 },
869 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
870 & ifmt_add2, { 0xc18 }
872 /* subc $dr,[$sr2+] */
874 { 0, 0, 0, 0 },
875 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
876 & ifmt_add2, { 0xc38 }
878 /* addcb $drb,[$sr2+] */
880 { 0, 0, 0, 0 },
881 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
882 & ifmt_addb2, { 0xc19 }
884 /* subcb $drb,[$sr2+] */
886 { 0, 0, 0, 0 },
887 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
888 & ifmt_addb2, { 0xc39 }
890 /* add $regmem8,$memgr8 */
892 { 0, 0, 0, 0 },
893 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
894 & ifmt_addrm2, { 0x2 }
896 /* add $memgr8,$regmem8 */
898 { 0, 0, 0, 0 },
899 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
900 & ifmt_addrm2, { 0x4 }
902 /* add $reg8,$memory */
904 { 0, 0, 0, 0 },
905 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
906 & ifmt_addrm, { 0x2 }
908 /* add $memory,$reg8 */
910 { 0, 0, 0, 0 },
911 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
912 & ifmt_addrm, { 0x4 }
914 /* sub $regmem8,$memgr8 */
916 { 0, 0, 0, 0 },
917 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
918 & ifmt_addrm2, { 0x22 }
920 /* sub $memgr8,$regmem8 */
922 { 0, 0, 0, 0 },
923 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
924 & ifmt_addrm2, { 0x24 }
926 /* sub $reg8,$memory */
928 { 0, 0, 0, 0 },
929 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
930 & ifmt_addrm, { 0x22 }
932 /* sub $memory,$reg8 */
934 { 0, 0, 0, 0 },
935 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
936 & ifmt_addrm, { 0x24 }
938 /* addb $regbmem8,$memgr8 */
940 { 0, 0, 0, 0 },
941 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
942 & ifmt_addbrm2, { 0x3 }
944 /* addb $memgr8,$regbmem8 */
946 { 0, 0, 0, 0 },
947 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
948 & ifmt_addbrm2, { 0x5 }
950 /* addb $regb8,$memory */
952 { 0, 0, 0, 0 },
953 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
954 & ifmt_addbrm, { 0x3 }
956 /* addb $memory,$regb8 */
958 { 0, 0, 0, 0 },
959 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
960 & ifmt_addbrm, { 0x5 }
962 /* subb $regbmem8,$memgr8 */
964 { 0, 0, 0, 0 },
965 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
966 & ifmt_addbrm2, { 0x23 }
968 /* subb $memgr8,$regbmem8 */
970 { 0, 0, 0, 0 },
971 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
972 & ifmt_addbrm2, { 0x25 }
974 /* subb $regb8,$memory */
976 { 0, 0, 0, 0 },
977 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
978 & ifmt_addbrm, { 0x23 }
980 /* subb $memory,$regb8 */
982 { 0, 0, 0, 0 },
983 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
984 & ifmt_addbrm, { 0x25 }
986 /* addc $regmem8,$memgr8 */
988 { 0, 0, 0, 0 },
989 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
990 & ifmt_addrm2, { 0x12 }
992 /* addc $memgr8,$regmem8 */
994 { 0, 0, 0, 0 },
995 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
996 & ifmt_addrm2, { 0x14 }
998 /* addc $reg8,$memory */
1000 { 0, 0, 0, 0 },
1001 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1002 & ifmt_addrm, { 0x12 }
1004 /* addc $memory,$reg8 */
1006 { 0, 0, 0, 0 },
1007 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1008 & ifmt_addrm, { 0x14 }
1010 /* subc $regmem8,$memgr8 */
1012 { 0, 0, 0, 0 },
1013 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1014 & ifmt_addrm2, { 0x32 }
1016 /* subc $memgr8,$regmem8 */
1018 { 0, 0, 0, 0 },
1019 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1020 & ifmt_addrm2, { 0x34 }
1022 /* subc $reg8,$memory */
1024 { 0, 0, 0, 0 },
1025 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1026 & ifmt_addrm, { 0x32 }
1028 /* subc $memory,$reg8 */
1030 { 0, 0, 0, 0 },
1031 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1032 & ifmt_addrm, { 0x34 }
1034 /* addcb $regbmem8,$memgr8 */
1036 { 0, 0, 0, 0 },
1037 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1038 & ifmt_addbrm2, { 0x13 }
1040 /* addcb $memgr8,$regbmem8 */
1042 { 0, 0, 0, 0 },
1043 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1044 & ifmt_addbrm2, { 0x15 }
1046 /* addcb $regb8,$memory */
1048 { 0, 0, 0, 0 },
1049 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1050 & ifmt_addbrm, { 0x13 }
1052 /* addcb $memory,$regb8 */
1054 { 0, 0, 0, 0 },
1055 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1056 & ifmt_addbrm, { 0x15 }
1058 /* subcb $regbmem8,$memgr8 */
1060 { 0, 0, 0, 0 },
1061 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1062 & ifmt_addbrm2, { 0x33 }
1064 /* subcb $memgr8,$regbmem8 */
1066 { 0, 0, 0, 0 },
1067 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1068 & ifmt_addbrm2, { 0x35 }
1070 /* subcb $regb8,$memory */
1072 { 0, 0, 0, 0 },
1073 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1074 & ifmt_addbrm, { 0x33 }
1076 /* subcb $memory,$regb8 */
1078 { 0, 0, 0, 0 },
1079 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1080 & ifmt_addbrm, { 0x35 }
1082 /* mul $src1,$src2 */
1084 { 0, 0, 0, 0 },
1085 { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1086 & ifmt_muls, { 0xb }
1088 /* mulu $src1,$src2 */
1090 { 0, 0, 0, 0 },
1091 { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
1092 & ifmt_muls, { 0x1b }
1094 /* div $srdiv */
1096 { 0, 0, 0, 0 },
1097 { { MNEM, ' ', OP (SRDIV), 0 } },
1098 & ifmt_div, { 0x4b }
1100 /* divl $srdiv */
1102 { 0, 0, 0, 0 },
1103 { { MNEM, ' ', OP (SRDIV), 0 } },
1104 & ifmt_div, { 0x6b }
1106 /* divlu $srdiv */
1108 { 0, 0, 0, 0 },
1109 { { MNEM, ' ', OP (SRDIV), 0 } },
1110 & ifmt_div, { 0x7b }
1112 /* divu $srdiv */
1114 { 0, 0, 0, 0 },
1115 { { MNEM, ' ', OP (SRDIV), 0 } },
1116 & ifmt_div, { 0x5b }
1118 /* cpl $dr */
1120 { 0, 0, 0, 0 },
1121 { { MNEM, ' ', OP (DR), 0 } },
1122 & ifmt_cpl, { 0x91 }
1124 /* cplb $drb */
1126 { 0, 0, 0, 0 },
1127 { { MNEM, ' ', OP (DRB), 0 } },
1128 & ifmt_cplb, { 0xb1 }
1130 /* neg $dr */
1132 { 0, 0, 0, 0 },
1133 { { MNEM, ' ', OP (DR), 0 } },
1134 & ifmt_cpl, { 0x81 }
1136 /* negb $drb */
1138 { 0, 0, 0, 0 },
1139 { { MNEM, ' ', OP (DRB), 0 } },
1140 & ifmt_cplb, { 0xa1 }
1142 /* and $dr,$sr */
1144 { 0, 0, 0, 0 },
1145 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1146 & ifmt_addr, { 0x60 }
1148 /* or $dr,$sr */
1150 { 0, 0, 0, 0 },
1151 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1152 & ifmt_addr, { 0x70 }
1154 /* xor $dr,$sr */
1156 { 0, 0, 0, 0 },
1157 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1158 & ifmt_addr, { 0x50 }
1160 /* andb $drb,$srb */
1162 { 0, 0, 0, 0 },
1163 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1164 & ifmt_addbr, { 0x61 }
1166 /* orb $drb,$srb */
1168 { 0, 0, 0, 0 },
1169 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1170 & ifmt_addbr, { 0x71 }
1172 /* xorb $drb,$srb */
1174 { 0, 0, 0, 0 },
1175 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1176 & ifmt_addbr, { 0x51 }
1178 /* and $dr,$hash$uimm3 */
1180 { 0, 0, 0, 0 },
1181 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1182 & ifmt_addrhpof3, { 0x68 }
1184 /* or $dr,$hash$uimm3 */
1186 { 0, 0, 0, 0 },
1187 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1188 & ifmt_addrhpof3, { 0x78 }
1190 /* xor $dr,$hash$uimm3 */
1192 { 0, 0, 0, 0 },
1193 { { MNEM, ' ', OP (DR), ',', OP (HASH), OP (UIMM3), 0 } },
1194 & ifmt_addrhpof3, { 0x58 }
1196 /* andb $drb,$hash$uimm3 */
1198 { 0, 0, 0, 0 },
1199 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1200 & ifmt_addbrhpag3, { 0x69 }
1202 /* orb $drb,$hash$uimm3 */
1204 { 0, 0, 0, 0 },
1205 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1206 & ifmt_addbrhpag3, { 0x79 }
1208 /* xorb $drb,$hash$uimm3 */
1210 { 0, 0, 0, 0 },
1211 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
1212 & ifmt_addbrhpag3, { 0x59 }
1214 /* and $reg8,$hash$uimm16 */
1216 { 0, 0, 0, 0 },
1217 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1218 & ifmt_addrhpof, { 0x66 }
1220 /* or $reg8,$hash$uimm16 */
1222 { 0, 0, 0, 0 },
1223 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1224 & ifmt_addrhpof, { 0x76 }
1226 /* xor $reg8,$hash$uimm16 */
1228 { 0, 0, 0, 0 },
1229 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1230 & ifmt_addrhpof, { 0x56 }
1232 /* andb $regb8,$hash$uimm8 */
1234 { 0, 0, 0, 0 },
1235 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1236 & ifmt_addrbhpof, { 0x67 }
1238 /* orb $regb8,$hash$uimm8 */
1240 { 0, 0, 0, 0 },
1241 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1242 & ifmt_addrbhpof, { 0x77 }
1244 /* xorb $regb8,$hash$uimm8 */
1246 { 0, 0, 0, 0 },
1247 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1248 & ifmt_addrbhpof, { 0x57 }
1250 /* and $dr,[$sr2] */
1252 { 0, 0, 0, 0 },
1253 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1254 & ifmt_add2, { 0x868 }
1256 /* or $dr,[$sr2] */
1258 { 0, 0, 0, 0 },
1259 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1260 & ifmt_add2, { 0x878 }
1262 /* xor $dr,[$sr2] */
1264 { 0, 0, 0, 0 },
1265 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
1266 & ifmt_add2, { 0x858 }
1268 /* andb $drb,[$sr2] */
1270 { 0, 0, 0, 0 },
1271 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1272 & ifmt_addb2, { 0x869 }
1274 /* orb $drb,[$sr2] */
1276 { 0, 0, 0, 0 },
1277 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1278 & ifmt_addb2, { 0x879 }
1280 /* xorb $drb,[$sr2] */
1282 { 0, 0, 0, 0 },
1283 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
1284 & ifmt_addb2, { 0x859 }
1286 /* and $dr,[$sr2+] */
1288 { 0, 0, 0, 0 },
1289 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1290 & ifmt_add2, { 0xc68 }
1292 /* or $dr,[$sr2+] */
1294 { 0, 0, 0, 0 },
1295 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1296 & ifmt_add2, { 0xc78 }
1298 /* xor $dr,[$sr2+] */
1300 { 0, 0, 0, 0 },
1301 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
1302 & ifmt_add2, { 0xc58 }
1304 /* andb $drb,[$sr2+] */
1306 { 0, 0, 0, 0 },
1307 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1308 & ifmt_addb2, { 0xc69 }
1310 /* orb $drb,[$sr2+] */
1312 { 0, 0, 0, 0 },
1313 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1314 & ifmt_addb2, { 0xc79 }
1316 /* xorb $drb,[$sr2+] */
1318 { 0, 0, 0, 0 },
1319 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
1320 & ifmt_addb2, { 0xc59 }
1322 /* and $pof$reg8,$upof16 */
1324 { 0, 0, 0, 0 },
1325 { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1326 & ifmt_addrpof, { 0x62 }
1328 /* or $pof$reg8,$upof16 */
1330 { 0, 0, 0, 0 },
1331 { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1332 & ifmt_addrpof, { 0x72 }
1334 /* xor $pof$reg8,$upof16 */
1336 { 0, 0, 0, 0 },
1337 { { MNEM, ' ', OP (POF), OP (REG8), ',', OP (UPOF16), 0 } },
1338 & ifmt_addrpof, { 0x52 }
1340 /* andb $pof$regb8,$upof16 */
1342 { 0, 0, 0, 0 },
1343 { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1344 & ifmt_addbrpof, { 0x63 }
1346 /* orb $pof$regb8,$upof16 */
1348 { 0, 0, 0, 0 },
1349 { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1350 & ifmt_addbrpof, { 0x73 }
1352 /* xorb $pof$regb8,$upof16 */
1354 { 0, 0, 0, 0 },
1355 { { MNEM, ' ', OP (POF), OP (REGB8), ',', OP (UPOF16), 0 } },
1356 & ifmt_addbrpof, { 0x53 }
1358 /* and $pof$upof16,$reg8 */
1360 { 0, 0, 0, 0 },
1361 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1362 & ifmt_addrpof, { 0x64 }
1364 /* or $pof$upof16,$reg8 */
1366 { 0, 0, 0, 0 },
1367 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1368 & ifmt_addrpof, { 0x74 }
1370 /* xor $pof$upof16,$reg8 */
1372 { 0, 0, 0, 0 },
1373 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REG8), 0 } },
1374 & ifmt_addrpof, { 0x54 }
1376 /* andb $pof$upof16,$regb8 */
1378 { 0, 0, 0, 0 },
1379 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1380 & ifmt_addbrpof, { 0x65 }
1382 /* orb $pof$upof16,$regb8 */
1384 { 0, 0, 0, 0 },
1385 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1386 & ifmt_addbrpof, { 0x75 }
1388 /* xorb $pof$upof16,$regb8 */
1390 { 0, 0, 0, 0 },
1391 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1392 & ifmt_addbrpof, { 0x55 }
1394 /* and $regmem8,$memgr8 */
1396 { 0, 0, 0, 0 },
1397 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1398 & ifmt_addrm2, { 0x62 }
1400 /* and $memgr8,$regmem8 */
1402 { 0, 0, 0, 0 },
1403 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1404 & ifmt_addrm2, { 0x64 }
1406 /* and $reg8,$memory */
1408 { 0, 0, 0, 0 },
1409 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1410 & ifmt_addrm, { 0x62 }
1412 /* and $memory,$reg8 */
1414 { 0, 0, 0, 0 },
1415 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1416 & ifmt_addrm, { 0x64 }
1418 /* or $regmem8,$memgr8 */
1420 { 0, 0, 0, 0 },
1421 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1422 & ifmt_addrm2, { 0x72 }
1424 /* or $memgr8,$regmem8 */
1426 { 0, 0, 0, 0 },
1427 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1428 & ifmt_addrm2, { 0x74 }
1430 /* or $reg8,$memory */
1432 { 0, 0, 0, 0 },
1433 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1434 & ifmt_addrm, { 0x72 }
1436 /* or $memory,$reg8 */
1438 { 0, 0, 0, 0 },
1439 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1440 & ifmt_addrm, { 0x74 }
1442 /* xor $regmem8,$memgr8 */
1444 { 0, 0, 0, 0 },
1445 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1446 & ifmt_addrm2, { 0x52 }
1448 /* xor $memgr8,$regmem8 */
1450 { 0, 0, 0, 0 },
1451 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1452 & ifmt_addrm2, { 0x54 }
1454 /* xor $reg8,$memory */
1456 { 0, 0, 0, 0 },
1457 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1458 & ifmt_addrm, { 0x52 }
1460 /* xor $memory,$reg8 */
1462 { 0, 0, 0, 0 },
1463 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1464 & ifmt_addrm, { 0x54 }
1466 /* andb $regbmem8,$memgr8 */
1468 { 0, 0, 0, 0 },
1469 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1470 & ifmt_addbrm2, { 0x63 }
1472 /* andb $memgr8,$regbmem8 */
1474 { 0, 0, 0, 0 },
1475 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1476 & ifmt_addbrm2, { 0x65 }
1478 /* andb $regb8,$memory */
1480 { 0, 0, 0, 0 },
1481 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1482 & ifmt_addbrm, { 0x63 }
1484 /* andb $memory,$regb8 */
1486 { 0, 0, 0, 0 },
1487 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1488 & ifmt_addbrm, { 0x65 }
1490 /* orb $regbmem8,$memgr8 */
1492 { 0, 0, 0, 0 },
1493 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1494 & ifmt_addbrm2, { 0x73 }
1496 /* orb $memgr8,$regbmem8 */
1498 { 0, 0, 0, 0 },
1499 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1500 & ifmt_addbrm2, { 0x75 }
1502 /* orb $regb8,$memory */
1504 { 0, 0, 0, 0 },
1505 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1506 & ifmt_addbrm, { 0x73 }
1508 /* orb $memory,$regb8 */
1510 { 0, 0, 0, 0 },
1511 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1512 & ifmt_addbrm, { 0x75 }
1514 /* xorb $regbmem8,$memgr8 */
1516 { 0, 0, 0, 0 },
1517 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1518 & ifmt_addbrm2, { 0x53 }
1520 /* xorb $memgr8,$regbmem8 */
1522 { 0, 0, 0, 0 },
1523 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1524 & ifmt_addbrm2, { 0x55 }
1526 /* xorb $regb8,$memory */
1528 { 0, 0, 0, 0 },
1529 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1530 & ifmt_addbrm, { 0x53 }
1532 /* xorb $memory,$regb8 */
1534 { 0, 0, 0, 0 },
1535 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1536 & ifmt_addbrm, { 0x55 }
1538 /* mov $dr,$sr */
1540 { 0, 0, 0, 0 },
1541 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
1542 & ifmt_addr, { 0xf0 }
1544 /* movb $drb,$srb */
1546 { 0, 0, 0, 0 },
1547 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
1548 & ifmt_addbr, { 0xf1 }
1550 /* mov $dri,$hash$u4 */
1552 { 0, 0, 0, 0 },
1553 { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (U4), 0 } },
1554 & ifmt_movri, { 0xe0 }
1556 /* movb $srb,$hash$u4 */
1558 { 0, 0, 0, 0 },
1559 { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (U4), 0 } },
1560 & ifmt_movbri, { 0xe1 }
1562 /* mov $reg8,$hash$uimm16 */
1564 { 0, 0, 0, 0 },
1565 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
1566 & ifmt_addrhpof, { 0xe6 }
1568 /* movb $regb8,$hash$uimm8 */
1570 { 0, 0, 0, 0 },
1571 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
1572 & ifmt_addrbhpof, { 0xe7 }
1574 /* mov $dr,[$sr] */
1576 { 0, 0, 0, 0 },
1577 { { MNEM, ' ', OP (DR), ',', '[', OP (SR), ']', 0 } },
1578 & ifmt_addr, { 0xa8 }
1580 /* movb $drb,[$sr] */
1582 { 0, 0, 0, 0 },
1583 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), ']', 0 } },
1584 & ifmt_movbr2, { 0xa9 }
1586 /* mov [$sr],$dr */
1588 { 0, 0, 0, 0 },
1589 { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DR), 0 } },
1590 & ifmt_addr, { 0xb8 }
1592 /* movb [$sr],$drb */
1594 { 0, 0, 0, 0 },
1595 { { MNEM, ' ', '[', OP (SR), ']', ',', OP (DRB), 0 } },
1596 & ifmt_movbr2, { 0xb9 }
1598 /* mov [-$sr],$dr */
1600 { 0, 0, 0, 0 },
1601 { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DR), 0 } },
1602 & ifmt_addr, { 0x88 }
1604 /* movb [-$sr],$drb */
1606 { 0, 0, 0, 0 },
1607 { { MNEM, ' ', '[', '-', OP (SR), ']', ',', OP (DRB), 0 } },
1608 & ifmt_movbr2, { 0x89 }
1610 /* mov $dr,[$sr+] */
1612 { 0, 0, 0, 0 },
1613 { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', ']', 0 } },
1614 & ifmt_addr, { 0x98 }
1616 /* movb $drb,[$sr+] */
1618 { 0, 0, 0, 0 },
1619 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', ']', 0 } },
1620 & ifmt_movbr2, { 0x99 }
1622 /* mov [$dr],[$sr] */
1624 { 0, 0, 0, 0 },
1625 { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
1626 & ifmt_addr, { 0xc8 }
1628 /* movb [$dr],[$sr] */
1630 { 0, 0, 0, 0 },
1631 { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), ']', 0 } },
1632 & ifmt_addr, { 0xc9 }
1634 /* mov [$dr+],[$sr] */
1636 { 0, 0, 0, 0 },
1637 { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
1638 & ifmt_addr, { 0xd8 }
1640 /* movb [$dr+],[$sr] */
1642 { 0, 0, 0, 0 },
1643 { { MNEM, ' ', '[', OP (DR), '+', ']', ',', '[', OP (SR), ']', 0 } },
1644 & ifmt_addr, { 0xd9 }
1646 /* mov [$dr],[$sr+] */
1648 { 0, 0, 0, 0 },
1649 { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
1650 & ifmt_addr, { 0xe8 }
1652 /* movb [$dr],[$sr+] */
1654 { 0, 0, 0, 0 },
1655 { { MNEM, ' ', '[', OP (DR), ']', ',', '[', OP (SR), '+', ']', 0 } },
1656 & ifmt_addr, { 0xe9 }
1658 /* mov $dr,[$sr+$hash$uimm16] */
1660 { 0, 0, 0, 0 },
1661 { { MNEM, ' ', OP (DR), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
1662 & ifmt_mov9i, { 0xd4 }
1664 /* movb $drb,[$sr+$hash$uimm16] */
1666 { 0, 0, 0, 0 },
1667 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', 0 } },
1668 & ifmt_movb9i, { 0xf4 }
1670 /* mov [$sr+$hash$uimm16],$dr */
1672 { 0, 0, 0, 0 },
1673 { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DR), 0 } },
1674 & ifmt_mov9i, { 0xc4 }
1676 /* movb [$sr+$hash$uimm16],$drb */
1678 { 0, 0, 0, 0 },
1679 { { MNEM, ' ', '[', OP (SR), '+', OP (HASH), OP (UIMM16), ']', ',', OP (DRB), 0 } },
1680 & ifmt_movb9i, { 0xe4 }
1682 /* mov [$src2],$memory */
1684 { 0, 0, 0, 0 },
1685 { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
1686 & ifmt_movri11, { 0x84 }
1688 /* movb [$src2],$memory */
1690 { 0, 0, 0, 0 },
1691 { { MNEM, ' ', '[', OP (SRC2), ']', ',', OP (MEMORY), 0 } },
1692 & ifmt_movri11, { 0xa4 }
1694 /* mov $memory,[$src2] */
1696 { 0, 0, 0, 0 },
1697 { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
1698 & ifmt_movri11, { 0x94 }
1700 /* movb $memory,[$src2] */
1702 { 0, 0, 0, 0 },
1703 { { MNEM, ' ', OP (MEMORY), ',', '[', OP (SRC2), ']', 0 } },
1704 & ifmt_movri11, { 0xb4 }
1706 /* mov $regoff8,$hash$pof$upof16 */
1708 { 0, 0, 0, 0 },
1709 { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (POF), OP (UPOF16), 0 } },
1710 & ifmt_movehm5, { 0xe6 }
1712 /* mov $regoff8,$hash$pag$upag16 */
1714 { 0, 0, 0, 0 },
1715 { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UPAG16), 0 } },
1716 & ifmt_movehm6, { 0xe6 }
1718 /* mov $regoff8,$hash$segm$useg16 */
1720 { 0, 0, 0, 0 },
1721 { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SEGM), OP (USEG16), 0 } },
1722 & ifmt_movehm7, { 0xe6 }
1724 /* mov $regoff8,$hash$sof$usof16 */
1726 { 0, 0, 0, 0 },
1727 { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
1728 & ifmt_movehm8, { 0xe6 }
1730 /* movb $regb8,$hash$pof$uimm8 */
1732 { 0, 0, 0, 0 },
1733 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (POF), OP (UIMM8), 0 } },
1734 & ifmt_addrbhpof, { 0xe7 }
1736 /* movb $regoff8,$hash$pag$uimm8 */
1738 { 0, 0, 0, 0 },
1739 { { MNEM, ' ', OP (REGOFF8), ',', OP (HASH), OP (PAG), OP (UIMM8), 0 } },
1740 & ifmt_movehm10, { 0xe7 }
1742 /* mov $regoff8,$pof$upof16 */
1744 { 0, 0, 0, 0 },
1745 { { MNEM, ' ', OP (REGOFF8), ',', OP (POF), OP (UPOF16), 0 } },
1746 & ifmt_movehm5, { 0xf2 }
1748 /* movb $regb8,$pof$upof16 */
1750 { 0, 0, 0, 0 },
1751 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
1752 & ifmt_addbrpof, { 0xf3 }
1754 /* mov $regoff8,$pag$upag16 */
1756 { 0, 0, 0, 0 },
1757 { { MNEM, ' ', OP (REGOFF8), ',', OP (PAG), OP (UPAG16), 0 } },
1758 & ifmt_movehm6, { 0xf2 }
1760 /* movb $regb8,$pag$upag16 */
1762 { 0, 0, 0, 0 },
1763 { { MNEM, ' ', OP (REGB8), ',', OP (PAG), OP (UPAG16), 0 } },
1764 & ifmt_addbrpag, { 0xf3 }
1766 /* mov $pof$upof16,$regoff8 */
1768 { 0, 0, 0, 0 },
1769 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGOFF8), 0 } },
1770 & ifmt_movehm5, { 0xf6 }
1772 /* movb $pof$upof16,$regb8 */
1774 { 0, 0, 0, 0 },
1775 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1776 & ifmt_addbrpof, { 0xf7 }
1778 /* mov $dri,$hash$pof$u4 */
1780 { 0, 0, 0, 0 },
1781 { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (POF), OP (U4), 0 } },
1782 & ifmt_movri, { 0xe0 }
1784 /* movb $srb,$hash$pof$u4 */
1786 { 0, 0, 0, 0 },
1787 { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (POF), OP (U4), 0 } },
1788 & ifmt_movbri, { 0xe1 }
1790 /* mov $dri,$hash$pag$u4 */
1792 { 0, 0, 0, 0 },
1793 { { MNEM, ' ', OP (DRI), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
1794 & ifmt_movri, { 0xe0 }
1796 /* movb $srb,$hash$pag$u4 */
1798 { 0, 0, 0, 0 },
1799 { { MNEM, ' ', OP (SRB), ',', OP (HASH), OP (PAG), OP (U4), 0 } },
1800 & ifmt_movbri, { 0xe1 }
1802 /* mov $regmem8,$memgr8 */
1804 { 0, 0, 0, 0 },
1805 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1806 & ifmt_addrm2, { 0xf2 }
1808 /* mov $memgr8,$regmem8 */
1810 { 0, 0, 0, 0 },
1811 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGMEM8), 0 } },
1812 & ifmt_addrm2, { 0xf6 }
1814 /* mov $reg8,$memory */
1816 { 0, 0, 0, 0 },
1817 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1818 & ifmt_addrm, { 0xf2 }
1820 /* mov $memory,$reg8 */
1822 { 0, 0, 0, 0 },
1823 { { MNEM, ' ', OP (MEMORY), ',', OP (REG8), 0 } },
1824 & ifmt_addrm, { 0xf6 }
1826 /* movb $regbmem8,$memgr8 */
1828 { 0, 0, 0, 0 },
1829 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
1830 & ifmt_addbrm2, { 0xf3 }
1832 /* movb $memgr8,$regbmem8 */
1834 { 0, 0, 0, 0 },
1835 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1836 & ifmt_addbrm2, { 0xf7 }
1838 /* movb $regb8,$memory */
1840 { 0, 0, 0, 0 },
1841 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
1842 & ifmt_addbrm, { 0xf3 }
1844 /* movb $memory,$regb8 */
1846 { 0, 0, 0, 0 },
1847 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1848 & ifmt_addbrm, { 0xf7 }
1850 /* movbs $sr,$drb */
1852 { 0, 0, 0, 0 },
1853 { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1854 & ifmt_movbr2, { 0xd0 }
1856 /* movbz $sr,$drb */
1858 { 0, 0, 0, 0 },
1859 { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1860 & ifmt_movbr2, { 0xc0 }
1862 /* movbs $regmem8,$pof$upof16 */
1864 { 0, 0, 0, 0 },
1865 { { MNEM, ' ', OP (REGMEM8), ',', OP (POF), OP (UPOF16), 0 } },
1866 & ifmt_movbsrpofm, { 0xd2 }
1868 /* movbs $pof$upof16,$regbmem8 */
1870 { 0, 0, 0, 0 },
1871 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGBMEM8), 0 } },
1872 & ifmt_movbspofmr, { 0xd5 }
1874 /* movbz $reg8,$pof$upof16 */
1876 { 0, 0, 0, 0 },
1877 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
1878 & ifmt_addrpof, { 0xc2 }
1880 /* movbz $pof$upof16,$regb8 */
1882 { 0, 0, 0, 0 },
1883 { { MNEM, ' ', OP (POF), OP (UPOF16), ',', OP (REGB8), 0 } },
1884 & ifmt_addbrpof, { 0xc5 }
1886 /* movbs $regmem8,$memgr8 */
1888 { 0, 0, 0, 0 },
1889 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1890 & ifmt_addrm2, { 0xd2 }
1892 /* movbs $memgr8,$regbmem8 */
1894 { 0, 0, 0, 0 },
1895 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1896 & ifmt_addbrm2, { 0xd5 }
1898 /* movbs $reg8,$memory */
1900 { 0, 0, 0, 0 },
1901 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1902 & ifmt_addrm, { 0xd2 }
1904 /* movbs $memory,$regb8 */
1906 { 0, 0, 0, 0 },
1907 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1908 & ifmt_addbrm, { 0xd5 }
1910 /* movbz $regmem8,$memgr8 */
1912 { 0, 0, 0, 0 },
1913 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
1914 & ifmt_addrm2, { 0xc2 }
1916 /* movbz $memgr8,$regbmem8 */
1918 { 0, 0, 0, 0 },
1919 { { MNEM, ' ', OP (MEMGR8), ',', OP (REGBMEM8), 0 } },
1920 & ifmt_addbrm2, { 0xc5 }
1922 /* movbz $reg8,$memory */
1924 { 0, 0, 0, 0 },
1925 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
1926 & ifmt_addrm, { 0xc2 }
1928 /* movbz $memory,$regb8 */
1930 { 0, 0, 0, 0 },
1931 { { MNEM, ' ', OP (MEMORY), ',', OP (REGB8), 0 } },
1932 & ifmt_addbrm, { 0xc5 }
1934 /* movbs $sr,$drb */
1936 { 0, 0, 0, 0 },
1937 { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1938 & ifmt_movbr2, { 0xd0 }
1940 /* movbz $sr,$drb */
1942 { 0, 0, 0, 0 },
1943 { { MNEM, ' ', OP (SR), ',', OP (DRB), 0 } },
1944 & ifmt_movbr2, { 0xc0 }
1946 /* jmpa+ $extcond,$caddr */
1948 { 0, 0, 0, 0 },
1949 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1950 & ifmt_jmpa0, { 0xea }
1952 /* jmpa $extcond,$caddr */
1954 { 0, 0, 0, 0 },
1955 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1956 & ifmt_jmpa0, { 0xea }
1958 /* jmpa- $extcond,$caddr */
1960 { 0, 0, 0, 0 },
1961 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
1962 & ifmt_jmpa_, { 0x1ea }
1964 /* jmpi $icond,[$sr] */
1966 { 0, 0, 0, 0 },
1967 { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
1968 & ifmt_jmpi, { 0x9c }
1970 /* jmpr $cond,$rel */
1972 { 0, 0, 0, 0 },
1973 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1974 & ifmt_jmpr_nenz, { 0x3d }
1976 /* jmpr $cond,$rel */
1978 { 0, 0, 0, 0 },
1979 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1980 & ifmt_jmpr_nenz, { 0xad }
1982 /* jmpr $cond,$rel */
1984 { 0, 0, 0, 0 },
1985 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1986 & ifmt_jmpr_nenz, { 0x2d }
1988 /* jmpr $cond,$rel */
1990 { 0, 0, 0, 0 },
1991 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1992 & ifmt_jmpr_nenz, { 0x4d }
1994 /* jmpr $cond,$rel */
1996 { 0, 0, 0, 0 },
1997 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
1998 & ifmt_jmpr_nenz, { 0x5d }
2000 /* jmpr $cond,$rel */
2002 { 0, 0, 0, 0 },
2003 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2004 & ifmt_jmpr_nenz, { 0x6d }
2006 /* jmpr $cond,$rel */
2008 { 0, 0, 0, 0 },
2009 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2010 & ifmt_jmpr_nenz, { 0x7d }
2012 /* jmpr $cond,$rel */
2014 { 0, 0, 0, 0 },
2015 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2016 & ifmt_jmpr_nenz, { 0x8d }
2018 /* jmpr $cond,$rel */
2020 { 0, 0, 0, 0 },
2021 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2022 & ifmt_jmpr_nenz, { 0x9d }
2024 /* jmpr $cond,$rel */
2026 { 0, 0, 0, 0 },
2027 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2028 & ifmt_jmpr_nenz, { 0x2d }
2030 /* jmpr $cond,$rel */
2032 { 0, 0, 0, 0 },
2033 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2034 & ifmt_jmpr_nenz, { 0x3d }
2036 /* jmpr $cond,$rel */
2038 { 0, 0, 0, 0 },
2039 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2040 & ifmt_jmpr_nenz, { 0x8d }
2042 /* jmpr $cond,$rel */
2044 { 0, 0, 0, 0 },
2045 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2046 & ifmt_jmpr_nenz, { 0xfd }
2048 /* jmpr $cond,$rel */
2050 { 0, 0, 0, 0 },
2051 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2052 & ifmt_jmpr_nenz, { 0x9d }
2054 /* jmpr $cond,$rel */
2056 { 0, 0, 0, 0 },
2057 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2058 & ifmt_jmpr_nenz, { 0xed }
2060 /* jmpr $cond,$rel */
2062 { 0, 0, 0, 0 },
2063 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2064 & ifmt_jmpr_nenz, { 0xbd }
2066 /* jmpr $cond,$rel */
2068 { 0, 0, 0, 0 },
2069 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2070 & ifmt_jmpr_nenz, { 0xdd }
2072 /* jmpr $cond,$rel */
2074 { 0, 0, 0, 0 },
2075 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2076 & ifmt_jmpr_nenz, { 0x1d }
2078 /* jmpr $cond,$rel */
2080 { 0, 0, 0, 0 },
2081 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2082 & ifmt_jmpr_nenz, { 0xd }
2084 /* jmpr $cond,$rel */
2086 { 0, 0, 0, 0 },
2087 { { MNEM, ' ', OP (COND), ',', OP (REL), 0 } },
2088 & ifmt_jmpr_nenz, { 0xcd }
2090 /* jmps $hash$segm$useg8,$hash$sof$usof16 */
2092 { 0, 0, 0, 0 },
2093 { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
2094 & ifmt_jmpseg, { 0xfa }
2096 /* jmps $seg,$caddr */
2098 { 0, 0, 0, 0 },
2099 { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
2100 & ifmt_jmps, { 0xfa }
2102 /* jb $genreg$dot$qlobit,$relhi */
2104 { 0, 0, 0, 0 },
2105 { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2106 & ifmt_jb, { 0x8a }
2108 /* jbc $genreg$dot$qlobit,$relhi */
2110 { 0, 0, 0, 0 },
2111 { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2112 & ifmt_jb, { 0xaa }
2114 /* jnb $genreg$dot$qlobit,$relhi */
2116 { 0, 0, 0, 0 },
2117 { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2118 & ifmt_jb, { 0x9a }
2120 /* jnbs $genreg$dot$qlobit,$relhi */
2122 { 0, 0, 0, 0 },
2123 { { MNEM, ' ', OP (GENREG), OP (DOT), OP (QLOBIT), ',', OP (RELHI), 0 } },
2124 & ifmt_jb, { 0xba }
2126 /* calla+ $extcond,$caddr */
2128 { 0, 0, 0, 0 },
2129 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2130 & ifmt_calla0, { 0xca }
2132 /* calla $extcond,$caddr */
2134 { 0, 0, 0, 0 },
2135 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2136 & ifmt_calla0, { 0xca }
2138 /* calla- $extcond,$caddr */
2140 { 0, 0, 0, 0 },
2141 { { MNEM, ' ', OP (EXTCOND), ',', OP (CADDR), 0 } },
2142 & ifmt_calla_, { 0x1ca }
2144 /* calli $icond,[$sr] */
2146 { 0, 0, 0, 0 },
2147 { { MNEM, ' ', OP (ICOND), ',', '[', OP (SR), ']', 0 } },
2148 & ifmt_jmpi, { 0xab }
2150 /* callr $rel */
2152 { 0, 0, 0, 0 },
2153 { { MNEM, ' ', OP (REL), 0 } },
2154 & ifmt_callr, { 0xbb }
2156 /* calls $hash$segm$useg8,$hash$sof$usof16 */
2158 { 0, 0, 0, 0 },
2159 { { MNEM, ' ', OP (HASH), OP (SEGM), OP (USEG8), ',', OP (HASH), OP (SOF), OP (USOF16), 0 } },
2160 & ifmt_callseg, { 0xda }
2162 /* calls $seg,$caddr */
2164 { 0, 0, 0, 0 },
2165 { { MNEM, ' ', OP (SEG), ',', OP (CADDR), 0 } },
2166 & ifmt_jmps, { 0xda }
2168 /* pcall $reg8,$caddr */
2170 { 0, 0, 0, 0 },
2171 { { MNEM, ' ', OP (REG8), ',', OP (CADDR), 0 } },
2172 & ifmt_pcall, { 0xe2 }
2174 /* trap $hash$uimm7 */
2176 { 0, 0, 0, 0 },
2177 { { MNEM, ' ', OP (HASH), OP (UIMM7), 0 } },
2178 & ifmt_trap, { 0x9b }
2180 /* ret */
2182 { 0, 0, 0, 0 },
2183 { { MNEM, 0 } },
2184 & ifmt_ret, { 0xcb }
2186 /* rets */
2188 { 0, 0, 0, 0 },
2189 { { MNEM, 0 } },
2190 & ifmt_ret, { 0xdb }
2192 /* retp $reg8 */
2194 { 0, 0, 0, 0 },
2195 { { MNEM, ' ', OP (REG8), 0 } },
2196 & ifmt_retp, { 0xeb }
2198 /* reti */
2200 { 0, 0, 0, 0 },
2201 { { MNEM, 0 } },
2202 & ifmt_reti, { 0x88fb }
2204 /* pop $reg8 */
2206 { 0, 0, 0, 0 },
2207 { { MNEM, ' ', OP (REG8), 0 } },
2208 & ifmt_retp, { 0xfc }
2210 /* push $reg8 */
2212 { 0, 0, 0, 0 },
2213 { { MNEM, ' ', OP (REG8), 0 } },
2214 & ifmt_retp, { 0xec }
2216 /* scxt $reg8,$hash$uimm16 */
2218 { 0, 0, 0, 0 },
2219 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2220 & ifmt_addrhpof, { 0xc6 }
2222 /* scxt $reg8,$pof$upof16 */
2224 { 0, 0, 0, 0 },
2225 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2226 & ifmt_addrpof, { 0xd6 }
2228 /* scxt $regmem8,$memgr8 */
2230 { 0, 0, 0, 0 },
2231 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2232 & ifmt_addrm2, { 0xd6 }
2234 /* scxt $reg8,$memory */
2236 { 0, 0, 0, 0 },
2237 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2238 & ifmt_addrm, { 0xd6 }
2240 /* nop */
2242 { 0, 0, 0, 0 },
2243 { { MNEM, 0 } },
2244 & ifmt_ret, { 0xcc }
2246 /* srst */
2248 { 0, 0, 0, 0 },
2249 { { MNEM, 0 } },
2250 & ifmt_srstm, { 0xb7b748b7 }
2252 /* idle */
2254 { 0, 0, 0, 0 },
2255 { { MNEM, 0 } },
2256 & ifmt_srstm, { 0x87877887 }
2258 /* pwrdn */
2260 { 0, 0, 0, 0 },
2261 { { MNEM, 0 } },
2262 & ifmt_srstm, { 0x97976897 }
2264 /* diswdt */
2266 { 0, 0, 0, 0 },
2267 { { MNEM, 0 } },
2268 & ifmt_srstm, { 0xa5a55aa5 }
2270 /* enwdt */
2272 { 0, 0, 0, 0 },
2273 { { MNEM, 0 } },
2274 & ifmt_srstm, { 0x85857a85 }
2276 /* einit */
2278 { 0, 0, 0, 0 },
2279 { { MNEM, 0 } },
2280 & ifmt_srstm, { 0xb5b54ab5 }
2282 /* srvwdt */
2284 { 0, 0, 0, 0 },
2285 { { MNEM, 0 } },
2286 & ifmt_srstm, { 0xa7a758a7 }
2288 /* sbrk */
2290 { 0, 0, 0, 0 },
2291 { { MNEM, 0 } },
2292 & ifmt_ret, { 0x8c }
2294 /* atomic $hash$uimm2 */
2296 { 0, 0, 0, 0 },
2297 { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
2298 & ifmt_atomic, { 0xd1 }
2300 /* extr $hash$uimm2 */
2302 { 0, 0, 0, 0 },
2303 { { MNEM, ' ', OP (HASH), OP (UIMM2), 0 } },
2304 & ifmt_atomic, { 0x80d1 }
2306 /* extp $sr,$hash$uimm2 */
2308 { 0, 0, 0, 0 },
2309 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2310 & ifmt_extp, { 0x40dc }
2312 /* extp $hash$pagenum,$hash$uimm2 */
2314 { 0, 0, 0, 0 },
2315 { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
2316 & ifmt_extp1, { 0x40d7 }
2318 /* extp $hash$pag$upag16,$hash$uimm2 */
2320 { 0, 0, 0, 0 },
2321 { { MNEM, ' ', OP (HASH), OP (PAG), OP (UPAG16), ',', OP (HASH), OP (UIMM2), 0 } },
2322 & ifmt_extpg1, { 0x40d7 }
2324 /* extpr $sr,$hash$uimm2 */
2326 { 0, 0, 0, 0 },
2327 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2328 & ifmt_extp, { 0xc0dc }
2330 /* extpr $hash$pagenum,$hash$uimm2 */
2332 { 0, 0, 0, 0 },
2333 { { MNEM, ' ', OP (HASH), OP (PAGENUM), ',', OP (HASH), OP (UIMM2), 0 } },
2334 & ifmt_extp1, { 0xc0d7 }
2336 /* exts $sr,$hash$uimm2 */
2338 { 0, 0, 0, 0 },
2339 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2340 & ifmt_extp, { 0xdc }
2342 /* exts $hash$seghi8,$hash$uimm2 */
2344 { 0, 0, 0, 0 },
2345 { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
2346 & ifmt_exts1, { 0xd7 }
2348 /* extsr $sr,$hash$uimm2 */
2350 { 0, 0, 0, 0 },
2351 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM2), 0 } },
2352 & ifmt_extp, { 0x80dc }
2354 /* extsr $hash$seghi8,$hash$uimm2 */
2356 { 0, 0, 0, 0 },
2357 { { MNEM, ' ', OP (HASH), OP (SEGHI8), ',', OP (HASH), OP (UIMM2), 0 } },
2358 & ifmt_exts1, { 0x80d7 }
2360 /* prior $dr,$sr */
2362 { 0, 0, 0, 0 },
2363 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2364 & ifmt_addr, { 0x2b }
2366 /* bclr $RegNam */
2368 { 0, 0, 0, 0 },
2369 { { MNEM, ' ', OP (REGNAM), 0 } },
2370 & ifmt_bclr18, { 0xbe }
2372 /* bclr $reg8$dot$qbit */
2374 { 0, 0, 0, 0 },
2375 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2376 & ifmt_bclr0, { 0xe }
2378 /* bclr $reg8$dot$qbit */
2380 { 0, 0, 0, 0 },
2381 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2382 & ifmt_bclr0, { 0x1e }
2384 /* bclr $reg8$dot$qbit */
2386 { 0, 0, 0, 0 },
2387 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2388 & ifmt_bclr0, { 0x2e }
2390 /* bclr $reg8$dot$qbit */
2392 { 0, 0, 0, 0 },
2393 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2394 & ifmt_bclr0, { 0x3e }
2396 /* bclr $reg8$dot$qbit */
2398 { 0, 0, 0, 0 },
2399 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2400 & ifmt_bclr0, { 0x4e }
2402 /* bclr $reg8$dot$qbit */
2404 { 0, 0, 0, 0 },
2405 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2406 & ifmt_bclr0, { 0x5e }
2408 /* bclr $reg8$dot$qbit */
2410 { 0, 0, 0, 0 },
2411 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2412 & ifmt_bclr0, { 0x6e }
2414 /* bclr $reg8$dot$qbit */
2416 { 0, 0, 0, 0 },
2417 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2418 & ifmt_bclr0, { 0x7e }
2420 /* bclr $reg8$dot$qbit */
2422 { 0, 0, 0, 0 },
2423 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2424 & ifmt_bclr0, { 0x8e }
2426 /* bclr $reg8$dot$qbit */
2428 { 0, 0, 0, 0 },
2429 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2430 & ifmt_bclr0, { 0x9e }
2432 /* bclr $reg8$dot$qbit */
2434 { 0, 0, 0, 0 },
2435 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2436 & ifmt_bclr0, { 0xae }
2438 /* bclr $reg8$dot$qbit */
2440 { 0, 0, 0, 0 },
2441 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2442 & ifmt_bclr0, { 0xbe }
2444 /* bclr $reg8$dot$qbit */
2446 { 0, 0, 0, 0 },
2447 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2448 & ifmt_bclr0, { 0xce }
2450 /* bclr $reg8$dot$qbit */
2452 { 0, 0, 0, 0 },
2453 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2454 & ifmt_bclr0, { 0xde }
2456 /* bclr $reg8$dot$qbit */
2458 { 0, 0, 0, 0 },
2459 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2460 & ifmt_bclr0, { 0xee }
2462 /* bclr $reg8$dot$qbit */
2464 { 0, 0, 0, 0 },
2465 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2466 & ifmt_bclr0, { 0xfe }
2468 /* bset $RegNam */
2470 { 0, 0, 0, 0 },
2471 { { MNEM, ' ', OP (REGNAM), 0 } },
2472 & ifmt_bclr18, { 0xbf }
2474 /* bset $reg8$dot$qbit */
2476 { 0, 0, 0, 0 },
2477 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2478 & ifmt_bclr0, { 0xf }
2480 /* bset $reg8$dot$qbit */
2482 { 0, 0, 0, 0 },
2483 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2484 & ifmt_bclr0, { 0x1f }
2486 /* bset $reg8$dot$qbit */
2488 { 0, 0, 0, 0 },
2489 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2490 & ifmt_bclr0, { 0x2f }
2492 /* bset $reg8$dot$qbit */
2494 { 0, 0, 0, 0 },
2495 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2496 & ifmt_bclr0, { 0x3f }
2498 /* bset $reg8$dot$qbit */
2500 { 0, 0, 0, 0 },
2501 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2502 & ifmt_bclr0, { 0x4f }
2504 /* bset $reg8$dot$qbit */
2506 { 0, 0, 0, 0 },
2507 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2508 & ifmt_bclr0, { 0x5f }
2510 /* bset $reg8$dot$qbit */
2512 { 0, 0, 0, 0 },
2513 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2514 & ifmt_bclr0, { 0x6f }
2516 /* bset $reg8$dot$qbit */
2518 { 0, 0, 0, 0 },
2519 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2520 & ifmt_bclr0, { 0x7f }
2522 /* bset $reg8$dot$qbit */
2524 { 0, 0, 0, 0 },
2525 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2526 & ifmt_bclr0, { 0x8f }
2528 /* bset $reg8$dot$qbit */
2530 { 0, 0, 0, 0 },
2531 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2532 & ifmt_bclr0, { 0x9f }
2534 /* bset $reg8$dot$qbit */
2536 { 0, 0, 0, 0 },
2537 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2538 & ifmt_bclr0, { 0xaf }
2540 /* bset $reg8$dot$qbit */
2542 { 0, 0, 0, 0 },
2543 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2544 & ifmt_bclr0, { 0xbf }
2546 /* bset $reg8$dot$qbit */
2548 { 0, 0, 0, 0 },
2549 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2550 & ifmt_bclr0, { 0xcf }
2552 /* bset $reg8$dot$qbit */
2554 { 0, 0, 0, 0 },
2555 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2556 & ifmt_bclr0, { 0xdf }
2558 /* bset $reg8$dot$qbit */
2560 { 0, 0, 0, 0 },
2561 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2562 & ifmt_bclr0, { 0xef }
2564 /* bset $reg8$dot$qbit */
2566 { 0, 0, 0, 0 },
2567 { { MNEM, ' ', OP (REG8), OP (DOT), OP (QBIT), 0 } },
2568 & ifmt_bclr0, { 0xff }
2570 /* bmov $reghi8$dot$qhibit,$reg8$dot$qlobit */
2572 { 0, 0, 0, 0 },
2573 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2574 & ifmt_bmov, { 0x4a }
2576 /* bmovn $reghi8$dot$qhibit,$reg8$dot$qlobit */
2578 { 0, 0, 0, 0 },
2579 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2580 & ifmt_bmov, { 0x3a }
2582 /* band $reghi8$dot$qhibit,$reg8$dot$qlobit */
2584 { 0, 0, 0, 0 },
2585 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2586 & ifmt_bmov, { 0x6a }
2588 /* bor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2590 { 0, 0, 0, 0 },
2591 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2592 & ifmt_bmov, { 0x5a }
2594 /* bxor $reghi8$dot$qhibit,$reg8$dot$qlobit */
2596 { 0, 0, 0, 0 },
2597 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2598 & ifmt_bmov, { 0x7a }
2600 /* bcmp $reghi8$dot$qhibit,$reg8$dot$qlobit */
2602 { 0, 0, 0, 0 },
2603 { { MNEM, ' ', OP (REGHI8), OP (DOT), OP (QHIBIT), ',', OP (REG8), OP (DOT), OP (QLOBIT), 0 } },
2604 & ifmt_bmov, { 0x2a }
2606 /* bfldl $reg8,$hash$mask8,$hash$datahi8 */
2608 { 0, 0, 0, 0 },
2609 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASK8), ',', OP (HASH), OP (DATAHI8), 0 } },
2610 & ifmt_bfldl, { 0xa }
2612 /* bfldh $reg8,$hash$masklo8,$hash$data8 */
2614 { 0, 0, 0, 0 },
2615 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (MASKLO8), ',', OP (HASH), OP (DATA8), 0 } },
2616 & ifmt_bfldh, { 0x1a }
2618 /* cmp $src1,$src2 */
2620 { 0, 0, 0, 0 },
2621 { { MNEM, ' ', OP (SRC1), ',', OP (SRC2), 0 } },
2622 & ifmt_muls, { 0x40 }
2624 /* cmpb $drb,$srb */
2626 { 0, 0, 0, 0 },
2627 { { MNEM, ' ', OP (DRB), ',', OP (SRB), 0 } },
2628 & ifmt_addbr, { 0x41 }
2630 /* cmp $src1,$hash$uimm3 */
2632 { 0, 0, 0, 0 },
2633 { { MNEM, ' ', OP (SRC1), ',', OP (HASH), OP (UIMM3), 0 } },
2634 & ifmt_cmpri, { 0x48 }
2636 /* cmpb $drb,$hash$uimm3 */
2638 { 0, 0, 0, 0 },
2639 { { MNEM, ' ', OP (DRB), ',', OP (HASH), OP (UIMM3), 0 } },
2640 & ifmt_addbrhpag3, { 0x49 }
2642 /* cmp $reg8,$hash$uimm16 */
2644 { 0, 0, 0, 0 },
2645 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2646 & ifmt_addrhpof, { 0x46 }
2648 /* cmpb $regb8,$hash$uimm8 */
2650 { 0, 0, 0, 0 },
2651 { { MNEM, ' ', OP (REGB8), ',', OP (HASH), OP (UIMM8), 0 } },
2652 & ifmt_addrbhpof, { 0x47 }
2654 /* cmp $dr,[$sr2] */
2656 { 0, 0, 0, 0 },
2657 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), ']', 0 } },
2658 & ifmt_add2, { 0x848 }
2660 /* cmpb $drb,[$sr2] */
2662 { 0, 0, 0, 0 },
2663 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), ']', 0 } },
2664 & ifmt_addb2, { 0x849 }
2666 /* cmp $dr,[$sr2+] */
2668 { 0, 0, 0, 0 },
2669 { { MNEM, ' ', OP (DR), ',', '[', OP (SR2), '+', ']', 0 } },
2670 & ifmt_add2, { 0xc48 }
2672 /* cmpb $drb,[$sr2+] */
2674 { 0, 0, 0, 0 },
2675 { { MNEM, ' ', OP (DRB), ',', '[', OP (SR2), '+', ']', 0 } },
2676 & ifmt_addb2, { 0xc49 }
2678 /* cmp $reg8,$pof$upof16 */
2680 { 0, 0, 0, 0 },
2681 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2682 & ifmt_addrpof, { 0x42 }
2684 /* cmpb $regb8,$pof$upof16 */
2686 { 0, 0, 0, 0 },
2687 { { MNEM, ' ', OP (REGB8), ',', OP (POF), OP (UPOF16), 0 } },
2688 & ifmt_addbrpof, { 0x43 }
2690 /* cmp $regmem8,$memgr8 */
2692 { 0, 0, 0, 0 },
2693 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2694 & ifmt_addrm2, { 0x42 }
2696 /* cmp $reg8,$memory */
2698 { 0, 0, 0, 0 },
2699 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2700 & ifmt_addrm, { 0x42 }
2702 /* cmpb $regbmem8,$memgr8 */
2704 { 0, 0, 0, 0 },
2705 { { MNEM, ' ', OP (REGBMEM8), ',', OP (MEMGR8), 0 } },
2706 & ifmt_addbrm2, { 0x43 }
2708 /* cmpb $regb8,$memory */
2710 { 0, 0, 0, 0 },
2711 { { MNEM, ' ', OP (REGB8), ',', OP (MEMORY), 0 } },
2712 & ifmt_addbrm, { 0x43 }
2714 /* cmpd1 $sr,$hash$uimm4 */
2716 { 0, 0, 0, 0 },
2717 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2718 & ifmt_cmpd1ri, { 0xa0 }
2720 /* cmpd2 $sr,$hash$uimm4 */
2722 { 0, 0, 0, 0 },
2723 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2724 & ifmt_cmpd1ri, { 0xb0 }
2726 /* cmpi1 $sr,$hash$uimm4 */
2728 { 0, 0, 0, 0 },
2729 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2730 & ifmt_cmpd1ri, { 0x80 }
2732 /* cmpi2 $sr,$hash$uimm4 */
2734 { 0, 0, 0, 0 },
2735 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2736 & ifmt_cmpd1ri, { 0x90 }
2738 /* cmpd1 $reg8,$hash$uimm16 */
2740 { 0, 0, 0, 0 },
2741 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2742 & ifmt_addrhpof, { 0xa6 }
2744 /* cmpd2 $reg8,$hash$uimm16 */
2746 { 0, 0, 0, 0 },
2747 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2748 & ifmt_addrhpof, { 0xb6 }
2750 /* cmpi1 $reg8,$hash$uimm16 */
2752 { 0, 0, 0, 0 },
2753 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2754 & ifmt_addrhpof, { 0x86 }
2756 /* cmpi2 $reg8,$hash$uimm16 */
2758 { 0, 0, 0, 0 },
2759 { { MNEM, ' ', OP (REG8), ',', OP (HASH), OP (UIMM16), 0 } },
2760 & ifmt_addrhpof, { 0x96 }
2762 /* cmpd1 $reg8,$pof$upof16 */
2764 { 0, 0, 0, 0 },
2765 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2766 & ifmt_addrpof, { 0xa2 }
2768 /* cmpd2 $reg8,$pof$upof16 */
2770 { 0, 0, 0, 0 },
2771 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2772 & ifmt_addrpof, { 0xb2 }
2774 /* cmpi1 $reg8,$pof$upof16 */
2776 { 0, 0, 0, 0 },
2777 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2778 & ifmt_addrpof, { 0x82 }
2780 /* cmpi2 $reg8,$pof$upof16 */
2782 { 0, 0, 0, 0 },
2783 { { MNEM, ' ', OP (REG8), ',', OP (POF), OP (UPOF16), 0 } },
2784 & ifmt_addrpof, { 0x92 }
2786 /* cmpd1 $regmem8,$memgr8 */
2788 { 0, 0, 0, 0 },
2789 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2790 & ifmt_addrm2, { 0xa2 }
2792 /* cmpd2 $regmem8,$memgr8 */
2794 { 0, 0, 0, 0 },
2795 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2796 & ifmt_addrm2, { 0xb2 }
2798 /* cmpi1 $regmem8,$memgr8 */
2800 { 0, 0, 0, 0 },
2801 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2802 & ifmt_addrm2, { 0x82 }
2804 /* cmpi2 $regmem8,$memgr8 */
2806 { 0, 0, 0, 0 },
2807 { { MNEM, ' ', OP (REGMEM8), ',', OP (MEMGR8), 0 } },
2808 & ifmt_addrm2, { 0x92 }
2810 /* cmpd1 $reg8,$memory */
2812 { 0, 0, 0, 0 },
2813 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2814 & ifmt_addrm, { 0xa2 }
2816 /* cmpd2 $reg8,$memory */
2818 { 0, 0, 0, 0 },
2819 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2820 & ifmt_addrm, { 0xb2 }
2822 /* cmpi1 $reg8,$memory */
2824 { 0, 0, 0, 0 },
2825 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2826 & ifmt_addrm, { 0x82 }
2828 /* cmpi2 $reg8,$memory */
2830 { 0, 0, 0, 0 },
2831 { { MNEM, ' ', OP (REG8), ',', OP (MEMORY), 0 } },
2832 & ifmt_addrm, { 0x92 }
2834 /* shl $dr,$sr */
2836 { 0, 0, 0, 0 },
2837 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2838 & ifmt_addr, { 0x4c }
2840 /* shr $dr,$sr */
2842 { 0, 0, 0, 0 },
2843 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2844 & ifmt_addr, { 0x6c }
2846 /* rol $dr,$sr */
2848 { 0, 0, 0, 0 },
2849 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2850 & ifmt_addr, { 0xc }
2852 /* ror $dr,$sr */
2854 { 0, 0, 0, 0 },
2855 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2856 & ifmt_addr, { 0x2c }
2858 /* ashr $dr,$sr */
2860 { 0, 0, 0, 0 },
2861 { { MNEM, ' ', OP (DR), ',', OP (SR), 0 } },
2862 & ifmt_addr, { 0xac }
2864 /* shl $sr,$hash$uimm4 */
2866 { 0, 0, 0, 0 },
2867 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2868 & ifmt_cmpd1ri, { 0x5c }
2870 /* shr $sr,$hash$uimm4 */
2872 { 0, 0, 0, 0 },
2873 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2874 & ifmt_cmpd1ri, { 0x7c }
2876 /* rol $sr,$hash$uimm4 */
2878 { 0, 0, 0, 0 },
2879 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2880 & ifmt_cmpd1ri, { 0x1c }
2882 /* ror $sr,$hash$uimm4 */
2884 { 0, 0, 0, 0 },
2885 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2886 & ifmt_cmpd1ri, { 0x3c }
2888 /* ashr $sr,$hash$uimm4 */
2890 { 0, 0, 0, 0 },
2891 { { MNEM, ' ', OP (SR), ',', OP (HASH), OP (UIMM4), 0 } },
2892 & ifmt_cmpd1ri, { 0xbc }
2896 #undef A
2897 #undef OPERAND
2898 #undef MNEM
2899 #undef OP
2901 /* Formats for ALIAS macro-insns. */
2903 #define F(f) & xc16x_cgen_ifld_table[XC16X_##f]
2904 #undef F
2906 /* Each non-simple macro entry points to an array of expansion possibilities. */
2908 #define A(a) (1 << CGEN_INSN_##a)
2909 #define OPERAND(op) XC16X_OPERAND_##op
2910 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
2911 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
2913 /* The macro instruction table. */
2915 static const CGEN_IBASE xc16x_cgen_macro_insn_table[] =
2919 /* The macro instruction opcode table. */
2921 static const CGEN_OPCODE xc16x_cgen_macro_insn_opcode_table[] =
2925 #undef A
2926 #undef OPERAND
2927 #undef MNEM
2928 #undef OP
2930 #ifndef CGEN_ASM_HASH_P
2931 #define CGEN_ASM_HASH_P(insn) 1
2932 #endif
2934 #ifndef CGEN_DIS_HASH_P
2935 #define CGEN_DIS_HASH_P(insn) 1
2936 #endif
2938 /* Return non-zero if INSN is to be added to the hash table.
2939 Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file. */
2941 static int
2942 asm_hash_insn_p (insn)
2943 const CGEN_INSN *insn ATTRIBUTE_UNUSED;
2945 return CGEN_ASM_HASH_P (insn);
2948 static int
2949 dis_hash_insn_p (insn)
2950 const CGEN_INSN *insn;
2952 /* If building the hash table and the NO-DIS attribute is present,
2953 ignore. */
2954 if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
2955 return 0;
2956 return CGEN_DIS_HASH_P (insn);
2959 #ifndef CGEN_ASM_HASH
2960 #define CGEN_ASM_HASH_SIZE 127
2961 #ifdef CGEN_MNEMONIC_OPERANDS
2962 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
2963 #else
2964 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
2965 #endif
2966 #endif
2968 /* It doesn't make much sense to provide a default here,
2969 but while this is under development we do.
2970 BUFFER is a pointer to the bytes of the insn, target order.
2971 VALUE is the first base_insn_bitsize bits as an int in host order. */
2973 #ifndef CGEN_DIS_HASH
2974 #define CGEN_DIS_HASH_SIZE 256
2975 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
2976 #endif
2978 /* The result is the hash value of the insn.
2979 Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file. */
2981 static unsigned int
2982 asm_hash_insn (mnem)
2983 const char * mnem;
2985 return CGEN_ASM_HASH (mnem);
2988 /* BUF is a pointer to the bytes of the insn, target order.
2989 VALUE is the first base_insn_bitsize bits as an int in host order. */
2991 static unsigned int
2992 dis_hash_insn (buf, value)
2993 const char * buf ATTRIBUTE_UNUSED;
2994 CGEN_INSN_INT value ATTRIBUTE_UNUSED;
2996 return CGEN_DIS_HASH (buf, value);
2999 /* Set the recorded length of the insn in the CGEN_FIELDS struct. */
3001 static void
3002 set_fields_bitsize (CGEN_FIELDS *fields, int size)
3004 CGEN_FIELDS_BITSIZE (fields) = size;
3007 /* Function to call before using the operand instance table.
3008 This plugs the opcode entries and macro instructions into the cpu table. */
3010 void
3011 xc16x_cgen_init_opcode_table (CGEN_CPU_DESC cd)
3013 int i;
3014 int num_macros = (sizeof (xc16x_cgen_macro_insn_table) /
3015 sizeof (xc16x_cgen_macro_insn_table[0]));
3016 const CGEN_IBASE *ib = & xc16x_cgen_macro_insn_table[0];
3017 const CGEN_OPCODE *oc = & xc16x_cgen_macro_insn_opcode_table[0];
3018 CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
3020 /* This test has been added to avoid a warning generated
3021 if memset is called with a third argument of value zero. */
3022 if (num_macros >= 1)
3023 memset (insns, 0, num_macros * sizeof (CGEN_INSN));
3024 for (i = 0; i < num_macros; ++i)
3026 insns[i].base = &ib[i];
3027 insns[i].opcode = &oc[i];
3028 xc16x_cgen_build_insn_regex (& insns[i]);
3030 cd->macro_insn_table.init_entries = insns;
3031 cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
3032 cd->macro_insn_table.num_init_entries = num_macros;
3034 oc = & xc16x_cgen_insn_opcode_table[0];
3035 insns = (CGEN_INSN *) cd->insn_table.init_entries;
3036 for (i = 0; i < MAX_INSNS; ++i)
3038 insns[i].opcode = &oc[i];
3039 xc16x_cgen_build_insn_regex (& insns[i]);
3042 cd->sizeof_fields = sizeof (CGEN_FIELDS);
3043 cd->set_fields_bitsize = set_fields_bitsize;
3045 cd->asm_hash_p = asm_hash_insn_p;
3046 cd->asm_hash = asm_hash_insn;
3047 cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
3049 cd->dis_hash_p = dis_hash_insn_p;
3050 cd->dis_hash = dis_hash_insn;
3051 cd->dis_hash_size = CGEN_DIS_HASH_SIZE;