?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
make_device_config: Fix non-fatal error message with dash and other shells
[qemu/agraf.git] / cris-dis.c
blob5fa67d9f29799d60b1ba0d9c645dcbe4bd2492b5
1 /* Disassembler code for CRIS.
2 Copyright 2000, 2001, 2002, 2004, 2005, 2006 Free Software Foundation, Inc.
3 Contributed by Axis Communications AB, Lund, Sweden.
4 Written by Hans-Peter Nilsson.
5
6 This file is part of the GNU binutils and GDB, the GNU debugger.
7
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
11 version.
12
13 This program is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, see <http://www.gnu.org/licenses/>. */
20
21 #include "qemu-common.h"
22 #include "dis-asm.h"
23 //#include "sysdep.h"
24 #include "target-cris/opcode-cris.h"
25 //#include "libiberty.h"
26
27 #define CONST_STRNEQ(STR1,STR2) (strncmp ((STR1), (STR2), sizeof (STR2) - 1) == 0)
28
29 /* cris-opc.c -- Table of opcodes for the CRIS processor.
30 Copyright 2000, 2001, 2004 Free Software Foundation, Inc.
31 Contributed by Axis Communications AB, Lund, Sweden.
32 Originally written for GAS 1.38.1 by Mikael Asker.
33 Reorganized by Hans-Peter Nilsson.
34
35 This file is part of GAS, GDB and the GNU binutils.
36
37 GAS, GDB, and GNU binutils is free software; you can redistribute it
38 and/or modify it under the terms of the GNU General Public License as
39 published by the Free Software Foundation; either version 2, or (at your
40 option) any later version.
41
42 GAS, GDB, and GNU binutils are distributed in the hope that they will be
43 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
44 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
45 GNU General Public License for more details.
46
47 You should have received a copy of the GNU General Public License
48 along with this program; if not, see <http://www.gnu.org/licenses/>. */
49
50 #ifndef NULL
51 #define NULL (0)
52 #endif
53
54 /* This table isn't used for CRISv32 and the size of immediate operands. */
55 const struct cris_spec_reg
56 cris_spec_regs[] =
57 {
58 {"bz", 0, 1, cris_ver_v32p, NULL},
59 {"p0", 0, 1, 0, NULL},
60 {"vr", 1, 1, 0, NULL},
61 {"p1", 1, 1, 0, NULL},
62 {"pid", 2, 1, cris_ver_v32p, NULL},
63 {"p2", 2, 1, cris_ver_v32p, NULL},
64 {"p2", 2, 1, cris_ver_warning, NULL},
65 {"srs", 3, 1, cris_ver_v32p, NULL},
66 {"p3", 3, 1, cris_ver_v32p, NULL},
67 {"p3", 3, 1, cris_ver_warning, NULL},
68 {"wz", 4, 2, cris_ver_v32p, NULL},
69 {"p4", 4, 2, 0, NULL},
70 {"ccr", 5, 2, cris_ver_v0_10, NULL},
71 {"exs", 5, 4, cris_ver_v32p, NULL},
72 {"p5", 5, 2, cris_ver_v0_10, NULL},
73 {"p5", 5, 4, cris_ver_v32p, NULL},
74 {"dcr0",6, 2, cris_ver_v0_3, NULL},
75 {"eda", 6, 4, cris_ver_v32p, NULL},
76 {"p6", 6, 2, cris_ver_v0_3, NULL},
77 {"p6", 6, 4, cris_ver_v32p, NULL},
78 {"dcr1/mof", 7, 4, cris_ver_v10p,
79 "Register `dcr1/mof' with ambiguous size specified. Guessing 4 bytes"},
80 {"dcr1/mof", 7, 2, cris_ver_v0_3,
81 "Register `dcr1/mof' with ambiguous size specified. Guessing 2 bytes"},
82 {"mof", 7, 4, cris_ver_v10p, NULL},
83 {"dcr1",7, 2, cris_ver_v0_3, NULL},
84 {"p7", 7, 4, cris_ver_v10p, NULL},
85 {"p7", 7, 2, cris_ver_v0_3, NULL},
86 {"dz", 8, 4, cris_ver_v32p, NULL},
87 {"p8", 8, 4, 0, NULL},
88 {"ibr", 9, 4, cris_ver_v0_10, NULL},
89 {"ebp", 9, 4, cris_ver_v32p, NULL},
90 {"p9", 9, 4, 0, NULL},
91 {"irp", 10, 4, cris_ver_v0_10, NULL},
92 {"erp", 10, 4, cris_ver_v32p, NULL},
93 {"p10", 10, 4, 0, NULL},
94 {"srp", 11, 4, 0, NULL},
95 {"p11", 11, 4, 0, NULL},
96 /* For disassembly use only. Accept at assembly with a warning. */
97 {"bar/dtp0", 12, 4, cris_ver_warning,
98 "Ambiguous register `bar/dtp0' specified"},
99 {"nrp", 12, 4, cris_ver_v32p, NULL},
100 {"bar", 12, 4, cris_ver_v8_10, NULL},
101 {"dtp0",12, 4, cris_ver_v0_3, NULL},
102 {"p12", 12, 4, 0, NULL},
103 /* For disassembly use only. Accept at assembly with a warning. */
104 {"dccr/dtp1",13, 4, cris_ver_warning,
105 "Ambiguous register `dccr/dtp1' specified"},
106 {"ccs", 13, 4, cris_ver_v32p, NULL},
107 {"dccr",13, 4, cris_ver_v8_10, NULL},
108 {"dtp1",13, 4, cris_ver_v0_3, NULL},
109 {"p13", 13, 4, 0, NULL},
110 {"brp", 14, 4, cris_ver_v3_10, NULL},
111 {"usp", 14, 4, cris_ver_v32p, NULL},
112 {"p14", 14, 4, cris_ver_v3p, NULL},
113 {"usp", 15, 4, cris_ver_v10, NULL},
114 {"spc", 15, 4, cris_ver_v32p, NULL},
115 {"p15", 15, 4, cris_ver_v10p, NULL},
116 {NULL, 0, 0, cris_ver_version_all, NULL}
117 };
118
119 /* Add version specifiers to this table when necessary.
120 The (now) regular coding of register names suggests a simpler
121 implementation. */
122 const struct cris_support_reg cris_support_regs[] =
123 {
124 {"s0", 0},
125 {"s1", 1},
126 {"s2", 2},
127 {"s3", 3},
128 {"s4", 4},
129 {"s5", 5},
130 {"s6", 6},
131 {"s7", 7},
132 {"s8", 8},
133 {"s9", 9},
134 {"s10", 10},
135 {"s11", 11},
136 {"s12", 12},
137 {"s13", 13},
138 {"s14", 14},
139 {"s15", 15},
140 {NULL, 0}
141 };
142
143 /* All CRIS opcodes are 16 bits.
144
145 - The match component is a mask saying which bits must match a
146 particular opcode in order for an instruction to be an instance
147 of that opcode.
148
149 - The args component is a string containing characters symbolically
150 matching the operands of an instruction. Used for both assembly
151 and disassembly.
152
153 Operand-matching characters:
154 [ ] , space
155 Verbatim.
156 A The string "ACR" (case-insensitive).
157 B Not really an operand. It causes a "BDAP -size,SP" prefix to be
158 output for the PUSH alias-instructions and recognizes a push-
159 prefix at disassembly. This letter isn't recognized for v32.
160 Must be followed by a R or P letter.
161 ! Non-match pattern, will not match if there's a prefix insn.
162 b Non-matching operand, used for branches with 16-bit
163 displacement. Only recognized by the disassembler.
164 c 5-bit unsigned immediate in bits <4:0>.
165 C 4-bit unsigned immediate in bits <3:0>.
166 d At assembly, optionally (as in put other cases before this one)
167 ".d" or ".D" at the start of the operands, followed by one space
168 character. At disassembly, nothing.
169 D General register in bits <15:12> and <3:0>.
170 f List of flags in bits <15:12> and <3:0>.
171 i 6-bit signed immediate in bits <5:0>.
172 I 6-bit unsigned immediate in bits <5:0>.
173 M Size modifier (B, W or D) for CLEAR instructions.
174 m Size modifier (B, W or D) in bits <5:4>
175 N A 32-bit dword, like in the difference between s and y.
176 This has no effect on bits in the opcode. Can also be expressed
177 as "[pc+]" in input.
178 n As N, but PC-relative (to the start of the instruction).
179 o [-128..127] word offset in bits <7:1> and <0>. Used by 8-bit
180 branch instructions.
181 O [-128..127] offset in bits <7:0>. Also matches a comma and a
182 general register after the expression, in bits <15:12>. Used
183 only for the BDAP prefix insn (in v32 the ADDOQ insn; same opcode).
184 P Special register in bits <15:12>.
185 p Indicates that the insn is a prefix insn. Must be first
186 character.
187 Q As O, but don't relax; force an 8-bit offset.
188 R General register in bits <15:12>.
189 r General register in bits <3:0>.
190 S Source operand in bit <10> and a prefix; a 3-operand prefix
191 without side-effect.
192 s Source operand in bits <10> and <3:0>, optionally with a
193 side-effect prefix, except [pc] (the name, not R15 as in ACR)
194 isn't allowed for v32 and higher.
195 T Support register in bits <15:12>.
196 u 4-bit (PC-relative) unsigned immediate word offset in bits <3:0>.
197 U Relaxes to either u or n, instruction is assumed LAPCQ or LAPC.
198 Not recognized at disassembly.
199 x Register-dot-modifier, for example "r5.w" in bits <15:12> and <5:4>.
200 y Like 's' but do not allow an integer at assembly.
201 Y The difference s-y; only an integer is allowed.
202 z Size modifier (B or W) in bit <4>. */
203
204
205 /* Please note the order of the opcodes in this table is significant.
206 The assembler requires that all instances of the same mnemonic must
207 be consecutive. If they aren't, the assembler might not recognize
208 them, or may indicate an internal error.
209
210 The disassembler should not normally care about the order of the
211 opcodes, but will prefer an earlier alternative if the "match-score"
212 (see cris-dis.c) is computed as equal.
213
214 It should not be significant for proper execution that this table is
215 in alphabetical order, but please follow that convention for an easy
216 overview. */
217
218 const struct cris_opcode
219 cris_opcodes[] =
220 {
221 {"abs", 0x06B0, 0x0940, "r,R", 0, SIZE_NONE, 0,
222 cris_abs_op},
223
224 {"add", 0x0600, 0x09c0, "m r,R", 0, SIZE_NONE, 0,
225 cris_reg_mode_add_sub_cmp_and_or_move_op},
226
227 {"add", 0x0A00, 0x01c0, "m s,R", 0, SIZE_FIELD, 0,
228 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
229
230 {"add", 0x0A00, 0x01c0, "m S,D", 0, SIZE_NONE,
231 cris_ver_v0_10,
232 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
233
234 {"add", 0x0a00, 0x05c0, "m S,R,r", 0, SIZE_NONE,
235 cris_ver_v0_10,
236 cris_three_operand_add_sub_cmp_and_or_op},
237
238 {"add", 0x0A00, 0x01c0, "m s,R", 0, SIZE_FIELD,
239 cris_ver_v32p,
240 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
241
242 {"addc", 0x0570, 0x0A80, "r,R", 0, SIZE_FIX_32,
243 cris_ver_v32p,
244 cris_not_implemented_op},
245
246 {"addc", 0x09A0, 0x0250, "s,R", 0, SIZE_FIX_32,
247 cris_ver_v32p,
248 cris_not_implemented_op},
249
250 {"addi", 0x0540, 0x0A80, "x,r,A", 0, SIZE_NONE,
251 cris_ver_v32p,
252 cris_addi_op},
253
254 {"addi", 0x0500, 0x0Ac0, "x,r", 0, SIZE_NONE, 0,
255 cris_addi_op},
256
257 /* This collates after "addo", but we want to disassemble as "addoq",
258 not "addo". */
259 {"addoq", 0x0100, 0x0E00, "Q,A", 0, SIZE_NONE,
260 cris_ver_v32p,
261 cris_not_implemented_op},
262
263 {"addo", 0x0940, 0x0280, "m s,R,A", 0, SIZE_FIELD_SIGNED,
264 cris_ver_v32p,
265 cris_not_implemented_op},
266
267 /* This must be located after the insn above, lest we misinterpret
268 "addo.b -1,r0,acr" as "addo .b-1,r0,acr". FIXME: Sounds like a
269 parser bug. */
270 {"addo", 0x0100, 0x0E00, "O,A", 0, SIZE_NONE,
271 cris_ver_v32p,
272 cris_not_implemented_op},
273
274 {"addq", 0x0200, 0x0Dc0, "I,R", 0, SIZE_NONE, 0,
275 cris_quick_mode_add_sub_op},
276
277 {"adds", 0x0420, 0x0Bc0, "z r,R", 0, SIZE_NONE, 0,
278 cris_reg_mode_add_sub_cmp_and_or_move_op},
279
280 /* FIXME: SIZE_FIELD_SIGNED and all necessary changes. */
281 {"adds", 0x0820, 0x03c0, "z s,R", 0, SIZE_FIELD, 0,
282 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
283
284 {"adds", 0x0820, 0x03c0, "z S,D", 0, SIZE_NONE,
285 cris_ver_v0_10,
286 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
287
288 {"adds", 0x0820, 0x07c0, "z S,R,r", 0, SIZE_NONE,
289 cris_ver_v0_10,
290 cris_three_operand_add_sub_cmp_and_or_op},
291
292 {"addu", 0x0400, 0x0be0, "z r,R", 0, SIZE_NONE, 0,
293 cris_reg_mode_add_sub_cmp_and_or_move_op},
294
295 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
296 {"addu", 0x0800, 0x03e0, "z s,R", 0, SIZE_FIELD, 0,
297 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
298
299 {"addu", 0x0800, 0x03e0, "z S,D", 0, SIZE_NONE,
300 cris_ver_v0_10,
301 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
302
303 {"addu", 0x0800, 0x07e0, "z S,R,r", 0, SIZE_NONE,
304 cris_ver_v0_10,
305 cris_three_operand_add_sub_cmp_and_or_op},
306
307 {"and", 0x0700, 0x08C0, "m r,R", 0, SIZE_NONE, 0,
308 cris_reg_mode_add_sub_cmp_and_or_move_op},
309
310 {"and", 0x0B00, 0x00C0, "m s,R", 0, SIZE_FIELD, 0,
311 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
312
313 {"and", 0x0B00, 0x00C0, "m S,D", 0, SIZE_NONE,
314 cris_ver_v0_10,
315 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
316
317 {"and", 0x0B00, 0x04C0, "m S,R,r", 0, SIZE_NONE,
318 cris_ver_v0_10,
319 cris_three_operand_add_sub_cmp_and_or_op},
320
321 {"andq", 0x0300, 0x0CC0, "i,R", 0, SIZE_NONE, 0,
322 cris_quick_mode_and_cmp_move_or_op},
323
324 {"asr", 0x0780, 0x0840, "m r,R", 0, SIZE_NONE, 0,
325 cris_asr_op},
326
327 {"asrq", 0x03a0, 0x0c40, "c,R", 0, SIZE_NONE, 0,
328 cris_asrq_op},
329
330 {"ax", 0x15B0, 0xEA4F, "", 0, SIZE_NONE, 0,
331 cris_ax_ei_setf_op},
332
333 /* FIXME: Should use branch #defines. */
334 {"b", 0x0dff, 0x0200, "b", 1, SIZE_NONE, 0,
335 cris_sixteen_bit_offset_branch_op},
336
337 {"ba",
338 BA_QUICK_OPCODE,
339 0x0F00+(0xF-CC_A)*0x1000, "o", 1, SIZE_NONE, 0,
340 cris_eight_bit_offset_branch_op},
341
342 /* Needs to come after the usual "ba o", which might be relaxed to
343 this one. */
344 {"ba", BA_DWORD_OPCODE,
345 0xffff & (~BA_DWORD_OPCODE), "n", 0, SIZE_FIX_32,
346 cris_ver_v32p,
347 cris_none_reg_mode_jump_op},
348
349 {"bas", 0x0EBF, 0x0140, "n,P", 0, SIZE_FIX_32,
350 cris_ver_v32p,
351 cris_none_reg_mode_jump_op},
352
353 {"basc", 0x0EFF, 0x0100, "n,P", 0, SIZE_FIX_32,
354 cris_ver_v32p,
355 cris_none_reg_mode_jump_op},
356
357 {"bcc",
358 BRANCH_QUICK_OPCODE+CC_CC*0x1000,
359 0x0f00+(0xF-CC_CC)*0x1000, "o", 1, SIZE_NONE, 0,
360 cris_eight_bit_offset_branch_op},
361
362 {"bcs",
363 BRANCH_QUICK_OPCODE+CC_CS*0x1000,
364 0x0f00+(0xF-CC_CS)*0x1000, "o", 1, SIZE_NONE, 0,
365 cris_eight_bit_offset_branch_op},
366
367 {"bdap",
368 BDAP_INDIR_OPCODE, BDAP_INDIR_Z_BITS, "pm s,R", 0, SIZE_FIELD_SIGNED,
369 cris_ver_v0_10,
370 cris_bdap_prefix},
371
372 {"bdap",
373 BDAP_QUICK_OPCODE, BDAP_QUICK_Z_BITS, "pO", 0, SIZE_NONE,
374 cris_ver_v0_10,
375 cris_quick_mode_bdap_prefix},
376
377 {"beq",
378 BRANCH_QUICK_OPCODE+CC_EQ*0x1000,
379 0x0f00+(0xF-CC_EQ)*0x1000, "o", 1, SIZE_NONE, 0,
380 cris_eight_bit_offset_branch_op},
381
382 /* This is deliberately put before "bext" to trump it, even though not
383 in alphabetical order, since we don't do excluding version checks
384 for v0..v10. */
385 {"bwf",
386 BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
387 0x0f00+(0xF-CC_EXT)*0x1000, "o", 1, SIZE_NONE,
388 cris_ver_v10,
389 cris_eight_bit_offset_branch_op},
390
391 {"bext",
392 BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
393 0x0f00+(0xF-CC_EXT)*0x1000, "o", 1, SIZE_NONE,
394 cris_ver_v0_3,
395 cris_eight_bit_offset_branch_op},
396
397 {"bge",
398 BRANCH_QUICK_OPCODE+CC_GE*0x1000,
399 0x0f00+(0xF-CC_GE)*0x1000, "o", 1, SIZE_NONE, 0,
400 cris_eight_bit_offset_branch_op},
401
402 {"bgt",
403 BRANCH_QUICK_OPCODE+CC_GT*0x1000,
404 0x0f00+(0xF-CC_GT)*0x1000, "o", 1, SIZE_NONE, 0,
405 cris_eight_bit_offset_branch_op},
406
407 {"bhi",
408 BRANCH_QUICK_OPCODE+CC_HI*0x1000,
409 0x0f00+(0xF-CC_HI)*0x1000, "o", 1, SIZE_NONE, 0,
410 cris_eight_bit_offset_branch_op},
411
412 {"bhs",
413 BRANCH_QUICK_OPCODE+CC_HS*0x1000,
414 0x0f00+(0xF-CC_HS)*0x1000, "o", 1, SIZE_NONE, 0,
415 cris_eight_bit_offset_branch_op},
416
417 {"biap", BIAP_OPCODE, BIAP_Z_BITS, "pm r,R", 0, SIZE_NONE,
418 cris_ver_v0_10,
419 cris_biap_prefix},
420
421 {"ble",
422 BRANCH_QUICK_OPCODE+CC_LE*0x1000,
423 0x0f00+(0xF-CC_LE)*0x1000, "o", 1, SIZE_NONE, 0,
424 cris_eight_bit_offset_branch_op},
425
426 {"blo",
427 BRANCH_QUICK_OPCODE+CC_LO*0x1000,
428 0x0f00+(0xF-CC_LO)*0x1000, "o", 1, SIZE_NONE, 0,
429 cris_eight_bit_offset_branch_op},
430
431 {"bls",
432 BRANCH_QUICK_OPCODE+CC_LS*0x1000,
433 0x0f00+(0xF-CC_LS)*0x1000, "o", 1, SIZE_NONE, 0,
434 cris_eight_bit_offset_branch_op},
435
436 {"blt",
437 BRANCH_QUICK_OPCODE+CC_LT*0x1000,
438 0x0f00+(0xF-CC_LT)*0x1000, "o", 1, SIZE_NONE, 0,
439 cris_eight_bit_offset_branch_op},
440
441 {"bmi",
442 BRANCH_QUICK_OPCODE+CC_MI*0x1000,
443 0x0f00+(0xF-CC_MI)*0x1000, "o", 1, SIZE_NONE, 0,
444 cris_eight_bit_offset_branch_op},
445
446 {"bmod", 0x0ab0, 0x0140, "s,R", 0, SIZE_FIX_32,
447 cris_ver_sim_v0_10,
448 cris_not_implemented_op},
449
450 {"bmod", 0x0ab0, 0x0140, "S,D", 0, SIZE_NONE,
451 cris_ver_sim_v0_10,
452 cris_not_implemented_op},
453
454 {"bmod", 0x0ab0, 0x0540, "S,R,r", 0, SIZE_NONE,
455 cris_ver_sim_v0_10,
456 cris_not_implemented_op},
457
458 {"bne",
459 BRANCH_QUICK_OPCODE+CC_NE*0x1000,
460 0x0f00+(0xF-CC_NE)*0x1000, "o", 1, SIZE_NONE, 0,
461 cris_eight_bit_offset_branch_op},
462
463 {"bound", 0x05c0, 0x0A00, "m r,R", 0, SIZE_NONE, 0,
464 cris_two_operand_bound_op},
465 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
466 {"bound", 0x09c0, 0x0200, "m s,R", 0, SIZE_FIELD,
467 cris_ver_v0_10,
468 cris_two_operand_bound_op},
469 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
470 {"bound", 0x0dcf, 0x0200, "m Y,R", 0, SIZE_FIELD, 0,
471 cris_two_operand_bound_op},
472 {"bound", 0x09c0, 0x0200, "m S,D", 0, SIZE_NONE,
473 cris_ver_v0_10,
474 cris_two_operand_bound_op},
475 {"bound", 0x09c0, 0x0600, "m S,R,r", 0, SIZE_NONE,
476 cris_ver_v0_10,
477 cris_three_operand_bound_op},
478
479 {"bpl",
480 BRANCH_QUICK_OPCODE+CC_PL*0x1000,
481 0x0f00+(0xF-CC_PL)*0x1000, "o", 1, SIZE_NONE, 0,
482 cris_eight_bit_offset_branch_op},
483
484 {"break", 0xe930, 0x16c0, "C", 0, SIZE_NONE,
485 cris_ver_v3p,
486 cris_break_op},
487
488 {"bsb",
489 BRANCH_QUICK_OPCODE+CC_EXT*0x1000,
490 0x0f00+(0xF-CC_EXT)*0x1000, "o", 1, SIZE_NONE,
491 cris_ver_v32p,
492 cris_eight_bit_offset_branch_op},
493
494 {"bsr", 0xBEBF, 0x4140, "n", 0, SIZE_FIX_32,
495 cris_ver_v32p,
496 cris_none_reg_mode_jump_op},
497
498 {"bsrc", 0xBEFF, 0x4100, "n", 0, SIZE_FIX_32,
499 cris_ver_v32p,
500 cris_none_reg_mode_jump_op},
501
502 {"bstore", 0x0af0, 0x0100, "s,R", 0, SIZE_FIX_32,
503 cris_ver_warning,
504 cris_not_implemented_op},
505
506 {"bstore", 0x0af0, 0x0100, "S,D", 0, SIZE_NONE,
507 cris_ver_warning,
508 cris_not_implemented_op},
509
510 {"bstore", 0x0af0, 0x0500, "S,R,r", 0, SIZE_NONE,
511 cris_ver_warning,
512 cris_not_implemented_op},
513
514 {"btst", 0x04F0, 0x0B00, "r,R", 0, SIZE_NONE, 0,
515 cris_btst_nop_op},
516 {"btstq", 0x0380, 0x0C60, "c,R", 0, SIZE_NONE, 0,
517 cris_btst_nop_op},
518
519 {"bvc",
520 BRANCH_QUICK_OPCODE+CC_VC*0x1000,
521 0x0f00+(0xF-CC_VC)*0x1000, "o", 1, SIZE_NONE, 0,
522 cris_eight_bit_offset_branch_op},
523
524 {"bvs",
525 BRANCH_QUICK_OPCODE+CC_VS*0x1000,
526 0x0f00+(0xF-CC_VS)*0x1000, "o", 1, SIZE_NONE, 0,
527 cris_eight_bit_offset_branch_op},
528
529 {"clear", 0x0670, 0x3980, "M r", 0, SIZE_NONE, 0,
530 cris_reg_mode_clear_op},
531
532 {"clear", 0x0A70, 0x3180, "M y", 0, SIZE_NONE, 0,
533 cris_none_reg_mode_clear_test_op},
534
535 {"clear", 0x0A70, 0x3180, "M S", 0, SIZE_NONE,
536 cris_ver_v0_10,
537 cris_none_reg_mode_clear_test_op},
538
539 {"clearf", 0x05F0, 0x0A00, "f", 0, SIZE_NONE, 0,
540 cris_clearf_di_op},
541
542 {"cmp", 0x06C0, 0x0900, "m r,R", 0, SIZE_NONE, 0,
543 cris_reg_mode_add_sub_cmp_and_or_move_op},
544
545 {"cmp", 0x0Ac0, 0x0100, "m s,R", 0, SIZE_FIELD, 0,
546 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
547
548 {"cmp", 0x0Ac0, 0x0100, "m S,D", 0, SIZE_NONE,
549 cris_ver_v0_10,
550 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
551
552 {"cmpq", 0x02C0, 0x0D00, "i,R", 0, SIZE_NONE, 0,
553 cris_quick_mode_and_cmp_move_or_op},
554
555 /* FIXME: SIZE_FIELD_SIGNED and all necessary changes. */
556 {"cmps", 0x08e0, 0x0300, "z s,R", 0, SIZE_FIELD, 0,
557 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
558
559 {"cmps", 0x08e0, 0x0300, "z S,D", 0, SIZE_NONE,
560 cris_ver_v0_10,
561 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
562
563 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
564 {"cmpu", 0x08c0, 0x0320, "z s,R" , 0, SIZE_FIELD, 0,
565 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
566
567 {"cmpu", 0x08c0, 0x0320, "z S,D", 0, SIZE_NONE,
568 cris_ver_v0_10,
569 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
570
571 {"di", 0x25F0, 0xDA0F, "", 0, SIZE_NONE, 0,
572 cris_clearf_di_op},
573
574 {"dip", DIP_OPCODE, DIP_Z_BITS, "ps", 0, SIZE_FIX_32,
575 cris_ver_v0_10,
576 cris_dip_prefix},
577
578 {"div", 0x0980, 0x0640, "m R,r", 0, SIZE_FIELD, 0,
579 cris_not_implemented_op},
580
581 {"dstep", 0x06f0, 0x0900, "r,R", 0, SIZE_NONE, 0,
582 cris_dstep_logshift_mstep_neg_not_op},
583
584 {"ei", 0x25B0, 0xDA4F, "", 0, SIZE_NONE, 0,
585 cris_ax_ei_setf_op},
586
587 {"fidxd", 0x0ab0, 0xf540, "[r]", 0, SIZE_NONE,
588 cris_ver_v32p,
589 cris_not_implemented_op},
590
591 {"fidxi", 0x0d30, 0xF2C0, "[r]", 0, SIZE_NONE,
592 cris_ver_v32p,
593 cris_not_implemented_op},
594
595 {"ftagd", 0x1AB0, 0xE540, "[r]", 0, SIZE_NONE,
596 cris_ver_v32p,
597 cris_not_implemented_op},
598
599 {"ftagi", 0x1D30, 0xE2C0, "[r]", 0, SIZE_NONE,
600 cris_ver_v32p,
601 cris_not_implemented_op},
602
603 {"halt", 0xF930, 0x06CF, "", 0, SIZE_NONE,
604 cris_ver_v32p,
605 cris_not_implemented_op},
606
607 {"jas", 0x09B0, 0x0640, "r,P", 0, SIZE_NONE,
608 cris_ver_v32p,
609 cris_reg_mode_jump_op},
610
611 {"jas", 0x0DBF, 0x0240, "N,P", 0, SIZE_FIX_32,
612 cris_ver_v32p,
613 cris_reg_mode_jump_op},
614
615 {"jasc", 0x0B30, 0x04C0, "r,P", 0, SIZE_NONE,
616 cris_ver_v32p,
617 cris_reg_mode_jump_op},
618
619 {"jasc", 0x0F3F, 0x00C0, "N,P", 0, SIZE_FIX_32,
620 cris_ver_v32p,
621 cris_reg_mode_jump_op},
622
623 {"jbrc", 0x69b0, 0x9640, "r", 0, SIZE_NONE,
624 cris_ver_v8_10,
625 cris_reg_mode_jump_op},
626
627 {"jbrc", 0x6930, 0x92c0, "s", 0, SIZE_FIX_32,
628 cris_ver_v8_10,
629 cris_none_reg_mode_jump_op},
630
631 {"jbrc", 0x6930, 0x92c0, "S", 0, SIZE_NONE,
632 cris_ver_v8_10,
633 cris_none_reg_mode_jump_op},
634
635 {"jir", 0xA9b0, 0x5640, "r", 0, SIZE_NONE,
636 cris_ver_v8_10,
637 cris_reg_mode_jump_op},
638
639 {"jir", 0xA930, 0x52c0, "s", 0, SIZE_FIX_32,
640 cris_ver_v8_10,
641 cris_none_reg_mode_jump_op},
642
643 {"jir", 0xA930, 0x52c0, "S", 0, SIZE_NONE,
644 cris_ver_v8_10,
645 cris_none_reg_mode_jump_op},
646
647 {"jirc", 0x29b0, 0xd640, "r", 0, SIZE_NONE,
648 cris_ver_v8_10,
649 cris_reg_mode_jump_op},
650
651 {"jirc", 0x2930, 0xd2c0, "s", 0, SIZE_FIX_32,
652 cris_ver_v8_10,
653 cris_none_reg_mode_jump_op},
654
655 {"jirc", 0x2930, 0xd2c0, "S", 0, SIZE_NONE,
656 cris_ver_v8_10,
657 cris_none_reg_mode_jump_op},
658
659 {"jsr", 0xB9b0, 0x4640, "r", 0, SIZE_NONE, 0,
660 cris_reg_mode_jump_op},
661
662 {"jsr", 0xB930, 0x42c0, "s", 0, SIZE_FIX_32,
663 cris_ver_v0_10,
664 cris_none_reg_mode_jump_op},
665
666 {"jsr", 0xBDBF, 0x4240, "N", 0, SIZE_FIX_32,
667 cris_ver_v32p,
668 cris_none_reg_mode_jump_op},
669
670 {"jsr", 0xB930, 0x42c0, "S", 0, SIZE_NONE,
671 cris_ver_v0_10,
672 cris_none_reg_mode_jump_op},
673
674 {"jsrc", 0x39b0, 0xc640, "r", 0, SIZE_NONE,
675 cris_ver_v8_10,
676 cris_reg_mode_jump_op},
677
678 {"jsrc", 0x3930, 0xc2c0, "s", 0, SIZE_FIX_32,
679 cris_ver_v8_10,
680 cris_none_reg_mode_jump_op},
681
682 {"jsrc", 0x3930, 0xc2c0, "S", 0, SIZE_NONE,
683 cris_ver_v8_10,
684 cris_none_reg_mode_jump_op},
685
686 {"jsrc", 0xBB30, 0x44C0, "r", 0, SIZE_NONE,
687 cris_ver_v32p,
688 cris_reg_mode_jump_op},
689
690 {"jsrc", 0xBF3F, 0x40C0, "N", 0, SIZE_FIX_32,
691 cris_ver_v32p,
692 cris_reg_mode_jump_op},
693
694 {"jump", 0x09b0, 0xF640, "r", 0, SIZE_NONE, 0,
695 cris_reg_mode_jump_op},
696
697 {"jump",
698 JUMP_INDIR_OPCODE, JUMP_INDIR_Z_BITS, "s", 0, SIZE_FIX_32,
699 cris_ver_v0_10,
700 cris_none_reg_mode_jump_op},
701
702 {"jump",
703 JUMP_INDIR_OPCODE, JUMP_INDIR_Z_BITS, "S", 0, SIZE_NONE,
704 cris_ver_v0_10,
705 cris_none_reg_mode_jump_op},
706
707 {"jump", 0x09F0, 0x060F, "P", 0, SIZE_NONE,
708 cris_ver_v32p,
709 cris_none_reg_mode_jump_op},
710
711 {"jump",
712 JUMP_PC_INCR_OPCODE_V32,
713 (0xffff & ~JUMP_PC_INCR_OPCODE_V32), "N", 0, SIZE_FIX_32,
714 cris_ver_v32p,
715 cris_none_reg_mode_jump_op},
716
717 {"jmpu", 0x8930, 0x72c0, "s", 0, SIZE_FIX_32,
718 cris_ver_v10,
719 cris_none_reg_mode_jump_op},
720
721 {"jmpu", 0x8930, 0x72c0, "S", 0, SIZE_NONE,
722 cris_ver_v10,
723 cris_none_reg_mode_jump_op},
724
725 {"lapc", 0x0970, 0x0680, "U,R", 0, SIZE_NONE,
726 cris_ver_v32p,
727 cris_not_implemented_op},
728
729 {"lapc", 0x0D7F, 0x0280, "dn,R", 0, SIZE_FIX_32,
730 cris_ver_v32p,
731 cris_not_implemented_op},
732
733 {"lapcq", 0x0970, 0x0680, "u,R", 0, SIZE_NONE,
734 cris_ver_v32p,
735 cris_addi_op},
736
737 {"lsl", 0x04C0, 0x0B00, "m r,R", 0, SIZE_NONE, 0,
738 cris_dstep_logshift_mstep_neg_not_op},
739
740 {"lslq", 0x03c0, 0x0C20, "c,R", 0, SIZE_NONE, 0,
741 cris_dstep_logshift_mstep_neg_not_op},
742
743 {"lsr", 0x07C0, 0x0800, "m r,R", 0, SIZE_NONE, 0,
744 cris_dstep_logshift_mstep_neg_not_op},
745
746 {"lsrq", 0x03e0, 0x0C00, "c,R", 0, SIZE_NONE, 0,
747 cris_dstep_logshift_mstep_neg_not_op},
748
749 {"lz", 0x0730, 0x08C0, "r,R", 0, SIZE_NONE,
750 cris_ver_v3p,
751 cris_not_implemented_op},
752
753 {"mcp", 0x07f0, 0x0800, "P,r", 0, SIZE_NONE,
754 cris_ver_v32p,
755 cris_not_implemented_op},
756
757 {"move", 0x0640, 0x0980, "m r,R", 0, SIZE_NONE, 0,
758 cris_reg_mode_add_sub_cmp_and_or_move_op},
759
760 {"move", 0x0A40, 0x0180, "m s,R", 0, SIZE_FIELD, 0,
761 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
762
763 {"move", 0x0A40, 0x0180, "m S,D", 0, SIZE_NONE,
764 cris_ver_v0_10,
765 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
766
767 {"move", 0x0630, 0x09c0, "r,P", 0, SIZE_NONE, 0,
768 cris_move_to_preg_op},
769
770 {"move", 0x0670, 0x0980, "P,r", 0, SIZE_NONE, 0,
771 cris_reg_mode_move_from_preg_op},
772
773 {"move", 0x0BC0, 0x0000, "m R,y", 0, SIZE_FIELD, 0,
774 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
775
776 {"move", 0x0BC0, 0x0000, "m D,S", 0, SIZE_NONE,
777 cris_ver_v0_10,
778 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
779
780 {"move",
781 MOVE_M_TO_PREG_OPCODE, MOVE_M_TO_PREG_ZBITS,
782 "s,P", 0, SIZE_SPEC_REG, 0,
783 cris_move_to_preg_op},
784
785 {"move", 0x0A30, 0x01c0, "S,P", 0, SIZE_NONE,
786 cris_ver_v0_10,
787 cris_move_to_preg_op},
788
789 {"move", 0x0A70, 0x0180, "P,y", 0, SIZE_SPEC_REG, 0,
790 cris_none_reg_mode_move_from_preg_op},
791
792 {"move", 0x0A70, 0x0180, "P,S", 0, SIZE_NONE,
793 cris_ver_v0_10,
794 cris_none_reg_mode_move_from_preg_op},
795
796 {"move", 0x0B70, 0x0480, "r,T", 0, SIZE_NONE,
797 cris_ver_v32p,
798 cris_not_implemented_op},
799
800 {"move", 0x0F70, 0x0080, "T,r", 0, SIZE_NONE,
801 cris_ver_v32p,
802 cris_not_implemented_op},
803
804 {"movem", 0x0BF0, 0x0000, "R,y", 0, SIZE_FIX_32, 0,
805 cris_move_reg_to_mem_movem_op},
806
807 {"movem", 0x0BF0, 0x0000, "D,S", 0, SIZE_NONE,
808 cris_ver_v0_10,
809 cris_move_reg_to_mem_movem_op},
810
811 {"movem", 0x0BB0, 0x0040, "s,R", 0, SIZE_FIX_32, 0,
812 cris_move_mem_to_reg_movem_op},
813
814 {"movem", 0x0BB0, 0x0040, "S,D", 0, SIZE_NONE,
815 cris_ver_v0_10,
816 cris_move_mem_to_reg_movem_op},
817
818 {"moveq", 0x0240, 0x0D80, "i,R", 0, SIZE_NONE, 0,
819 cris_quick_mode_and_cmp_move_or_op},
820
821 {"movs", 0x0460, 0x0B80, "z r,R", 0, SIZE_NONE, 0,
822 cris_reg_mode_add_sub_cmp_and_or_move_op},
823
824 /* FIXME: SIZE_FIELD_SIGNED and all necessary changes. */
825 {"movs", 0x0860, 0x0380, "z s,R", 0, SIZE_FIELD, 0,
826 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
827
828 {"movs", 0x0860, 0x0380, "z S,D", 0, SIZE_NONE,
829 cris_ver_v0_10,
830 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
831
832 {"movu", 0x0440, 0x0Ba0, "z r,R", 0, SIZE_NONE, 0,
833 cris_reg_mode_add_sub_cmp_and_or_move_op},
834
835 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
836 {"movu", 0x0840, 0x03a0, "z s,R", 0, SIZE_FIELD, 0,
837 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
838
839 {"movu", 0x0840, 0x03a0, "z S,D", 0, SIZE_NONE,
840 cris_ver_v0_10,
841 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
842
843 {"mstep", 0x07f0, 0x0800, "r,R", 0, SIZE_NONE,
844 cris_ver_v0_10,
845 cris_dstep_logshift_mstep_neg_not_op},
846
847 {"muls", 0x0d00, 0x02c0, "m r,R", 0, SIZE_NONE,
848 cris_ver_v10p,
849 cris_muls_op},
850
851 {"mulu", 0x0900, 0x06c0, "m r,R", 0, SIZE_NONE,
852 cris_ver_v10p,
853 cris_mulu_op},
854
855 {"neg", 0x0580, 0x0A40, "m r,R", 0, SIZE_NONE, 0,
856 cris_dstep_logshift_mstep_neg_not_op},
857
858 {"nop", NOP_OPCODE, NOP_Z_BITS, "", 0, SIZE_NONE,
859 cris_ver_v0_10,
860 cris_btst_nop_op},
861
862 {"nop", NOP_OPCODE_V32, NOP_Z_BITS_V32, "", 0, SIZE_NONE,
863 cris_ver_v32p,
864 cris_btst_nop_op},
865
866 {"not", 0x8770, 0x7880, "r", 0, SIZE_NONE, 0,
867 cris_dstep_logshift_mstep_neg_not_op},
868
869 {"or", 0x0740, 0x0880, "m r,R", 0, SIZE_NONE, 0,
870 cris_reg_mode_add_sub_cmp_and_or_move_op},
871
872 {"or", 0x0B40, 0x0080, "m s,R", 0, SIZE_FIELD, 0,
873 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
874
875 {"or", 0x0B40, 0x0080, "m S,D", 0, SIZE_NONE,
876 cris_ver_v0_10,
877 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
878
879 {"or", 0x0B40, 0x0480, "m S,R,r", 0, SIZE_NONE,
880 cris_ver_v0_10,
881 cris_three_operand_add_sub_cmp_and_or_op},
882
883 {"orq", 0x0340, 0x0C80, "i,R", 0, SIZE_NONE, 0,
884 cris_quick_mode_and_cmp_move_or_op},
885
886 {"pop", 0x0E6E, 0x0191, "!R", 0, SIZE_NONE,
887 cris_ver_v0_10,
888 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
889
890 {"pop", 0x0e3e, 0x01c1, "!P", 0, SIZE_NONE,
891 cris_ver_v0_10,
892 cris_none_reg_mode_move_from_preg_op},
893
894 {"push", 0x0FEE, 0x0011, "BR", 0, SIZE_NONE,
895 cris_ver_v0_10,
896 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
897
898 {"push", 0x0E7E, 0x0181, "BP", 0, SIZE_NONE,
899 cris_ver_v0_10,
900 cris_move_to_preg_op},
901
902 {"rbf", 0x3b30, 0xc0c0, "y", 0, SIZE_NONE,
903 cris_ver_v10,
904 cris_not_implemented_op},
905
906 {"rbf", 0x3b30, 0xc0c0, "S", 0, SIZE_NONE,
907 cris_ver_v10,
908 cris_not_implemented_op},
909
910 {"rfe", 0x2930, 0xD6CF, "", 0, SIZE_NONE,
911 cris_ver_v32p,
912 cris_not_implemented_op},
913
914 {"rfg", 0x4930, 0xB6CF, "", 0, SIZE_NONE,
915 cris_ver_v32p,
916 cris_not_implemented_op},
917
918 {"rfn", 0x5930, 0xA6CF, "", 0, SIZE_NONE,
919 cris_ver_v32p,
920 cris_not_implemented_op},
921
922 {"ret", 0xB67F, 0x4980, "", 1, SIZE_NONE,
923 cris_ver_v0_10,
924 cris_reg_mode_move_from_preg_op},
925
926 {"ret", 0xB9F0, 0x460F, "", 1, SIZE_NONE,
927 cris_ver_v32p,
928 cris_reg_mode_move_from_preg_op},
929
930 {"retb", 0xe67f, 0x1980, "", 1, SIZE_NONE,
931 cris_ver_v0_10,
932 cris_reg_mode_move_from_preg_op},
933
934 {"rete", 0xA9F0, 0x560F, "", 1, SIZE_NONE,
935 cris_ver_v32p,
936 cris_reg_mode_move_from_preg_op},
937
938 {"reti", 0xA67F, 0x5980, "", 1, SIZE_NONE,
939 cris_ver_v0_10,
940 cris_reg_mode_move_from_preg_op},
941
942 {"retn", 0xC9F0, 0x360F, "", 1, SIZE_NONE,
943 cris_ver_v32p,
944 cris_reg_mode_move_from_preg_op},
945
946 {"sbfs", 0x3b70, 0xc080, "y", 0, SIZE_NONE,
947 cris_ver_v10,
948 cris_not_implemented_op},
949
950 {"sbfs", 0x3b70, 0xc080, "S", 0, SIZE_NONE,
951 cris_ver_v10,
952 cris_not_implemented_op},
953
954 {"sa",
955 0x0530+CC_A*0x1000,
956 0x0AC0+(0xf-CC_A)*0x1000, "r", 0, SIZE_NONE, 0,
957 cris_scc_op},
958
959 {"ssb",
960 0x0530+CC_EXT*0x1000,
961 0x0AC0+(0xf-CC_EXT)*0x1000, "r", 0, SIZE_NONE,
962 cris_ver_v32p,
963 cris_scc_op},
964
965 {"scc",
966 0x0530+CC_CC*0x1000,
967 0x0AC0+(0xf-CC_CC)*0x1000, "r", 0, SIZE_NONE, 0,
968 cris_scc_op},
969
970 {"scs",
971 0x0530+CC_CS*0x1000,
972 0x0AC0+(0xf-CC_CS)*0x1000, "r", 0, SIZE_NONE, 0,
973 cris_scc_op},
974
975 {"seq",
976 0x0530+CC_EQ*0x1000,
977 0x0AC0+(0xf-CC_EQ)*0x1000, "r", 0, SIZE_NONE, 0,
978 cris_scc_op},
979
980 {"setf", 0x05b0, 0x0A40, "f", 0, SIZE_NONE, 0,
981 cris_ax_ei_setf_op},
982
983 {"sfe", 0x3930, 0xC6CF, "", 0, SIZE_NONE,
984 cris_ver_v32p,
985 cris_not_implemented_op},
986
987 /* Need to have "swf" in front of "sext" so it is the one displayed in
988 disassembly. */
989 {"swf",
990 0x0530+CC_EXT*0x1000,
991 0x0AC0+(0xf-CC_EXT)*0x1000, "r", 0, SIZE_NONE,
992 cris_ver_v10,
993 cris_scc_op},
994
995 {"sext",
996 0x0530+CC_EXT*0x1000,
997 0x0AC0+(0xf-CC_EXT)*0x1000, "r", 0, SIZE_NONE,
998 cris_ver_v0_3,
999 cris_scc_op},
1000
1001 {"sge",
1002 0x0530+CC_GE*0x1000,
1003 0x0AC0+(0xf-CC_GE)*0x1000, "r", 0, SIZE_NONE, 0,
1004 cris_scc_op},
1005
1006 {"sgt",
1007 0x0530+CC_GT*0x1000,
1008 0x0AC0+(0xf-CC_GT)*0x1000, "r", 0, SIZE_NONE, 0,
1009 cris_scc_op},
1010
1011 {"shi",
1012 0x0530+CC_HI*0x1000,
1013 0x0AC0+(0xf-CC_HI)*0x1000, "r", 0, SIZE_NONE, 0,
1014 cris_scc_op},
1015
1016 {"shs",
1017 0x0530+CC_HS*0x1000,
1018 0x0AC0+(0xf-CC_HS)*0x1000, "r", 0, SIZE_NONE, 0,
1019 cris_scc_op},
1020
1021 {"sle",
1022 0x0530+CC_LE*0x1000,
1023 0x0AC0+(0xf-CC_LE)*0x1000, "r", 0, SIZE_NONE, 0,
1024 cris_scc_op},
1025
1026 {"slo",
1027 0x0530+CC_LO*0x1000,
1028 0x0AC0+(0xf-CC_LO)*0x1000, "r", 0, SIZE_NONE, 0,
1029 cris_scc_op},
1030
1031 {"sls",
1032 0x0530+CC_LS*0x1000,
1033 0x0AC0+(0xf-CC_LS)*0x1000, "r", 0, SIZE_NONE, 0,
1034 cris_scc_op},
1035
1036 {"slt",
1037 0x0530+CC_LT*0x1000,
1038 0x0AC0+(0xf-CC_LT)*0x1000, "r", 0, SIZE_NONE, 0,
1039 cris_scc_op},
1040
1041 {"smi",
1042 0x0530+CC_MI*0x1000,
1043 0x0AC0+(0xf-CC_MI)*0x1000, "r", 0, SIZE_NONE, 0,
1044 cris_scc_op},
1045
1046 {"sne",
1047 0x0530+CC_NE*0x1000,
1048 0x0AC0+(0xf-CC_NE)*0x1000, "r", 0, SIZE_NONE, 0,
1049 cris_scc_op},
1050
1051 {"spl",
1052 0x0530+CC_PL*0x1000,
1053 0x0AC0+(0xf-CC_PL)*0x1000, "r", 0, SIZE_NONE, 0,
1054 cris_scc_op},
1055
1056 {"sub", 0x0680, 0x0940, "m r,R", 0, SIZE_NONE, 0,
1057 cris_reg_mode_add_sub_cmp_and_or_move_op},
1058
1059 {"sub", 0x0a80, 0x0140, "m s,R", 0, SIZE_FIELD, 0,
1060 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1061
1062 {"sub", 0x0a80, 0x0140, "m S,D", 0, SIZE_NONE,
1063 cris_ver_v0_10,
1064 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1065
1066 {"sub", 0x0a80, 0x0540, "m S,R,r", 0, SIZE_NONE,
1067 cris_ver_v0_10,
1068 cris_three_operand_add_sub_cmp_and_or_op},
1069
1070 {"subq", 0x0280, 0x0d40, "I,R", 0, SIZE_NONE, 0,
1071 cris_quick_mode_add_sub_op},
1072
1073 {"subs", 0x04a0, 0x0b40, "z r,R", 0, SIZE_NONE, 0,
1074 cris_reg_mode_add_sub_cmp_and_or_move_op},
1075
1076 /* FIXME: SIZE_FIELD_SIGNED and all necessary changes. */
1077 {"subs", 0x08a0, 0x0340, "z s,R", 0, SIZE_FIELD, 0,
1078 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1079
1080 {"subs", 0x08a0, 0x0340, "z S,D", 0, SIZE_NONE,
1081 cris_ver_v0_10,
1082 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1083
1084 {"subs", 0x08a0, 0x0740, "z S,R,r", 0, SIZE_NONE,
1085 cris_ver_v0_10,
1086 cris_three_operand_add_sub_cmp_and_or_op},
1087
1088 {"subu", 0x0480, 0x0b60, "z r,R", 0, SIZE_NONE, 0,
1089 cris_reg_mode_add_sub_cmp_and_or_move_op},
1090
1091 /* FIXME: SIZE_FIELD_UNSIGNED and all necessary changes. */
1092 {"subu", 0x0880, 0x0360, "z s,R", 0, SIZE_FIELD, 0,
1093 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1094
1095 {"subu", 0x0880, 0x0360, "z S,D", 0, SIZE_NONE,
1096 cris_ver_v0_10,
1097 cris_none_reg_mode_add_sub_cmp_and_or_move_op},
1098
1099 {"subu", 0x0880, 0x0760, "z S,R,r", 0, SIZE_NONE,
1100 cris_ver_v0_10,
1101 cris_three_operand_add_sub_cmp_and_or_op},
1102
1103 {"svc",
1104 0x0530+CC_VC*0x1000,
1105 0x0AC0+(0xf-CC_VC)*0x1000, "r", 0, SIZE_NONE, 0,
1106 cris_scc_op},
1107
1108 {"svs",
1109 0x0530+CC_VS*0x1000,
1110 0x0AC0+(0xf-CC_VS)*0x1000, "r", 0, SIZE_NONE, 0,
1111 cris_scc_op},
1112
1113 /* The insn "swapn" is the same as "not" and will be disassembled as
1114 such, but the swap* family of mnmonics are generally v8-and-higher
1115 only, so count it in. */
1116 {"swapn", 0x8770, 0x7880, "r", 0, SIZE_NONE,
1117 cris_ver_v8p,
1118 cris_not_implemented_op},
1119
1120 {"swapw", 0x4770, 0xb880, "r", 0, SIZE_NONE,
1121 cris_ver_v8p,
1122 cris_not_implemented_op},
1123
1124 {"swapnw", 0xc770, 0x3880, "r", 0, SIZE_NONE,
1125 cris_ver_v8p,
1126 cris_not_implemented_op},
1127
1128 {"swapb", 0x2770, 0xd880, "r", 0, SIZE_NONE,
1129 cris_ver_v8p,
1130 cris_not_implemented_op},
1131
1132 {"swapnb", 0xA770, 0x5880, "r", 0, SIZE_NONE,
1133 cris_ver_v8p,
1134 cris_not_implemented_op},
1135
1136 {"swapwb", 0x6770, 0x9880, "r", 0, SIZE_NONE,
1137 cris_ver_v8p,
1138 cris_not_implemented_op},
1139
1140 {"swapnwb", 0xE770, 0x1880, "r", 0, SIZE_NONE,
1141 cris_ver_v8p,
1142 cris_not_implemented_op},
1143
1144 {"swapr", 0x1770, 0xe880, "r", 0, SIZE_NONE,
1145 cris_ver_v8p,
1146 cris_not_implemented_op},
1147
1148 {"swapnr", 0x9770, 0x6880, "r", 0, SIZE_NONE,
1149 cris_ver_v8p,
1150 cris_not_implemented_op},
1151
1152 {"swapwr", 0x5770, 0xa880, "r", 0, SIZE_NONE,
1153 cris_ver_v8p,
1154 cris_not_implemented_op},
1155
1156 {"swapnwr", 0xd770, 0x2880, "r", 0, SIZE_NONE,
1157 cris_ver_v8p,
1158 cris_not_implemented_op},
1159
1160 {"swapbr", 0x3770, 0xc880, "r", 0, SIZE_NONE,
1161 cris_ver_v8p,
1162 cris_not_implemented_op},
1163
1164 {"swapnbr", 0xb770, 0x4880, "r", 0, SIZE_NONE,
1165 cris_ver_v8p,
1166 cris_not_implemented_op},
1167
1168 {"swapwbr", 0x7770, 0x8880, "r", 0, SIZE_NONE,
1169 cris_ver_v8p,
1170 cris_not_implemented_op},
1171
1172 {"swapnwbr", 0xf770, 0x0880, "r", 0, SIZE_NONE,
1173 cris_ver_v8p,
1174 cris_not_implemented_op},
1175
1176 {"test", 0x0640, 0x0980, "m D", 0, SIZE_NONE,
1177 cris_ver_v0_10,
1178 cris_reg_mode_test_op},
1179
1180 {"test", 0x0b80, 0xf040, "m y", 0, SIZE_FIELD, 0,
1181 cris_none_reg_mode_clear_test_op},
1182
1183 {"test", 0x0b80, 0xf040, "m S", 0, SIZE_NONE,
1184 cris_ver_v0_10,
1185 cris_none_reg_mode_clear_test_op},
1186
1187 {"xor", 0x07B0, 0x0840, "r,R", 0, SIZE_NONE, 0,
1188 cris_xor_op},
1189
1190 {NULL, 0, 0, NULL, 0, 0, 0, cris_not_implemented_op}
1191 };
1192
1193 /* Condition-names, indexed by the CC_* numbers as found in cris.h. */
1194 const char * const
1195 cris_cc_strings[] =
1196 {
1197 "hs",
1198 "lo",
1199 "ne",
1200 "eq",
1201 "vc",
1202 "vs",
1203 "pl",
1204 "mi",
1205 "ls",
1206 "hi",
1207 "ge",
1208 "lt",
1209 "gt",
1210 "le",
1211 "a",
1212 /* This is a placeholder. In v0, this would be "ext". In v32, this
1213 is "sb". See cris_conds15. */
1214 "wf"
1215 };
1216
1217 /* Different names and semantics for condition 1111 (0xf). */
1218 const struct cris_cond15 cris_cond15s[] =
1219 {
1220 /* FIXME: In what version did condition "ext" disappear? */
1221 {"ext", cris_ver_v0_3},
1222 {"wf", cris_ver_v10},
1223 {"sb", cris_ver_v32p},
1224 {NULL, 0}
1225 };
1226
1227
1228 /*
1229 * Local variables:
1230 * eval: (c-set-style "gnu")
1231 * indent-tabs-mode: t
1232 * End:
1233 */
1234
1235
1236 /* No instruction will be disassembled longer than this. In theory, and
1237 in silicon, address prefixes can be cascaded. In practice, cascading
1238 is not used by GCC, and not supported by the assembler. */
1239 #ifndef MAX_BYTES_PER_CRIS_INSN
1240 #define MAX_BYTES_PER_CRIS_INSN 8
1241 #endif
1242
1243 /* Whether or not to decode prefixes, folding it into the following
1244 instruction. FIXME: Make this optional later. */
1245 #ifndef PARSE_PREFIX
1246 #define PARSE_PREFIX 1
1247 #endif
1248
1249 /* Sometimes we prefix all registers with this character. */
1250 #define REGISTER_PREFIX_CHAR '$'
1251
1252 /* Whether or not to trace the following sequence:
1253 sub* X,r%d
1254 bound* Y,r%d
1255 adds.w [pc+r%d.w],pc
1256
1257 This is the assembly form of a switch-statement in C.
1258 The "sub is optional. If there is none, then X will be zero.
1259 X is the value of the first case,
1260 Y is the number of cases (including default).
1261
1262 This results in case offsets printed on the form:
1263 case N: -> case_address
1264 where N is an estimation on the corresponding 'case' operand in C,
1265 and case_address is where execution of that case continues after the
1266 sequence presented above.
1267
1268 The old style of output was to print the offsets as instructions,
1269 which made it hard to follow "case"-constructs in the disassembly,
1270 and caused a lot of annoying warnings about undefined instructions.
1271
1272 FIXME: Make this optional later. */
1273 #ifndef TRACE_CASE
1274 #define TRACE_CASE (disdata->trace_case)
1275 #endif
1276
1277 enum cris_disass_family
1278 { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
1279
1280 /* Stored in the disasm_info->private_data member. */
1281 struct cris_disasm_data
1282 {
1283 /* Whether to print something less confusing if we find something
1284 matching a switch-construct. */
1285 bfd_boolean trace_case;
1286
1287 /* Whether this code is flagged as crisv32. FIXME: Should be an enum
1288 that includes "compatible". */
1289 enum cris_disass_family distype;
1290 };
1291
1292 /* Value of first element in switch. */
1293 static long case_offset = 0;
1294
1295 /* How many more case-offsets to print. */
1296 static long case_offset_counter = 0;
1297
1298 /* Number of case offsets. */
1299 static long no_of_case_offsets = 0;
1300
1301 /* Candidate for next case_offset. */
1302 static long last_immediate = 0;
1303
1304 static int cris_constraint
1305 (const char *, unsigned, unsigned, struct cris_disasm_data *);
1306
1307 /* Parse disassembler options and store state in info. FIXME: For the
1308 time being, we abuse static variables. */
1309
1310 static bfd_boolean
1311 cris_parse_disassembler_options (disassemble_info *info,
1312 enum cris_disass_family distype)
1313 {
1314 struct cris_disasm_data *disdata;
1315
1316 info->private_data = calloc (1, sizeof (struct cris_disasm_data));
1317 disdata = (struct cris_disasm_data *) info->private_data;
1318 if (disdata == NULL)
1319 return false;
1320
1321 /* Default true. */
1322 disdata->trace_case
1323 = (info->disassembler_options == NULL
1324 || (strcmp (info->disassembler_options, "nocase") != 0));
1325
1326 disdata->distype = distype;
1327 return true;
1328 }
1329
1330 static const struct cris_spec_reg *
1331 spec_reg_info (unsigned int sreg, enum cris_disass_family distype)
1332 {
1333 int i;
1334
1335 for (i = 0; cris_spec_regs[i].name != NULL; i++)
1336 {
1337 if (cris_spec_regs[i].number == sreg)
1338 {
1339 if (distype == cris_dis_v32)
1340 switch (cris_spec_regs[i].applicable_version)
1341 {
1342 case cris_ver_warning:
1343 case cris_ver_version_all:
1344 case cris_ver_v3p:
1345 case cris_ver_v8p:
1346 case cris_ver_v10p:
1347 case cris_ver_v32p:
1348 /* No ambiguous sizes or register names with CRISv32. */
1349 if (cris_spec_regs[i].warning == NULL)
1350 return &cris_spec_regs[i];
1351 default:
1352 ;
1353 }
1354 else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
1355 return &cris_spec_regs[i];
1356 }
1357 }
1358
1359 return NULL;
1360 }
1361
1362 /* Return the number of bits in the argument. */
1363
1364 static int
1365 number_of_bits (unsigned int val)
1366 {
1367 int bits;
1368
1369 for (bits = 0; val != 0; val &= val - 1)
1370 bits++;
1371
1372 return bits;
1373 }
1374
1375 /* Get an entry in the opcode-table. */
1376
1377 static const struct cris_opcode *
1378 get_opcode_entry (unsigned int insn,
1379 unsigned int prefix_insn,
1380 struct cris_disasm_data *disdata)
1381 {
1382 /* For non-prefixed insns, we keep a table of pointers, indexed by the
1383 insn code. Each entry is initialized when found to be NULL. */
1384 static const struct cris_opcode **opc_table = NULL;
1385
1386 const struct cris_opcode *max_matchedp = NULL;
1387 const struct cris_opcode **prefix_opc_table = NULL;
1388
1389 /* We hold a table for each prefix that need to be handled differently. */
1390 static const struct cris_opcode **dip_prefixes = NULL;
1391 static const struct cris_opcode **bdapq_m1_prefixes = NULL;
1392 static const struct cris_opcode **bdapq_m2_prefixes = NULL;
1393 static const struct cris_opcode **bdapq_m4_prefixes = NULL;
1394 static const struct cris_opcode **rest_prefixes = NULL;
1395
1396 /* Allocate and clear the opcode-table. */
1397 if (opc_table == NULL)
1398 {
1399 opc_table = qemu_malloc (65536 * sizeof (opc_table[0]));
1400
1401 memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
1402
1403 dip_prefixes
1404 = qemu_malloc (65536 * sizeof (const struct cris_opcode **));
1405
1406 memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
1407
1408 bdapq_m1_prefixes
1409 = qemu_malloc (65536 * sizeof (const struct cris_opcode **));
1410
1411 memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
1412
1413 bdapq_m2_prefixes
1414 = qemu_malloc (65536 * sizeof (const struct cris_opcode **));
1415
1416 memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
1417
1418 bdapq_m4_prefixes
1419 = qemu_malloc (65536 * sizeof (const struct cris_opcode **));
1420
1421 memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
1422
1423 rest_prefixes
1424 = qemu_malloc (65536 * sizeof (const struct cris_opcode **));
1425
1426 memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
1427 }
1428
1429 /* Get the right table if this is a prefix.
1430 This code is connected to cris_constraints in that it knows what
1431 prefixes play a role in recognition of patterns; the necessary
1432 state is reflected by which table is used. If constraints
1433 involving match or non-match of prefix insns are changed, then this
1434 probably needs changing too. */
1435 if (prefix_insn != NO_CRIS_PREFIX)
1436 {
1437 const struct cris_opcode *popcodep
1438 = (opc_table[prefix_insn] != NULL
1439 ? opc_table[prefix_insn]
1440 : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
1441
1442 if (popcodep == NULL)
1443 return NULL;
1444
1445 if (popcodep->match == BDAP_QUICK_OPCODE)
1446 {
1447 /* Since some offsets are recognized with "push" macros, we
1448 have to have different tables for them. */
1449 int offset = (prefix_insn & 255);
1450
1451 if (offset > 127)
1452 offset -= 256;
1453
1454 switch (offset)
1455 {
1456 case -4:
1457 prefix_opc_table = bdapq_m4_prefixes;
1458 break;
1459
1460 case -2:
1461 prefix_opc_table = bdapq_m2_prefixes;
1462 break;
1463
1464 case -1:
1465 prefix_opc_table = bdapq_m1_prefixes;
1466 break;
1467
1468 default:
1469 prefix_opc_table = rest_prefixes;
1470 break;
1471 }
1472 }
1473 else if (popcodep->match == DIP_OPCODE)
1474 /* We don't allow postincrement when the prefix is DIP, so use a
1475 different table for DIP. */
1476 prefix_opc_table = dip_prefixes;
1477 else
1478 prefix_opc_table = rest_prefixes;
1479 }
1480
1481 if (prefix_insn != NO_CRIS_PREFIX
1482 && prefix_opc_table[insn] != NULL)
1483 max_matchedp = prefix_opc_table[insn];
1484 else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
1485 max_matchedp = opc_table[insn];
1486 else
1487 {
1488 const struct cris_opcode *opcodep;
1489 int max_level_of_match = -1;
1490
1491 for (opcodep = cris_opcodes;
1492 opcodep->name != NULL;
1493 opcodep++)
1494 {
1495 int level_of_match;
1496
1497 if (disdata->distype == cris_dis_v32)
1498 {
1499 switch (opcodep->applicable_version)
1500 {
1501 case cris_ver_version_all:
1502 break;
1503
1504 case cris_ver_v0_3:
1505 case cris_ver_v0_10:
1506 case cris_ver_v3_10:
1507 case cris_ver_sim_v0_10:
1508 case cris_ver_v8_10:
1509 case cris_ver_v10:
1510 case cris_ver_warning:
1511 continue;
1512
1513 case cris_ver_v3p:
1514 case cris_ver_v8p:
1515 case cris_ver_v10p:
1516 case cris_ver_v32p:
1517 break;
1518
1519 case cris_ver_v8:
1520 abort ();
1521 default:
1522 abort ();
1523 }
1524 }
1525 else
1526 {
1527 switch (opcodep->applicable_version)
1528 {
1529 case cris_ver_version_all:
1530 case cris_ver_v0_3:
1531 case cris_ver_v3p:
1532 case cris_ver_v0_10:
1533 case cris_ver_v8p:
1534 case cris_ver_v8_10:
1535 case cris_ver_v10:
1536 case cris_ver_sim_v0_10:
1537 case cris_ver_v10p:
1538 case cris_ver_warning:
1539 break;
1540
1541 case cris_ver_v32p:
1542 continue;
1543
1544 case cris_ver_v8:
1545 abort ();
1546 default:
1547 abort ();
1548 }
1549 }
1550
1551 /* We give a double lead for bits matching the template in
1552 cris_opcodes. Not even, because then "move p8,r10" would
1553 be given 2 bits lead over "clear.d r10". When there's a
1554 tie, the first entry in the table wins. This is
1555 deliberate, to avoid a more complicated recognition
1556 formula. */
1557 if ((opcodep->match & insn) == opcodep->match
1558 && (opcodep->lose & insn) == 0
1559 && ((level_of_match
1560 = cris_constraint (opcodep->args,
1561 insn,
1562 prefix_insn,
1563 disdata))
1564 >= 0)
1565 && ((level_of_match
1566 += 2 * number_of_bits (opcodep->match
1567 | opcodep->lose))
1568 > max_level_of_match))
1569 {
1570 max_matchedp = opcodep;
1571 max_level_of_match = level_of_match;
1572
1573 /* If there was a full match, never mind looking
1574 further. */
1575 if (level_of_match >= 2 * 16)
1576 break;
1577 }
1578 }
1579 /* Fill in the new entry.
1580
1581 If there are changes to the opcode-table involving prefixes, and
1582 disassembly then does not work correctly, try removing the
1583 else-clause below that fills in the prefix-table. If that
1584 helps, you need to change the prefix_opc_table setting above, or
1585 something related. */
1586 if (prefix_insn == NO_CRIS_PREFIX)
1587 opc_table[insn] = max_matchedp;
1588 else
1589 prefix_opc_table[insn] = max_matchedp;
1590 }
1591
1592 return max_matchedp;
1593 }
1594
1595 /* Return -1 if the constraints of a bitwise-matched instruction say
1596 that there is no match. Otherwise return a nonnegative number
1597 indicating the confidence in the match (higher is better). */
1598
1599 static int
1600 cris_constraint (const char *cs,
1601 unsigned int insn,
1602 unsigned int prefix_insn,
1603 struct cris_disasm_data *disdata)
1604 {
1605 int retval = 0;
1606 int tmp;
1607 int prefix_ok = 0;
1608 const char *s;
1609
1610 for (s = cs; *s; s++)
1611 switch (*s)
1612 {
1613 case '!':
1614 /* Do not recognize "pop" if there's a prefix and then only for
1615 v0..v10. */
1616 if (prefix_insn != NO_CRIS_PREFIX
1617 || disdata->distype != cris_dis_v0_v10)
1618 return -1;
1619 break;
1620
1621 case 'U':
1622 /* Not recognized at disassembly. */
1623 return -1;
1624
1625 case 'M':
1626 /* Size modifier for "clear", i.e. special register 0, 4 or 8.
1627 Check that it is one of them. Only special register 12 could
1628 be mismatched, but checking for matches is more logical than
1629 checking for mismatches when there are only a few cases. */
1630 tmp = ((insn >> 12) & 0xf);
1631 if (tmp != 0 && tmp != 4 && tmp != 8)
1632 return -1;
1633 break;
1634
1635 case 'm':
1636 if ((insn & 0x30) == 0x30)
1637 return -1;
1638 break;
1639
1640 case 'S':
1641 /* A prefix operand without side-effect. */
1642 if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
1643 {
1644 prefix_ok = 1;
1645 break;
1646 }
1647 else
1648 return -1;
1649
1650 case 's':
1651 case 'y':
1652 case 'Y':
1653 /* If this is a prefixed insn with postincrement (side-effect),
1654 the prefix must not be DIP. */
1655 if (prefix_insn != NO_CRIS_PREFIX)
1656 {
1657 if (insn & 0x400)
1658 {
1659 const struct cris_opcode *prefix_opcodep
1660 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
1661
1662 if (prefix_opcodep->match == DIP_OPCODE)
1663 return -1;
1664 }
1665
1666 prefix_ok = 1;
1667 }
1668 break;
1669
1670 case 'B':
1671 /* If we don't fall through, then the prefix is ok. */
1672 prefix_ok = 1;
1673
1674 /* A "push" prefix. Check for valid "push" size.
1675 In case of special register, it may be != 4. */
1676 if (prefix_insn != NO_CRIS_PREFIX)
1677 {
1678 /* Match the prefix insn to BDAPQ. */
1679 const struct cris_opcode *prefix_opcodep
1680 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
1681
1682 if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
1683 {
1684 int pushsize = (prefix_insn & 255);
1685
1686 if (pushsize > 127)
1687 pushsize -= 256;
1688
1689 if (s[1] == 'P')
1690 {
1691 unsigned int spec_reg = (insn >> 12) & 15;
1692 const struct cris_spec_reg *sregp
1693 = spec_reg_info (spec_reg, disdata->distype);
1694
1695 /* For a special-register, the "prefix size" must
1696 match the size of the register. */
1697 if (sregp && sregp->reg_size == (unsigned int) -pushsize)
1698 break;
1699 }
1700 else if (s[1] == 'R')
1701 {
1702 if ((insn & 0x30) == 0x20 && pushsize == -4)
1703 break;
1704 }
1705 /* FIXME: Should abort here; next constraint letter
1706 *must* be 'P' or 'R'. */
1707 }
1708 }
1709 return -1;
1710
1711 case 'D':
1712 retval = (((insn >> 12) & 15) == (insn & 15));
1713 if (!retval)
1714 return -1;
1715 else
1716 retval += 4;
1717 break;
1718
1719 case 'P':
1720 {
1721 const struct cris_spec_reg *sregp
1722 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1723
1724 /* Since we match four bits, we will give a value of 4-1 = 3
1725 in a match. If there is a corresponding exact match of a
1726 special register in another pattern, it will get a value of
1727 4, which will be higher. This should be correct in that an
1728 exact pattern would match better than a general pattern.
1729
1730 Note that there is a reason for not returning zero; the
1731 pattern for "clear" is partly matched in the bit-pattern
1732 (the two lower bits must be zero), while the bit-pattern
1733 for a move from a special register is matched in the
1734 register constraint. */
1735
1736 if (sregp != NULL)
1737 {
1738 retval += 3;
1739 break;
1740 }
1741 else
1742 return -1;
1743 }
1744 }
1745
1746 if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
1747 return -1;
1748
1749 return retval;
1750 }
1751
1752 /* Format number as hex with a leading "0x" into outbuffer. */
1753
1754 static char *
1755 format_hex (unsigned long number,
1756 char *outbuffer,
1757 struct cris_disasm_data *disdata)
1758 {
1759 /* Truncate negative numbers on >32-bit hosts. */
1760 number &= 0xffffffff;
1761
1762 sprintf (outbuffer, "0x%lx", number);
1763
1764 /* Save this value for the "case" support. */
1765 if (TRACE_CASE)
1766 last_immediate = number;
1767
1768 return outbuffer + strlen (outbuffer);
1769 }
1770
1771 /* Format number as decimal into outbuffer. Parameter signedp says
1772 whether the number should be formatted as signed (!= 0) or
1773 unsigned (== 0). */
1774
1775 static char *
1776 format_dec (long number, char *outbuffer, int signedp)
1777 {
1778 last_immediate = number;
1779 sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
1780
1781 return outbuffer + strlen (outbuffer);
1782 }
1783
1784 /* Format the name of the general register regno into outbuffer. */
1785
1786 static char *
1787 format_reg (struct cris_disasm_data *disdata,
1788 int regno,
1789 char *outbuffer_start,
1790 bfd_boolean with_reg_prefix)
1791 {
1792 char *outbuffer = outbuffer_start;
1793
1794 if (with_reg_prefix)
1795 *outbuffer++ = REGISTER_PREFIX_CHAR;
1796
1797 switch (regno)
1798 {
1799 case 15:
1800 /* For v32, there is no context in which we output PC. */
1801 if (disdata->distype == cris_dis_v32)
1802 strcpy (outbuffer, "acr");
1803 else
1804 strcpy (outbuffer, "pc");
1805 break;
1806
1807 case 14:
1808 strcpy (outbuffer, "sp");
1809 break;
1810
1811 default:
1812 sprintf (outbuffer, "r%d", regno);
1813 break;
1814 }
1815
1816 return outbuffer_start + strlen (outbuffer_start);
1817 }
1818
1819 /* Format the name of a support register into outbuffer. */
1820
1821 static char *
1822 format_sup_reg (unsigned int regno,
1823 char *outbuffer_start,
1824 bfd_boolean with_reg_prefix)
1825 {
1826 char *outbuffer = outbuffer_start;
1827 int i;
1828
1829 if (with_reg_prefix)
1830 *outbuffer++ = REGISTER_PREFIX_CHAR;
1831
1832 for (i = 0; cris_support_regs[i].name != NULL; i++)
1833 if (cris_support_regs[i].number == regno)
1834 {
1835 sprintf (outbuffer, "%s", cris_support_regs[i].name);
1836 return outbuffer_start + strlen (outbuffer_start);
1837 }
1838
1839 /* There's supposed to be register names covering all numbers, though
1840 some may be generic names. */
1841 sprintf (outbuffer, "format_sup_reg-BUG");
1842 return outbuffer_start + strlen (outbuffer_start);
1843 }
1844
1845 /* Return the length of an instruction. */
1846
1847 static unsigned
1848 bytes_to_skip (unsigned int insn,
1849 const struct cris_opcode *matchedp,
1850 enum cris_disass_family distype,
1851 const struct cris_opcode *prefix_matchedp)
1852 {
1853 /* Each insn is a word plus "immediate" operands. */
1854 unsigned to_skip = 2;
1855 const char *template = matchedp->args;
1856 const char *s;
1857
1858 for (s = template; *s; s++)
1859 if ((*s == 's' || *s == 'N' || *s == 'Y')
1860 && (insn & 0x400) && (insn & 15) == 15
1861 && prefix_matchedp == NULL)
1862 {
1863 /* Immediate via [pc+], so we have to check the size of the
1864 operand. */
1865 int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
1866
1867 if (matchedp->imm_oprnd_size == SIZE_FIX_32)
1868 to_skip += 4;
1869 else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
1870 {
1871 const struct cris_spec_reg *sregp
1872 = spec_reg_info ((insn >> 12) & 15, distype);
1873
1874 /* FIXME: Improve error handling; should have been caught
1875 earlier. */
1876 if (sregp == NULL)
1877 return 2;
1878
1879 /* PC is incremented by two, not one, for a byte. Except on
1880 CRISv32, where constants are always DWORD-size for
1881 special registers. */
1882 to_skip +=
1883 distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
1884 }
1885 else
1886 to_skip += (mode_size + 1) & ~1;
1887 }
1888 else if (*s == 'n')
1889 to_skip += 4;
1890 else if (*s == 'b')
1891 to_skip += 2;
1892
1893 return to_skip;
1894 }
1895
1896 /* Print condition code flags. */
1897
1898 static char *
1899 print_flags (struct cris_disasm_data *disdata, unsigned int insn, char *cp)
1900 {
1901 /* Use the v8 (Etrax 100) flag definitions for disassembly.
1902 The differences with v0 (Etrax 1..4) vs. Svinto are:
1903 v0 'd' <=> v8 'm'
1904 v0 'e' <=> v8 'b'.
1905 FIXME: Emit v0..v3 flag names somehow. */
1906 static const char v8_fnames[] = "cvznxibm";
1907 static const char v32_fnames[] = "cvznxiup";
1908 const char *fnames
1909 = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
1910
1911 unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
1912 int i;
1913
1914 for (i = 0; i < 8; i++)
1915 if (flagbits & (1 << i))
1916 *cp++ = fnames[i];
1917
1918 return cp;
1919 }
1920
1921 /* Print out an insn with its operands, and update the info->insn_type
1922 fields. The prefix_opcodep and the rest hold a prefix insn that is
1923 supposed to be output as an address mode. */
1924
1925 static void
1926 print_with_operands (const struct cris_opcode *opcodep,
1927 unsigned int insn,
1928 unsigned char *buffer,
1929 bfd_vma addr,
1930 disassemble_info *info,
1931 /* If a prefix insn was before this insn (and is supposed
1932 to be output as an address), here is a description of
1933 it. */
1934 const struct cris_opcode *prefix_opcodep,
1935 unsigned int prefix_insn,
1936 unsigned char *prefix_buffer,
1937 bfd_boolean with_reg_prefix)
1938 {
1939 /* Get a buffer of somewhat reasonable size where we store
1940 intermediate parts of the insn. */
1941 char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
1942 char *tp = temp;
1943 static const char mode_char[] = "bwd?";
1944 const char *s;
1945 const char *cs;
1946 struct cris_disasm_data *disdata
1947 = (struct cris_disasm_data *) info->private_data;
1948
1949 /* Print out the name first thing we do. */
1950 (*info->fprintf_func) (info->stream, "%s", opcodep->name);
1951
1952 cs = opcodep->args;
1953 s = cs;
1954
1955 /* Ignore any prefix indicator. */
1956 if (*s == 'p')
1957 s++;
1958
1959 if (*s == 'm' || *s == 'M' || *s == 'z')
1960 {
1961 *tp++ = '.';
1962
1963 /* Get the size-letter. */
1964 *tp++ = *s == 'M'
1965 ? (insn & 0x8000 ? 'd'
1966 : insn & 0x4000 ? 'w' : 'b')
1967 : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
1968
1969 /* Ignore the size and the space character that follows. */
1970 s += 2;
1971 }
1972
1973 /* Add a space if this isn't a long-branch, because for those will add
1974 the condition part of the name later. */
1975 if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
1976 *tp++ = ' ';
1977
1978 /* Fill in the insn-type if deducible from the name (and there's no
1979 better way). */
1980 if (opcodep->name[0] == 'j')
1981 {
1982 if (CONST_STRNEQ (opcodep->name, "jsr"))
1983 /* It's "jsr" or "jsrc". */
1984 info->insn_type = dis_jsr;
1985 else
1986 /* Any other jump-type insn is considered a branch. */
1987 info->insn_type = dis_branch;
1988 }
1989
1990 /* We might know some more fields right now. */
1991 info->branch_delay_insns = opcodep->delayed;
1992
1993 /* Handle operands. */
1994 for (; *s; s++)
1995 {
1996 switch (*s)
1997 {
1998 case 'T':
1999 tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
2000 break;
2001
2002 case 'A':
2003 if (with_reg_prefix)
2004 *tp++ = REGISTER_PREFIX_CHAR;
2005 *tp++ = 'a';
2006 *tp++ = 'c';
2007 *tp++ = 'r';
2008 break;
2009
2010 case '[':
2011 case ']':
2012 case ',':
2013 *tp++ = *s;
2014 break;
2015
2016 case '!':
2017 /* Ignore at this point; used at earlier stages to avoid
2018 recognition if there's a prefix at something that in other
2019 ways looks like a "pop". */
2020 break;
2021
2022 case 'd':
2023 /* Ignore. This is an optional ".d " on the large one of
2024 relaxable insns. */
2025 break;
2026
2027 case 'B':
2028 /* This was the prefix that made this a "push". We've already
2029 handled it by recognizing it, so signal that the prefix is
2030 handled by setting it to NULL. */
2031 prefix_opcodep = NULL;
2032 break;
2033
2034 case 'D':
2035 case 'r':
2036 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2037 break;
2038
2039 case 'R':
2040 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2041 break;
2042
2043 case 'n':
2044 {
2045 /* Like N but pc-relative to the start of the insn. */
2046 unsigned long number
2047 = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
2048 + buffer[5] * 0x1000000 + addr);
2049
2050 /* Finish off and output previous formatted bytes. */
2051 *tp = 0;
2052 if (temp[0])
2053 (*info->fprintf_func) (info->stream, "%s", temp);
2054 tp = temp;
2055
2056 (*info->print_address_func) ((bfd_vma) number, info);
2057 }
2058 break;
2059
2060 case 'u':
2061 {
2062 /* Like n but the offset is bits <3:0> in the instruction. */
2063 unsigned long number = (buffer[0] & 0xf) * 2 + addr;
2064
2065 /* Finish off and output previous formatted bytes. */
2066 *tp = 0;
2067 if (temp[0])
2068 (*info->fprintf_func) (info->stream, "%s", temp);
2069 tp = temp;
2070
2071 (*info->print_address_func) ((bfd_vma) number, info);
2072 }
2073 break;
2074
2075 case 'N':
2076 case 'y':
2077 case 'Y':
2078 case 'S':
2079 case 's':
2080 /* Any "normal" memory operand. */
2081 if ((insn & 0x400) && (insn & 15) == 15 && prefix_opcodep == NULL)
2082 {
2083 /* We're looking at [pc+], i.e. we need to output an immediate
2084 number, where the size can depend on different things. */
2085 long number;
2086 int signedp
2087 = ((*cs == 'z' && (insn & 0x20))
2088 || opcodep->match == BDAP_QUICK_OPCODE);
2089 int nbytes;
2090
2091 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
2092 nbytes = 4;
2093 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
2094 {
2095 const struct cris_spec_reg *sregp
2096 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2097
2098 /* A NULL return should have been as a non-match earlier,
2099 so catch it as an internal error in the error-case
2100 below. */
2101 if (sregp == NULL)
2102 /* Whatever non-valid size. */
2103 nbytes = 42;
2104 else
2105 /* PC is always incremented by a multiple of two.
2106 For CRISv32, immediates are always 4 bytes for
2107 special registers. */
2108 nbytes = disdata->distype == cris_dis_v32
2109 ? 4 : (sregp->reg_size + 1) & ~1;
2110 }
2111 else
2112 {
2113 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
2114
2115 if (mode_size == 1)
2116 nbytes = 2;
2117 else
2118 nbytes = mode_size;
2119 }
2120
2121 switch (nbytes)
2122 {
2123 case 1:
2124 number = buffer[2];
2125 if (signedp && number > 127)
2126 number -= 256;
2127 break;
2128
2129 case 2:
2130 number = buffer[2] + buffer[3] * 256;
2131 if (signedp && number > 32767)
2132 number -= 65536;
2133 break;
2134
2135 case 4:
2136 number
2137 = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
2138 + buffer[5] * 0x1000000;
2139 break;
2140
2141 default:
2142 strcpy (tp, "bug");
2143 tp += 3;
2144 number = 42;
2145 }
2146
2147 if ((*cs == 'z' && (insn & 0x20))
2148 || (opcodep->match == BDAP_QUICK_OPCODE
2149 && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
2150 tp = format_dec (number, tp, signedp);
2151 else
2152 {
2153 unsigned int highbyte = (number >> 24) & 0xff;
2154
2155 /* Either output this as an address or as a number. If it's
2156 a dword with the same high-byte as the address of the
2157 insn, assume it's an address, and also if it's a non-zero
2158 non-0xff high-byte. If this is a jsr or a jump, then
2159 it's definitely an address. */
2160 if (nbytes == 4
2161 && (highbyte == ((addr >> 24) & 0xff)
2162 || (highbyte != 0 && highbyte != 0xff)
2163 || info->insn_type == dis_branch
2164 || info->insn_type == dis_jsr))
2165 {
2166 /* Finish off and output previous formatted bytes. */
2167 *tp = 0;
2168 tp = temp;
2169 if (temp[0])
2170 (*info->fprintf_func) (info->stream, "%s", temp);
2171
2172 (*info->print_address_func) ((bfd_vma) number, info);
2173
2174 info->target = number;
2175 }
2176 else
2177 tp = format_hex (number, tp, disdata);
2178 }
2179 }
2180 else
2181 {
2182 /* Not an immediate number. Then this is a (possibly
2183 prefixed) memory operand. */
2184 if (info->insn_type != dis_nonbranch)
2185 {
2186 int mode_size
2187 = 1 << ((insn >> 4)
2188 & (opcodep->args[0] == 'z' ? 1 : 3));
2189 int size;
2190 info->insn_type = dis_dref;
2191 info->flags |= CRIS_DIS_FLAG_MEMREF;
2192
2193 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
2194 size = 4;
2195 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
2196 {
2197 const struct cris_spec_reg *sregp
2198 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2199
2200 /* FIXME: Improve error handling; should have been caught
2201 earlier. */
2202 if (sregp == NULL)
2203 size = 4;
2204 else
2205 size = sregp->reg_size;
2206 }
2207 else
2208 size = mode_size;
2209
2210 info->data_size = size;
2211 }
2212
2213 *tp++ = '[';
2214
2215 if (prefix_opcodep
2216 /* We don't match dip with a postincremented field
2217 as a side-effect address mode. */
2218 && ((insn & 0x400) == 0
2219 || prefix_opcodep->match != DIP_OPCODE))
2220 {
2221 if (insn & 0x400)
2222 {
2223 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2224 *tp++ = '=';
2225 }
2226
2227
2228 /* We mainly ignore the prefix format string when the
2229 address-mode syntax is output. */
2230 switch (prefix_opcodep->match)
2231 {
2232 case DIP_OPCODE:
2233 /* It's [r], [r+] or [pc+]. */
2234 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
2235 {
2236 /* It's [pc+]. This cannot possibly be anything
2237 but an address. */
2238 unsigned long number
2239 = prefix_buffer[2] + prefix_buffer[3] * 256
2240 + prefix_buffer[4] * 65536
2241 + prefix_buffer[5] * 0x1000000;
2242
2243 info->target = (bfd_vma) number;
2244
2245 /* Finish off and output previous formatted
2246 data. */
2247 *tp = 0;
2248 tp = temp;
2249 if (temp[0])
2250 (*info->fprintf_func) (info->stream, "%s", temp);
2251
2252 (*info->print_address_func) ((bfd_vma) number, info);
2253 }
2254 else
2255 {
2256 /* For a memref in an address, we use target2.
2257 In this case, target is zero. */
2258 info->flags
2259 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2260 | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
2261
2262 info->target2 = prefix_insn & 15;
2263
2264 *tp++ = '[';
2265 tp = format_reg (disdata, prefix_insn & 15, tp,
2266 with_reg_prefix);
2267 if (prefix_insn & 0x400)
2268 *tp++ = '+';
2269 *tp++ = ']';
2270 }
2271 break;
2272
2273 case BDAP_QUICK_OPCODE:
2274 {
2275 int number;
2276
2277 number = prefix_buffer[0];
2278 if (number > 127)
2279 number -= 256;
2280
2281 /* Output "reg+num" or, if num < 0, "reg-num". */
2282 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2283 with_reg_prefix);
2284 if (number >= 0)
2285 *tp++ = '+';
2286 tp = format_dec (number, tp, 1);
2287
2288 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2289 info->target = (prefix_insn >> 12) & 15;
2290 info->target2 = (bfd_vma) number;
2291 break;
2292 }
2293
2294 case BIAP_OPCODE:
2295 /* Output "r+R.m". */
2296 tp = format_reg (disdata, prefix_insn & 15, tp,
2297 with_reg_prefix);
2298 *tp++ = '+';
2299 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2300 with_reg_prefix);
2301 *tp++ = '.';
2302 *tp++ = mode_char[(prefix_insn >> 4) & 3];
2303
2304 info->flags
2305 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2306 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
2307
2308 | ((prefix_insn & 0x8000)
2309 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
2310 : ((prefix_insn & 0x8000)
2311 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
2312
2313 /* Is it the casejump? It's a "adds.w [pc+r%d.w],pc". */
2314 if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
2315 /* Then start interpreting data as offsets. */
2316 case_offset_counter = no_of_case_offsets;
2317 break;
2318
2319 case BDAP_INDIR_OPCODE:
2320 /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
2321 "r-s". */
2322 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
2323 with_reg_prefix);
2324
2325 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
2326 {
2327 long number;
2328 unsigned int nbytes;
2329
2330 /* It's a value. Get its size. */
2331 int mode_size = 1 << ((prefix_insn >> 4) & 3);
2332
2333 if (mode_size == 1)
2334 nbytes = 2;
2335 else
2336 nbytes = mode_size;
2337
2338 switch (nbytes)
2339 {
2340 case 1:
2341 number = prefix_buffer[2];
2342 if (number > 127)
2343 number -= 256;
2344 break;
2345
2346 case 2:
2347 number = prefix_buffer[2] + prefix_buffer[3] * 256;
2348 if (number > 32767)
2349 number -= 65536;
2350 break;
2351
2352 case 4:
2353 number
2354 = prefix_buffer[2] + prefix_buffer[3] * 256
2355 + prefix_buffer[4] * 65536
2356 + prefix_buffer[5] * 0x1000000;
2357 break;
2358
2359 default:
2360 strcpy (tp, "bug");
2361 tp += 3;
2362 number = 42;
2363 }
2364
2365 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2366 info->target2 = (bfd_vma) number;
2367
2368 /* If the size is dword, then assume it's an
2369 address. */
2370 if (nbytes == 4)
2371 {
2372 /* Finish off and output previous formatted
2373 bytes. */
2374 *tp++ = '+';
2375 *tp = 0;
2376 tp = temp;
2377 (*info->fprintf_func) (info->stream, "%s", temp);
2378
2379 (*info->print_address_func) ((bfd_vma) number, info);
2380 }
2381 else
2382 {
2383 if (number >= 0)
2384 *tp++ = '+';
2385 tp = format_dec (number, tp, 1);
2386 }
2387 }
2388 else
2389 {
2390 /* Output "r+[R].m" or "r+[R+].m". */
2391 *tp++ = '+';
2392 *tp++ = '[';
2393 tp = format_reg (disdata, prefix_insn & 15, tp,
2394 with_reg_prefix);
2395 if (prefix_insn & 0x400)
2396 *tp++ = '+';
2397 *tp++ = ']';
2398 *tp++ = '.';
2399 *tp++ = mode_char[(prefix_insn >> 4) & 3];
2400
2401 info->flags
2402 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
2403 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
2404 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
2405
2406 | (((prefix_insn >> 4) == 2)
2407 ? 0
2408 : (((prefix_insn >> 4) & 3) == 1
2409 ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
2410 : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
2411 }
2412 break;
2413
2414 default:
2415 (*info->fprintf_func) (info->stream, "?prefix-bug");
2416 }
2417
2418 /* To mark that the prefix is used, reset it. */
2419 prefix_opcodep = NULL;
2420 }
2421 else
2422 {
2423 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
2424
2425 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
2426 info->target = insn & 15;
2427
2428 if (insn & 0x400)
2429 *tp++ = '+';
2430 }
2431 *tp++ = ']';
2432 }
2433 break;
2434
2435 case 'x':
2436 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2437 *tp++ = '.';
2438 *tp++ = mode_char[(insn >> 4) & 3];
2439 break;
2440
2441 case 'I':
2442 tp = format_dec (insn & 63, tp, 0);
2443 break;
2444
2445 case 'b':
2446 {
2447 int where = buffer[2] + buffer[3] * 256;
2448
2449 if (where > 32767)
2450 where -= 65536;
2451
2452 where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
2453
2454 if (insn == BA_PC_INCR_OPCODE)
2455 info->insn_type = dis_branch;
2456 else
2457 info->insn_type = dis_condbranch;
2458
2459 info->target = (bfd_vma) where;
2460
2461 *tp = 0;
2462 tp = temp;
2463 (*info->fprintf_func) (info->stream, "%s%s ",
2464 temp, cris_cc_strings[insn >> 12]);
2465
2466 (*info->print_address_func) ((bfd_vma) where, info);
2467 }
2468 break;
2469
2470 case 'c':
2471 tp = format_dec (insn & 31, tp, 0);
2472 break;
2473
2474 case 'C':
2475 tp = format_dec (insn & 15, tp, 0);
2476 break;
2477
2478 case 'o':
2479 {
2480 long offset = insn & 0xfe;
2481 bfd_vma target;
2482
2483 if (insn & 1)
2484 offset |= ~0xff;
2485
2486 if (opcodep->match == BA_QUICK_OPCODE)
2487 info->insn_type = dis_branch;
2488 else
2489 info->insn_type = dis_condbranch;
2490
2491 target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
2492 info->target = target;
2493 *tp = 0;
2494 tp = temp;
2495 (*info->fprintf_func) (info->stream, "%s", temp);
2496 (*info->print_address_func) (target, info);
2497 }
2498 break;
2499
2500 case 'Q':
2501 case 'O':
2502 {
2503 long number = buffer[0];
2504
2505 if (number > 127)
2506 number = number - 256;
2507
2508 tp = format_dec (number, tp, 1);
2509 *tp++ = ',';
2510 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
2511 }
2512 break;
2513
2514 case 'f':
2515 tp = print_flags (disdata, insn, tp);
2516 break;
2517
2518 case 'i':
2519 tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
2520 break;
2521
2522 case 'P':
2523 {
2524 const struct cris_spec_reg *sregp
2525 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
2526
2527 if (sregp->name == NULL)
2528 /* Should have been caught as a non-match eariler. */
2529 *tp++ = '?';
2530 else
2531 {
2532 if (with_reg_prefix)
2533 *tp++ = REGISTER_PREFIX_CHAR;
2534 strcpy (tp, sregp->name);
2535 tp += strlen (tp);
2536 }
2537 }
2538 break;
2539
2540 default:
2541 strcpy (tp, "???");
2542 tp += 3;
2543 }
2544 }
2545
2546 *tp = 0;
2547
2548 if (prefix_opcodep)
2549 (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
2550 prefix_opcodep->name, prefix_opcodep->args);
2551
2552 (*info->fprintf_func) (info->stream, "%s", temp);
2553
2554 /* Get info for matching case-tables, if we don't have any active.
2555 We assume that the last constant seen is used; either in the insn
2556 itself or in a "move.d const,rN, sub.d rN,rM"-like sequence. */
2557 if (TRACE_CASE && case_offset_counter == 0)
2558 {
2559 if (CONST_STRNEQ (opcodep->name, "sub"))
2560 case_offset = last_immediate;
2561
2562 /* It could also be an "add", if there are negative case-values. */
2563 else if (CONST_STRNEQ (opcodep->name, "add"))
2564 /* The first case is the negated operand to the add. */
2565 case_offset = -last_immediate;
2566
2567 /* A bound insn will tell us the number of cases. */
2568 else if (CONST_STRNEQ (opcodep->name, "bound"))
2569 no_of_case_offsets = last_immediate + 1;
2570
2571 /* A jump or jsr or branch breaks the chain of insns for a
2572 case-table, so assume default first-case again. */
2573 else if (info->insn_type == dis_jsr
2574 || info->insn_type == dis_branch
2575 || info->insn_type == dis_condbranch)
2576 case_offset = 0;
2577 }
2578 }
2579
2580
2581 /* Print the CRIS instruction at address memaddr on stream. Returns
2582 length of the instruction, in bytes. Prefix register names with `$' if
2583 WITH_REG_PREFIX. */
2584
2585 static int
2586 print_insn_cris_generic (bfd_vma memaddr,
2587 disassemble_info *info,
2588 bfd_boolean with_reg_prefix)
2589 {
2590 int nbytes;
2591 unsigned int insn;
2592 const struct cris_opcode *matchedp;
2593 int advance = 0;
2594 struct cris_disasm_data *disdata
2595 = (struct cris_disasm_data *) info->private_data;
2596
2597 /* No instruction will be disassembled as longer than this number of
2598 bytes; stacked prefixes will not be expanded. */
2599 unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
2600 unsigned char *bufp;
2601 int status = 0;
2602 bfd_vma addr;
2603
2604 /* There will be an "out of range" error after the last instruction.
2605 Reading pairs of bytes in decreasing number, we hope that we will get
2606 at least the amount that we will consume.
2607
2608 If we can't get any data, or we do not get enough data, we print
2609 the error message. */
2610
2611 nbytes = info->buffer_length;
2612 if (nbytes > MAX_BYTES_PER_CRIS_INSN)
2613 nbytes = MAX_BYTES_PER_CRIS_INSN;
2614 status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
2615
2616 /* If we did not get all we asked for, then clear the rest.
2617 Hopefully this makes a reproducible result in case of errors. */
2618 if (nbytes != MAX_BYTES_PER_CRIS_INSN)
2619 memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
2620
2621 addr = memaddr;
2622 bufp = buffer;
2623
2624 /* Set some defaults for the insn info. */
2625 info->insn_info_valid = 1;
2626 info->branch_delay_insns = 0;
2627 info->data_size = 0;
2628 info->insn_type = dis_nonbranch;
2629 info->flags = 0;
2630 info->target = 0;
2631 info->target2 = 0;
2632
2633 /* If we got any data, disassemble it. */
2634 if (nbytes != 0)
2635 {
2636 matchedp = NULL;
2637
2638 insn = bufp[0] + bufp[1] * 256;
2639
2640 /* If we're in a case-table, don't disassemble the offsets. */
2641 if (TRACE_CASE && case_offset_counter != 0)
2642 {
2643 info->insn_type = dis_noninsn;
2644 advance += 2;
2645
2646 /* If to print data as offsets, then shortcut here. */
2647 (*info->fprintf_func) (info->stream, "case %ld%s: -> ",
2648 case_offset + no_of_case_offsets
2649 - case_offset_counter,
2650 case_offset_counter == 1 ? "/default" :
2651 "");
2652
2653 (*info->print_address_func) ((bfd_vma)
2654 ((short) (insn)
2655 + (long) (addr
2656 - (no_of_case_offsets
2657 - case_offset_counter)
2658 * 2)), info);
2659 case_offset_counter--;
2660
2661 /* The default case start (without a "sub" or "add") must be
2662 zero. */
2663 if (case_offset_counter == 0)
2664 case_offset = 0;
2665 }
2666 else if (insn == 0)
2667 {
2668 /* We're often called to disassemble zeroes. While this is a
2669 valid "bcc .+2" insn, it is also useless enough and enough
2670 of a nuiscance that we will just output "bcc .+2" for it
2671 and signal it as a noninsn. */
2672 (*info->fprintf_func) (info->stream,
2673 disdata->distype == cris_dis_v32
2674 ? "bcc ." : "bcc .+2");
2675 info->insn_type = dis_noninsn;
2676 advance += 2;
2677 }
2678 else
2679 {
2680 const struct cris_opcode *prefix_opcodep = NULL;
2681 unsigned char *prefix_buffer = bufp;
2682 unsigned int prefix_insn = insn;
2683 int prefix_size = 0;
2684
2685 matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
2686
2687 /* Check if we're supposed to write out prefixes as address
2688 modes and if this was a prefix. */
2689 if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
2690 {
2691 /* If it's a prefix, put it into the prefix vars and get the
2692 main insn. */
2693 prefix_size = bytes_to_skip (prefix_insn, matchedp,
2694 disdata->distype, NULL);
2695 prefix_opcodep = matchedp;
2696
2697 insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
2698 matchedp = get_opcode_entry (insn, prefix_insn, disdata);
2699
2700 if (matchedp != NULL)
2701 {
2702 addr += prefix_size;
2703 bufp += prefix_size;
2704 advance += prefix_size;
2705 }
2706 else
2707 {
2708 /* The "main" insn wasn't valid, at least not when
2709 prefixed. Put back things enough to output the
2710 prefix insn only, as a normal insn. */
2711 matchedp = prefix_opcodep;
2712 insn = prefix_insn;
2713 prefix_opcodep = NULL;
2714 }
2715 }
2716
2717 if (matchedp == NULL)
2718 {
2719 (*info->fprintf_func) (info->stream, "??0x%x", insn);
2720 advance += 2;
2721
2722 info->insn_type = dis_noninsn;
2723 }
2724 else
2725 {
2726 advance
2727 += bytes_to_skip (insn, matchedp, disdata->distype,
2728 prefix_opcodep);
2729
2730 /* The info_type and assorted fields will be set according
2731 to the operands. */
2732 print_with_operands (matchedp, insn, bufp, addr, info,
2733 prefix_opcodep, prefix_insn,
2734 prefix_buffer, with_reg_prefix);
2735 }
2736 }
2737 }
2738 else
2739 info->insn_type = dis_noninsn;
2740
2741 /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
2742 status when reading that much, and the insn decoding indicated a
2743 length exceeding what we read, there is an error. */
2744 if (status != 0 && (nbytes == 0 || advance > nbytes))
2745 {
2746 (*info->memory_error_func) (status, memaddr, info);
2747 return -1;
2748 }
2749
2750 /* Max supported insn size with one folded prefix insn. */
2751 info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
2752
2753 /* I would like to set this to a fixed value larger than the actual
2754 number of bytes to print in order to avoid spaces between bytes,
2755 but objdump.c (2.9.1) does not like that, so we print 16-bit
2756 chunks, which is the next choice. */
2757 info->bytes_per_chunk = 2;
2758
2759 /* Printing bytes in order of increasing addresses makes sense,
2760 especially on a little-endian target.
2761 This is completely the opposite of what you think; setting this to
2762 BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
2763 we want. */
2764 info->display_endian = BFD_ENDIAN_BIG;
2765
2766 return advance;
2767 }
2768
2769 /* Disassemble, prefixing register names with `$'. CRIS v0..v10. */
2770 static int
2771 print_insn_cris_with_register_prefix (bfd_vma vma,
2772 disassemble_info *info)
2773 {
2774 if (info->private_data == NULL
2775 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
2776 return -1;
2777 return print_insn_cris_generic (vma, info, true);
2778 }
2779 /* Disassemble, prefixing register names with `$'. CRIS v32. */
2780
2781 static int
2782 print_insn_crisv32_with_register_prefix (bfd_vma vma,
2783 disassemble_info *info)
2784 {
2785 if (info->private_data == NULL
2786 && !cris_parse_disassembler_options (info, cris_dis_v32))
2787 return -1;
2788 return print_insn_cris_generic (vma, info, true);
2789 }
2790
2791 #if 0
2792 /* Disassemble, prefixing register names with `$'.
2793 Common v10 and v32 subset. */
2794
2795 static int
2796 print_insn_crisv10_v32_with_register_prefix (bfd_vma vma,
2797 disassemble_info *info)
2798 {
2799 if (info->private_data == NULL
2800 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
2801 return -1;
2802 return print_insn_cris_generic (vma, info, true);
2803 }
2804
2805 /* Disassemble, no prefixes on register names. CRIS v0..v10. */
2806
2807 static int
2808 print_insn_cris_without_register_prefix (bfd_vma vma,
2809 disassemble_info *info)
2810 {
2811 if (info->private_data == NULL
2812 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
2813 return -1;
2814 return print_insn_cris_generic (vma, info, false);
2815 }
2816
2817 /* Disassemble, no prefixes on register names. CRIS v32. */
2818
2819 static int
2820 print_insn_crisv32_without_register_prefix (bfd_vma vma,
2821 disassemble_info *info)
2822 {
2823 if (info->private_data == NULL
2824 && !cris_parse_disassembler_options (info, cris_dis_v32))
2825 return -1;
2826 return print_insn_cris_generic (vma, info, false);
2827 }
2828
2829 /* Disassemble, no prefixes on register names.
2830 Common v10 and v32 subset. */
2831
2832 static int
2833 print_insn_crisv10_v32_without_register_prefix (bfd_vma vma,
2834 disassemble_info *info)
2835 {
2836 if (info->private_data == NULL
2837 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
2838 return -1;
2839 return print_insn_cris_generic (vma, info, false);
2840 }
2841 #endif
2842
2843 int
2844 print_insn_crisv10 (bfd_vma vma,
2845 disassemble_info *info)
2846 {
2847 return print_insn_cris_with_register_prefix(vma, info);
2848 }
2849
2850 int
2851 print_insn_crisv32 (bfd_vma vma,
2852 disassemble_info *info)
2853 {
2854 return print_insn_crisv32_with_register_prefix(vma, info);
2855 }
2856
2857 /* Return a disassembler-function that prints registers with a `$' prefix,
2858 or one that prints registers without a prefix.
2859 FIXME: We should improve the solution to avoid the multitude of
2860 functions seen above. */
2861 #if 0
2862 disassembler_ftype
2863 cris_get_disassembler (bfd *abfd)
2864 {
2865 /* If there's no bfd in sight, we return what is valid as input in all
2866 contexts if fed back to the assembler: disassembly *with* register
2867 prefix. Unfortunately this will be totally wrong for v32. */
2868 if (abfd == NULL)
2869 return print_insn_cris_with_register_prefix;
2870
2871 if (bfd_get_symbol_leading_char (abfd) == 0)
2872 {
2873 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
2874 return print_insn_crisv32_with_register_prefix;
2875 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
2876 return print_insn_crisv10_v32_with_register_prefix;
2877
2878 /* We default to v10. This may be specifically specified in the
2879 bfd mach, but is also the default setting. */
2880 return print_insn_cris_with_register_prefix;
2881 }
2882
2883 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
2884 return print_insn_crisv32_without_register_prefix;
2885 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
2886 return print_insn_crisv10_v32_without_register_prefix;
2887 return print_insn_cris_without_register_prefix;
2888 }
2889 #endif
2890 /* Local variables:
2891 eval: (c-set-style "gnu")
2892 indent-tabs-mode: t
2893 End: */
Qemu with PowerPC KVM improvements