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