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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [opcodes/] [mep-opc.c] - Blame information for rev 156

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Instruction opcode table for mep.
2
 
3
THIS FILE IS MACHINE GENERATED WITH CGEN.
4
 
5
Copyright 1996-2007 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 "mep-desc.h"
30
#include "mep-opc.h"
31
#include "libiberty.h"
32
 
33
/* -- opc.c */
34
#include "elf/mep.h"
35
 
36
/* A mask for all ISAs executed by the core. */
37
CGEN_ATTR_VALUE_BITSET_TYPE mep_all_core_isas_mask = {0, 0};
38
 
39
void
40
init_mep_all_core_isas_mask (void)
41
{
42
  if (mep_all_core_isas_mask.length != 0)
43
    return;
44
  cgen_bitset_init (& mep_all_core_isas_mask, ISA_MAX);
45
  cgen_bitset_set (& mep_all_core_isas_mask, ISA_MEP);
46
  /* begin-all-core-isas */
47
  cgen_bitset_add (& mep_all_core_isas_mask, ISA_EXT_CORE1);
48
  cgen_bitset_add (& mep_all_core_isas_mask, ISA_EXT_CORE2);
49
  /* end-all-core-isas */
50
}
51
 
52
CGEN_ATTR_VALUE_BITSET_TYPE mep_all_cop_isas_mask = {0, 0};
53
 
54
void
55
init_mep_all_cop_isas_mask (void)
56
{
57
  if (mep_all_cop_isas_mask.length != 0)
58
    return;
59
  cgen_bitset_init (& mep_all_cop_isas_mask, ISA_MAX);
60
  /* begin-all-cop-isas */
61
  cgen_bitset_add (& mep_all_cop_isas_mask, ISA_EXT_COP2_16);
62
  cgen_bitset_add (& mep_all_cop_isas_mask, ISA_EXT_COP2_32);
63
  cgen_bitset_add (& mep_all_cop_isas_mask, ISA_EXT_COP2_48);
64
  cgen_bitset_add (& mep_all_cop_isas_mask, ISA_EXT_COP2_64);
65
  /* end-all-cop-isas */
66
}
67
 
68
int
69
mep_insn_supported_by_isa (const CGEN_INSN *insn, CGEN_ATTR_VALUE_BITSET_TYPE *isa_mask)
70
{
71
  CGEN_BITSET insn_isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
72
  return cgen_bitset_intersect_p (& insn_isas, isa_mask);
73
}
74
 
75
#define OPTION_MASK \
76
        ( (1 << CGEN_INSN_OPTIONAL_BIT_INSN) \
77
        | (1 << CGEN_INSN_OPTIONAL_MUL_INSN) \
78
        | (1 << CGEN_INSN_OPTIONAL_DIV_INSN) \
79
        | (1 << CGEN_INSN_OPTIONAL_DEBUG_INSN) \
80
        | (1 << CGEN_INSN_OPTIONAL_LDZ_INSN) \
81
        | (1 << CGEN_INSN_OPTIONAL_ABS_INSN) \
82
        | (1 << CGEN_INSN_OPTIONAL_AVE_INSN) \
83
        | (1 << CGEN_INSN_OPTIONAL_MINMAX_INSN) \
84
        | (1 << CGEN_INSN_OPTIONAL_CLIP_INSN) \
85
        | (1 << CGEN_INSN_OPTIONAL_SAT_INSN) \
86
        | (1 << CGEN_INSN_OPTIONAL_UCI_INSN) \
87
        | (1 << CGEN_INSN_OPTIONAL_DSP_INSN) \
88
        | (1 << CGEN_INSN_OPTIONAL_CP_INSN) \
89
        | (1 << CGEN_INSN_OPTIONAL_CP64_INSN) )
90
 
91
 
92
mep_config_map_struct mep_config_map[] =
93
{
94
  /* config-map-start */
95
  /* Default entry: mep core only, all options enabled. */
96
  { "", 0, EF_MEP_CPU_C2, 1, 0, {1,"\x0"}, {1,"\x0"}, {1,"\x0"}, {1,"\x0"}, {1,"\x0"}, {1,"\x80"}, OPTION_MASK },
97
  { "simple", CONFIG_SIMPLE, EF_MEP_CPU_C2, 1, 0, { 1, "\x0" }, { 1, "\x0" }, { 1, "\x0" }, { 1, "\x0" }, { 1, "\x0" }, { 1, "\xc0" },
98
 
99
  { "fmax", CONFIG_FMAX, EF_MEP_CPU_C2, 1, 0, { 1, "\x10" }, { 1, "\x8" }, { 1, "\x4" }, { 1, "\x2" }, { 1, "\x1e" }, { 1, "\xa0" },
100
 
101
        | (1 << CGEN_INSN_OPTIONAL_CP_INSN)
102
        | (1 << CGEN_INSN_OPTIONAL_MUL_INSN)
103
        | (1 << CGEN_INSN_OPTIONAL_DIV_INSN)
104
        | (1 << CGEN_INSN_OPTIONAL_BIT_INSN)
105
        | (1 << CGEN_INSN_OPTIONAL_LDZ_INSN)
106
        | (1 << CGEN_INSN_OPTIONAL_ABS_INSN)
107
        | (1 << CGEN_INSN_OPTIONAL_AVE_INSN)
108
        | (1 << CGEN_INSN_OPTIONAL_MINMAX_INSN)
109
        | (1 << CGEN_INSN_OPTIONAL_CLIP_INSN)
110
        | (1 << CGEN_INSN_OPTIONAL_SAT_INSN) },
111
  /* config-map-end */
112
  { 0, 0, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, 0 }
113
};
114
 
115
int mep_config_index = 0;
116
 
117
static int
118
check_configured_mach (int machs)
119
{
120
  /* All base insns are supported.  */
121
  int mach = 1 << MACH_BASE;
122
  switch (MEP_CPU)
123
    {
124
    case EF_MEP_CPU_C2:
125
    case EF_MEP_CPU_C3:
126
      mach |= (1 << MACH_MEP);
127
      break;
128
    case EF_MEP_CPU_H1:
129
      mach |= (1 << MACH_H1);
130
      break;
131
    default:
132
      break;
133
    }
134
  return machs & mach;
135
}
136
 
137
int
138
mep_cgen_insn_supported (CGEN_CPU_DESC cd, const CGEN_INSN *insn)
139
{
140
  int iconfig = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_CONFIG);
141
  int machs = CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_MACH);
142
  CGEN_BITSET isas = CGEN_INSN_BITSET_ATTR_VALUE (insn, CGEN_INSN_ISA);
143
  int ok1;
144
  int ok2;
145
  int ok3;
146
 
147
  /* If the insn has an option bit set that we don't want,
148
     reject it.  */
149
  if (CGEN_INSN_ATTRS (insn)->bool & OPTION_MASK & ~MEP_OMASK)
150
    return 0;
151
 
152
  /* If attributes are absent, assume no restriction. */
153
  if (machs == 0)
154
    machs = ~0;
155
 
156
  ok1 = ((machs & cd->machs) && cgen_bitset_intersect_p (& isas, cd->isas));
157
  /* If the insn is config-specific, make sure it matches.  */
158
  ok2 =  (iconfig == 0 || iconfig == MEP_CONFIG);
159
  /* Make sure the insn is supported by the configured mach  */
160
  ok3 = check_configured_mach (machs);
161
 
162
  return (ok1 && ok2 && ok3);
163
}
164
/* The hash functions are recorded here to help keep assembler code out of
165
   the disassembler and vice versa.  */
166
 
167
static int asm_hash_insn_p        (const CGEN_INSN *);
168
static unsigned int asm_hash_insn (const char *);
169
static int dis_hash_insn_p        (const CGEN_INSN *);
170
static unsigned int dis_hash_insn (const char *, CGEN_INSN_INT);
171
 
172
/* Instruction formats.  */
173
 
174
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
175
#define F(f) & mep_cgen_ifld_table[MEP_##f]
176
#else
177
#define F(f) & mep_cgen_ifld_table[MEP_/**/f]
178
#endif
179
static const CGEN_IFMT ifmt_empty ATTRIBUTE_UNUSED = {
180
  0, 0, 0x0, { { 0 } }
181
};
182
 
183
static const CGEN_IFMT ifmt_sb ATTRIBUTE_UNUSED = {
184
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
185
};
186
 
187
static const CGEN_IFMT ifmt_sh ATTRIBUTE_UNUSED = {
188
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
189
};
190
 
191
static const CGEN_IFMT ifmt_sw ATTRIBUTE_UNUSED = {
192
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
193
};
194
 
195
static const CGEN_IFMT ifmt_lbu ATTRIBUTE_UNUSED = {
196
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
197
};
198
 
199
static const CGEN_IFMT ifmt_lhu ATTRIBUTE_UNUSED = {
200
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
201
};
202
 
203
static const CGEN_IFMT ifmt_sw_sp ATTRIBUTE_UNUSED = {
204
  16, 16, 0xf083, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_8) }, { F (F_7U9A4) }, { F (F_SUB2) }, { 0 } }
205
};
206
 
207
static const CGEN_IFMT ifmt_sb_tp ATTRIBUTE_UNUSED = {
208
  16, 16, 0xf880, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_8) }, { F (F_7U9) }, { 0 } }
209
};
210
 
211
static const CGEN_IFMT ifmt_sh_tp ATTRIBUTE_UNUSED = {
212
  16, 16, 0xf881, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_8) }, { F (F_7U9A2) }, { F (F_15) }, { 0 } }
213
};
214
 
215
static const CGEN_IFMT ifmt_sw_tp ATTRIBUTE_UNUSED = {
216
  16, 16, 0xf883, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_8) }, { F (F_7U9A4) }, { F (F_SUB2) }, { 0 } }
217
};
218
 
219
static const CGEN_IFMT ifmt_lbu_tp ATTRIBUTE_UNUSED = {
220
  16, 16, 0xf880, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_8) }, { F (F_7U9) }, { 0 } }
221
};
222
 
223
static const CGEN_IFMT ifmt_lhu_tp ATTRIBUTE_UNUSED = {
224
  16, 16, 0xf881, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_8) }, { F (F_7U9A2) }, { F (F_15) }, { 0 } }
225
};
226
 
227
static const CGEN_IFMT ifmt_sb16 ATTRIBUTE_UNUSED = {
228
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
229
};
230
 
231
static const CGEN_IFMT ifmt_sh16 ATTRIBUTE_UNUSED = {
232
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
233
};
234
 
235
static const CGEN_IFMT ifmt_sw16 ATTRIBUTE_UNUSED = {
236
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
237
};
238
 
239
static const CGEN_IFMT ifmt_lbu16 ATTRIBUTE_UNUSED = {
240
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
241
};
242
 
243
static const CGEN_IFMT ifmt_lhu16 ATTRIBUTE_UNUSED = {
244
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
245
};
246
 
247
static const CGEN_IFMT ifmt_sw24 ATTRIBUTE_UNUSED = {
248
  32, 32, 0xf0030000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_24U8A4N) }, { F (F_SUB2) }, { 0 } }
249
};
250
 
251
static const CGEN_IFMT ifmt_extb ATTRIBUTE_UNUSED = {
252
  16, 16, 0xf0ff, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
253
};
254
 
255
static const CGEN_IFMT ifmt_ssarb ATTRIBUTE_UNUSED = {
256
  16, 16, 0xfc0f, { { F (F_MAJOR) }, { F (F_4) }, { F (F_5) }, { F (F_2U6) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
257
};
258
 
259
static const CGEN_IFMT ifmt_mov ATTRIBUTE_UNUSED = {
260
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
261
};
262
 
263
static const CGEN_IFMT ifmt_movi8 ATTRIBUTE_UNUSED = {
264
  16, 16, 0xf000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_8S8) }, { 0 } }
265
};
266
 
267
static const CGEN_IFMT ifmt_movi16 ATTRIBUTE_UNUSED = {
268
  32, 32, 0xf0ff0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
269
};
270
 
271
static const CGEN_IFMT ifmt_movu24 ATTRIBUTE_UNUSED = {
272
  32, 32, 0xf8000000, { { F (F_MAJOR) }, { F (F_4) }, { F (F_RN3) }, { F (F_24U8N) }, { 0 } }
273
};
274
 
275
static const CGEN_IFMT ifmt_movu16 ATTRIBUTE_UNUSED = {
276
  32, 32, 0xf0ff0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16U16) }, { 0 } }
277
};
278
 
279
static const CGEN_IFMT ifmt_add3 ATTRIBUTE_UNUSED = {
280
  16, 16, 0xf000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_RL) }, { 0 } }
281
};
282
 
283
static const CGEN_IFMT ifmt_add ATTRIBUTE_UNUSED = {
284
  16, 16, 0xf003, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_6S8) }, { F (F_SUB2) }, { 0 } }
285
};
286
 
287
static const CGEN_IFMT ifmt_add3i ATTRIBUTE_UNUSED = {
288
  16, 16, 0xf083, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_8) }, { F (F_7U9A4) }, { F (F_SUB2) }, { 0 } }
289
};
290
 
291
static const CGEN_IFMT ifmt_slt3i ATTRIBUTE_UNUSED = {
292
  16, 16, 0xf007, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_5U8) }, { F (F_SUB3) }, { 0 } }
293
};
294
 
295
static const CGEN_IFMT ifmt_add3x ATTRIBUTE_UNUSED = {
296
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
297
};
298
 
299
static const CGEN_IFMT ifmt_sltu3x ATTRIBUTE_UNUSED = {
300
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16U16) }, { 0 } }
301
};
302
 
303
static const CGEN_IFMT ifmt_bra ATTRIBUTE_UNUSED = {
304
  16, 16, 0xf001, { { F (F_MAJOR) }, { F (F_12S4A2) }, { F (F_15) }, { 0 } }
305
};
306
 
307
static const CGEN_IFMT ifmt_beqz ATTRIBUTE_UNUSED = {
308
  16, 16, 0xf001, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_8S8A2) }, { F (F_15) }, { 0 } }
309
};
310
 
311
static const CGEN_IFMT ifmt_beqi ATTRIBUTE_UNUSED = {
312
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_4U8) }, { F (F_SUB4) }, { F (F_17S16A2) }, { 0 } }
313
};
314
 
315
static const CGEN_IFMT ifmt_beq ATTRIBUTE_UNUSED = {
316
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_17S16A2) }, { 0 } }
317
};
318
 
319
static const CGEN_IFMT ifmt_bsr24 ATTRIBUTE_UNUSED = {
320
  32, 32, 0xf80f0000, { { F (F_MAJOR) }, { F (F_4) }, { F (F_24S5A2N) }, { F (F_SUB4) }, { 0 } }
321
};
322
 
323
static const CGEN_IFMT ifmt_jmp ATTRIBUTE_UNUSED = {
324
  16, 16, 0xff0f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
325
};
326
 
327
static const CGEN_IFMT ifmt_jmp24 ATTRIBUTE_UNUSED = {
328
  32, 32, 0xf80f0000, { { F (F_MAJOR) }, { F (F_4) }, { F (F_24U5A2N) }, { F (F_SUB4) }, { 0 } }
329
};
330
 
331
static const CGEN_IFMT ifmt_ret ATTRIBUTE_UNUSED = {
332
  16, 16, 0xffff, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
333
};
334
 
335
static const CGEN_IFMT ifmt_repeat ATTRIBUTE_UNUSED = {
336
  32, 32, 0xf0ff0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_17S16A2) }, { 0 } }
337
};
338
 
339
static const CGEN_IFMT ifmt_erepeat ATTRIBUTE_UNUSED = {
340
  32, 32, 0xffff0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_17S16A2) }, { 0 } }
341
};
342
 
343
static const CGEN_IFMT ifmt_stc_lp ATTRIBUTE_UNUSED = {
344
  16, 16, 0xf0ff, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_CSRN_LO) }, { F (F_12) }, { F (F_13) }, { F (F_14) }, { F (F_CSRN_HI) }, { 0 } }
345
};
346
 
347
static const CGEN_IFMT ifmt_stc ATTRIBUTE_UNUSED = {
348
  16, 16, 0xf00e, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_CSRN) }, { F (F_12) }, { F (F_13) }, { F (F_14) }, { 0 } }
349
};
350
 
351
static const CGEN_IFMT ifmt_swi ATTRIBUTE_UNUSED = {
352
  16, 16, 0xffcf, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_8) }, { F (F_9) }, { F (F_2U10) }, { F (F_SUB4) }, { 0 } }
353
};
354
 
355
static const CGEN_IFMT ifmt_bsetm ATTRIBUTE_UNUSED = {
356
  16, 16, 0xf80f, { { F (F_MAJOR) }, { F (F_4) }, { F (F_3U5) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
357
};
358
 
359
static const CGEN_IFMT ifmt_tas ATTRIBUTE_UNUSED = {
360
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
361
};
362
 
363
static const CGEN_IFMT ifmt_cache ATTRIBUTE_UNUSED = {
364
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
365
};
366
 
367
static const CGEN_IFMT ifmt_madd ATTRIBUTE_UNUSED = {
368
  32, 32, 0xf00fffff, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16U16) }, { 0 } }
369
};
370
 
371
static const CGEN_IFMT ifmt_clip ATTRIBUTE_UNUSED = {
372
  32, 32, 0xf0ffff07, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_EXT) }, { F (F_5U24) }, { F (F_29) }, { F (F_30) }, { F (F_31) }, { 0 } }
373
};
374
 
375
static const CGEN_IFMT ifmt_swcp ATTRIBUTE_UNUSED = {
376
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
377
};
378
 
379
static const CGEN_IFMT ifmt_smcp ATTRIBUTE_UNUSED = {
380
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
381
};
382
 
383
static const CGEN_IFMT ifmt_swcp16 ATTRIBUTE_UNUSED = {
384
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
385
};
386
 
387
static const CGEN_IFMT ifmt_smcp16 ATTRIBUTE_UNUSED = {
388
  32, 32, 0xf00f0000, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_16S16) }, { 0 } }
389
};
390
 
391
static const CGEN_IFMT ifmt_sbcpa ATTRIBUTE_UNUSED = {
392
  32, 32, 0xf00fff00, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_EXT) }, { F (F_8S24) }, { 0 } }
393
};
394
 
395
static const CGEN_IFMT ifmt_shcpa ATTRIBUTE_UNUSED = {
396
  32, 32, 0xf00fff01, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_EXT) }, { F (F_8S24A2) }, { F (F_31) }, { 0 } }
397
};
398
 
399
static const CGEN_IFMT ifmt_swcpa ATTRIBUTE_UNUSED = {
400
  32, 32, 0xf00fff03, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_EXT) }, { F (F_8S24A4) }, { F (F_30) }, { F (F_31) }, { 0 } }
401
};
402
 
403
static const CGEN_IFMT ifmt_smcpa ATTRIBUTE_UNUSED = {
404
  32, 32, 0xf00fff07, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_EXT) }, { F (F_8S24A8) }, { F (F_29) }, { F (F_30) }, { F (F_31) }, { 0 } }
405
};
406
 
407
static const CGEN_IFMT ifmt_bcpeq ATTRIBUTE_UNUSED = {
408
  32, 32, 0xff0f0000, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { F (F_17S16A2) }, { 0 } }
409
};
410
 
411
static const CGEN_IFMT ifmt_sim_syscall ATTRIBUTE_UNUSED = {
412
  16, 16, 0xf8ef, { { F (F_MAJOR) }, { F (F_4) }, { F (F_CALLNUM) }, { F (F_8) }, { F (F_9) }, { F (F_10) }, { F (F_SUB4) }, { 0 } }
413
};
414
 
415
static const CGEN_IFMT ifmt_fadds ATTRIBUTE_UNUSED = {
416
  32, 32, 0xf0fff001, { { F (F_FMAX_0_4) }, { F (F_FMAX_FRD) }, { F (F_FMAX_8_4) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_FRN) }, { F (F_FMAX_FRM) }, { F (F_FMAX_31_1) }, { 0 } }
417
};
418
 
419
static const CGEN_IFMT ifmt_fsqrts ATTRIBUTE_UNUSED = {
420
  32, 32, 0xf0fff0f3, { { F (F_FMAX_0_4) }, { F (F_FMAX_FRD) }, { F (F_FMAX_8_4) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_FRN) }, { F (F_FMAX_24_4) }, { F (F_FMAX_30_1) }, { F (F_FMAX_31_1) }, { 0 } }
421
};
422
 
423
static const CGEN_IFMT ifmt_froundws ATTRIBUTE_UNUSED = {
424
  32, 32, 0xf0fff0f3, { { F (F_FMAX_0_4) }, { F (F_FMAX_FRD) }, { F (F_FMAX_8_4) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_FRN) }, { F (F_FMAX_24_4) }, { F (F_FMAX_30_1) }, { F (F_FMAX_31_1) }, { 0 } }
425
};
426
 
427
static const CGEN_IFMT ifmt_fcvtsw ATTRIBUTE_UNUSED = {
428
  32, 32, 0xf0fff0f3, { { F (F_FMAX_0_4) }, { F (F_FMAX_FRD) }, { F (F_FMAX_8_4) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_FRN) }, { F (F_FMAX_24_4) }, { F (F_FMAX_30_1) }, { F (F_FMAX_31_1) }, { 0 } }
429
};
430
 
431
static const CGEN_IFMT ifmt_fcmpfs ATTRIBUTE_UNUSED = {
432
  32, 32, 0xfffff009, { { F (F_FMAX_0_4) }, { F (F_FMAX_4_4) }, { F (F_FMAX_8_4) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_FRN) }, { F (F_FMAX_FRM) }, { F (F_FMAX_28_1) }, { F (F_FMAX_31_1) }, { 0 } }
433
};
434
 
435
static const CGEN_IFMT ifmt_cmov_frn_rm ATTRIBUTE_UNUSED = {
436
  32, 32, 0xf00ffff7, { { F (F_FMAX_0_4) }, { F (F_FMAX_FRD) }, { F (F_FMAX_RM) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_20_4) }, { F (F_FMAX_24_4) }, { F (F_FMAX_29_1) }, { F (F_FMAX_30_1) }, { F (F_FMAX_31_1) }, { 0 } }
437
};
438
 
439
static const CGEN_IFMT ifmt_cmovc_ccrn_rm ATTRIBUTE_UNUSED = {
440
  32, 32, 0xf00fffff, { { F (F_FMAX_0_4) }, { F (F_FMAX_4_4) }, { F (F_FMAX_RM) }, { F (F_FMAX_12_4) }, { F (F_FMAX_16_4) }, { F (F_FMAX_20_4) }, { F (F_FMAX_24_4) }, { F (F_FMAX_28_1) }, { F (F_FMAX_29_1) }, { F (F_FMAX_30_1) }, { F (F_FMAX_31_1) }, { 0 } }
441
};
442
 
443
#undef F
444
 
445
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
446
#define A(a) (1 << CGEN_INSN_##a)
447
#else
448
#define A(a) (1 << CGEN_INSN_/**/a)
449
#endif
450
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
451
#define OPERAND(op) MEP_OPERAND_##op
452
#else
453
#define OPERAND(op) MEP_OPERAND_/**/op
454
#endif
455
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
456
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
457
 
458
/* The instruction table.  */
459
 
460
static const CGEN_OPCODE mep_cgen_insn_opcode_table[MAX_INSNS] =
461
{
462
  /* Special null first entry.
463
     A `num' value of zero is thus invalid.
464
     Also, the special `invalid' insn resides here.  */
465
  { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
466
/* sb $rnc,($rma) */
467
  {
468
    { 0, 0, 0, 0 },
469
    { { MNEM, ' ', OP (RNC), ',', '(', OP (RMA), ')', 0 } },
470
    & ifmt_sb, { 0x8 }
471
  },
472
/* sh $rns,($rma) */
473
  {
474
    { 0, 0, 0, 0 },
475
    { { MNEM, ' ', OP (RNS), ',', '(', OP (RMA), ')', 0 } },
476
    & ifmt_sh, { 0x9 }
477
  },
478
/* sw $rnl,($rma) */
479
  {
480
    { 0, 0, 0, 0 },
481
    { { MNEM, ' ', OP (RNL), ',', '(', OP (RMA), ')', 0 } },
482
    & ifmt_sw, { 0xa }
483
  },
484
/* lb $rnc,($rma) */
485
  {
486
    { 0, 0, 0, 0 },
487
    { { MNEM, ' ', OP (RNC), ',', '(', OP (RMA), ')', 0 } },
488
    & ifmt_sb, { 0xc }
489
  },
490
/* lh $rns,($rma) */
491
  {
492
    { 0, 0, 0, 0 },
493
    { { MNEM, ' ', OP (RNS), ',', '(', OP (RMA), ')', 0 } },
494
    & ifmt_sh, { 0xd }
495
  },
496
/* lw $rnl,($rma) */
497
  {
498
    { 0, 0, 0, 0 },
499
    { { MNEM, ' ', OP (RNL), ',', '(', OP (RMA), ')', 0 } },
500
    & ifmt_sw, { 0xe }
501
  },
502
/* lbu $rnuc,($rma) */
503
  {
504
    { 0, 0, 0, 0 },
505
    { { MNEM, ' ', OP (RNUC), ',', '(', OP (RMA), ')', 0 } },
506
    & ifmt_lbu, { 0xb }
507
  },
508
/* lhu $rnus,($rma) */
509
  {
510
    { 0, 0, 0, 0 },
511
    { { MNEM, ' ', OP (RNUS), ',', '(', OP (RMA), ')', 0 } },
512
    & ifmt_lhu, { 0xf }
513
  },
514
/* sw $rnl,$udisp7a4($spr) */
515
  {
516
    { 0, 0, 0, 0 },
517
    { { MNEM, ' ', OP (RNL), ',', OP (UDISP7A4), '(', OP (SPR), ')', 0 } },
518
    & ifmt_sw_sp, { 0x4002 }
519
  },
520
/* lw $rnl,$udisp7a4($spr) */
521
  {
522
    { 0, 0, 0, 0 },
523
    { { MNEM, ' ', OP (RNL), ',', OP (UDISP7A4), '(', OP (SPR), ')', 0 } },
524
    & ifmt_sw_sp, { 0x4003 }
525
  },
526
/* sb $rn3c,$udisp7($tpr) */
527
  {
528
    { 0, 0, 0, 0 },
529
    { { MNEM, ' ', OP (RN3C), ',', OP (UDISP7), '(', OP (TPR), ')', 0 } },
530
    & ifmt_sb_tp, { 0x8000 }
531
  },
532
/* sh $rn3s,$udisp7a2($tpr) */
533
  {
534
    { 0, 0, 0, 0 },
535
    { { MNEM, ' ', OP (RN3S), ',', OP (UDISP7A2), '(', OP (TPR), ')', 0 } },
536
    & ifmt_sh_tp, { 0x8080 }
537
  },
538
/* sw $rn3l,$udisp7a4($tpr) */
539
  {
540
    { 0, 0, 0, 0 },
541
    { { MNEM, ' ', OP (RN3L), ',', OP (UDISP7A4), '(', OP (TPR), ')', 0 } },
542
    & ifmt_sw_tp, { 0x4082 }
543
  },
544
/* lb $rn3c,$udisp7($tpr) */
545
  {
546
    { 0, 0, 0, 0 },
547
    { { MNEM, ' ', OP (RN3C), ',', OP (UDISP7), '(', OP (TPR), ')', 0 } },
548
    & ifmt_sb_tp, { 0x8800 }
549
  },
550
/* lh $rn3s,$udisp7a2($tpr) */
551
  {
552
    { 0, 0, 0, 0 },
553
    { { MNEM, ' ', OP (RN3S), ',', OP (UDISP7A2), '(', OP (TPR), ')', 0 } },
554
    & ifmt_sh_tp, { 0x8880 }
555
  },
556
/* lw $rn3l,$udisp7a4($tpr) */
557
  {
558
    { 0, 0, 0, 0 },
559
    { { MNEM, ' ', OP (RN3L), ',', OP (UDISP7A4), '(', OP (TPR), ')', 0 } },
560
    & ifmt_sw_tp, { 0x4083 }
561
  },
562
/* lbu $rn3uc,$udisp7($tpr) */
563
  {
564
    { 0, 0, 0, 0 },
565
    { { MNEM, ' ', OP (RN3UC), ',', OP (UDISP7), '(', OP (TPR), ')', 0 } },
566
    & ifmt_lbu_tp, { 0x4880 }
567
  },
568
/* lhu $rn3us,$udisp7a2($tpr) */
569
  {
570
    { 0, 0, 0, 0 },
571
    { { MNEM, ' ', OP (RN3US), ',', OP (UDISP7A2), '(', OP (TPR), ')', 0 } },
572
    & ifmt_lhu_tp, { 0x8881 }
573
  },
574
/* sb $rnc,$sdisp16($rma) */
575
  {
576
    { 0, 0, 0, 0 },
577
    { { MNEM, ' ', OP (RNC), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
578
    & ifmt_sb16, { 0xc0080000 }
579
  },
580
/* sh $rns,$sdisp16($rma) */
581
  {
582
    { 0, 0, 0, 0 },
583
    { { MNEM, ' ', OP (RNS), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
584
    & ifmt_sh16, { 0xc0090000 }
585
  },
586
/* sw $rnl,$sdisp16($rma) */
587
  {
588
    { 0, 0, 0, 0 },
589
    { { MNEM, ' ', OP (RNL), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
590
    & ifmt_sw16, { 0xc00a0000 }
591
  },
592
/* lb $rnc,$sdisp16($rma) */
593
  {
594
    { 0, 0, 0, 0 },
595
    { { MNEM, ' ', OP (RNC), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
596
    & ifmt_sb16, { 0xc00c0000 }
597
  },
598
/* lh $rns,$sdisp16($rma) */
599
  {
600
    { 0, 0, 0, 0 },
601
    { { MNEM, ' ', OP (RNS), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
602
    & ifmt_sh16, { 0xc00d0000 }
603
  },
604
/* lw $rnl,$sdisp16($rma) */
605
  {
606
    { 0, 0, 0, 0 },
607
    { { MNEM, ' ', OP (RNL), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
608
    & ifmt_sw16, { 0xc00e0000 }
609
  },
610
/* lbu $rnuc,$sdisp16($rma) */
611
  {
612
    { 0, 0, 0, 0 },
613
    { { MNEM, ' ', OP (RNUC), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
614
    & ifmt_lbu16, { 0xc00b0000 }
615
  },
616
/* lhu $rnus,$sdisp16($rma) */
617
  {
618
    { 0, 0, 0, 0 },
619
    { { MNEM, ' ', OP (RNUS), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
620
    & ifmt_lhu16, { 0xc00f0000 }
621
  },
622
/* sw $rnl,($addr24a4) */
623
  {
624
    { 0, 0, 0, 0 },
625
    { { MNEM, ' ', OP (RNL), ',', '(', OP (ADDR24A4), ')', 0 } },
626
    & ifmt_sw24, { 0xe0020000 }
627
  },
628
/* lw $rnl,($addr24a4) */
629
  {
630
    { 0, 0, 0, 0 },
631
    { { MNEM, ' ', OP (RNL), ',', '(', OP (ADDR24A4), ')', 0 } },
632
    & ifmt_sw24, { 0xe0030000 }
633
  },
634
/* extb $rn */
635
  {
636
    { 0, 0, 0, 0 },
637
    { { MNEM, ' ', OP (RN), 0 } },
638
    & ifmt_extb, { 0x100d }
639
  },
640
/* exth $rn */
641
  {
642
    { 0, 0, 0, 0 },
643
    { { MNEM, ' ', OP (RN), 0 } },
644
    & ifmt_extb, { 0x102d }
645
  },
646
/* extub $rn */
647
  {
648
    { 0, 0, 0, 0 },
649
    { { MNEM, ' ', OP (RN), 0 } },
650
    & ifmt_extb, { 0x108d }
651
  },
652
/* extuh $rn */
653
  {
654
    { 0, 0, 0, 0 },
655
    { { MNEM, ' ', OP (RN), 0 } },
656
    & ifmt_extb, { 0x10ad }
657
  },
658
/* ssarb $udisp2($rm) */
659
  {
660
    { 0, 0, 0, 0 },
661
    { { MNEM, ' ', OP (UDISP2), '(', OP (RM), ')', 0 } },
662
    & ifmt_ssarb, { 0x100c }
663
  },
664
/* mov $rn,$rm */
665
  {
666
    { 0, 0, 0, 0 },
667
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
668
    & ifmt_mov, { 0x0 }
669
  },
670
/* mov $rn,$simm8 */
671
  {
672
    { 0, 0, 0, 0 },
673
    { { MNEM, ' ', OP (RN), ',', OP (SIMM8), 0 } },
674
    & ifmt_movi8, { 0x5000 }
675
  },
676
/* mov $rn,$simm16 */
677
  {
678
    { 0, 0, 0, 0 },
679
    { { MNEM, ' ', OP (RN), ',', OP (SIMM16), 0 } },
680
    & ifmt_movi16, { 0xc0010000 }
681
  },
682
/* movu $rn3,$uimm24 */
683
  {
684
    { 0, 0, 0, 0 },
685
    { { MNEM, ' ', OP (RN3), ',', OP (UIMM24), 0 } },
686
    & ifmt_movu24, { 0xd0000000 }
687
  },
688
/* movu $rn,$uimm16 */
689
  {
690
    { 0, 0, 0, 0 },
691
    { { MNEM, ' ', OP (RN), ',', OP (UIMM16), 0 } },
692
    & ifmt_movu16, { 0xc0110000 }
693
  },
694
/* movh $rn,$uimm16 */
695
  {
696
    { 0, 0, 0, 0 },
697
    { { MNEM, ' ', OP (RN), ',', OP (UIMM16), 0 } },
698
    & ifmt_movu16, { 0xc0210000 }
699
  },
700
/* add3 $rl,$rn,$rm */
701
  {
702
    { 0, 0, 0, 0 },
703
    { { MNEM, ' ', OP (RL), ',', OP (RN), ',', OP (RM), 0 } },
704
    & ifmt_add3, { 0x9000 }
705
  },
706
/* add $rn,$simm6 */
707
  {
708
    { 0, 0, 0, 0 },
709
    { { MNEM, ' ', OP (RN), ',', OP (SIMM6), 0 } },
710
    & ifmt_add, { 0x6000 }
711
  },
712
/* add3 $rn,$spr,$uimm7a4 */
713
  {
714
    { 0, 0, 0, 0 },
715
    { { MNEM, ' ', OP (RN), ',', OP (SPR), ',', OP (UIMM7A4), 0 } },
716
    & ifmt_add3i, { 0x4000 }
717
  },
718
/* advck3 \$0,$rn,$rm */
719
  {
720
    { 0, 0, 0, 0 },
721
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
722
    & ifmt_mov, { 0x7 }
723
  },
724
/* sub $rn,$rm */
725
  {
726
    { 0, 0, 0, 0 },
727
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
728
    & ifmt_mov, { 0x4 }
729
  },
730
/* sbvck3 \$0,$rn,$rm */
731
  {
732
    { 0, 0, 0, 0 },
733
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
734
    & ifmt_mov, { 0x5 }
735
  },
736
/* neg $rn,$rm */
737
  {
738
    { 0, 0, 0, 0 },
739
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
740
    & ifmt_mov, { 0x1 }
741
  },
742
/* slt3 \$0,$rn,$rm */
743
  {
744
    { 0, 0, 0, 0 },
745
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
746
    & ifmt_mov, { 0x2 }
747
  },
748
/* sltu3 \$0,$rn,$rm */
749
  {
750
    { 0, 0, 0, 0 },
751
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
752
    & ifmt_mov, { 0x3 }
753
  },
754
/* slt3 \$0,$rn,$uimm5 */
755
  {
756
    { 0, 0, 0, 0 },
757
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (UIMM5), 0 } },
758
    & ifmt_slt3i, { 0x6001 }
759
  },
760
/* sltu3 \$0,$rn,$uimm5 */
761
  {
762
    { 0, 0, 0, 0 },
763
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (UIMM5), 0 } },
764
    & ifmt_slt3i, { 0x6005 }
765
  },
766
/* sl1ad3 \$0,$rn,$rm */
767
  {
768
    { 0, 0, 0, 0 },
769
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
770
    & ifmt_mov, { 0x2006 }
771
  },
772
/* sl2ad3 \$0,$rn,$rm */
773
  {
774
    { 0, 0, 0, 0 },
775
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (RM), 0 } },
776
    & ifmt_mov, { 0x2007 }
777
  },
778
/* add3 $rn,$rm,$simm16 */
779
  {
780
    { 0, 0, 0, 0 },
781
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (SIMM16), 0 } },
782
    & ifmt_add3x, { 0xc0000000 }
783
  },
784
/* slt3 $rn,$rm,$simm16 */
785
  {
786
    { 0, 0, 0, 0 },
787
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (SIMM16), 0 } },
788
    & ifmt_add3x, { 0xc0020000 }
789
  },
790
/* sltu3 $rn,$rm,$uimm16 */
791
  {
792
    { 0, 0, 0, 0 },
793
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (UIMM16), 0 } },
794
    & ifmt_sltu3x, { 0xc0030000 }
795
  },
796
/* or $rn,$rm */
797
  {
798
    { 0, 0, 0, 0 },
799
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
800
    & ifmt_mov, { 0x1000 }
801
  },
802
/* and $rn,$rm */
803
  {
804
    { 0, 0, 0, 0 },
805
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
806
    & ifmt_mov, { 0x1001 }
807
  },
808
/* xor $rn,$rm */
809
  {
810
    { 0, 0, 0, 0 },
811
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
812
    & ifmt_mov, { 0x1002 }
813
  },
814
/* nor $rn,$rm */
815
  {
816
    { 0, 0, 0, 0 },
817
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
818
    & ifmt_mov, { 0x1003 }
819
  },
820
/* or3 $rn,$rm,$uimm16 */
821
  {
822
    { 0, 0, 0, 0 },
823
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (UIMM16), 0 } },
824
    & ifmt_sltu3x, { 0xc0040000 }
825
  },
826
/* and3 $rn,$rm,$uimm16 */
827
  {
828
    { 0, 0, 0, 0 },
829
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (UIMM16), 0 } },
830
    & ifmt_sltu3x, { 0xc0050000 }
831
  },
832
/* xor3 $rn,$rm,$uimm16 */
833
  {
834
    { 0, 0, 0, 0 },
835
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (UIMM16), 0 } },
836
    & ifmt_sltu3x, { 0xc0060000 }
837
  },
838
/* sra $rn,$rm */
839
  {
840
    { 0, 0, 0, 0 },
841
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
842
    & ifmt_mov, { 0x200d }
843
  },
844
/* srl $rn,$rm */
845
  {
846
    { 0, 0, 0, 0 },
847
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
848
    & ifmt_mov, { 0x200c }
849
  },
850
/* sll $rn,$rm */
851
  {
852
    { 0, 0, 0, 0 },
853
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
854
    & ifmt_mov, { 0x200e }
855
  },
856
/* sra $rn,$uimm5 */
857
  {
858
    { 0, 0, 0, 0 },
859
    { { MNEM, ' ', OP (RN), ',', OP (UIMM5), 0 } },
860
    & ifmt_slt3i, { 0x6003 }
861
  },
862
/* srl $rn,$uimm5 */
863
  {
864
    { 0, 0, 0, 0 },
865
    { { MNEM, ' ', OP (RN), ',', OP (UIMM5), 0 } },
866
    & ifmt_slt3i, { 0x6002 }
867
  },
868
/* sll $rn,$uimm5 */
869
  {
870
    { 0, 0, 0, 0 },
871
    { { MNEM, ' ', OP (RN), ',', OP (UIMM5), 0 } },
872
    & ifmt_slt3i, { 0x6006 }
873
  },
874
/* sll3 \$0,$rn,$uimm5 */
875
  {
876
    { 0, 0, 0, 0 },
877
    { { MNEM, ' ', '$', '0', ',', OP (RN), ',', OP (UIMM5), 0 } },
878
    & ifmt_slt3i, { 0x6007 }
879
  },
880
/* fsft $rn,$rm */
881
  {
882
    { 0, 0, 0, 0 },
883
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
884
    & ifmt_mov, { 0x200f }
885
  },
886
/* bra $pcrel12a2 */
887
  {
888
    { 0, 0, 0, 0 },
889
    { { MNEM, ' ', OP (PCREL12A2), 0 } },
890
    & ifmt_bra, { 0xb000 }
891
  },
892
/* beqz $rn,$pcrel8a2 */
893
  {
894
    { 0, 0, 0, 0 },
895
    { { MNEM, ' ', OP (RN), ',', OP (PCREL8A2), 0 } },
896
    & ifmt_beqz, { 0xa000 }
897
  },
898
/* bnez $rn,$pcrel8a2 */
899
  {
900
    { 0, 0, 0, 0 },
901
    { { MNEM, ' ', OP (RN), ',', OP (PCREL8A2), 0 } },
902
    & ifmt_beqz, { 0xa001 }
903
  },
904
/* beqi $rn,$uimm4,$pcrel17a2 */
905
  {
906
    { 0, 0, 0, 0 },
907
    { { MNEM, ' ', OP (RN), ',', OP (UIMM4), ',', OP (PCREL17A2), 0 } },
908
    & ifmt_beqi, { 0xe0000000 }
909
  },
910
/* bnei $rn,$uimm4,$pcrel17a2 */
911
  {
912
    { 0, 0, 0, 0 },
913
    { { MNEM, ' ', OP (RN), ',', OP (UIMM4), ',', OP (PCREL17A2), 0 } },
914
    & ifmt_beqi, { 0xe0040000 }
915
  },
916
/* blti $rn,$uimm4,$pcrel17a2 */
917
  {
918
    { 0, 0, 0, 0 },
919
    { { MNEM, ' ', OP (RN), ',', OP (UIMM4), ',', OP (PCREL17A2), 0 } },
920
    & ifmt_beqi, { 0xe00c0000 }
921
  },
922
/* bgei $rn,$uimm4,$pcrel17a2 */
923
  {
924
    { 0, 0, 0, 0 },
925
    { { MNEM, ' ', OP (RN), ',', OP (UIMM4), ',', OP (PCREL17A2), 0 } },
926
    & ifmt_beqi, { 0xe0080000 }
927
  },
928
/* beq $rn,$rm,$pcrel17a2 */
929
  {
930
    { 0, 0, 0, 0 },
931
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (PCREL17A2), 0 } },
932
    & ifmt_beq, { 0xe0010000 }
933
  },
934
/* bne $rn,$rm,$pcrel17a2 */
935
  {
936
    { 0, 0, 0, 0 },
937
    { { MNEM, ' ', OP (RN), ',', OP (RM), ',', OP (PCREL17A2), 0 } },
938
    & ifmt_beq, { 0xe0050000 }
939
  },
940
/* bsr $pcrel12a2 */
941
  {
942
    { 0, 0, 0, 0 },
943
    { { MNEM, ' ', OP (PCREL12A2), 0 } },
944
    & ifmt_bra, { 0xb001 }
945
  },
946
/* bsr $pcrel24a2 */
947
  {
948
    { 0, 0, 0, 0 },
949
    { { MNEM, ' ', OP (PCREL24A2), 0 } },
950
    & ifmt_bsr24, { 0xd8090000 }
951
  },
952
/* jmp $rm */
953
  {
954
    { 0, 0, 0, 0 },
955
    { { MNEM, ' ', OP (RM), 0 } },
956
    & ifmt_jmp, { 0x100e }
957
  },
958
/* jmp $pcabs24a2 */
959
  {
960
    { 0, 0, 0, 0 },
961
    { { MNEM, ' ', OP (PCABS24A2), 0 } },
962
    & ifmt_jmp24, { 0xd8080000 }
963
  },
964
/* jsr $rm */
965
  {
966
    { 0, 0, 0, 0 },
967
    { { MNEM, ' ', OP (RM), 0 } },
968
    & ifmt_jmp, { 0x100f }
969
  },
970
/* ret */
971
  {
972
    { 0, 0, 0, 0 },
973
    { { MNEM, 0 } },
974
    & ifmt_ret, { 0x7002 }
975
  },
976
/* repeat $rn,$pcrel17a2 */
977
  {
978
    { 0, 0, 0, 0 },
979
    { { MNEM, ' ', OP (RN), ',', OP (PCREL17A2), 0 } },
980
    & ifmt_repeat, { 0xe0090000 }
981
  },
982
/* erepeat $pcrel17a2 */
983
  {
984
    { 0, 0, 0, 0 },
985
    { { MNEM, ' ', OP (PCREL17A2), 0 } },
986
    & ifmt_erepeat, { 0xe0190000 }
987
  },
988
/* stc $rn,\$lp */
989
  {
990
    { 0, 0, 0, 0 },
991
    { { MNEM, ' ', OP (RN), ',', '$', 'l', 'p', 0 } },
992
    & ifmt_stc_lp, { 0x7018 }
993
  },
994
/* stc $rn,\$hi */
995
  {
996
    { 0, 0, 0, 0 },
997
    { { MNEM, ' ', OP (RN), ',', '$', 'h', 'i', 0 } },
998
    & ifmt_stc_lp, { 0x7078 }
999
  },
1000
/* stc $rn,\$lo */
1001
  {
1002
    { 0, 0, 0, 0 },
1003
    { { MNEM, ' ', OP (RN), ',', '$', 'l', 'o', 0 } },
1004
    & ifmt_stc_lp, { 0x7088 }
1005
  },
1006
/* stc $rn,$csrn */
1007
  {
1008
    { 0, 0, 0, 0 },
1009
    { { MNEM, ' ', OP (RN), ',', OP (CSRN), 0 } },
1010
    & ifmt_stc, { 0x7008 }
1011
  },
1012
/* ldc $rn,\$lp */
1013
  {
1014
    { 0, 0, 0, 0 },
1015
    { { MNEM, ' ', OP (RN), ',', '$', 'l', 'p', 0 } },
1016
    & ifmt_stc_lp, { 0x701a }
1017
  },
1018
/* ldc $rn,\$hi */
1019
  {
1020
    { 0, 0, 0, 0 },
1021
    { { MNEM, ' ', OP (RN), ',', '$', 'h', 'i', 0 } },
1022
    & ifmt_stc_lp, { 0x707a }
1023
  },
1024
/* ldc $rn,\$lo */
1025
  {
1026
    { 0, 0, 0, 0 },
1027
    { { MNEM, ' ', OP (RN), ',', '$', 'l', 'o', 0 } },
1028
    & ifmt_stc_lp, { 0x708a }
1029
  },
1030
/* ldc $rn,$csrn */
1031
  {
1032
    { 0, 0, 0, 0 },
1033
    { { MNEM, ' ', OP (RN), ',', OP (CSRN), 0 } },
1034
    & ifmt_stc, { 0x700a }
1035
  },
1036
/* di */
1037
  {
1038
    { 0, 0, 0, 0 },
1039
    { { MNEM, 0 } },
1040
    & ifmt_ret, { 0x7000 }
1041
  },
1042
/* ei */
1043
  {
1044
    { 0, 0, 0, 0 },
1045
    { { MNEM, 0 } },
1046
    & ifmt_ret, { 0x7010 }
1047
  },
1048
/* reti */
1049
  {
1050
    { 0, 0, 0, 0 },
1051
    { { MNEM, 0 } },
1052
    & ifmt_ret, { 0x7012 }
1053
  },
1054
/* halt */
1055
  {
1056
    { 0, 0, 0, 0 },
1057
    { { MNEM, 0 } },
1058
    & ifmt_ret, { 0x7022 }
1059
  },
1060
/* sleep */
1061
  {
1062
    { 0, 0, 0, 0 },
1063
    { { MNEM, 0 } },
1064
    & ifmt_ret, { 0x7062 }
1065
  },
1066
/* swi $uimm2 */
1067
  {
1068
    { 0, 0, 0, 0 },
1069
    { { MNEM, ' ', OP (UIMM2), 0 } },
1070
    & ifmt_swi, { 0x7006 }
1071
  },
1072
/* break */
1073
  {
1074
    { 0, 0, 0, 0 },
1075
    { { MNEM, 0 } },
1076
    & ifmt_ret, { 0x7032 }
1077
  },
1078
/* syncm */
1079
  {
1080
    { 0, 0, 0, 0 },
1081
    { { MNEM, 0 } },
1082
    & ifmt_ret, { 0x7011 }
1083
  },
1084
/* stcb $rn,$uimm16 */
1085
  {
1086
    { 0, 0, 0, 0 },
1087
    { { MNEM, ' ', OP (RN), ',', OP (UIMM16), 0 } },
1088
    & ifmt_movu16, { 0xf0040000 }
1089
  },
1090
/* ldcb $rn,$uimm16 */
1091
  {
1092
    { 0, 0, 0, 0 },
1093
    { { MNEM, ' ', OP (RN), ',', OP (UIMM16), 0 } },
1094
    & ifmt_movu16, { 0xf0140000 }
1095
  },
1096
/* bsetm ($rma),$uimm3 */
1097
  {
1098
    { 0, 0, 0, 0 },
1099
    { { MNEM, ' ', '(', OP (RMA), ')', ',', OP (UIMM3), 0 } },
1100
    & ifmt_bsetm, { 0x2000 }
1101
  },
1102
/* bclrm ($rma),$uimm3 */
1103
  {
1104
    { 0, 0, 0, 0 },
1105
    { { MNEM, ' ', '(', OP (RMA), ')', ',', OP (UIMM3), 0 } },
1106
    & ifmt_bsetm, { 0x2001 }
1107
  },
1108
/* bnotm ($rma),$uimm3 */
1109
  {
1110
    { 0, 0, 0, 0 },
1111
    { { MNEM, ' ', '(', OP (RMA), ')', ',', OP (UIMM3), 0 } },
1112
    & ifmt_bsetm, { 0x2002 }
1113
  },
1114
/* btstm \$0,($rma),$uimm3 */
1115
  {
1116
    { 0, 0, 0, 0 },
1117
    { { MNEM, ' ', '$', '0', ',', '(', OP (RMA), ')', ',', OP (UIMM3), 0 } },
1118
    & ifmt_bsetm, { 0x2003 }
1119
  },
1120
/* tas $rn,($rma) */
1121
  {
1122
    { 0, 0, 0, 0 },
1123
    { { MNEM, ' ', OP (RN), ',', '(', OP (RMA), ')', 0 } },
1124
    & ifmt_tas, { 0x2004 }
1125
  },
1126
/* cache $cimm4,($rma) */
1127
  {
1128
    { 0, 0, 0, 0 },
1129
    { { MNEM, ' ', OP (CIMM4), ',', '(', OP (RMA), ')', 0 } },
1130
    & ifmt_cache, { 0x7004 }
1131
  },
1132
/* mul $rn,$rm */
1133
  {
1134
    { 0, 0, 0, 0 },
1135
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1136
    & ifmt_mov, { 0x1004 }
1137
  },
1138
/* mulu $rn,$rm */
1139
  {
1140
    { 0, 0, 0, 0 },
1141
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1142
    & ifmt_mov, { 0x1005 }
1143
  },
1144
/* mulr $rn,$rm */
1145
  {
1146
    { 0, 0, 0, 0 },
1147
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1148
    & ifmt_mov, { 0x1006 }
1149
  },
1150
/* mulru $rn,$rm */
1151
  {
1152
    { 0, 0, 0, 0 },
1153
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1154
    & ifmt_mov, { 0x1007 }
1155
  },
1156
/* madd $rn,$rm */
1157
  {
1158
    { 0, 0, 0, 0 },
1159
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1160
    & ifmt_madd, { 0xf0013004 }
1161
  },
1162
/* maddu $rn,$rm */
1163
  {
1164
    { 0, 0, 0, 0 },
1165
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1166
    & ifmt_madd, { 0xf0013005 }
1167
  },
1168
/* maddr $rn,$rm */
1169
  {
1170
    { 0, 0, 0, 0 },
1171
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1172
    & ifmt_madd, { 0xf0013006 }
1173
  },
1174
/* maddru $rn,$rm */
1175
  {
1176
    { 0, 0, 0, 0 },
1177
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1178
    & ifmt_madd, { 0xf0013007 }
1179
  },
1180
/* div $rn,$rm */
1181
  {
1182
    { 0, 0, 0, 0 },
1183
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1184
    & ifmt_mov, { 0x1008 }
1185
  },
1186
/* divu $rn,$rm */
1187
  {
1188
    { 0, 0, 0, 0 },
1189
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1190
    & ifmt_mov, { 0x1009 }
1191
  },
1192
/* dret */
1193
  {
1194
    { 0, 0, 0, 0 },
1195
    { { MNEM, 0 } },
1196
    & ifmt_ret, { 0x7013 }
1197
  },
1198
/* dbreak */
1199
  {
1200
    { 0, 0, 0, 0 },
1201
    { { MNEM, 0 } },
1202
    & ifmt_ret, { 0x7033 }
1203
  },
1204
/* ldz $rn,$rm */
1205
  {
1206
    { 0, 0, 0, 0 },
1207
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1208
    & ifmt_madd, { 0xf0010000 }
1209
  },
1210
/* abs $rn,$rm */
1211
  {
1212
    { 0, 0, 0, 0 },
1213
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1214
    & ifmt_madd, { 0xf0010003 }
1215
  },
1216
/* ave $rn,$rm */
1217
  {
1218
    { 0, 0, 0, 0 },
1219
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1220
    & ifmt_madd, { 0xf0010002 }
1221
  },
1222
/* min $rn,$rm */
1223
  {
1224
    { 0, 0, 0, 0 },
1225
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1226
    & ifmt_madd, { 0xf0010004 }
1227
  },
1228
/* max $rn,$rm */
1229
  {
1230
    { 0, 0, 0, 0 },
1231
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1232
    & ifmt_madd, { 0xf0010005 }
1233
  },
1234
/* minu $rn,$rm */
1235
  {
1236
    { 0, 0, 0, 0 },
1237
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1238
    & ifmt_madd, { 0xf0010006 }
1239
  },
1240
/* maxu $rn,$rm */
1241
  {
1242
    { 0, 0, 0, 0 },
1243
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1244
    & ifmt_madd, { 0xf0010007 }
1245
  },
1246
/* clip $rn,$cimm5 */
1247
  {
1248
    { 0, 0, 0, 0 },
1249
    { { MNEM, ' ', OP (RN), ',', OP (CIMM5), 0 } },
1250
    & ifmt_clip, { 0xf0011000 }
1251
  },
1252
/* clipu $rn,$cimm5 */
1253
  {
1254
    { 0, 0, 0, 0 },
1255
    { { MNEM, ' ', OP (RN), ',', OP (CIMM5), 0 } },
1256
    & ifmt_clip, { 0xf0011001 }
1257
  },
1258
/* sadd $rn,$rm */
1259
  {
1260
    { 0, 0, 0, 0 },
1261
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1262
    & ifmt_madd, { 0xf0010008 }
1263
  },
1264
/* ssub $rn,$rm */
1265
  {
1266
    { 0, 0, 0, 0 },
1267
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1268
    & ifmt_madd, { 0xf001000a }
1269
  },
1270
/* saddu $rn,$rm */
1271
  {
1272
    { 0, 0, 0, 0 },
1273
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1274
    & ifmt_madd, { 0xf0010009 }
1275
  },
1276
/* ssubu $rn,$rm */
1277
  {
1278
    { 0, 0, 0, 0 },
1279
    { { MNEM, ' ', OP (RN), ',', OP (RM), 0 } },
1280
    & ifmt_madd, { 0xf001000b }
1281
  },
1282
/* swcp $crn,($rma) */
1283
  {
1284
    { 0, 0, 0, 0 },
1285
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), ')', 0 } },
1286
    & ifmt_swcp, { 0x3008 }
1287
  },
1288
/* lwcp $crn,($rma) */
1289
  {
1290
    { 0, 0, 0, 0 },
1291
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), ')', 0 } },
1292
    & ifmt_swcp, { 0x3009 }
1293
  },
1294
/* smcp $crn64,($rma) */
1295
  {
1296
    { 0, 0, 0, 0 },
1297
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), ')', 0 } },
1298
    & ifmt_smcp, { 0x300a }
1299
  },
1300
/* lmcp $crn64,($rma) */
1301
  {
1302
    { 0, 0, 0, 0 },
1303
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), ')', 0 } },
1304
    & ifmt_smcp, { 0x300b }
1305
  },
1306
/* swcpi $crn,($rma+) */
1307
  {
1308
    { 0, 0, 0, 0 },
1309
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', 0 } },
1310
    & ifmt_swcp, { 0x3000 }
1311
  },
1312
/* lwcpi $crn,($rma+) */
1313
  {
1314
    { 0, 0, 0, 0 },
1315
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', 0 } },
1316
    & ifmt_swcp, { 0x3001 }
1317
  },
1318
/* smcpi $crn64,($rma+) */
1319
  {
1320
    { 0, 0, 0, 0 },
1321
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', 0 } },
1322
    & ifmt_smcp, { 0x3002 }
1323
  },
1324
/* lmcpi $crn64,($rma+) */
1325
  {
1326
    { 0, 0, 0, 0 },
1327
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', 0 } },
1328
    & ifmt_smcp, { 0x3003 }
1329
  },
1330
/* swcp $crn,$sdisp16($rma) */
1331
  {
1332
    { 0, 0, 0, 0 },
1333
    { { MNEM, ' ', OP (CRN), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
1334
    & ifmt_swcp16, { 0xf00c0000 }
1335
  },
1336
/* lwcp $crn,$sdisp16($rma) */
1337
  {
1338
    { 0, 0, 0, 0 },
1339
    { { MNEM, ' ', OP (CRN), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
1340
    & ifmt_swcp16, { 0xf00d0000 }
1341
  },
1342
/* smcp $crn64,$sdisp16($rma) */
1343
  {
1344
    { 0, 0, 0, 0 },
1345
    { { MNEM, ' ', OP (CRN64), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
1346
    & ifmt_smcp16, { 0xf00e0000 }
1347
  },
1348
/* lmcp $crn64,$sdisp16($rma) */
1349
  {
1350
    { 0, 0, 0, 0 },
1351
    { { MNEM, ' ', OP (CRN64), ',', OP (SDISP16), '(', OP (RMA), ')', 0 } },
1352
    & ifmt_smcp16, { 0xf00f0000 }
1353
  },
1354
/* sbcpa $crn,($rma+),$cdisp8 */
1355
  {
1356
    { 0, 0, 0, 0 },
1357
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1358
    & ifmt_sbcpa, { 0xf0050000 }
1359
  },
1360
/* lbcpa $crn,($rma+),$cdisp8 */
1361
  {
1362
    { 0, 0, 0, 0 },
1363
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1364
    & ifmt_sbcpa, { 0xf0054000 }
1365
  },
1366
/* shcpa $crn,($rma+),$cdisp8a2 */
1367
  {
1368
    { 0, 0, 0, 0 },
1369
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1370
    & ifmt_shcpa, { 0xf0051000 }
1371
  },
1372
/* lhcpa $crn,($rma+),$cdisp8a2 */
1373
  {
1374
    { 0, 0, 0, 0 },
1375
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1376
    & ifmt_shcpa, { 0xf0055000 }
1377
  },
1378
/* swcpa $crn,($rma+),$cdisp8a4 */
1379
  {
1380
    { 0, 0, 0, 0 },
1381
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1382
    & ifmt_swcpa, { 0xf0052000 }
1383
  },
1384
/* lwcpa $crn,($rma+),$cdisp8a4 */
1385
  {
1386
    { 0, 0, 0, 0 },
1387
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1388
    & ifmt_swcpa, { 0xf0056000 }
1389
  },
1390
/* smcpa $crn64,($rma+),$cdisp8a8 */
1391
  {
1392
    { 0, 0, 0, 0 },
1393
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1394
    & ifmt_smcpa, { 0xf0053000 }
1395
  },
1396
/* lmcpa $crn64,($rma+),$cdisp8a8 */
1397
  {
1398
    { 0, 0, 0, 0 },
1399
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1400
    & ifmt_smcpa, { 0xf0057000 }
1401
  },
1402
/* sbcpm0 $crn,($rma+),$cdisp8 */
1403
  {
1404
    { 0, 0, 0, 0 },
1405
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1406
    & ifmt_sbcpa, { 0xf0050800 }
1407
  },
1408
/* lbcpm0 $crn,($rma+),$cdisp8 */
1409
  {
1410
    { 0, 0, 0, 0 },
1411
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1412
    & ifmt_sbcpa, { 0xf0054800 }
1413
  },
1414
/* shcpm0 $crn,($rma+),$cdisp8a2 */
1415
  {
1416
    { 0, 0, 0, 0 },
1417
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1418
    & ifmt_shcpa, { 0xf0051800 }
1419
  },
1420
/* lhcpm0 $crn,($rma+),$cdisp8a2 */
1421
  {
1422
    { 0, 0, 0, 0 },
1423
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1424
    & ifmt_shcpa, { 0xf0055800 }
1425
  },
1426
/* swcpm0 $crn,($rma+),$cdisp8a4 */
1427
  {
1428
    { 0, 0, 0, 0 },
1429
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1430
    & ifmt_swcpa, { 0xf0052800 }
1431
  },
1432
/* lwcpm0 $crn,($rma+),$cdisp8a4 */
1433
  {
1434
    { 0, 0, 0, 0 },
1435
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1436
    & ifmt_swcpa, { 0xf0056800 }
1437
  },
1438
/* smcpm0 $crn64,($rma+),$cdisp8a8 */
1439
  {
1440
    { 0, 0, 0, 0 },
1441
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1442
    & ifmt_smcpa, { 0xf0053800 }
1443
  },
1444
/* lmcpm0 $crn64,($rma+),$cdisp8a8 */
1445
  {
1446
    { 0, 0, 0, 0 },
1447
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1448
    & ifmt_smcpa, { 0xf0057800 }
1449
  },
1450
/* sbcpm1 $crn,($rma+),$cdisp8 */
1451
  {
1452
    { 0, 0, 0, 0 },
1453
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1454
    & ifmt_sbcpa, { 0xf0050c00 }
1455
  },
1456
/* lbcpm1 $crn,($rma+),$cdisp8 */
1457
  {
1458
    { 0, 0, 0, 0 },
1459
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8), 0 } },
1460
    & ifmt_sbcpa, { 0xf0054c00 }
1461
  },
1462
/* shcpm1 $crn,($rma+),$cdisp8a2 */
1463
  {
1464
    { 0, 0, 0, 0 },
1465
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1466
    & ifmt_shcpa, { 0xf0051c00 }
1467
  },
1468
/* lhcpm1 $crn,($rma+),$cdisp8a2 */
1469
  {
1470
    { 0, 0, 0, 0 },
1471
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A2), 0 } },
1472
    & ifmt_shcpa, { 0xf0055c00 }
1473
  },
1474
/* swcpm1 $crn,($rma+),$cdisp8a4 */
1475
  {
1476
    { 0, 0, 0, 0 },
1477
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1478
    & ifmt_swcpa, { 0xf0052c00 }
1479
  },
1480
/* lwcpm1 $crn,($rma+),$cdisp8a4 */
1481
  {
1482
    { 0, 0, 0, 0 },
1483
    { { MNEM, ' ', OP (CRN), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A4), 0 } },
1484
    & ifmt_swcpa, { 0xf0056c00 }
1485
  },
1486
/* smcpm1 $crn64,($rma+),$cdisp8a8 */
1487
  {
1488
    { 0, 0, 0, 0 },
1489
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1490
    & ifmt_smcpa, { 0xf0053c00 }
1491
  },
1492
/* lmcpm1 $crn64,($rma+),$cdisp8a8 */
1493
  {
1494
    { 0, 0, 0, 0 },
1495
    { { MNEM, ' ', OP (CRN64), ',', '(', OP (RMA), '+', ')', ',', OP (CDISP8A8), 0 } },
1496
    & ifmt_smcpa, { 0xf0057c00 }
1497
  },
1498
/* bcpeq $cccc,$pcrel17a2 */
1499
  {
1500
    { 0, 0, 0, 0 },
1501
    { { MNEM, ' ', OP (CCCC), ',', OP (PCREL17A2), 0 } },
1502
    & ifmt_bcpeq, { 0xd8040000 }
1503
  },
1504
/* bcpne $cccc,$pcrel17a2 */
1505
  {
1506
    { 0, 0, 0, 0 },
1507
    { { MNEM, ' ', OP (CCCC), ',', OP (PCREL17A2), 0 } },
1508
    & ifmt_bcpeq, { 0xd8050000 }
1509
  },
1510
/* bcpat $cccc,$pcrel17a2 */
1511
  {
1512
    { 0, 0, 0, 0 },
1513
    { { MNEM, ' ', OP (CCCC), ',', OP (PCREL17A2), 0 } },
1514
    & ifmt_bcpeq, { 0xd8060000 }
1515
  },
1516
/* bcpaf $cccc,$pcrel17a2 */
1517
  {
1518
    { 0, 0, 0, 0 },
1519
    { { MNEM, ' ', OP (CCCC), ',', OP (PCREL17A2), 0 } },
1520
    & ifmt_bcpeq, { 0xd8070000 }
1521
  },
1522
/* synccp */
1523
  {
1524
    { 0, 0, 0, 0 },
1525
    { { MNEM, 0 } },
1526
    & ifmt_ret, { 0x7021 }
1527
  },
1528
/* jsrv $rm */
1529
  {
1530
    { 0, 0, 0, 0 },
1531
    { { MNEM, ' ', OP (RM), 0 } },
1532
    & ifmt_jmp, { 0x180f }
1533
  },
1534
/* bsrv $pcrel24a2 */
1535
  {
1536
    { 0, 0, 0, 0 },
1537
    { { MNEM, ' ', OP (PCREL24A2), 0 } },
1538
    & ifmt_bsr24, { 0xd80b0000 }
1539
  },
1540
/* --unused-- */
1541
  {
1542
    { 0, 0, 0, 0 },
1543
    { { MNEM, 0 } },
1544
    & ifmt_sim_syscall, { 0x7800 }
1545
  },
1546
/* --reserved-- */
1547
  {
1548
    { 0, 0, 0, 0 },
1549
    { { MNEM, 0 } },
1550
    & ifmt_mov, { 0x6 }
1551
  },
1552
/* --reserved-- */
1553
  {
1554
    { 0, 0, 0, 0 },
1555
    { { MNEM, 0 } },
1556
    & ifmt_mov, { 0x100a }
1557
  },
1558
/* --reserved-- */
1559
  {
1560
    { 0, 0, 0, 0 },
1561
    { { MNEM, 0 } },
1562
    & ifmt_mov, { 0x100b }
1563
  },
1564
/* --reserved-- */
1565
  {
1566
    { 0, 0, 0, 0 },
1567
    { { MNEM, 0 } },
1568
    & ifmt_mov, { 0x2005 }
1569
  },
1570
/* --reserved-- */
1571
  {
1572
    { 0, 0, 0, 0 },
1573
    { { MNEM, 0 } },
1574
    & ifmt_mov, { 0x2008 }
1575
  },
1576
/* --reserved-- */
1577
  {
1578
    { 0, 0, 0, 0 },
1579
    { { MNEM, 0 } },
1580
    & ifmt_mov, { 0x2009 }
1581
  },
1582
/* --reserved-- */
1583
  {
1584
    { 0, 0, 0, 0 },
1585
    { { MNEM, 0 } },
1586
    & ifmt_mov, { 0x200a }
1587
  },
1588
/* --reserved-- */
1589
  {
1590
    { 0, 0, 0, 0 },
1591
    { { MNEM, 0 } },
1592
    & ifmt_mov, { 0x200b }
1593
  },
1594
/* --reserved-- */
1595
  {
1596
    { 0, 0, 0, 0 },
1597
    { { MNEM, 0 } },
1598
    & ifmt_mov, { 0x3004 }
1599
  },
1600
/* --reserved-- */
1601
  {
1602
    { 0, 0, 0, 0 },
1603
    { { MNEM, 0 } },
1604
    & ifmt_mov, { 0x3005 }
1605
  },
1606
/* --reserved-- */
1607
  {
1608
    { 0, 0, 0, 0 },
1609
    { { MNEM, 0 } },
1610
    & ifmt_mov, { 0x3006 }
1611
  },
1612
/* --reserved-- */
1613
  {
1614
    { 0, 0, 0, 0 },
1615
    { { MNEM, 0 } },
1616
    & ifmt_mov, { 0x3007 }
1617
  },
1618
/* --reserved-- */
1619
  {
1620
    { 0, 0, 0, 0 },
1621
    { { MNEM, 0 } },
1622
    & ifmt_mov, { 0x300c }
1623
  },
1624
/* --reserved-- */
1625
  {
1626
    { 0, 0, 0, 0 },
1627
    { { MNEM, 0 } },
1628
    & ifmt_mov, { 0x300d }
1629
  },
1630
/* --reserved-- */
1631
  {
1632
    { 0, 0, 0, 0 },
1633
    { { MNEM, 0 } },
1634
    & ifmt_mov, { 0x300e }
1635
  },
1636
/* --reserved-- */
1637
  {
1638
    { 0, 0, 0, 0 },
1639
    { { MNEM, 0 } },
1640
    & ifmt_mov, { 0x300f }
1641
  },
1642
/* --reserved-- */
1643
  {
1644
    { 0, 0, 0, 0 },
1645
    { { MNEM, 0 } },
1646
    & ifmt_mov, { 0x7007 }
1647
  },
1648
/* --reserved-- */
1649
  {
1650
    { 0, 0, 0, 0 },
1651
    { { MNEM, 0 } },
1652
    & ifmt_mov, { 0x700e }
1653
  },
1654
/* --reserved-- */
1655
  {
1656
    { 0, 0, 0, 0 },
1657
    { { MNEM, 0 } },
1658
    & ifmt_mov, { 0x700f }
1659
  },
1660
/* --reserved-- */
1661
  {
1662
    { 0, 0, 0, 0 },
1663
    { { MNEM, 0 } },
1664
    & ifmt_mov, { 0xc007 }
1665
  },
1666
/* --reserved-- */
1667
  {
1668
    { 0, 0, 0, 0 },
1669
    { { MNEM, 0 } },
1670
    & ifmt_mov, { 0xe00d }
1671
  },
1672
/* --reserved-- */
1673
  {
1674
    { 0, 0, 0, 0 },
1675
    { { MNEM, 0 } },
1676
    & ifmt_mov, { 0xf003 }
1677
  },
1678
/* --reserved-- */
1679
  {
1680
    { 0, 0, 0, 0 },
1681
    { { MNEM, 0 } },
1682
    & ifmt_mov, { 0xf006 }
1683
  },
1684
/* --reserved-- */
1685
  {
1686
    { 0, 0, 0, 0 },
1687
    { { MNEM, 0 } },
1688
    & ifmt_mov, { 0xf008 }
1689
  },
1690
/* --reserved-- */
1691
  {
1692
    { 0, 0, 0, 0 },
1693
    { { MNEM, 0 } },
1694
    & ifmt_mov, { 0x7005 }
1695
  },
1696
/* --reserved-- */
1697
  {
1698
    { 0, 0, 0, 0 },
1699
    { { MNEM, 0 } },
1700
    & ifmt_mov, { 0x700c }
1701
  },
1702
/* --reserved-- */
1703
  {
1704
    { 0, 0, 0, 0 },
1705
    { { MNEM, 0 } },
1706
    & ifmt_mov, { 0x700d }
1707
  },
1708
/* fadds ${fmax-FRd},${fmax-FRn},${fmax-FRm} */
1709
  {
1710
    { 0, 0, 0, 0 },
1711
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1712
    & ifmt_fadds, { 0xf0070000 }
1713
  },
1714
/* fsubs ${fmax-FRd},${fmax-FRn},${fmax-FRm} */
1715
  {
1716
    { 0, 0, 0, 0 },
1717
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1718
    & ifmt_fadds, { 0xf0170000 }
1719
  },
1720
/* fmuls ${fmax-FRd},${fmax-FRn},${fmax-FRm} */
1721
  {
1722
    { 0, 0, 0, 0 },
1723
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1724
    & ifmt_fadds, { 0xf0270000 }
1725
  },
1726
/* fdivs ${fmax-FRd},${fmax-FRn},${fmax-FRm} */
1727
  {
1728
    { 0, 0, 0, 0 },
1729
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1730
    & ifmt_fadds, { 0xf0370000 }
1731
  },
1732
/* fsqrts ${fmax-FRd},${fmax-FRn} */
1733
  {
1734
    { 0, 0, 0, 0 },
1735
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), 0 } },
1736
    & ifmt_fsqrts, { 0xf0470000 }
1737
  },
1738
/* fabss ${fmax-FRd},${fmax-FRn} */
1739
  {
1740
    { 0, 0, 0, 0 },
1741
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), 0 } },
1742
    & ifmt_fsqrts, { 0xf0570000 }
1743
  },
1744
/* fnegs ${fmax-FRd},${fmax-FRn} */
1745
  {
1746
    { 0, 0, 0, 0 },
1747
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), 0 } },
1748
    & ifmt_fsqrts, { 0xf0770000 }
1749
  },
1750
/* fmovs ${fmax-FRd},${fmax-FRn} */
1751
  {
1752
    { 0, 0, 0, 0 },
1753
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN), 0 } },
1754
    & ifmt_fsqrts, { 0xf0670000 }
1755
  },
1756
/* froundws ${fmax-FRd-int},${fmax-FRn} */
1757
  {
1758
    { 0, 0, 0, 0 },
1759
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_FRN), 0 } },
1760
    & ifmt_froundws, { 0xf0c70000 }
1761
  },
1762
/* ftruncws ${fmax-FRd-int},${fmax-FRn} */
1763
  {
1764
    { 0, 0, 0, 0 },
1765
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_FRN), 0 } },
1766
    & ifmt_froundws, { 0xf0d70000 }
1767
  },
1768
/* fceilws ${fmax-FRd-int},${fmax-FRn} */
1769
  {
1770
    { 0, 0, 0, 0 },
1771
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_FRN), 0 } },
1772
    & ifmt_froundws, { 0xf0e70000 }
1773
  },
1774
/* ffloorws ${fmax-FRd-int},${fmax-FRn} */
1775
  {
1776
    { 0, 0, 0, 0 },
1777
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_FRN), 0 } },
1778
    & ifmt_froundws, { 0xf0f70000 }
1779
  },
1780
/* fcvtws ${fmax-FRd-int},${fmax-FRn} */
1781
  {
1782
    { 0, 0, 0, 0 },
1783
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_FRN), 0 } },
1784
    & ifmt_froundws, { 0xf0471000 }
1785
  },
1786
/* fcvtsw ${fmax-FRd},${fmax-FRn-int} */
1787
  {
1788
    { 0, 0, 0, 0 },
1789
    { { MNEM, ' ', OP (FMAX_FRD), ',', OP (FMAX_FRN_INT), 0 } },
1790
    & ifmt_fcvtsw, { 0xf0079000 }
1791
  },
1792
/* fcmpfs ${fmax-FRn},${fmax-FRm} */
1793
  {
1794
    { 0, 0, 0, 0 },
1795
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1796
    & ifmt_fcmpfs, { 0xf0072000 }
1797
  },
1798
/* fcmpus ${fmax-FRn},${fmax-FRm} */
1799
  {
1800
    { 0, 0, 0, 0 },
1801
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1802
    & ifmt_fcmpfs, { 0xf0172000 }
1803
  },
1804
/* fcmpes ${fmax-FRn},${fmax-FRm} */
1805
  {
1806
    { 0, 0, 0, 0 },
1807
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1808
    & ifmt_fcmpfs, { 0xf0272000 }
1809
  },
1810
/* fcmpues ${fmax-FRn},${fmax-FRm} */
1811
  {
1812
    { 0, 0, 0, 0 },
1813
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1814
    & ifmt_fcmpfs, { 0xf0372000 }
1815
  },
1816
/* fcmpls ${fmax-FRn},${fmax-FRm} */
1817
  {
1818
    { 0, 0, 0, 0 },
1819
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1820
    & ifmt_fcmpfs, { 0xf0472000 }
1821
  },
1822
/* fcmpuls ${fmax-FRn},${fmax-FRm} */
1823
  {
1824
    { 0, 0, 0, 0 },
1825
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1826
    & ifmt_fcmpfs, { 0xf0572000 }
1827
  },
1828
/* fcmples ${fmax-FRn},${fmax-FRm} */
1829
  {
1830
    { 0, 0, 0, 0 },
1831
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1832
    & ifmt_fcmpfs, { 0xf0672000 }
1833
  },
1834
/* fcmpules ${fmax-FRn},${fmax-FRm} */
1835
  {
1836
    { 0, 0, 0, 0 },
1837
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1838
    & ifmt_fcmpfs, { 0xf0772000 }
1839
  },
1840
/* fcmpfis ${fmax-FRn},${fmax-FRm} */
1841
  {
1842
    { 0, 0, 0, 0 },
1843
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1844
    & ifmt_fcmpfs, { 0xf0872000 }
1845
  },
1846
/* fcmpuis ${fmax-FRn},${fmax-FRm} */
1847
  {
1848
    { 0, 0, 0, 0 },
1849
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1850
    & ifmt_fcmpfs, { 0xf0972000 }
1851
  },
1852
/* fcmpeis ${fmax-FRn},${fmax-FRm} */
1853
  {
1854
    { 0, 0, 0, 0 },
1855
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1856
    & ifmt_fcmpfs, { 0xf0a72000 }
1857
  },
1858
/* fcmpueis ${fmax-FRn},${fmax-FRm} */
1859
  {
1860
    { 0, 0, 0, 0 },
1861
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1862
    & ifmt_fcmpfs, { 0xf0b72000 }
1863
  },
1864
/* fcmplis ${fmax-FRn},${fmax-FRm} */
1865
  {
1866
    { 0, 0, 0, 0 },
1867
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1868
    & ifmt_fcmpfs, { 0xf0c72000 }
1869
  },
1870
/* fcmpulis ${fmax-FRn},${fmax-FRm} */
1871
  {
1872
    { 0, 0, 0, 0 },
1873
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1874
    & ifmt_fcmpfs, { 0xf0d72000 }
1875
  },
1876
/* fcmpleis ${fmax-FRn},${fmax-FRm} */
1877
  {
1878
    { 0, 0, 0, 0 },
1879
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1880
    & ifmt_fcmpfs, { 0xf0e72000 }
1881
  },
1882
/* fcmpuleis ${fmax-FRn},${fmax-FRm} */
1883
  {
1884
    { 0, 0, 0, 0 },
1885
    { { MNEM, ' ', OP (FMAX_FRN), ',', OP (FMAX_FRM), 0 } },
1886
    & ifmt_fcmpfs, { 0xf0f72000 }
1887
  },
1888
/* cmov ${fmax-FRd-int},${fmax-Rm} */
1889
  {
1890
    { 0, 0, 0, 0 },
1891
    { { MNEM, ' ', OP (FMAX_FRD_INT), ',', OP (FMAX_RM), 0 } },
1892
    & ifmt_cmov_frn_rm, { 0xf007f000 }
1893
  },
1894
/* cmov ${fmax-Rm},${fmax-FRd-int} */
1895
  {
1896
    { 0, 0, 0, 0 },
1897
    { { MNEM, ' ', OP (FMAX_RM), ',', OP (FMAX_FRD_INT), 0 } },
1898
    & ifmt_cmov_frn_rm, { 0xf007f001 }
1899
  },
1900
/* cmovc ${fmax-CCRn},${fmax-Rm} */
1901
  {
1902
    { 0, 0, 0, 0 },
1903
    { { MNEM, ' ', OP (FMAX_CCRN), ',', OP (FMAX_RM), 0 } },
1904
    & ifmt_cmovc_ccrn_rm, { 0xf007f002 }
1905
  },
1906
/* cmovc ${fmax-Rm},${fmax-CCRn} */
1907
  {
1908
    { 0, 0, 0, 0 },
1909
    { { MNEM, ' ', OP (FMAX_RM), ',', OP (FMAX_CCRN), 0 } },
1910
    & ifmt_cmovc_ccrn_rm, { 0xf007f003 }
1911
  },
1912
};
1913
 
1914
#undef A
1915
#undef OPERAND
1916
#undef MNEM
1917
#undef OP
1918
 
1919
/* Formats for ALIAS macro-insns.  */
1920
 
1921
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1922
#define F(f) & mep_cgen_ifld_table[MEP_##f]
1923
#else
1924
#define F(f) & mep_cgen_ifld_table[MEP_/**/f]
1925
#endif
1926
static const CGEN_IFMT ifmt_nop ATTRIBUTE_UNUSED = {
1927
  16, 16, 0xffff, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1928
};
1929
 
1930
static const CGEN_IFMT ifmt_sb16_0 ATTRIBUTE_UNUSED = {
1931
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1932
};
1933
 
1934
static const CGEN_IFMT ifmt_sh16_0 ATTRIBUTE_UNUSED = {
1935
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1936
};
1937
 
1938
static const CGEN_IFMT ifmt_sw16_0 ATTRIBUTE_UNUSED = {
1939
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1940
};
1941
 
1942
static const CGEN_IFMT ifmt_lb16_0 ATTRIBUTE_UNUSED = {
1943
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1944
};
1945
 
1946
static const CGEN_IFMT ifmt_lh16_0 ATTRIBUTE_UNUSED = {
1947
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1948
};
1949
 
1950
static const CGEN_IFMT ifmt_lw16_0 ATTRIBUTE_UNUSED = {
1951
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1952
};
1953
 
1954
static const CGEN_IFMT ifmt_lbu16_0 ATTRIBUTE_UNUSED = {
1955
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1956
};
1957
 
1958
static const CGEN_IFMT ifmt_lhu16_0 ATTRIBUTE_UNUSED = {
1959
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_RN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1960
};
1961
 
1962
static const CGEN_IFMT ifmt_swcp16_0 ATTRIBUTE_UNUSED = {
1963
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1964
};
1965
 
1966
static const CGEN_IFMT ifmt_lwcp16_0 ATTRIBUTE_UNUSED = {
1967
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1968
};
1969
 
1970
static const CGEN_IFMT ifmt_smcp16_0 ATTRIBUTE_UNUSED = {
1971
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1972
};
1973
 
1974
static const CGEN_IFMT ifmt_lmcp16_0 ATTRIBUTE_UNUSED = {
1975
  16, 16, 0xf00f, { { F (F_MAJOR) }, { F (F_CRN) }, { F (F_RM) }, { F (F_SUB4) }, { 0 } }
1976
};
1977
 
1978
#undef F
1979
 
1980
/* Each non-simple macro entry points to an array of expansion possibilities.  */
1981
 
1982
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1983
#define A(a) (1 << CGEN_INSN_##a)
1984
#else
1985
#define A(a) (1 << CGEN_INSN_/**/a)
1986
#endif
1987
#if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1988
#define OPERAND(op) MEP_OPERAND_##op
1989
#else
1990
#define OPERAND(op) MEP_OPERAND_/**/op
1991
#endif
1992
#define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
1993
#define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
1994
 
1995
/* The macro instruction table.  */
1996
 
1997
static const CGEN_IBASE mep_cgen_macro_insn_table[] =
1998
{
1999
/* nop */
2000
  {
2001
    -1, "nop", "nop", 16,
2002
    { 0|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\x80" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2003
  },
2004
/* sb $rnc,$zero($rma) */
2005
  {
2006
    -1, "sb16-0", "sb", 16,
2007
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2008
  },
2009
/* sh $rns,$zero($rma) */
2010
  {
2011
    -1, "sh16-0", "sh", 16,
2012
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2013
  },
2014
/* sw $rnl,$zero($rma) */
2015
  {
2016
    -1, "sw16-0", "sw", 16,
2017
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2018
  },
2019
/* lb $rnc,$zero($rma) */
2020
  {
2021
    -1, "lb16-0", "lb", 16,
2022
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2023
  },
2024
/* lh $rns,$zero($rma) */
2025
  {
2026
    -1, "lh16-0", "lh", 16,
2027
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2028
  },
2029
/* lw $rnl,$zero($rma) */
2030
  {
2031
    -1, "lw16-0", "lw", 16,
2032
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2033
  },
2034
/* lbu $rnuc,$zero($rma) */
2035
  {
2036
    -1, "lbu16-0", "lbu", 16,
2037
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2038
  },
2039
/* lhu $rnus,$zero($rma) */
2040
  {
2041
    -1, "lhu16-0", "lhu", 16,
2042
    { 0|A(NO_DIS)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2043
  },
2044
/* swcp $crn,$zero($rma) */
2045
  {
2046
    -1, "swcp16-0", "swcp", 16,
2047
    { 0|A(NO_DIS)|A(OPTIONAL_CP_INSN)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2048
  },
2049
/* lwcp $crn,$zero($rma) */
2050
  {
2051
    -1, "lwcp16-0", "lwcp", 16,
2052
    { 0|A(NO_DIS)|A(OPTIONAL_CP_INSN)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2053
  },
2054
/* smcp $crn64,$zero($rma) */
2055
  {
2056
    -1, "smcp16-0", "smcp", 16,
2057
    { 0|A(NO_DIS)|A(OPTIONAL_CP64_INSN)|A(OPTIONAL_CP_INSN)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2058
  },
2059
/* lmcp $crn64,$zero($rma) */
2060
  {
2061
    -1, "lmcp16-0", "lmcp", 16,
2062
    { 0|A(NO_DIS)|A(OPTIONAL_CP64_INSN)|A(OPTIONAL_CP_INSN)|A(ALIAS), { { { (1<<MACH_BASE), 0 } }, { { 1, "\xe0" } }, { { 0, 0 } }, { { CONFIG_NONE, 0 } } } }
2063
  },
2064
};
2065
 
2066
/* The macro instruction opcode table.  */
2067
 
2068
static const CGEN_OPCODE mep_cgen_macro_insn_opcode_table[] =
2069
{
2070
/* nop */
2071
  {
2072
    { 0, 0, 0, 0 },
2073
    { { MNEM, 0 } },
2074
    & ifmt_nop, { 0x0 }
2075
  },
2076
/* sb $rnc,$zero($rma) */
2077
  {
2078
    { 0, 0, 0, 0 },
2079
    { { MNEM, ' ', OP (RNC), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2080
    & ifmt_sb16_0, { 0x8 }
2081
  },
2082
/* sh $rns,$zero($rma) */
2083
  {
2084
    { 0, 0, 0, 0 },
2085
    { { MNEM, ' ', OP (RNS), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2086
    & ifmt_sh16_0, { 0x9 }
2087
  },
2088
/* sw $rnl,$zero($rma) */
2089
  {
2090
    { 0, 0, 0, 0 },
2091
    { { MNEM, ' ', OP (RNL), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2092
    & ifmt_sw16_0, { 0xa }
2093
  },
2094
/* lb $rnc,$zero($rma) */
2095
  {
2096
    { 0, 0, 0, 0 },
2097
    { { MNEM, ' ', OP (RNC), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2098
    & ifmt_lb16_0, { 0xc }
2099
  },
2100
/* lh $rns,$zero($rma) */
2101
  {
2102
    { 0, 0, 0, 0 },
2103
    { { MNEM, ' ', OP (RNS), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2104
    & ifmt_lh16_0, { 0xd }
2105
  },
2106
/* lw $rnl,$zero($rma) */
2107
  {
2108
    { 0, 0, 0, 0 },
2109
    { { MNEM, ' ', OP (RNL), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2110
    & ifmt_lw16_0, { 0xe }
2111
  },
2112
/* lbu $rnuc,$zero($rma) */
2113
  {
2114
    { 0, 0, 0, 0 },
2115
    { { MNEM, ' ', OP (RNUC), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2116
    & ifmt_lbu16_0, { 0xb }
2117
  },
2118
/* lhu $rnus,$zero($rma) */
2119
  {
2120
    { 0, 0, 0, 0 },
2121
    { { MNEM, ' ', OP (RNUS), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2122
    & ifmt_lhu16_0, { 0xf }
2123
  },
2124
/* swcp $crn,$zero($rma) */
2125
  {
2126
    { 0, 0, 0, 0 },
2127
    { { MNEM, ' ', OP (CRN), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2128
    & ifmt_swcp16_0, { 0x3008 }
2129
  },
2130
/* lwcp $crn,$zero($rma) */
2131
  {
2132
    { 0, 0, 0, 0 },
2133
    { { MNEM, ' ', OP (CRN), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2134
    & ifmt_lwcp16_0, { 0x3009 }
2135
  },
2136
/* smcp $crn64,$zero($rma) */
2137
  {
2138
    { 0, 0, 0, 0 },
2139
    { { MNEM, ' ', OP (CRN64), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2140
    & ifmt_smcp16_0, { 0x300a }
2141
  },
2142
/* lmcp $crn64,$zero($rma) */
2143
  {
2144
    { 0, 0, 0, 0 },
2145
    { { MNEM, ' ', OP (CRN64), ',', OP (ZERO), '(', OP (RMA), ')', 0 } },
2146
    & ifmt_lmcp16_0, { 0x300b }
2147
  },
2148
};
2149
 
2150
#undef A
2151
#undef OPERAND
2152
#undef MNEM
2153
#undef OP
2154
 
2155
#ifndef CGEN_ASM_HASH_P
2156
#define CGEN_ASM_HASH_P(insn) 1
2157
#endif
2158
 
2159
#ifndef CGEN_DIS_HASH_P
2160
#define CGEN_DIS_HASH_P(insn) 1
2161
#endif
2162
 
2163
/* Return non-zero if INSN is to be added to the hash table.
2164
   Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file.  */
2165
 
2166
static int
2167
asm_hash_insn_p (insn)
2168
     const CGEN_INSN *insn ATTRIBUTE_UNUSED;
2169
{
2170
  return CGEN_ASM_HASH_P (insn);
2171
}
2172
 
2173
static int
2174
dis_hash_insn_p (insn)
2175
     const CGEN_INSN *insn;
2176
{
2177
  /* If building the hash table and the NO-DIS attribute is present,
2178
     ignore.  */
2179
  if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NO_DIS))
2180
    return 0;
2181
  return CGEN_DIS_HASH_P (insn);
2182
}
2183
 
2184
#ifndef CGEN_ASM_HASH
2185
#define CGEN_ASM_HASH_SIZE 127
2186
#ifdef CGEN_MNEMONIC_OPERANDS
2187
#define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
2188
#else
2189
#define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
2190
#endif
2191
#endif
2192
 
2193
/* It doesn't make much sense to provide a default here,
2194
   but while this is under development we do.
2195
   BUFFER is a pointer to the bytes of the insn, target order.
2196
   VALUE is the first base_insn_bitsize bits as an int in host order.  */
2197
 
2198
#ifndef CGEN_DIS_HASH
2199
#define CGEN_DIS_HASH_SIZE 256
2200
#define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
2201
#endif
2202
 
2203
/* The result is the hash value of the insn.
2204
   Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file.  */
2205
 
2206
static unsigned int
2207
asm_hash_insn (mnem)
2208
     const char * mnem;
2209
{
2210
  return CGEN_ASM_HASH (mnem);
2211
}
2212
 
2213
/* BUF is a pointer to the bytes of the insn, target order.
2214
   VALUE is the first base_insn_bitsize bits as an int in host order.  */
2215
 
2216
static unsigned int
2217
dis_hash_insn (buf, value)
2218
     const char * buf ATTRIBUTE_UNUSED;
2219
     CGEN_INSN_INT value ATTRIBUTE_UNUSED;
2220
{
2221
  return CGEN_DIS_HASH (buf, value);
2222
}
2223
 
2224
/* Set the recorded length of the insn in the CGEN_FIELDS struct.  */
2225
 
2226
static void
2227
set_fields_bitsize (CGEN_FIELDS *fields, int size)
2228
{
2229
  CGEN_FIELDS_BITSIZE (fields) = size;
2230
}
2231
 
2232
/* Function to call before using the operand instance table.
2233
   This plugs the opcode entries and macro instructions into the cpu table.  */
2234
 
2235
void
2236
mep_cgen_init_opcode_table (CGEN_CPU_DESC cd)
2237
{
2238
  int i;
2239
  int num_macros = (sizeof (mep_cgen_macro_insn_table) /
2240
                    sizeof (mep_cgen_macro_insn_table[0]));
2241
  const CGEN_IBASE *ib = & mep_cgen_macro_insn_table[0];
2242
  const CGEN_OPCODE *oc = & mep_cgen_macro_insn_opcode_table[0];
2243
  CGEN_INSN *insns = xmalloc (num_macros * sizeof (CGEN_INSN));
2244
 
2245
  memset (insns, 0, num_macros * sizeof (CGEN_INSN));
2246
  for (i = 0; i < num_macros; ++i)
2247
    {
2248
      insns[i].base = &ib[i];
2249
      insns[i].opcode = &oc[i];
2250
      mep_cgen_build_insn_regex (& insns[i]);
2251
    }
2252
  cd->macro_insn_table.init_entries = insns;
2253
  cd->macro_insn_table.entry_size = sizeof (CGEN_IBASE);
2254
  cd->macro_insn_table.num_init_entries = num_macros;
2255
 
2256
  oc = & mep_cgen_insn_opcode_table[0];
2257
  insns = (CGEN_INSN *) cd->insn_table.init_entries;
2258
  for (i = 0; i < MAX_INSNS; ++i)
2259
    {
2260
      insns[i].opcode = &oc[i];
2261
      mep_cgen_build_insn_regex (& insns[i]);
2262
    }
2263
 
2264
  cd->sizeof_fields = sizeof (CGEN_FIELDS);
2265
  cd->set_fields_bitsize = set_fields_bitsize;
2266
 
2267
  cd->asm_hash_p = asm_hash_insn_p;
2268
  cd->asm_hash = asm_hash_insn;
2269
  cd->asm_hash_size = CGEN_ASM_HASH_SIZE;
2270
 
2271
  cd->dis_hash_p = dis_hash_insn_p;
2272
  cd->dis_hash = dis_hash_insn;
2273
  cd->dis_hash_size = CGEN_DIS_HASH_SIZE;
2274
}

powered by: WebSVN 2.1.0

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