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