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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [opcodes/] [xc16x-opc.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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