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