1 /* Disassembler code for CRIS.
2 Copyright (C) 2000-2024 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 opcodes library.
7
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
11 any later version.
12
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 #include "sysdep.h"
24 #include "dis-asm.h"
25 #include "opcode/cris.h"
26 #include "libiberty.h"
27
28 /* No instruction will be disassembled longer than this. In theory, and
29 in silicon, address prefixes can be cascaded. In practice, cascading
30 is not used by GCC, and not supported by the assembler. */
31 #ifndef MAX_BYTES_PER_CRIS_INSN
32 #define MAX_BYTES_PER_CRIS_INSN 8
33 #endif
34
35 /* Whether or not to decode prefixes, folding it into the following
36 instruction. FIXME: Make this optional later. */
37 #ifndef PARSE_PREFIX
38 #define PARSE_PREFIX 1
39 #endif
40
41 /* Sometimes we prefix all registers with this character. */
42 #define REGISTER_PREFIX_CHAR '$'
43
44 /* Whether or not to trace the following sequence:
45 sub* X,r%d
46 bound* Y,r%d
47 adds.w [pc+r%d.w],pc
48
49 This is the assembly form of a switch-statement in C.
50 The "sub is optional. If there is none, then X will be zero.
51 X is the value of the first case,
52 Y is the number of cases (including default).
53
54 This results in case offsets printed on the form:
55 case N: -> case_address
56 where N is an estimation on the corresponding 'case' operand in C,
57 and case_address is where execution of that case continues after the
58 sequence presented above.
59
60 The old style of output was to print the offsets as instructions,
61 which made it hard to follow "case"-constructs in the disassembly,
62 and caused a lot of annoying warnings about undefined instructions.
63
64 FIXME: Make this optional later. */
65 #ifndef TRACE_CASE
66 #define TRACE_CASE (disdata->trace_case)
67 #endif
68
69 enum cris_disass_family
70 { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
71
72 /* Stored in the disasm_info->private_data member. */
73 struct cris_disasm_data
74 {
75 /* Whether to print something less confusing if we find something
76 matching a switch-construct. */
77 bool trace_case;
78
79 /* Whether this code is flagged as crisv32. FIXME: Should be an enum
80 that includes "compatible". */
81 enum cris_disass_family distype;
82 };
83
84 /* Value of first element in switch. */
85 static long case_offset = 0;
86
87 /* How many more case-offsets to print. */
88 static long case_offset_counter = 0;
89
90 /* Number of case offsets. */
91 static long no_of_case_offsets = 0;
92
93 /* Candidate for next case_offset. */
94 static long last_immediate = 0;
95
96 static int cris_constraint
97 (const char *, unsigned, unsigned, struct cris_disasm_data *);
98
99 /* Parse disassembler options and store state in info. FIXME: For the
100 time being, we abuse static variables. */
101
102 static bool
cris_parse_disassembler_options(disassemble_info * info,enum cris_disass_family distype)103 cris_parse_disassembler_options (disassemble_info *info,
104 enum cris_disass_family distype)
105 {
106 struct cris_disasm_data *disdata;
107
108 info->private_data = calloc (1, sizeof (struct cris_disasm_data));
109 disdata = (struct cris_disasm_data *) info->private_data;
110 if (disdata == NULL)
111 return false;
112
113 /* Default true. */
114 disdata->trace_case
115 = (info->disassembler_options == NULL
116 || (strcmp (info->disassembler_options, "nocase") != 0));
117
118 disdata->distype = distype;
119 return true;
120 }
121
122 static const struct cris_spec_reg *
spec_reg_info(unsigned int sreg,enum cris_disass_family distype)123 spec_reg_info (unsigned int sreg, enum cris_disass_family distype)
124 {
125 int i;
126
127 for (i = 0; cris_spec_regs[i].name != NULL; i++)
128 {
129 if (cris_spec_regs[i].number == sreg)
130 {
131 if (distype == cris_dis_v32)
132 switch (cris_spec_regs[i].applicable_version)
133 {
134 case cris_ver_warning:
135 case cris_ver_version_all:
136 case cris_ver_v3p:
137 case cris_ver_v8p:
138 case cris_ver_v10p:
139 case cris_ver_v32p:
140 /* No ambiguous sizes or register names with CRISv32. */
141 if (cris_spec_regs[i].warning == NULL)
142 return &cris_spec_regs[i];
143 default:
144 ;
145 }
146 else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
147 return &cris_spec_regs[i];
148 }
149 }
150
151 return NULL;
152 }
153
154 /* Return the number of bits in the argument. */
155
156 static int
number_of_bits(unsigned int val)157 number_of_bits (unsigned int val)
158 {
159 int bits;
160
161 for (bits = 0; val != 0; val &= val - 1)
162 bits++;
163
164 return bits;
165 }
166
167 /* Get an entry in the opcode-table. */
168
169 static const struct cris_opcode *
get_opcode_entry(unsigned int insn,unsigned int prefix_insn,struct cris_disasm_data * disdata)170 get_opcode_entry (unsigned int insn,
171 unsigned int prefix_insn,
172 struct cris_disasm_data *disdata)
173 {
174 /* For non-prefixed insns, we keep a table of pointers, indexed by the
175 insn code. Each entry is initialized when found to be NULL. */
176 static const struct cris_opcode **opc_table = NULL;
177
178 const struct cris_opcode *max_matchedp = NULL;
179 const struct cris_opcode **prefix_opc_table = NULL;
180
181 /* We hold a table for each prefix that need to be handled differently. */
182 static const struct cris_opcode **dip_prefixes = NULL;
183 static const struct cris_opcode **bdapq_m1_prefixes = NULL;
184 static const struct cris_opcode **bdapq_m2_prefixes = NULL;
185 static const struct cris_opcode **bdapq_m4_prefixes = NULL;
186 static const struct cris_opcode **rest_prefixes = NULL;
187
188 /* Allocate and clear the opcode-table. */
189 if (opc_table == NULL)
190 {
191 opc_table = malloc (65536 * sizeof (opc_table[0]));
192 if (opc_table == NULL)
193 return NULL;
194
195 memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
196
197 dip_prefixes
198 = malloc (65536 * sizeof (const struct cris_opcode **));
199 if (dip_prefixes == NULL)
200 return NULL;
201
202 memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
203
204 bdapq_m1_prefixes
205 = malloc (65536 * sizeof (const struct cris_opcode **));
206 if (bdapq_m1_prefixes == NULL)
207 return NULL;
208
209 memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
210
211 bdapq_m2_prefixes
212 = malloc (65536 * sizeof (const struct cris_opcode **));
213 if (bdapq_m2_prefixes == NULL)
214 return NULL;
215
216 memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
217
218 bdapq_m4_prefixes
219 = malloc (65536 * sizeof (const struct cris_opcode **));
220 if (bdapq_m4_prefixes == NULL)
221 return NULL;
222
223 memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
224
225 rest_prefixes
226 = malloc (65536 * sizeof (const struct cris_opcode **));
227 if (rest_prefixes == NULL)
228 return NULL;
229
230 memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
231 }
232
233 /* Get the right table if this is a prefix.
234 This code is connected to cris_constraints in that it knows what
235 prefixes play a role in recognition of patterns; the necessary
236 state is reflected by which table is used. If constraints
237 involving match or non-match of prefix insns are changed, then this
238 probably needs changing too. */
239 if (prefix_insn != NO_CRIS_PREFIX)
240 {
241 const struct cris_opcode *popcodep
242 = (opc_table[prefix_insn] != NULL
243 ? opc_table[prefix_insn]
244 : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
245
246 if (popcodep == NULL)
247 return NULL;
248
249 if (popcodep->match == BDAP_QUICK_OPCODE)
250 {
251 /* Since some offsets are recognized with "push" macros, we
252 have to have different tables for them. */
253 int offset = (prefix_insn & 255);
254
255 if (offset > 127)
256 offset -= 256;
257
258 switch (offset)
259 {
260 case -4:
261 prefix_opc_table = bdapq_m4_prefixes;
262 break;
263
264 case -2:
265 prefix_opc_table = bdapq_m2_prefixes;
266 break;
267
268 case -1:
269 prefix_opc_table = bdapq_m1_prefixes;
270 break;
271
272 default:
273 prefix_opc_table = rest_prefixes;
274 break;
275 }
276 }
277 else if (popcodep->match == DIP_OPCODE)
278 /* We don't allow postincrement when the prefix is DIP, so use a
279 different table for DIP. */
280 prefix_opc_table = dip_prefixes;
281 else
282 prefix_opc_table = rest_prefixes;
283 }
284
285 if (prefix_insn != NO_CRIS_PREFIX
286 && prefix_opc_table[insn] != NULL)
287 max_matchedp = prefix_opc_table[insn];
288 else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
289 max_matchedp = opc_table[insn];
290 else
291 {
292 const struct cris_opcode *opcodep;
293 int max_level_of_match = -1;
294
295 for (opcodep = cris_opcodes;
296 opcodep->name != NULL;
297 opcodep++)
298 {
299 int level_of_match;
300
301 if (disdata->distype == cris_dis_v32)
302 {
303 switch (opcodep->applicable_version)
304 {
305 case cris_ver_version_all:
306 break;
307
308 case cris_ver_v0_3:
309 case cris_ver_v0_10:
310 case cris_ver_v3_10:
311 case cris_ver_sim_v0_10:
312 case cris_ver_v8_10:
313 case cris_ver_v10:
314 case cris_ver_warning:
315 continue;
316
317 case cris_ver_v3p:
318 case cris_ver_v8p:
319 case cris_ver_v10p:
320 case cris_ver_v32p:
321 break;
322
323 case cris_ver_v8:
324 abort ();
325 default:
326 abort ();
327 }
328 }
329 else
330 {
331 switch (opcodep->applicable_version)
332 {
333 case cris_ver_version_all:
334 case cris_ver_v0_3:
335 case cris_ver_v3p:
336 case cris_ver_v0_10:
337 case cris_ver_v8p:
338 case cris_ver_v8_10:
339 case cris_ver_v10:
340 case cris_ver_sim_v0_10:
341 case cris_ver_v10p:
342 case cris_ver_warning:
343 break;
344
345 case cris_ver_v32p:
346 continue;
347
348 case cris_ver_v8:
349 abort ();
350 default:
351 abort ();
352 }
353 }
354
355 /* We give a double lead for bits matching the template in
356 cris_opcodes. Not even, because then "move p8,r10" would
357 be given 2 bits lead over "clear.d r10". When there's a
358 tie, the first entry in the table wins. This is
359 deliberate, to avoid a more complicated recognition
360 formula. */
361 if ((opcodep->match & insn) == opcodep->match
362 && (opcodep->lose & insn) == 0
363 && ((level_of_match
364 = cris_constraint (opcodep->args,
365 insn,
366 prefix_insn,
367 disdata))
368 >= 0)
369 && ((level_of_match
370 += 2 * number_of_bits (opcodep->match
371 | opcodep->lose))
372 > max_level_of_match))
373 {
374 max_matchedp = opcodep;
375 max_level_of_match = level_of_match;
376
377 /* If there was a full match, never mind looking
378 further. */
379 if (level_of_match >= 2 * 16)
380 break;
381 }
382 }
383 /* Fill in the new entry.
384
385 If there are changes to the opcode-table involving prefixes, and
386 disassembly then does not work correctly, try removing the
387 else-clause below that fills in the prefix-table. If that
388 helps, you need to change the prefix_opc_table setting above, or
389 something related. */
390 if (prefix_insn == NO_CRIS_PREFIX)
391 opc_table[insn] = max_matchedp;
392 else
393 prefix_opc_table[insn] = max_matchedp;
394 }
395
396 return max_matchedp;
397 }
398
399 /* Return -1 if the constraints of a bitwise-matched instruction say
400 that there is no match. Otherwise return a nonnegative number
401 indicating the confidence in the match (higher is better). */
402
403 static int
cris_constraint(const char * cs,unsigned int insn,unsigned int prefix_insn,struct cris_disasm_data * disdata)404 cris_constraint (const char *cs,
405 unsigned int insn,
406 unsigned int prefix_insn,
407 struct cris_disasm_data *disdata)
408 {
409 int retval = 0;
410 int tmp;
411 int prefix_ok = 0;
412 const char *s;
413
414 for (s = cs; *s; s++)
415 switch (*s)
416 {
417 case '!':
418 /* Do not recognize "pop" if there's a prefix and then only for
419 v0..v10. */
420 if (prefix_insn != NO_CRIS_PREFIX
421 || disdata->distype != cris_dis_v0_v10)
422 return -1;
423 break;
424
425 case 'U':
426 /* Not recognized at disassembly. */
427 return -1;
428
429 case 'M':
430 /* Size modifier for "clear", i.e. special register 0, 4 or 8.
431 Check that it is one of them. Only special register 12 could
432 be mismatched, but checking for matches is more logical than
433 checking for mismatches when there are only a few cases. */
434 tmp = ((insn >> 12) & 0xf);
435 if (tmp != 0 && tmp != 4 && tmp != 8)
436 return -1;
437 break;
438
439 case 'm':
440 if ((insn & 0x30) == 0x30)
441 return -1;
442 break;
443
444 case 'S':
445 /* A prefix operand without side-effect. */
446 if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
447 {
448 prefix_ok = 1;
449 break;
450 }
451 else
452 return -1;
453
454 case 's':
455 case 'y':
456 case 'Y':
457 /* If this is a prefixed insn with postincrement (side-effect),
458 the prefix must not be DIP. */
459 if (prefix_insn != NO_CRIS_PREFIX)
460 {
461 if (insn & 0x400)
462 {
463 const struct cris_opcode *prefix_opcodep
464 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
465
466 if (prefix_opcodep->match == DIP_OPCODE)
467 return -1;
468 }
469
470 prefix_ok = 1;
471 }
472 break;
473
474 case 'B':
475 /* If we don't fall through, then the prefix is ok. */
476 prefix_ok = 1;
477
478 /* A "push" prefix. Check for valid "push" size.
479 In case of special register, it may be != 4. */
480 if (prefix_insn != NO_CRIS_PREFIX)
481 {
482 /* Match the prefix insn to BDAPQ. */
483 const struct cris_opcode *prefix_opcodep
484 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
485
486 if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
487 {
488 int pushsize = (prefix_insn & 255);
489
490 if (pushsize > 127)
491 pushsize -= 256;
492
493 if (s[1] == 'P')
494 {
495 unsigned int spec_reg = (insn >> 12) & 15;
496 const struct cris_spec_reg *sregp
497 = spec_reg_info (spec_reg, disdata->distype);
498
499 /* For a special-register, the "prefix size" must
500 match the size of the register. */
501 if (sregp && sregp->reg_size == (unsigned int) -pushsize)
502 break;
503 }
504 else if (s[1] == 'R')
505 {
506 if ((insn & 0x30) == 0x20 && pushsize == -4)
507 break;
508 }
509 /* FIXME: Should abort here; next constraint letter
510 *must* be 'P' or 'R'. */
511 }
512 }
513 return -1;
514
515 case 'D':
516 retval = (((insn >> 12) & 15) == (insn & 15));
517 if (!retval)
518 return -1;
519 else
520 retval += 4;
521 break;
522
523 case 'P':
524 {
525 const struct cris_spec_reg *sregp
526 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
527
528 /* Since we match four bits, we will give a value of 4-1 = 3
529 in a match. If there is a corresponding exact match of a
530 special register in another pattern, it will get a value of
531 4, which will be higher. This should be correct in that an
532 exact pattern would match better than a general pattern.
533
534 Note that there is a reason for not returning zero; the
535 pattern for "clear" is partly matched in the bit-pattern
536 (the two lower bits must be zero), while the bit-pattern
537 for a move from a special register is matched in the
538 register constraint. */
539
540 if (sregp != NULL)
541 {
542 retval += 3;
543 break;
544 }
545 else
546 return -1;
547 }
548 }
549
550 if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
551 return -1;
552
553 return retval;
554 }
555
556 /* Format number as hex with a leading "0x" into outbuffer. */
557
558 static char *
format_hex(unsigned long number,char * outbuffer,struct cris_disasm_data * disdata)559 format_hex (unsigned long number,
560 char *outbuffer,
561 struct cris_disasm_data *disdata)
562 {
563 /* Truncate negative numbers on >32-bit hosts. */
564 number &= 0xffffffff;
565
566 /* Save this value for the "case" support. */
567 if (TRACE_CASE)
568 last_immediate = number;
569
570 return outbuffer + sprintf (outbuffer, "0x%lx", number);
571 }
572
573 /* Format number as decimal into outbuffer. Parameter signedp says
574 whether the number should be formatted as signed (!= 0) or
575 unsigned (== 0). */
576
577 static char *
format_dec(long number,char * outbuffer,int signedp)578 format_dec (long number, char *outbuffer, int signedp)
579 {
580 last_immediate = number;
581 return outbuffer + sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
582 }
583
584 /* Format the name of the general register regno into outbuffer. */
585
586 static char *
format_reg(struct cris_disasm_data * disdata,int regno,char * outbuffer,bool with_reg_prefix)587 format_reg (struct cris_disasm_data *disdata,
588 int regno,
589 char *outbuffer,
590 bool with_reg_prefix)
591 {
592 if (with_reg_prefix)
593 *outbuffer++ = REGISTER_PREFIX_CHAR;
594
595 switch (regno)
596 {
597 case 15:
598 /* For v32, there is no context in which we output PC. */
599 if (disdata->distype == cris_dis_v32)
600 outbuffer = stpcpy (outbuffer, "acr");
601 else
602 outbuffer = stpcpy (outbuffer, "pc");
603 break;
604
605 case 14:
606 outbuffer = stpcpy (outbuffer, "sp");
607 break;
608
609 default:
610 outbuffer += sprintf (outbuffer, "r%d", regno);
611 break;
612 }
613
614 return outbuffer;
615 }
616
617 /* Format the name of a support register into outbuffer. */
618
619 static char *
format_sup_reg(unsigned int regno,char * outbuffer,bool with_reg_prefix)620 format_sup_reg (unsigned int regno,
621 char *outbuffer,
622 bool with_reg_prefix)
623 {
624 int i;
625
626 if (with_reg_prefix)
627 *outbuffer++ = REGISTER_PREFIX_CHAR;
628
629 for (i = 0; cris_support_regs[i].name != NULL; i++)
630 if (cris_support_regs[i].number == regno)
631 return stpcpy (outbuffer, cris_support_regs[i].name);
632
633 /* There's supposed to be register names covering all numbers, though
634 some may be generic names. */
635 return stpcpy (outbuffer, "format_sup_reg-BUG");
636 }
637
638 /* Return the length of an instruction. */
639
640 static unsigned
bytes_to_skip(unsigned int insn,const struct cris_opcode * matchedp,enum cris_disass_family distype,const struct cris_opcode * prefix_matchedp)641 bytes_to_skip (unsigned int insn,
642 const struct cris_opcode *matchedp,
643 enum cris_disass_family distype,
644 const struct cris_opcode *prefix_matchedp)
645 {
646 /* Each insn is a word plus "immediate" operands. */
647 unsigned to_skip = 2;
648 const char *template_name = (const char *) matchedp->args;
649 const char *s;
650
651 for (s = template_name; *s; s++)
652 if ((*s == 's' || *s == 'N' || *s == 'Y')
653 && (insn & 0x400) && (insn & 15) == 15
654 && prefix_matchedp == NULL)
655 {
656 /* Immediate via [pc+], so we have to check the size of the
657 operand. */
658 int mode_size = 1 << ((insn >> 4) & (*template_name == 'z' ? 1 : 3));
659
660 if (matchedp->imm_oprnd_size == SIZE_FIX_32)
661 to_skip += 4;
662 else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
663 {
664 const struct cris_spec_reg *sregp
665 = spec_reg_info ((insn >> 12) & 15, distype);
666
667 /* FIXME: Improve error handling; should have been caught
668 earlier. */
669 if (sregp == NULL)
670 return 2;
671
672 /* PC is incremented by two, not one, for a byte. Except on
673 CRISv32, where constants are always DWORD-size for
674 special registers. */
675 to_skip +=
676 distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
677 }
678 else
679 to_skip += (mode_size + 1) & ~1;
680 }
681 else if (*s == 'n')
682 to_skip += 4;
683 else if (*s == 'b')
684 to_skip += 2;
685
686 return to_skip;
687 }
688
689 /* Print condition code flags. */
690
691 static char *
print_flags(struct cris_disasm_data * disdata,unsigned int insn,char * cp)692 print_flags (struct cris_disasm_data *disdata, unsigned int insn, char *cp)
693 {
694 /* Use the v8 (Etrax 100) flag definitions for disassembly.
695 The differences with v0 (Etrax 1..4) vs. Svinto are:
696 v0 'd' <=> v8 'm'
697 v0 'e' <=> v8 'b'.
698 FIXME: Emit v0..v3 flag names somehow. */
699 static const char v8_fnames[] = "cvznxibm";
700 static const char v32_fnames[] = "cvznxiup";
701 const char *fnames
702 = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
703
704 unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
705 int i;
706
707 for (i = 0; i < 8; i++)
708 if (flagbits & (1 << i))
709 *cp++ = fnames[i];
710
711 return cp;
712 }
713
714 /* Print out an insn with its operands, and update the info->insn_type
715 fields. The prefix_opcodep and the rest hold a prefix insn that is
716 supposed to be output as an address mode. */
717
718 static void
print_with_operands(const struct cris_opcode * opcodep,unsigned int insn,unsigned char * buffer,bfd_vma addr,disassemble_info * info,const struct cris_opcode * prefix_opcodep,unsigned int prefix_insn,unsigned char * prefix_buffer,bool with_reg_prefix)719 print_with_operands (const struct cris_opcode *opcodep,
720 unsigned int insn,
721 unsigned char *buffer,
722 bfd_vma addr,
723 disassemble_info *info,
724 /* If a prefix insn was before this insn (and is supposed
725 to be output as an address), here is a description of
726 it. */
727 const struct cris_opcode *prefix_opcodep,
728 unsigned int prefix_insn,
729 unsigned char *prefix_buffer,
730 bool with_reg_prefix)
731 {
732 /* Get a buffer of somewhat reasonable size where we store
733 intermediate parts of the insn. */
734 char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
735 char *tp = temp;
736 static const char mode_char[] = "bwd?";
737 const char *s;
738 const char *cs;
739 struct cris_disasm_data *disdata
740 = (struct cris_disasm_data *) info->private_data;
741
742 /* Print out the name first thing we do. */
743 (*info->fprintf_func) (info->stream, "%s", opcodep->name);
744
745 cs = opcodep->args;
746 s = cs;
747
748 /* Ignore any prefix indicator. */
749 if (*s == 'p')
750 s++;
751
752 if (*s == 'm' || *s == 'M' || *s == 'z')
753 {
754 *tp++ = '.';
755
756 /* Get the size-letter. */
757 *tp++ = *s == 'M'
758 ? (insn & 0x8000 ? 'd'
759 : insn & 0x4000 ? 'w' : 'b')
760 : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
761
762 /* Ignore the size and the space character that follows. */
763 s += 2;
764 }
765
766 /* Add a space if this isn't a long-branch, because for those will add
767 the condition part of the name later. */
768 if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
769 *tp++ = ' ';
770
771 /* Fill in the insn-type if deducible from the name (and there's no
772 better way). */
773 if (opcodep->name[0] == 'j')
774 {
775 if (startswith (opcodep->name, "jsr"))
776 /* It's "jsr" or "jsrc". */
777 info->insn_type = dis_jsr;
778 else
779 /* Any other jump-type insn is considered a branch. */
780 info->insn_type = dis_branch;
781 }
782
783 /* We might know some more fields right now. */
784 info->branch_delay_insns = opcodep->delayed;
785
786 /* Handle operands. */
787 for (; *s; s++)
788 {
789 switch (*s)
790 {
791 case 'T':
792 tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
793 break;
794
795 case 'A':
796 if (with_reg_prefix)
797 *tp++ = REGISTER_PREFIX_CHAR;
798 *tp++ = 'a';
799 *tp++ = 'c';
800 *tp++ = 'r';
801 break;
802
803 case '[':
804 case ']':
805 case ',':
806 *tp++ = *s;
807 break;
808
809 case '!':
810 /* Ignore at this point; used at earlier stages to avoid
811 recognition if there's a prefix at something that in other
812 ways looks like a "pop". */
813 break;
814
815 case 'd':
816 /* Ignore. This is an optional ".d " on the large one of
817 relaxable insns. */
818 break;
819
820 case 'B':
821 /* This was the prefix that made this a "push". We've already
822 handled it by recognizing it, so signal that the prefix is
823 handled by setting it to NULL. */
824 prefix_opcodep = NULL;
825 break;
826
827 case 'D':
828 case 'r':
829 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
830 break;
831
832 case 'R':
833 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
834 break;
835
836 case 'n':
837 {
838 /* Like N but pc-relative to the start of the insn. */
839 int32_t number = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
840 + buffer[5] * 0x1000000u);
841
842 /* Finish off and output previous formatted bytes. */
843 *tp = 0;
844 if (temp[0])
845 (*info->fprintf_func) (info->stream, "%s", temp);
846 tp = temp;
847
848 (*info->print_address_func) (addr + number, info);
849 }
850 break;
851
852 case 'u':
853 {
854 /* Like n but the offset is bits <3:0> in the instruction. */
855 unsigned int number = (buffer[0] & 0xf) * 2;
856
857 /* Finish off and output previous formatted bytes. */
858 *tp = 0;
859 if (temp[0])
860 (*info->fprintf_func) (info->stream, "%s", temp);
861 tp = temp;
862
863 (*info->print_address_func) (addr + number, info);
864 }
865 break;
866
867 case 'N':
868 case 'y':
869 case 'Y':
870 case 'S':
871 case 's':
872 /* Any "normal" memory operand. */
873 if ((insn & 0x400) && (insn & 15) == 15 && prefix_opcodep == NULL)
874 {
875 /* We're looking at [pc+], i.e. we need to output an immediate
876 number, where the size can depend on different things. */
877 int32_t number;
878 int signedp
879 = ((*cs == 'z' && (insn & 0x20))
880 || opcodep->match == BDAP_QUICK_OPCODE);
881 int nbytes;
882
883 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
884 nbytes = 4;
885 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
886 {
887 const struct cris_spec_reg *sregp
888 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
889
890 /* A NULL return should have been as a non-match earlier,
891 so catch it as an internal error in the error-case
892 below. */
893 if (sregp == NULL)
894 /* Whatever non-valid size. */
895 nbytes = 42;
896 else
897 /* PC is always incremented by a multiple of two.
898 For CRISv32, immediates are always 4 bytes for
899 special registers. */
900 nbytes = disdata->distype == cris_dis_v32
901 ? 4 : (sregp->reg_size + 1) & ~1;
902 }
903 else
904 {
905 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
906
907 if (mode_size == 1)
908 nbytes = 2;
909 else
910 nbytes = mode_size;
911 }
912
913 switch (nbytes)
914 {
915 case 1:
916 number = buffer[2];
917 if (signedp && number > 127)
918 number -= 256;
919 break;
920
921 case 2:
922 number = buffer[2] + buffer[3] * 256;
923 if (signedp && number > 32767)
924 number -= 65536;
925 break;
926
927 case 4:
928 number = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
929 + buffer[5] * 0x1000000u);
930 break;
931
932 default:
933 strcpy (tp, "bug");
934 tp += 3;
935 number = 42;
936 }
937
938 if ((*cs == 'z' && (insn & 0x20))
939 || (opcodep->match == BDAP_QUICK_OPCODE
940 && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
941 tp = format_dec (number, tp, signedp);
942 else
943 {
944 unsigned int highbyte = (number >> 24) & 0xff;
945
946 /* Either output this as an address or as a number. If it's
947 a dword with the same high-byte as the address of the
948 insn, assume it's an address, and also if it's a non-zero
949 non-0xff high-byte. If this is a jsr or a jump, then
950 it's definitely an address. */
951 if (nbytes == 4
952 && (highbyte == ((addr >> 24) & 0xff)
953 || (highbyte != 0 && highbyte != 0xff)
954 || info->insn_type == dis_branch
955 || info->insn_type == dis_jsr))
956 {
957 /* Finish off and output previous formatted bytes. */
958 *tp = 0;
959 tp = temp;
960 if (temp[0])
961 (*info->fprintf_func) (info->stream, "%s", temp);
962
963 (*info->print_address_func) ((bfd_vma) number, info);
964
965 info->target = number;
966 }
967 else
968 tp = format_hex (number, tp, disdata);
969 }
970 }
971 else
972 {
973 /* Not an immediate number. Then this is a (possibly
974 prefixed) memory operand. */
975 if (info->insn_type != dis_nonbranch)
976 {
977 int mode_size
978 = 1 << ((insn >> 4)
979 & (opcodep->args[0] == 'z' ? 1 : 3));
980 int size;
981 info->insn_type = dis_dref;
982 info->flags |= CRIS_DIS_FLAG_MEMREF;
983
984 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
985 size = 4;
986 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
987 {
988 const struct cris_spec_reg *sregp
989 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
990
991 /* FIXME: Improve error handling; should have been caught
992 earlier. */
993 if (sregp == NULL)
994 size = 4;
995 else
996 size = sregp->reg_size;
997 }
998 else
999 size = mode_size;
1000
1001 info->data_size = size;
1002 }
1003
1004 *tp++ = '[';
1005
1006 if (prefix_opcodep
1007 /* We don't match dip with a postincremented field
1008 as a side-effect address mode. */
1009 && ((insn & 0x400) == 0
1010 || prefix_opcodep->match != DIP_OPCODE))
1011 {
1012 if (insn & 0x400)
1013 {
1014 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1015 *tp++ = '=';
1016 }
1017
1018
1019 /* We mainly ignore the prefix format string when the
1020 address-mode syntax is output. */
1021 switch (prefix_opcodep->match)
1022 {
1023 case DIP_OPCODE:
1024 /* It's [r], [r+] or [pc+]. */
1025 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1026 {
1027 /* It's [pc+]. This cannot possibly be anything
1028 but an address. */
1029 int32_t number = (prefix_buffer[2]
1030 + prefix_buffer[3] * 256
1031 + prefix_buffer[4] * 65536
1032 + prefix_buffer[5] * 0x1000000u);
1033
1034 info->target = (bfd_vma) number;
1035
1036 /* Finish off and output previous formatted
1037 data. */
1038 *tp = 0;
1039 tp = temp;
1040 if (temp[0])
1041 (*info->fprintf_func) (info->stream, "%s", temp);
1042
1043 (*info->print_address_func) ((bfd_vma) number, info);
1044 }
1045 else
1046 {
1047 /* For a memref in an address, we use target2.
1048 In this case, target is zero. */
1049 info->flags
1050 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1051 | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
1052
1053 info->target2 = prefix_insn & 15;
1054
1055 *tp++ = '[';
1056 tp = format_reg (disdata, prefix_insn & 15, tp,
1057 with_reg_prefix);
1058 if (prefix_insn & 0x400)
1059 *tp++ = '+';
1060 *tp++ = ']';
1061 }
1062 break;
1063
1064 case BDAP_QUICK_OPCODE:
1065 {
1066 int number;
1067
1068 number = prefix_buffer[0];
1069 if (number > 127)
1070 number -= 256;
1071
1072 /* Output "reg+num" or, if num < 0, "reg-num". */
1073 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1074 with_reg_prefix);
1075 if (number >= 0)
1076 *tp++ = '+';
1077 tp = format_dec (number, tp, 1);
1078
1079 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1080 info->target = (prefix_insn >> 12) & 15;
1081 info->target2 = (bfd_vma) number;
1082 break;
1083 }
1084
1085 case BIAP_OPCODE:
1086 /* Output "r+R.m". */
1087 tp = format_reg (disdata, prefix_insn & 15, tp,
1088 with_reg_prefix);
1089 *tp++ = '+';
1090 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1091 with_reg_prefix);
1092 *tp++ = '.';
1093 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1094
1095 info->flags
1096 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1097 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1098
1099 | ((prefix_insn & 0x8000)
1100 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1101 : ((prefix_insn & 0x8000)
1102 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
1103
1104 /* Is it the casejump? It's a "adds.w [pc+r%d.w],pc". */
1105 if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
1106 /* Then start interpreting data as offsets. */
1107 case_offset_counter = no_of_case_offsets;
1108 break;
1109
1110 case BDAP_INDIR_OPCODE:
1111 /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1112 "r-s". */
1113 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1114 with_reg_prefix);
1115
1116 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1117 {
1118 int32_t number;
1119 unsigned int nbytes;
1120
1121 /* It's a value. Get its size. */
1122 int mode_size = 1 << ((prefix_insn >> 4) & 3);
1123
1124 if (mode_size == 1)
1125 nbytes = 2;
1126 else
1127 nbytes = mode_size;
1128
1129 switch (nbytes)
1130 {
1131 case 1:
1132 number = prefix_buffer[2];
1133 if (number > 127)
1134 number -= 256;
1135 break;
1136
1137 case 2:
1138 number = prefix_buffer[2] + prefix_buffer[3] * 256;
1139 if (number > 32767)
1140 number -= 65536;
1141 break;
1142
1143 case 4:
1144 number = (prefix_buffer[2] + prefix_buffer[3] * 256
1145 + prefix_buffer[4] * 65536
1146 + prefix_buffer[5] * 0x1000000u);
1147 break;
1148
1149 default:
1150 strcpy (tp, "bug");
1151 tp += 3;
1152 number = 42;
1153 }
1154
1155 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1156 info->target2 = (bfd_vma) number;
1157
1158 /* If the size is dword, then assume it's an
1159 address. */
1160 if (nbytes == 4)
1161 {
1162 /* Finish off and output previous formatted
1163 bytes. */
1164 *tp++ = '+';
1165 *tp = 0;
1166 tp = temp;
1167 (*info->fprintf_func) (info->stream, "%s", temp);
1168
1169 (*info->print_address_func) ((bfd_vma) number, info);
1170 }
1171 else
1172 {
1173 if (number >= 0)
1174 *tp++ = '+';
1175 tp = format_dec (number, tp, 1);
1176 }
1177 }
1178 else
1179 {
1180 /* Output "r+[R].m" or "r+[R+].m". */
1181 *tp++ = '+';
1182 *tp++ = '[';
1183 tp = format_reg (disdata, prefix_insn & 15, tp,
1184 with_reg_prefix);
1185 if (prefix_insn & 0x400)
1186 *tp++ = '+';
1187 *tp++ = ']';
1188 *tp++ = '.';
1189 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1190
1191 info->flags
1192 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1193 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1194 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1195
1196 | (((prefix_insn >> 4) == 2)
1197 ? 0
1198 : (((prefix_insn >> 4) & 3) == 1
1199 ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1200 : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
1201 }
1202 break;
1203
1204 default:
1205 (*info->fprintf_func) (info->stream, "?prefix-bug");
1206 }
1207
1208 /* To mark that the prefix is used, reset it. */
1209 prefix_opcodep = NULL;
1210 }
1211 else
1212 {
1213 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1214
1215 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1216 info->target = insn & 15;
1217
1218 if (insn & 0x400)
1219 *tp++ = '+';
1220 }
1221 *tp++ = ']';
1222 }
1223 break;
1224
1225 case 'x':
1226 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1227 *tp++ = '.';
1228 *tp++ = mode_char[(insn >> 4) & 3];
1229 break;
1230
1231 case 'I':
1232 tp = format_dec (insn & 63, tp, 0);
1233 break;
1234
1235 case 'b':
1236 {
1237 int where = buffer[2] + buffer[3] * 256;
1238
1239 if (where > 32767)
1240 where -= 65536;
1241
1242 where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
1243
1244 if (insn == BA_PC_INCR_OPCODE)
1245 info->insn_type = dis_branch;
1246 else
1247 info->insn_type = dis_condbranch;
1248
1249 info->target = (bfd_vma) where;
1250
1251 *tp = 0;
1252 tp = temp;
1253 (*info->fprintf_func) (info->stream, "%s%s ",
1254 temp, cris_cc_strings[insn >> 12]);
1255
1256 (*info->print_address_func) ((bfd_vma) where, info);
1257 }
1258 break;
1259
1260 case 'c':
1261 tp = format_dec (insn & 31, tp, 0);
1262 break;
1263
1264 case 'C':
1265 tp = format_dec (insn & 15, tp, 0);
1266 break;
1267
1268 case 'o':
1269 {
1270 long offset = insn & 0xfe;
1271 bfd_vma target;
1272
1273 if (insn & 1)
1274 offset |= ~0xff;
1275
1276 if (opcodep->match == BA_QUICK_OPCODE)
1277 info->insn_type = dis_branch;
1278 else
1279 info->insn_type = dis_condbranch;
1280
1281 target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
1282 info->target = target;
1283 *tp = 0;
1284 tp = temp;
1285 (*info->fprintf_func) (info->stream, "%s", temp);
1286 (*info->print_address_func) (target, info);
1287 }
1288 break;
1289
1290 case 'Q':
1291 case 'O':
1292 {
1293 long number = buffer[0];
1294
1295 if (number > 127)
1296 number = number - 256;
1297
1298 tp = format_dec (number, tp, 1);
1299 *tp++ = ',';
1300 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1301 }
1302 break;
1303
1304 case 'f':
1305 tp = print_flags (disdata, insn, tp);
1306 break;
1307
1308 case 'i':
1309 tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
1310 break;
1311
1312 case 'P':
1313 {
1314 const struct cris_spec_reg *sregp
1315 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1316
1317 if (sregp->name == NULL)
1318 /* Should have been caught as a non-match eariler. */
1319 *tp++ = '?';
1320 else
1321 {
1322 if (with_reg_prefix)
1323 *tp++ = REGISTER_PREFIX_CHAR;
1324 strcpy (tp, sregp->name);
1325 tp += strlen (tp);
1326 }
1327 }
1328 break;
1329
1330 default:
1331 strcpy (tp, "???");
1332 tp += 3;
1333 }
1334 }
1335
1336 *tp = 0;
1337
1338 if (prefix_opcodep)
1339 (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
1340 prefix_opcodep->name, prefix_opcodep->args);
1341
1342 (*info->fprintf_func) (info->stream, "%s", temp);
1343
1344 /* Get info for matching case-tables, if we don't have any active.
1345 We assume that the last constant seen is used; either in the insn
1346 itself or in a "move.d const,rN, sub.d rN,rM"-like sequence. */
1347 if (TRACE_CASE && case_offset_counter == 0)
1348 {
1349 if (startswith (opcodep->name, "sub"))
1350 case_offset = last_immediate;
1351
1352 /* It could also be an "add", if there are negative case-values. */
1353 else if (startswith (opcodep->name, "add"))
1354 /* The first case is the negated operand to the add. */
1355 case_offset = -last_immediate;
1356
1357 /* A bound insn will tell us the number of cases. */
1358 else if (startswith (opcodep->name, "bound"))
1359 no_of_case_offsets = last_immediate + 1;
1360
1361 /* A jump or jsr or branch breaks the chain of insns for a
1362 case-table, so assume default first-case again. */
1363 else if (info->insn_type == dis_jsr
1364 || info->insn_type == dis_branch
1365 || info->insn_type == dis_condbranch)
1366 case_offset = 0;
1367 }
1368 }
1369
1370
1371 /* Print the CRIS instruction at address memaddr on stream. Returns
1372 length of the instruction, in bytes. Prefix register names with `$' if
1373 WITH_REG_PREFIX. */
1374
1375 static int
print_insn_cris_generic(bfd_vma memaddr,disassemble_info * info,bool with_reg_prefix)1376 print_insn_cris_generic (bfd_vma memaddr,
1377 disassemble_info *info,
1378 bool with_reg_prefix)
1379 {
1380 int nbytes;
1381 unsigned int insn;
1382 const struct cris_opcode *matchedp;
1383 int advance = 0;
1384 struct cris_disasm_data *disdata
1385 = (struct cris_disasm_data *) info->private_data;
1386
1387 /* No instruction will be disassembled as longer than this number of
1388 bytes; stacked prefixes will not be expanded. */
1389 unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
1390 unsigned char *bufp;
1391 int status = 0;
1392 bfd_vma addr;
1393
1394 /* There will be an "out of range" error after the last instruction.
1395 Reading pairs of bytes in decreasing number, we hope that we will get
1396 at least the amount that we will consume.
1397
1398 If we can't get any data, or we do not get enough data, we print
1399 the error message. */
1400
1401 for (nbytes = MAX_BYTES_PER_CRIS_INSN; nbytes > 0; nbytes -= 2)
1402 {
1403 status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
1404 if (status == 0)
1405 break;
1406 }
1407
1408 /* If we did not get all we asked for, then clear the rest.
1409 Hopefully this makes a reproducible result in case of errors. */
1410 if (nbytes != MAX_BYTES_PER_CRIS_INSN)
1411 memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
1412
1413 addr = memaddr;
1414 bufp = buffer;
1415
1416 /* Set some defaults for the insn info. */
1417 info->insn_info_valid = 1;
1418 info->branch_delay_insns = 0;
1419 info->data_size = 0;
1420 info->insn_type = dis_nonbranch;
1421 info->flags = 0;
1422 info->target = 0;
1423 info->target2 = 0;
1424
1425 /* If we got any data, disassemble it. */
1426 if (nbytes != 0)
1427 {
1428 matchedp = NULL;
1429
1430 insn = bufp[0] + bufp[1] * 256;
1431
1432 /* If we're in a case-table, don't disassemble the offsets. */
1433 if (TRACE_CASE && case_offset_counter != 0)
1434 {
1435 info->insn_type = dis_noninsn;
1436 advance += 2;
1437
1438 /* If to print data as offsets, then shortcut here. */
1439 (*info->fprintf_func) (info->stream, "case %ld%s: -> ",
1440 case_offset + no_of_case_offsets
1441 - case_offset_counter,
1442 case_offset_counter == 1 ? "/default" :
1443 "");
1444
1445 (*info->print_address_func) ((bfd_vma)
1446 ((short) (insn)
1447 + (long) (addr
1448 - (no_of_case_offsets
1449 - case_offset_counter)
1450 * 2)), info);
1451 case_offset_counter--;
1452
1453 /* The default case start (without a "sub" or "add") must be
1454 zero. */
1455 if (case_offset_counter == 0)
1456 case_offset = 0;
1457 }
1458 else if (insn == 0)
1459 {
1460 /* We're often called to disassemble zeroes. While this is a
1461 valid "bcc .+2" insn, it is also useless enough and enough
1462 of a nuiscance that we will just output "bcc .+2" for it
1463 and signal it as a noninsn. */
1464 (*info->fprintf_func) (info->stream,
1465 disdata->distype == cris_dis_v32
1466 ? "bcc ." : "bcc .+2");
1467 info->insn_type = dis_noninsn;
1468 advance += 2;
1469 }
1470 else
1471 {
1472 const struct cris_opcode *prefix_opcodep = NULL;
1473 unsigned char *prefix_buffer = bufp;
1474 unsigned int prefix_insn = insn;
1475 int prefix_size = 0;
1476
1477 matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
1478
1479 /* Check if we're supposed to write out prefixes as address
1480 modes and if this was a prefix. */
1481 if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
1482 {
1483 /* If it's a prefix, put it into the prefix vars and get the
1484 main insn. */
1485 prefix_size = bytes_to_skip (prefix_insn, matchedp,
1486 disdata->distype, NULL);
1487 prefix_opcodep = matchedp;
1488
1489 insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
1490 matchedp = get_opcode_entry (insn, prefix_insn, disdata);
1491
1492 if (matchedp != NULL)
1493 {
1494 addr += prefix_size;
1495 bufp += prefix_size;
1496 advance += prefix_size;
1497 }
1498 else
1499 {
1500 /* The "main" insn wasn't valid, at least not when
1501 prefixed. Put back things enough to output the
1502 prefix insn only, as a normal insn. */
1503 matchedp = prefix_opcodep;
1504 insn = prefix_insn;
1505 prefix_opcodep = NULL;
1506 }
1507 }
1508
1509 if (matchedp == NULL)
1510 {
1511 (*info->fprintf_func) (info->stream, "??0x%x", insn);
1512 advance += 2;
1513
1514 info->insn_type = dis_noninsn;
1515 }
1516 else
1517 {
1518 advance
1519 += bytes_to_skip (insn, matchedp, disdata->distype,
1520 prefix_opcodep);
1521
1522 /* The info_type and assorted fields will be set according
1523 to the operands. */
1524 print_with_operands (matchedp, insn, bufp, addr, info,
1525 prefix_opcodep, prefix_insn,
1526 prefix_buffer, with_reg_prefix);
1527 }
1528 }
1529 }
1530 else
1531 info->insn_type = dis_noninsn;
1532
1533 /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1534 status when reading that much, and the insn decoding indicated a
1535 length exceeding what we read, there is an error. */
1536 if (status != 0 && (nbytes == 0 || advance > nbytes))
1537 {
1538 (*info->memory_error_func) (status, memaddr, info);
1539 return -1;
1540 }
1541
1542 /* Max supported insn size with one folded prefix insn. */
1543 info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
1544
1545 /* I would like to set this to a fixed value larger than the actual
1546 number of bytes to print in order to avoid spaces between bytes,
1547 but objdump.c (2.9.1) does not like that, so we print 16-bit
1548 chunks, which is the next choice. */
1549 info->bytes_per_chunk = 2;
1550
1551 /* Printing bytes in order of increasing addresses makes sense,
1552 especially on a little-endian target.
1553 This is completely the opposite of what you think; setting this to
1554 BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1555 we want. */
1556 info->display_endian = BFD_ENDIAN_BIG;
1557
1558 return advance;
1559 }
1560
1561 /* Disassemble, prefixing register names with `$'. CRIS v0..v10. */
1562
1563 static int
print_insn_cris_with_register_prefix(bfd_vma vma,disassemble_info * info)1564 print_insn_cris_with_register_prefix (bfd_vma vma,
1565 disassemble_info *info)
1566 {
1567 if (info->private_data == NULL
1568 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1569 return -1;
1570 return print_insn_cris_generic (vma, info, true);
1571 }
1572
1573 /* Disassemble, prefixing register names with `$'. CRIS v32. */
1574
1575 static int
print_insn_crisv32_with_register_prefix(bfd_vma vma,disassemble_info * info)1576 print_insn_crisv32_with_register_prefix (bfd_vma vma,
1577 disassemble_info *info)
1578 {
1579 if (info->private_data == NULL
1580 && !cris_parse_disassembler_options (info, cris_dis_v32))
1581 return -1;
1582 return print_insn_cris_generic (vma, info, true);
1583 }
1584
1585 /* Disassemble, prefixing register names with `$'.
1586 Common v10 and v32 subset. */
1587
1588 static int
print_insn_crisv10_v32_with_register_prefix(bfd_vma vma,disassemble_info * info)1589 print_insn_crisv10_v32_with_register_prefix (bfd_vma vma,
1590 disassemble_info *info)
1591 {
1592 if (info->private_data == NULL
1593 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1594 return -1;
1595 return print_insn_cris_generic (vma, info, true);
1596 }
1597
1598 /* Disassemble, no prefixes on register names. CRIS v0..v10. */
1599
1600 static int
print_insn_cris_without_register_prefix(bfd_vma vma,disassemble_info * info)1601 print_insn_cris_without_register_prefix (bfd_vma vma,
1602 disassemble_info *info)
1603 {
1604 if (info->private_data == NULL
1605 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1606 return -1;
1607 return print_insn_cris_generic (vma, info, false);
1608 }
1609
1610 /* Disassemble, no prefixes on register names. CRIS v32. */
1611
1612 static int
print_insn_crisv32_without_register_prefix(bfd_vma vma,disassemble_info * info)1613 print_insn_crisv32_without_register_prefix (bfd_vma vma,
1614 disassemble_info *info)
1615 {
1616 if (info->private_data == NULL
1617 && !cris_parse_disassembler_options (info, cris_dis_v32))
1618 return -1;
1619 return print_insn_cris_generic (vma, info, false);
1620 }
1621
1622 /* Disassemble, no prefixes on register names.
1623 Common v10 and v32 subset. */
1624
1625 static int
print_insn_crisv10_v32_without_register_prefix(bfd_vma vma,disassemble_info * info)1626 print_insn_crisv10_v32_without_register_prefix (bfd_vma vma,
1627 disassemble_info *info)
1628 {
1629 if (info->private_data == NULL
1630 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1631 return -1;
1632 return print_insn_cris_generic (vma, info, false);
1633 }
1634
1635 /* Return a disassembler-function that prints registers with a `$' prefix,
1636 or one that prints registers without a prefix.
1637 FIXME: We should improve the solution to avoid the multitude of
1638 functions seen above. */
1639
1640 disassembler_ftype
cris_get_disassembler(bfd * abfd)1641 cris_get_disassembler (bfd *abfd)
1642 {
1643 /* If there's no bfd in sight, we return what is valid as input in all
1644 contexts if fed back to the assembler: disassembly *with* register
1645 prefix. Unfortunately this will be totally wrong for v32. */
1646 if (abfd == NULL)
1647 return print_insn_cris_with_register_prefix;
1648
1649 if (bfd_get_symbol_leading_char (abfd) == 0)
1650 {
1651 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1652 return print_insn_crisv32_with_register_prefix;
1653 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1654 return print_insn_crisv10_v32_with_register_prefix;
1655
1656 /* We default to v10. This may be specifically specified in the
1657 bfd mach, but is also the default setting. */
1658 return print_insn_cris_with_register_prefix;
1659 }
1660
1661 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1662 return print_insn_crisv32_without_register_prefix;
1663 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1664 return print_insn_crisv10_v32_without_register_prefix;
1665 return print_insn_cris_without_register_prefix;
1666 }
1667
1668 /* Local variables:
1669 eval: (c-set-style "gnu")
1670 indent-tabs-mode: t
1671 End: */
1672