1 /* Instruction opcode table for m32r.
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
5 Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
7 This file is part of the GNU Binutils and/or GDB, the GNU debugger.
9 This program 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 2, or (at your option)
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License along
20 with this program; if not, write to the Free Software Foundation, Inc.,
21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
29 #include "m32r-desc.h"
31 #include "libiberty.h"
33 /* The hash functions are recorded here to help keep assembler code out of
34 the disassembler and vice versa. */
36 static int asm_hash_insn_p
PARAMS ((const CGEN_INSN
*));
37 static unsigned int asm_hash_insn
PARAMS ((const char *));
38 static int dis_hash_insn_p
PARAMS ((const CGEN_INSN
*));
39 static unsigned int dis_hash_insn
PARAMS ((const char *, CGEN_INSN_INT
));
40 static void set_fields_bitsize
PARAMS ((CGEN_FIELDS
*, int));
42 /* Instruction formats. */
44 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
45 #define F(f) & m32r_cgen_ifld_table[M32R_##f]
47 #define F(f) & m32r_cgen_ifld_table[M32R_/**/f]
49 static const CGEN_IFMT ifmt_empty
= {
53 static const CGEN_IFMT ifmt_add
= {
54 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
57 static const CGEN_IFMT ifmt_add3
= {
58 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
61 static const CGEN_IFMT ifmt_and3
= {
62 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_UIMM16
) }, { 0 } }
65 static const CGEN_IFMT ifmt_or3
= {
66 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_UIMM16
) }, { 0 } }
69 static const CGEN_IFMT ifmt_addi
= {
70 16, 16, 0xf000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_SIMM8
) }, { 0 } }
73 static const CGEN_IFMT ifmt_addv3
= {
74 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
77 static const CGEN_IFMT ifmt_bc8
= {
78 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
81 static const CGEN_IFMT ifmt_bc24
= {
82 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
85 static const CGEN_IFMT ifmt_beq
= {
86 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_DISP16
) }, { 0 } }
89 static const CGEN_IFMT ifmt_beqz
= {
90 32, 32, 0xfff00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_DISP16
) }, { 0 } }
93 static const CGEN_IFMT ifmt_cmp
= {
94 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
97 static const CGEN_IFMT ifmt_cmpi
= {
98 32, 32, 0xfff00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
101 static const CGEN_IFMT ifmt_cmpz
= {
102 16, 16, 0xfff0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
105 static const CGEN_IFMT ifmt_div
= {
106 32, 32, 0xf0f0ffff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
109 static const CGEN_IFMT ifmt_jc
= {
110 16, 16, 0xfff0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
113 static const CGEN_IFMT ifmt_ld24
= {
114 32, 32, 0xf0000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_UIMM24
) }, { 0 } }
117 static const CGEN_IFMT ifmt_ldi16
= {
118 32, 32, 0xf0ff0000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
121 static const CGEN_IFMT ifmt_machi_a
= {
122 16, 16, 0xf070, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_ACC
) }, { F (F_OP23
) }, { F (F_R2
) }, { 0 } }
125 static const CGEN_IFMT ifmt_mvfachi
= {
126 16, 16, 0xf0ff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
129 static const CGEN_IFMT ifmt_mvfachi_a
= {
130 16, 16, 0xf0f3, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_OP3
) }, { 0 } }
133 static const CGEN_IFMT ifmt_mvfc
= {
134 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
137 static const CGEN_IFMT ifmt_mvtachi
= {
138 16, 16, 0xf0ff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
141 static const CGEN_IFMT ifmt_mvtachi_a
= {
142 16, 16, 0xf0f3, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_OP3
) }, { 0 } }
145 static const CGEN_IFMT ifmt_mvtc
= {
146 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
149 static const CGEN_IFMT ifmt_nop
= {
150 16, 16, 0xffff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
153 static const CGEN_IFMT ifmt_rac_dsi
= {
154 16, 16, 0xf3f2, { { F (F_OP1
) }, { F (F_ACCD
) }, { F (F_BITS67
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_BIT14
) }, { F (F_IMM1
) }, { 0 } }
157 static const CGEN_IFMT ifmt_seth
= {
158 32, 32, 0xf0ff0000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_HI16
) }, { 0 } }
161 static const CGEN_IFMT ifmt_slli
= {
162 16, 16, 0xf0e0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_SHIFT_OP2
) }, { F (F_UIMM5
) }, { 0 } }
165 static const CGEN_IFMT ifmt_st_d
= {
166 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
169 static const CGEN_IFMT ifmt_trap
= {
170 16, 16, 0xfff0, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_UIMM4
) }, { 0 } }
173 static const CGEN_IFMT ifmt_satb
= {
174 32, 32, 0xf0f0ffff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_UIMM16
) }, { 0 } }
179 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
180 #define A(a) (1 << CGEN_INSN_##a)
182 #define A(a) (1 << CGEN_INSN_/**/a)
184 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
185 #define OPERAND(op) M32R_OPERAND_##op
187 #define OPERAND(op) M32R_OPERAND_/**/op
189 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
190 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
192 /* The instruction table. */
194 static const CGEN_OPCODE m32r_cgen_insn_opcode_table
[MAX_INSNS
] =
196 /* Special null first entry.
197 A `num' value of zero is thus invalid.
198 Also, the special `invalid' insn resides here. */
199 { { 0, 0, 0, 0 }, {{0}}, 0, {0}},
203 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
206 /* add3 $dr,$sr,$hash$slo16 */
209 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (HASH
), OP (SLO16
), 0 } },
210 & ifmt_add3
, { 0x80a00000 }
215 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
218 /* and3 $dr,$sr,$uimm16 */
221 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (UIMM16
), 0 } },
222 & ifmt_and3
, { 0x80c00000 }
227 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
230 /* or3 $dr,$sr,$hash$ulo16 */
233 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (HASH
), OP (ULO16
), 0 } },
234 & ifmt_or3
, { 0x80e00000 }
239 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
242 /* xor3 $dr,$sr,$uimm16 */
245 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (UIMM16
), 0 } },
246 & ifmt_and3
, { 0x80d00000 }
248 /* addi $dr,$simm8 */
251 { { MNEM
, ' ', OP (DR
), ',', OP (SIMM8
), 0 } },
252 & ifmt_addi
, { 0x4000 }
257 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
260 /* addv3 $dr,$sr,$simm16 */
263 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (SIMM16
), 0 } },
264 & ifmt_addv3
, { 0x80800000 }
269 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
275 { { MNEM
, ' ', OP (DISP8
), 0 } },
276 & ifmt_bc8
, { 0x7c00 }
281 { { MNEM
, ' ', OP (DISP24
), 0 } },
282 & ifmt_bc24
, { 0xfc000000 }
284 /* beq $src1,$src2,$disp16 */
287 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (DISP16
), 0 } },
288 & ifmt_beq
, { 0xb0000000 }
290 /* beqz $src2,$disp16 */
293 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
294 & ifmt_beqz
, { 0xb0800000 }
296 /* bgez $src2,$disp16 */
299 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
300 & ifmt_beqz
, { 0xb0b00000 }
302 /* bgtz $src2,$disp16 */
305 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
306 & ifmt_beqz
, { 0xb0d00000 }
308 /* blez $src2,$disp16 */
311 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
312 & ifmt_beqz
, { 0xb0c00000 }
314 /* bltz $src2,$disp16 */
317 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
318 & ifmt_beqz
, { 0xb0a00000 }
320 /* bnez $src2,$disp16 */
323 { { MNEM
, ' ', OP (SRC2
), ',', OP (DISP16
), 0 } },
324 & ifmt_beqz
, { 0xb0900000 }
329 { { MNEM
, ' ', OP (DISP8
), 0 } },
330 & ifmt_bc8
, { 0x7e00 }
335 { { MNEM
, ' ', OP (DISP24
), 0 } },
336 & ifmt_bc24
, { 0xfe000000 }
341 { { MNEM
, ' ', OP (DISP8
), 0 } },
342 & ifmt_bc8
, { 0x7800 }
347 { { MNEM
, ' ', OP (DISP24
), 0 } },
348 & ifmt_bc24
, { 0xf8000000 }
353 { { MNEM
, ' ', OP (DISP8
), 0 } },
354 & ifmt_bc8
, { 0x7d00 }
359 { { MNEM
, ' ', OP (DISP24
), 0 } },
360 & ifmt_bc24
, { 0xfd000000 }
362 /* bne $src1,$src2,$disp16 */
365 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (DISP16
), 0 } },
366 & ifmt_beq
, { 0xb0100000 }
371 { { MNEM
, ' ', OP (DISP8
), 0 } },
372 & ifmt_bc8
, { 0x7f00 }
377 { { MNEM
, ' ', OP (DISP24
), 0 } },
378 & ifmt_bc24
, { 0xff000000 }
383 { { MNEM
, ' ', OP (DISP8
), 0 } },
384 & ifmt_bc8
, { 0x7900 }
389 { { MNEM
, ' ', OP (DISP24
), 0 } },
390 & ifmt_bc24
, { 0xf9000000 }
392 /* cmp $src1,$src2 */
395 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
398 /* cmpi $src2,$simm16 */
401 { { MNEM
, ' ', OP (SRC2
), ',', OP (SIMM16
), 0 } },
402 & ifmt_cmpi
, { 0x80400000 }
404 /* cmpu $src1,$src2 */
407 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
410 /* cmpui $src2,$simm16 */
413 { { MNEM
, ' ', OP (SRC2
), ',', OP (SIMM16
), 0 } },
414 & ifmt_cmpi
, { 0x80500000 }
416 /* cmpeq $src1,$src2 */
419 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
425 { { MNEM
, ' ', OP (SRC2
), 0 } },
426 & ifmt_cmpz
, { 0x70 }
431 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
432 & ifmt_div
, { 0x90000000 }
437 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
438 & ifmt_div
, { 0x90100000 }
443 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
444 & ifmt_div
, { 0x90200000 }
449 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
450 & ifmt_div
, { 0x90300000 }
455 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
456 & ifmt_div
, { 0x90000010 }
461 { { MNEM
, ' ', OP (SR
), 0 } },
462 & ifmt_jc
, { 0x1cc0 }
467 { { MNEM
, ' ', OP (SR
), 0 } },
468 & ifmt_jc
, { 0x1dc0 }
473 { { MNEM
, ' ', OP (SR
), 0 } },
474 & ifmt_jc
, { 0x1ec0 }
479 { { MNEM
, ' ', OP (SR
), 0 } },
480 & ifmt_jc
, { 0x1fc0 }
485 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
486 & ifmt_add
, { 0x20c0 }
488 /* ld $dr,@($slo16,$sr) */
491 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SLO16
), ',', OP (SR
), ')', 0 } },
492 & ifmt_add3
, { 0xa0c00000 }
497 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
498 & ifmt_add
, { 0x2080 }
500 /* ldb $dr,@($slo16,$sr) */
503 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SLO16
), ',', OP (SR
), ')', 0 } },
504 & ifmt_add3
, { 0xa0800000 }
509 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
510 & ifmt_add
, { 0x20a0 }
512 /* ldh $dr,@($slo16,$sr) */
515 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SLO16
), ',', OP (SR
), ')', 0 } },
516 & ifmt_add3
, { 0xa0a00000 }
521 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
522 & ifmt_add
, { 0x2090 }
524 /* ldub $dr,@($slo16,$sr) */
527 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SLO16
), ',', OP (SR
), ')', 0 } },
528 & ifmt_add3
, { 0xa0900000 }
533 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
534 & ifmt_add
, { 0x20b0 }
536 /* lduh $dr,@($slo16,$sr) */
539 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SLO16
), ',', OP (SR
), ')', 0 } },
540 & ifmt_add3
, { 0xa0b00000 }
545 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), '+', 0 } },
546 & ifmt_add
, { 0x20e0 }
548 /* ld24 $dr,$uimm24 */
551 { { MNEM
, ' ', OP (DR
), ',', OP (UIMM24
), 0 } },
552 & ifmt_ld24
, { 0xe0000000 }
554 /* ldi8 $dr,$simm8 */
557 { { MNEM
, ' ', OP (DR
), ',', OP (SIMM8
), 0 } },
558 & ifmt_addi
, { 0x6000 }
560 /* ldi16 $dr,$hash$slo16 */
563 { { MNEM
, ' ', OP (DR
), ',', OP (HASH
), OP (SLO16
), 0 } },
564 & ifmt_ldi16
, { 0x90f00000 }
569 { { MNEM
, ' ', OP (DR
), ',', '@', OP (SR
), 0 } },
570 & ifmt_add
, { 0x20d0 }
572 /* machi $src1,$src2 */
575 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
576 & ifmt_cmp
, { 0x3040 }
578 /* machi $src1,$src2,$acc */
581 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
582 & ifmt_machi_a
, { 0x3040 }
584 /* maclo $src1,$src2 */
587 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
588 & ifmt_cmp
, { 0x3050 }
590 /* maclo $src1,$src2,$acc */
593 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
594 & ifmt_machi_a
, { 0x3050 }
596 /* macwhi $src1,$src2 */
599 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
600 & ifmt_cmp
, { 0x3060 }
602 /* macwhi $src1,$src2,$acc */
605 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
606 & ifmt_machi_a
, { 0x3060 }
608 /* macwlo $src1,$src2 */
611 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
612 & ifmt_cmp
, { 0x3070 }
614 /* macwlo $src1,$src2,$acc */
617 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
618 & ifmt_machi_a
, { 0x3070 }
623 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
624 & ifmt_add
, { 0x1060 }
626 /* mulhi $src1,$src2 */
629 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
630 & ifmt_cmp
, { 0x3000 }
632 /* mulhi $src1,$src2,$acc */
635 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
636 & ifmt_machi_a
, { 0x3000 }
638 /* mullo $src1,$src2 */
641 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
642 & ifmt_cmp
, { 0x3010 }
644 /* mullo $src1,$src2,$acc */
647 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
648 & ifmt_machi_a
, { 0x3010 }
650 /* mulwhi $src1,$src2 */
653 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
654 & ifmt_cmp
, { 0x3020 }
656 /* mulwhi $src1,$src2,$acc */
659 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
660 & ifmt_machi_a
, { 0x3020 }
662 /* mulwlo $src1,$src2 */
665 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
666 & ifmt_cmp
, { 0x3030 }
668 /* mulwlo $src1,$src2,$acc */
671 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), ',', OP (ACC
), 0 } },
672 & ifmt_machi_a
, { 0x3030 }
677 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
678 & ifmt_add
, { 0x1080 }
683 { { MNEM
, ' ', OP (DR
), 0 } },
684 & ifmt_mvfachi
, { 0x50f0 }
686 /* mvfachi $dr,$accs */
689 { { MNEM
, ' ', OP (DR
), ',', OP (ACCS
), 0 } },
690 & ifmt_mvfachi_a
, { 0x50f0 }
695 { { MNEM
, ' ', OP (DR
), 0 } },
696 & ifmt_mvfachi
, { 0x50f1 }
698 /* mvfaclo $dr,$accs */
701 { { MNEM
, ' ', OP (DR
), ',', OP (ACCS
), 0 } },
702 & ifmt_mvfachi_a
, { 0x50f1 }
707 { { MNEM
, ' ', OP (DR
), 0 } },
708 & ifmt_mvfachi
, { 0x50f2 }
710 /* mvfacmi $dr,$accs */
713 { { MNEM
, ' ', OP (DR
), ',', OP (ACCS
), 0 } },
714 & ifmt_mvfachi_a
, { 0x50f2 }
719 { { MNEM
, ' ', OP (DR
), ',', OP (SCR
), 0 } },
720 & ifmt_mvfc
, { 0x1090 }
725 { { MNEM
, ' ', OP (SRC1
), 0 } },
726 & ifmt_mvtachi
, { 0x5070 }
728 /* mvtachi $src1,$accs */
731 { { MNEM
, ' ', OP (SRC1
), ',', OP (ACCS
), 0 } },
732 & ifmt_mvtachi_a
, { 0x5070 }
737 { { MNEM
, ' ', OP (SRC1
), 0 } },
738 & ifmt_mvtachi
, { 0x5071 }
740 /* mvtaclo $src1,$accs */
743 { { MNEM
, ' ', OP (SRC1
), ',', OP (ACCS
), 0 } },
744 & ifmt_mvtachi_a
, { 0x5071 }
749 { { MNEM
, ' ', OP (SR
), ',', OP (DCR
), 0 } },
750 & ifmt_mvtc
, { 0x10a0 }
755 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
762 & ifmt_nop
, { 0x7000 }
767 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
774 & ifmt_nop
, { 0x5090 }
776 /* rac $accd,$accs,$imm1 */
779 { { MNEM
, ' ', OP (ACCD
), ',', OP (ACCS
), ',', OP (IMM1
), 0 } },
780 & ifmt_rac_dsi
, { 0x5090 }
786 & ifmt_nop
, { 0x5080 }
788 /* rach $accd,$accs,$imm1 */
791 { { MNEM
, ' ', OP (ACCD
), ',', OP (ACCS
), ',', OP (IMM1
), 0 } },
792 & ifmt_rac_dsi
, { 0x5080 }
798 & ifmt_nop
, { 0x10d6 }
800 /* seth $dr,$hash$hi16 */
803 { { MNEM
, ' ', OP (DR
), ',', OP (HASH
), OP (HI16
), 0 } },
804 & ifmt_seth
, { 0xd0c00000 }
809 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
810 & ifmt_add
, { 0x1040 }
812 /* sll3 $dr,$sr,$simm16 */
815 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (SIMM16
), 0 } },
816 & ifmt_addv3
, { 0x90c00000 }
818 /* slli $dr,$uimm5 */
821 { { MNEM
, ' ', OP (DR
), ',', OP (UIMM5
), 0 } },
822 & ifmt_slli
, { 0x5040 }
827 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
828 & ifmt_add
, { 0x1020 }
830 /* sra3 $dr,$sr,$simm16 */
833 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (SIMM16
), 0 } },
834 & ifmt_addv3
, { 0x90a00000 }
836 /* srai $dr,$uimm5 */
839 { { MNEM
, ' ', OP (DR
), ',', OP (UIMM5
), 0 } },
840 & ifmt_slli
, { 0x5020 }
845 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
846 & ifmt_add
, { 0x1000 }
848 /* srl3 $dr,$sr,$simm16 */
851 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), ',', OP (SIMM16
), 0 } },
852 & ifmt_addv3
, { 0x90800000 }
854 /* srli $dr,$uimm5 */
857 { { MNEM
, ' ', OP (DR
), ',', OP (UIMM5
), 0 } },
858 & ifmt_slli
, { 0x5000 }
860 /* st $src1,@$src2 */
863 { { MNEM
, ' ', OP (SRC1
), ',', '@', OP (SRC2
), 0 } },
864 & ifmt_cmp
, { 0x2040 }
866 /* st $src1,@($slo16,$src2) */
869 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SLO16
), ',', OP (SRC2
), ')', 0 } },
870 & ifmt_st_d
, { 0xa0400000 }
872 /* stb $src1,@$src2 */
875 { { MNEM
, ' ', OP (SRC1
), ',', '@', OP (SRC2
), 0 } },
876 & ifmt_cmp
, { 0x2000 }
878 /* stb $src1,@($slo16,$src2) */
881 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SLO16
), ',', OP (SRC2
), ')', 0 } },
882 & ifmt_st_d
, { 0xa0000000 }
884 /* sth $src1,@$src2 */
887 { { MNEM
, ' ', OP (SRC1
), ',', '@', OP (SRC2
), 0 } },
888 & ifmt_cmp
, { 0x2020 }
890 /* sth $src1,@($slo16,$src2) */
893 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SLO16
), ',', OP (SRC2
), ')', 0 } },
894 & ifmt_st_d
, { 0xa0200000 }
896 /* st $src1,@+$src2 */
899 { { MNEM
, ' ', OP (SRC1
), ',', '@', '+', OP (SRC2
), 0 } },
900 & ifmt_cmp
, { 0x2060 }
902 /* st $src1,@-$src2 */
905 { { MNEM
, ' ', OP (SRC1
), ',', '@', '-', OP (SRC2
), 0 } },
906 & ifmt_cmp
, { 0x2070 }
911 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
917 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
923 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
929 { { MNEM
, ' ', OP (UIMM4
), 0 } },
930 & ifmt_trap
, { 0x10f0 }
932 /* unlock $src1,@$src2 */
935 { { MNEM
, ' ', OP (SRC1
), ',', '@', OP (SRC2
), 0 } },
936 & ifmt_cmp
, { 0x2050 }
941 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
942 & ifmt_satb
, { 0x80600300 }
947 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
948 & ifmt_satb
, { 0x80600200 }
953 { { MNEM
, ' ', OP (DR
), ',', OP (SR
), 0 } },
954 & ifmt_satb
, { 0x80600000 }
959 { { MNEM
, ' ', OP (SRC2
), 0 } },
960 & ifmt_cmpz
, { 0x370 }
966 & ifmt_nop
, { 0x50e4 }
968 /* macwu1 $src1,$src2 */
971 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
972 & ifmt_cmp
, { 0x50b0 }
974 /* msblo $src1,$src2 */
977 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
978 & ifmt_cmp
, { 0x50d0 }
980 /* mulwu1 $src1,$src2 */
983 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
984 & ifmt_cmp
, { 0x50a0 }
986 /* maclh1 $src1,$src2 */
989 { { MNEM
, ' ', OP (SRC1
), ',', OP (SRC2
), 0 } },
990 & ifmt_cmp
, { 0x50c0 }
996 & ifmt_nop
, { 0x7401 }
1002 & ifmt_nop
, { 0x7501 }
1011 /* Formats for ALIAS macro-insns. */
1013 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1014 #define F(f) & m32r_cgen_ifld_table[M32R_##f]
1016 #define F(f) & m32r_cgen_ifld_table[M32R_/**/f]
1018 static const CGEN_IFMT ifmt_bc8r
= {
1019 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1022 static const CGEN_IFMT ifmt_bc24r
= {
1023 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1026 static const CGEN_IFMT ifmt_bl8r
= {
1027 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1030 static const CGEN_IFMT ifmt_bl24r
= {
1031 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1034 static const CGEN_IFMT ifmt_bcl8r
= {
1035 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1038 static const CGEN_IFMT ifmt_bcl24r
= {
1039 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1042 static const CGEN_IFMT ifmt_bnc8r
= {
1043 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1046 static const CGEN_IFMT ifmt_bnc24r
= {
1047 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1050 static const CGEN_IFMT ifmt_bra8r
= {
1051 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1054 static const CGEN_IFMT ifmt_bra24r
= {
1055 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1058 static const CGEN_IFMT ifmt_bncl8r
= {
1059 16, 16, 0xff00, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP8
) }, { 0 } }
1062 static const CGEN_IFMT ifmt_bncl24r
= {
1063 32, 32, 0xff000000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_DISP24
) }, { 0 } }
1066 static const CGEN_IFMT ifmt_ld_2
= {
1067 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1070 static const CGEN_IFMT ifmt_ld_d2
= {
1071 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1074 static const CGEN_IFMT ifmt_ldb_2
= {
1075 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1078 static const CGEN_IFMT ifmt_ldb_d2
= {
1079 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1082 static const CGEN_IFMT ifmt_ldh_2
= {
1083 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1086 static const CGEN_IFMT ifmt_ldh_d2
= {
1087 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1090 static const CGEN_IFMT ifmt_ldub_2
= {
1091 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1094 static const CGEN_IFMT ifmt_ldub_d2
= {
1095 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1098 static const CGEN_IFMT ifmt_lduh_2
= {
1099 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1102 static const CGEN_IFMT ifmt_lduh_d2
= {
1103 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1106 static const CGEN_IFMT ifmt_pop
= {
1107 16, 16, 0xf0ff, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_OP2
) }, { F (F_R2
) }, { 0 } }
1110 static const CGEN_IFMT ifmt_ldi8a
= {
1111 16, 16, 0xf000, { { F (F_OP1
) }, { F (F_R1
) }, { F (F_SIMM8
) }, { 0 } }
1114 static const CGEN_IFMT ifmt_ldi16a
= {
1115 32, 32, 0xf0ff0000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R2
) }, { F (F_R1
) }, { F (F_SIMM16
) }, { 0 } }
1118 static const CGEN_IFMT ifmt_rac_d
= {
1119 16, 16, 0xf3ff, { { F (F_OP1
) }, { F (F_ACCD
) }, { F (F_BITS67
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_BIT14
) }, { F (F_IMM1
) }, { 0 } }
1122 static const CGEN_IFMT ifmt_rac_ds
= {
1123 16, 16, 0xf3f3, { { F (F_OP1
) }, { F (F_ACCD
) }, { F (F_BITS67
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_BIT14
) }, { F (F_IMM1
) }, { 0 } }
1126 static const CGEN_IFMT ifmt_rach_d
= {
1127 16, 16, 0xf3ff, { { F (F_OP1
) }, { F (F_ACCD
) }, { F (F_BITS67
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_BIT14
) }, { F (F_IMM1
) }, { 0 } }
1130 static const CGEN_IFMT ifmt_rach_ds
= {
1131 16, 16, 0xf3f3, { { F (F_OP1
) }, { F (F_ACCD
) }, { F (F_BITS67
) }, { F (F_OP2
) }, { F (F_ACCS
) }, { F (F_BIT14
) }, { F (F_IMM1
) }, { 0 } }
1134 static const CGEN_IFMT ifmt_st_2
= {
1135 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1138 static const CGEN_IFMT ifmt_st_d2
= {
1139 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1142 static const CGEN_IFMT ifmt_stb_2
= {
1143 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1146 static const CGEN_IFMT ifmt_stb_d2
= {
1147 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1150 static const CGEN_IFMT ifmt_sth_2
= {
1151 16, 16, 0xf0f0, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1154 static const CGEN_IFMT ifmt_sth_d2
= {
1155 32, 32, 0xf0f00000, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { F (F_SIMM16
) }, { 0 } }
1158 static const CGEN_IFMT ifmt_push
= {
1159 16, 16, 0xf0ff, { { F (F_OP1
) }, { F (F_OP2
) }, { F (F_R1
) }, { F (F_R2
) }, { 0 } }
1164 /* Each non-simple macro entry points to an array of expansion possibilities. */
1166 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1167 #define A(a) (1 << CGEN_INSN_##a)
1169 #define A(a) (1 << CGEN_INSN_/**/a)
1171 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
1172 #define OPERAND(op) M32R_OPERAND_##op
1174 #define OPERAND(op) M32R_OPERAND_/**/op
1176 #define MNEM CGEN_SYNTAX_MNEMONIC /* syntax value for mnemonic */
1177 #define OP(field) CGEN_SYNTAX_MAKE_FIELD (OPERAND (field))
1179 /* The macro instruction table. */
1181 static const CGEN_IBASE m32r_cgen_macro_insn_table
[] =
1185 -1, "bc8r", "bc", 16,
1186 { 0|A(RELAXABLE
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1190 -1, "bc24r", "bc", 32,
1191 { 0|A(RELAX
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1195 -1, "bl8r", "bl", 16,
1196 { 0|A(RELAXABLE
)|A(FILL_SLOT
)|A(UNCOND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1200 -1, "bl24r", "bl", 32,
1201 { 0|A(RELAX
)|A(UNCOND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1205 -1, "bcl8r", "bcl", 16,
1206 { 0|A(RELAXABLE
)|A(FILL_SLOT
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_O
} }
1210 -1, "bcl24r", "bcl", 32,
1211 { 0|A(RELAX
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_NONE
} }
1215 -1, "bnc8r", "bnc", 16,
1216 { 0|A(RELAXABLE
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1220 -1, "bnc24r", "bnc", 32,
1221 { 0|A(RELAX
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1225 -1, "bra8r", "bra", 16,
1226 { 0|A(RELAXABLE
)|A(FILL_SLOT
)|A(UNCOND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1230 -1, "bra24r", "bra", 32,
1231 { 0|A(RELAX
)|A(UNCOND_CTI
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1235 -1, "bncl8r", "bncl", 16,
1236 { 0|A(RELAXABLE
)|A(FILL_SLOT
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_O
} }
1240 -1, "bncl24r", "bncl", 32,
1241 { 0|A(RELAX
)|A(COND_CTI
)|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_NONE
} }
1245 -1, "ld-2", "ld", 16,
1246 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1248 /* ld $dr,@($sr,$slo16) */
1250 -1, "ld-d2", "ld", 32,
1251 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1253 /* ldb $dr,@($sr) */
1255 -1, "ldb-2", "ldb", 16,
1256 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1258 /* ldb $dr,@($sr,$slo16) */
1260 -1, "ldb-d2", "ldb", 32,
1261 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1263 /* ldh $dr,@($sr) */
1265 -1, "ldh-2", "ldh", 16,
1266 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1268 /* ldh $dr,@($sr,$slo16) */
1270 -1, "ldh-d2", "ldh", 32,
1271 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1273 /* ldub $dr,@($sr) */
1275 -1, "ldub-2", "ldub", 16,
1276 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1278 /* ldub $dr,@($sr,$slo16) */
1280 -1, "ldub-d2", "ldub", 32,
1281 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1283 /* lduh $dr,@($sr) */
1285 -1, "lduh-2", "lduh", 16,
1286 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1288 /* lduh $dr,@($sr,$slo16) */
1290 -1, "lduh-d2", "lduh", 32,
1291 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1295 -1, "pop", "pop", 16,
1296 { 0|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1298 /* ldi $dr,$simm8 */
1300 -1, "ldi8a", "ldi", 16,
1301 { 0|A(ALIAS
), { (1<<MACH_BASE
), PIPE_OS
} }
1303 /* ldi $dr,$hash$slo16 */
1305 -1, "ldi16a", "ldi", 32,
1306 { 0|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1310 -1, "rac-d", "rac", 16,
1311 { 0|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_S
} }
1313 /* rac $accd,$accs */
1315 -1, "rac-ds", "rac", 16,
1316 { 0|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_S
} }
1320 -1, "rach-d", "rach", 16,
1321 { 0|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_S
} }
1323 /* rach $accd,$accs */
1325 -1, "rach-ds", "rach", 16,
1326 { 0|A(ALIAS
), { (1<<MACH_M32RX
), PIPE_S
} }
1328 /* st $src1,@($src2) */
1330 -1, "st-2", "st", 16,
1331 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1333 /* st $src1,@($src2,$slo16) */
1335 -1, "st-d2", "st", 32,
1336 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1338 /* stb $src1,@($src2) */
1340 -1, "stb-2", "stb", 16,
1341 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1343 /* stb $src1,@($src2,$slo16) */
1345 -1, "stb-d2", "stb", 32,
1346 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1348 /* sth $src1,@($src2) */
1350 -1, "sth-2", "sth", 16,
1351 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_O
} }
1353 /* sth $src1,@($src2,$slo16) */
1355 -1, "sth-d2", "sth", 32,
1356 { 0|A(NO_DIS
)|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1360 -1, "push", "push", 16,
1361 { 0|A(ALIAS
), { (1<<MACH_BASE
), PIPE_NONE
} }
1365 /* The macro instruction opcode table. */
1367 static const CGEN_OPCODE m32r_cgen_macro_insn_opcode_table
[] =
1372 { { MNEM
, ' ', OP (DISP8
), 0 } },
1373 & ifmt_bc8r
, { 0x7c00 }
1378 { { MNEM
, ' ', OP (DISP24
), 0 } },
1379 & ifmt_bc24r
, { 0xfc000000 }
1384 { { MNEM
, ' ', OP (DISP8
), 0 } },
1385 & ifmt_bl8r
, { 0x7e00 }
1390 { { MNEM
, ' ', OP (DISP24
), 0 } },
1391 & ifmt_bl24r
, { 0xfe000000 }
1396 { { MNEM
, ' ', OP (DISP8
), 0 } },
1397 & ifmt_bcl8r
, { 0x7800 }
1402 { { MNEM
, ' ', OP (DISP24
), 0 } },
1403 & ifmt_bcl24r
, { 0xf8000000 }
1408 { { MNEM
, ' ', OP (DISP8
), 0 } },
1409 & ifmt_bnc8r
, { 0x7d00 }
1414 { { MNEM
, ' ', OP (DISP24
), 0 } },
1415 & ifmt_bnc24r
, { 0xfd000000 }
1420 { { MNEM
, ' ', OP (DISP8
), 0 } },
1421 & ifmt_bra8r
, { 0x7f00 }
1426 { { MNEM
, ' ', OP (DISP24
), 0 } },
1427 & ifmt_bra24r
, { 0xff000000 }
1432 { { MNEM
, ' ', OP (DISP8
), 0 } },
1433 & ifmt_bncl8r
, { 0x7900 }
1438 { { MNEM
, ' ', OP (DISP24
), 0 } },
1439 & ifmt_bncl24r
, { 0xf9000000 }
1444 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ')', 0 } },
1445 & ifmt_ld_2
, { 0x20c0 }
1447 /* ld $dr,@($sr,$slo16) */
1450 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ',', OP (SLO16
), ')', 0 } },
1451 & ifmt_ld_d2
, { 0xa0c00000 }
1453 /* ldb $dr,@($sr) */
1456 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ')', 0 } },
1457 & ifmt_ldb_2
, { 0x2080 }
1459 /* ldb $dr,@($sr,$slo16) */
1462 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ',', OP (SLO16
), ')', 0 } },
1463 & ifmt_ldb_d2
, { 0xa0800000 }
1465 /* ldh $dr,@($sr) */
1468 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ')', 0 } },
1469 & ifmt_ldh_2
, { 0x20a0 }
1471 /* ldh $dr,@($sr,$slo16) */
1474 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ',', OP (SLO16
), ')', 0 } },
1475 & ifmt_ldh_d2
, { 0xa0a00000 }
1477 /* ldub $dr,@($sr) */
1480 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ')', 0 } },
1481 & ifmt_ldub_2
, { 0x2090 }
1483 /* ldub $dr,@($sr,$slo16) */
1486 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ',', OP (SLO16
), ')', 0 } },
1487 & ifmt_ldub_d2
, { 0xa0900000 }
1489 /* lduh $dr,@($sr) */
1492 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ')', 0 } },
1493 & ifmt_lduh_2
, { 0x20b0 }
1495 /* lduh $dr,@($sr,$slo16) */
1498 { { MNEM
, ' ', OP (DR
), ',', '@', '(', OP (SR
), ',', OP (SLO16
), ')', 0 } },
1499 & ifmt_lduh_d2
, { 0xa0b00000 }
1504 { { MNEM
, ' ', OP (DR
), 0 } },
1505 & ifmt_pop
, { 0x20ef }
1507 /* ldi $dr,$simm8 */
1510 { { MNEM
, ' ', OP (DR
), ',', OP (SIMM8
), 0 } },
1511 & ifmt_ldi8a
, { 0x6000 }
1513 /* ldi $dr,$hash$slo16 */
1516 { { MNEM
, ' ', OP (DR
), ',', OP (HASH
), OP (SLO16
), 0 } },
1517 & ifmt_ldi16a
, { 0x90f00000 }
1522 { { MNEM
, ' ', OP (ACCD
), 0 } },
1523 & ifmt_rac_d
, { 0x5090 }
1525 /* rac $accd,$accs */
1528 { { MNEM
, ' ', OP (ACCD
), ',', OP (ACCS
), 0 } },
1529 & ifmt_rac_ds
, { 0x5090 }
1534 { { MNEM
, ' ', OP (ACCD
), 0 } },
1535 & ifmt_rach_d
, { 0x5080 }
1537 /* rach $accd,$accs */
1540 { { MNEM
, ' ', OP (ACCD
), ',', OP (ACCS
), 0 } },
1541 & ifmt_rach_ds
, { 0x5080 }
1543 /* st $src1,@($src2) */
1546 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ')', 0 } },
1547 & ifmt_st_2
, { 0x2040 }
1549 /* st $src1,@($src2,$slo16) */
1552 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ',', OP (SLO16
), ')', 0 } },
1553 & ifmt_st_d2
, { 0xa0400000 }
1555 /* stb $src1,@($src2) */
1558 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ')', 0 } },
1559 & ifmt_stb_2
, { 0x2000 }
1561 /* stb $src1,@($src2,$slo16) */
1564 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ',', OP (SLO16
), ')', 0 } },
1565 & ifmt_stb_d2
, { 0xa0000000 }
1567 /* sth $src1,@($src2) */
1570 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ')', 0 } },
1571 & ifmt_sth_2
, { 0x2020 }
1573 /* sth $src1,@($src2,$slo16) */
1576 { { MNEM
, ' ', OP (SRC1
), ',', '@', '(', OP (SRC2
), ',', OP (SLO16
), ')', 0 } },
1577 & ifmt_sth_d2
, { 0xa0200000 }
1582 { { MNEM
, ' ', OP (SRC1
), 0 } },
1583 & ifmt_push
, { 0x207f }
1592 #ifndef CGEN_ASM_HASH_P
1593 #define CGEN_ASM_HASH_P(insn) 1
1596 #ifndef CGEN_DIS_HASH_P
1597 #define CGEN_DIS_HASH_P(insn) 1
1600 /* Return non-zero if INSN is to be added to the hash table.
1601 Targets are free to override CGEN_{ASM,DIS}_HASH_P in the .opc file. */
1604 asm_hash_insn_p (insn
)
1605 const CGEN_INSN
*insn ATTRIBUTE_UNUSED
;
1607 return CGEN_ASM_HASH_P (insn
);
1611 dis_hash_insn_p (insn
)
1612 const CGEN_INSN
*insn
;
1614 /* If building the hash table and the NO-DIS attribute is present,
1616 if (CGEN_INSN_ATTR_VALUE (insn
, CGEN_INSN_NO_DIS
))
1618 return CGEN_DIS_HASH_P (insn
);
1621 #ifndef CGEN_ASM_HASH
1622 #define CGEN_ASM_HASH_SIZE 127
1623 #ifdef CGEN_MNEMONIC_OPERANDS
1624 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE)
1626 #define CGEN_ASM_HASH(mnem) (*(unsigned char *) (mnem) % CGEN_ASM_HASH_SIZE) /*FIXME*/
1630 /* It doesn't make much sense to provide a default here,
1631 but while this is under development we do.
1632 BUFFER is a pointer to the bytes of the insn, target order.
1633 VALUE is the first base_insn_bitsize bits as an int in host order. */
1635 #ifndef CGEN_DIS_HASH
1636 #define CGEN_DIS_HASH_SIZE 256
1637 #define CGEN_DIS_HASH(buf, value) (*(unsigned char *) (buf))
1640 /* The result is the hash value of the insn.
1641 Targets are free to override CGEN_{ASM,DIS}_HASH in the .opc file. */
1644 asm_hash_insn (mnem
)
1647 return CGEN_ASM_HASH (mnem
);
1650 /* BUF is a pointer to the bytes of the insn, target order.
1651 VALUE is the first base_insn_bitsize bits as an int in host order. */
1654 dis_hash_insn (buf
, value
)
1656 CGEN_INSN_INT value ATTRIBUTE_UNUSED
;
1658 return CGEN_DIS_HASH (buf
, value
);
1661 /* Set the recorded length of the insn in the CGEN_FIELDS struct. */
1664 set_fields_bitsize (fields
, size
)
1665 CGEN_FIELDS
*fields
;
1668 CGEN_FIELDS_BITSIZE (fields
) = size
;
1671 /* Function to call before using the operand instance table.
1672 This plugs the opcode entries and macro instructions into the cpu table. */
1675 m32r_cgen_init_opcode_table (cd
)
1679 int num_macros
= (sizeof (m32r_cgen_macro_insn_table
) /
1680 sizeof (m32r_cgen_macro_insn_table
[0]));
1681 const CGEN_IBASE
*ib
= & m32r_cgen_macro_insn_table
[0];
1682 const CGEN_OPCODE
*oc
= & m32r_cgen_macro_insn_opcode_table
[0];
1683 CGEN_INSN
*insns
= (CGEN_INSN
*) xmalloc (num_macros
* sizeof (CGEN_INSN
));
1684 memset (insns
, 0, num_macros
* sizeof (CGEN_INSN
));
1685 for (i
= 0; i
< num_macros
; ++i
)
1687 insns
[i
].base
= &ib
[i
];
1688 insns
[i
].opcode
= &oc
[i
];
1689 m32r_cgen_build_insn_regex (& insns
[i
]);
1691 cd
->macro_insn_table
.init_entries
= insns
;
1692 cd
->macro_insn_table
.entry_size
= sizeof (CGEN_IBASE
);
1693 cd
->macro_insn_table
.num_init_entries
= num_macros
;
1695 oc
= & m32r_cgen_insn_opcode_table
[0];
1696 insns
= (CGEN_INSN
*) cd
->insn_table
.init_entries
;
1697 for (i
= 0; i
< MAX_INSNS
; ++i
)
1699 insns
[i
].opcode
= &oc
[i
];
1700 m32r_cgen_build_insn_regex (& insns
[i
]);
1703 cd
->sizeof_fields
= sizeof (CGEN_FIELDS
);
1704 cd
->set_fields_bitsize
= set_fields_bitsize
;
1706 cd
->asm_hash_p
= asm_hash_insn_p
;
1707 cd
->asm_hash
= asm_hash_insn
;
1708 cd
->asm_hash_size
= CGEN_ASM_HASH_SIZE
;
1710 cd
->dis_hash_p
= dis_hash_insn_p
;
1711 cd
->dis_hash
= dis_hash_insn
;
1712 cd
->dis_hash_size
= CGEN_DIS_HASH_SIZE
;