[ gas/ChangeLog ]
[binutils.git] / opcodes / cris-dis.c
blobf6c63cb280dd153d7e4206d0f5077ded9349e3f1
1 /* Disassembler code for CRIS.
2 Copyright 2000, 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Axis Communications AB, Lund, Sweden.
4 Written by Hans-Peter Nilsson.
6 This file is part of the GNU binutils and GDB, the GNU debugger.
8 This program is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any later
11 version.
13 This program is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
16 more details.
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. */
23 #include "dis-asm.h"
24 #include "sysdep.h"
25 #include "opcode/cris.h"
26 #include "libiberty.h"
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
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
41 /* Sometimes we prefix all registers with this character. */
42 #define REGISTER_PREFIX_CHAR '$'
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
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).
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.
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.
64 FIXME: Make this optional later. */
65 #ifndef TRACE_CASE
66 #define TRACE_CASE (disdata->trace_case)
67 #endif
69 enum cris_disass_family
70 { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
72 /* Stored in the disasm_info->private_data member. */
73 struct cris_disasm_data
75 /* Whether to print something less confusing if we find something
76 matching a switch-construct. */
77 bfd_boolean trace_case;
79 /* Whether this code is flagged as crisv32. FIXME: Should be an enum
80 that includes "compatible". */
81 enum cris_disass_family distype;
84 /* Value of first element in switch. */
85 static long case_offset = 0;
87 /* How many more case-offsets to print. */
88 static long case_offset_counter = 0;
90 /* Number of case offsets. */
91 static long no_of_case_offsets = 0;
93 /* Candidate for next case_offset. */
94 static long last_immediate = 0;
96 static int cris_constraint
97 (const char *, unsigned, unsigned, struct cris_disasm_data *);
99 /* Parse disassembler options and store state in info. FIXME: For the
100 time being, we abuse static variables. */
102 static bfd_boolean
103 cris_parse_disassembler_options (disassemble_info *info,
104 enum cris_disass_family distype)
106 struct cris_disasm_data *disdata;
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;
113 /* Default true. */
114 disdata->trace_case
115 = (info->disassembler_options == NULL
116 || (strcmp (info->disassembler_options, "nocase") != 0));
118 disdata->distype = distype;
119 return TRUE;
122 static const struct cris_spec_reg *
123 spec_reg_info (unsigned int sreg, enum cris_disass_family distype)
125 int i;
127 for (i = 0; cris_spec_regs[i].name != NULL; i++)
129 if (cris_spec_regs[i].number == sreg)
131 if (distype == cris_dis_v32)
132 switch (cris_spec_regs[i].applicable_version)
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:
146 else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
147 return &cris_spec_regs[i];
151 return NULL;
154 /* Return the number of bits in the argument. */
156 static int
157 number_of_bits (unsigned int val)
159 int bits;
161 for (bits = 0; val != 0; val &= val - 1)
162 bits++;
164 return bits;
167 /* Get an entry in the opcode-table. */
169 static const struct cris_opcode *
170 get_opcode_entry (unsigned int insn,
171 unsigned int prefix_insn,
172 struct cris_disasm_data *disdata)
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;
178 const struct cris_opcode *max_matchedp = NULL;
179 const struct cris_opcode **prefix_opc_table = NULL;
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;
188 /* Allocate and clear the opcode-table. */
189 if (opc_table == NULL)
191 opc_table = malloc (65536 * sizeof (opc_table[0]));
192 if (opc_table == NULL)
193 return NULL;
195 memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
197 dip_prefixes
198 = malloc (65536 * sizeof (const struct cris_opcode **));
199 if (dip_prefixes == NULL)
200 return NULL;
202 memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
204 bdapq_m1_prefixes
205 = malloc (65536 * sizeof (const struct cris_opcode **));
206 if (bdapq_m1_prefixes == NULL)
207 return NULL;
209 memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
211 bdapq_m2_prefixes
212 = malloc (65536 * sizeof (const struct cris_opcode **));
213 if (bdapq_m2_prefixes == NULL)
214 return NULL;
216 memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
218 bdapq_m4_prefixes
219 = malloc (65536 * sizeof (const struct cris_opcode **));
220 if (bdapq_m4_prefixes == NULL)
221 return NULL;
223 memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
225 rest_prefixes
226 = malloc (65536 * sizeof (const struct cris_opcode **));
227 if (rest_prefixes == NULL)
228 return NULL;
230 memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
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)
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));
246 if (popcodep == NULL)
247 return NULL;
249 if (popcodep->match == BDAP_QUICK_OPCODE)
251 /* Since some offsets are recognized with "push" macros, we
252 have to have different tables for them. */
253 int offset = (prefix_insn & 255);
255 if (offset > 127)
256 offset -= 256;
258 switch (offset)
260 case -4:
261 prefix_opc_table = bdapq_m4_prefixes;
262 break;
264 case -2:
265 prefix_opc_table = bdapq_m2_prefixes;
266 break;
268 case -1:
269 prefix_opc_table = bdapq_m1_prefixes;
270 break;
272 default:
273 prefix_opc_table = rest_prefixes;
274 break;
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;
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
292 const struct cris_opcode *opcodep;
293 int max_level_of_match = -1;
295 for (opcodep = cris_opcodes;
296 opcodep->name != NULL;
297 opcodep++)
299 int level_of_match;
301 if (disdata->distype == cris_dis_v32)
303 switch (opcodep->applicable_version)
305 case cris_ver_version_all:
306 break;
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;
317 case cris_ver_v3p:
318 case cris_ver_v8p:
319 case cris_ver_v10p:
320 case cris_ver_v32p:
321 break;
323 case cris_ver_v8:
324 abort ();
325 default:
326 abort ();
329 else
331 switch (opcodep->applicable_version)
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;
345 case cris_ver_v32p:
346 continue;
348 case cris_ver_v8:
349 abort ();
350 default:
351 abort ();
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))
374 max_matchedp = opcodep;
375 max_level_of_match = level_of_match;
377 /* If there was a full match, never mind looking
378 further. */
379 if (level_of_match >= 2 * 16)
380 break;
383 /* Fill in the new entry.
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;
396 return max_matchedp;
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). */
403 static int
404 cris_constraint (const char *cs,
405 unsigned int insn,
406 unsigned int prefix_insn,
407 struct cris_disasm_data *disdata)
409 int retval = 0;
410 int tmp;
411 int prefix_ok = 0;
412 const char *s;
414 for (s = cs; *s; s++)
415 switch (*s)
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;
425 case 'U':
426 /* Not recognized at disassembly. */
427 return -1;
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;
439 case 'm':
440 if ((insn & 0x30) == 0x30)
441 return -1;
442 break;
444 case 'S':
445 /* A prefix operand without side-effect. */
446 if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
448 prefix_ok = 1;
449 break;
451 else
452 return -1;
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)
461 if (insn & 0x400)
463 const struct cris_opcode *prefix_opcodep
464 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
466 if (prefix_opcodep->match == DIP_OPCODE)
467 return -1;
470 prefix_ok = 1;
472 break;
474 case 'B':
475 /* If we don't fall through, then the prefix is ok. */
476 prefix_ok = 1;
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)
482 /* Match the prefix insn to BDAPQ. */
483 const struct cris_opcode *prefix_opcodep
484 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
486 if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
488 int pushsize = (prefix_insn & 255);
490 if (pushsize > 127)
491 pushsize -= 256;
493 if (s[1] == 'P')
495 unsigned int spec_reg = (insn >> 12) & 15;
496 const struct cris_spec_reg *sregp
497 = spec_reg_info (spec_reg, disdata->distype);
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;
504 else if (s[1] == 'R')
506 if ((insn & 0x30) == 0x20 && pushsize == -4)
507 break;
509 /* FIXME: Should abort here; next constraint letter
510 *must* be 'P' or 'R'. */
513 return -1;
515 case 'D':
516 retval = (((insn >> 12) & 15) == (insn & 15));
517 if (!retval)
518 return -1;
519 else
520 retval += 4;
521 break;
523 case 'P':
525 const struct cris_spec_reg *sregp
526 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
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.
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. */
540 if (sregp != NULL)
542 retval += 3;
543 break;
545 else
546 return -1;
550 if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
551 return -1;
553 return retval;
556 /* Format number as hex with a leading "0x" into outbuffer. */
558 static char *
559 format_hex (unsigned long number,
560 char *outbuffer,
561 struct cris_disasm_data *disdata)
563 /* Truncate negative numbers on >32-bit hosts. */
564 number &= 0xffffffff;
566 sprintf (outbuffer, "0x%lx", number);
568 /* Save this value for the "case" support. */
569 if (TRACE_CASE)
570 last_immediate = number;
572 return outbuffer + strlen (outbuffer);
575 /* Format number as decimal into outbuffer. Parameter signedp says
576 whether the number should be formatted as signed (!= 0) or
577 unsigned (== 0). */
579 static char *
580 format_dec (long number, char *outbuffer, int signedp)
582 last_immediate = number;
583 sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
585 return outbuffer + strlen (outbuffer);
588 /* Format the name of the general register regno into outbuffer. */
590 static char *
591 format_reg (struct cris_disasm_data *disdata,
592 int regno,
593 char *outbuffer_start,
594 bfd_boolean with_reg_prefix)
596 char *outbuffer = outbuffer_start;
598 if (with_reg_prefix)
599 *outbuffer++ = REGISTER_PREFIX_CHAR;
601 switch (regno)
603 case 15:
604 /* For v32, there is no context in which we output PC. */
605 if (disdata->distype == cris_dis_v32)
606 strcpy (outbuffer, "acr");
607 else
608 strcpy (outbuffer, "pc");
609 break;
611 case 14:
612 strcpy (outbuffer, "sp");
613 break;
615 default:
616 sprintf (outbuffer, "r%d", regno);
617 break;
620 return outbuffer_start + strlen (outbuffer_start);
623 /* Format the name of a support register into outbuffer. */
625 static char *
626 format_sup_reg (unsigned int regno,
627 char *outbuffer_start,
628 bfd_boolean with_reg_prefix)
630 char *outbuffer = outbuffer_start;
631 int i;
633 if (with_reg_prefix)
634 *outbuffer++ = REGISTER_PREFIX_CHAR;
636 for (i = 0; cris_support_regs[i].name != NULL; i++)
637 if (cris_support_regs[i].number == regno)
639 sprintf (outbuffer, "%s", cris_support_regs[i].name);
640 return outbuffer_start + strlen (outbuffer_start);
643 /* There's supposed to be register names covering all numbers, though
644 some may be generic names. */
645 sprintf (outbuffer, "format_sup_reg-BUG");
646 return outbuffer_start + strlen (outbuffer_start);
649 /* Return the length of an instruction. */
651 static unsigned
652 bytes_to_skip (unsigned int insn,
653 const struct cris_opcode *matchedp,
654 enum cris_disass_family distype,
655 const struct cris_opcode *prefix_matchedp)
657 /* Each insn is a word plus "immediate" operands. */
658 unsigned to_skip = 2;
659 const char *template = matchedp->args;
660 const char *s;
662 for (s = template; *s; s++)
663 if ((*s == 's' || *s == 'N' || *s == 'Y')
664 && (insn & 0x400) && (insn & 15) == 15
665 && prefix_matchedp == NULL)
667 /* Immediate via [pc+], so we have to check the size of the
668 operand. */
669 int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
671 if (matchedp->imm_oprnd_size == SIZE_FIX_32)
672 to_skip += 4;
673 else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
675 const struct cris_spec_reg *sregp
676 = spec_reg_info ((insn >> 12) & 15, distype);
678 /* FIXME: Improve error handling; should have been caught
679 earlier. */
680 if (sregp == NULL)
681 return 2;
683 /* PC is incremented by two, not one, for a byte. Except on
684 CRISv32, where constants are always DWORD-size for
685 special registers. */
686 to_skip +=
687 distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
689 else
690 to_skip += (mode_size + 1) & ~1;
692 else if (*s == 'n')
693 to_skip += 4;
694 else if (*s == 'b')
695 to_skip += 2;
697 return to_skip;
700 /* Print condition code flags. */
702 static char *
703 print_flags (struct cris_disasm_data *disdata, unsigned int insn, char *cp)
705 /* Use the v8 (Etrax 100) flag definitions for disassembly.
706 The differences with v0 (Etrax 1..4) vs. Svinto are:
707 v0 'd' <=> v8 'm'
708 v0 'e' <=> v8 'b'.
709 FIXME: Emit v0..v3 flag names somehow. */
710 static const char v8_fnames[] = "cvznxibm";
711 static const char v32_fnames[] = "cvznxiup";
712 const char *fnames
713 = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
715 unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
716 int i;
718 for (i = 0; i < 8; i++)
719 if (flagbits & (1 << i))
720 *cp++ = fnames[i];
722 return cp;
725 /* Print out an insn with its operands, and update the info->insn_type
726 fields. The prefix_opcodep and the rest hold a prefix insn that is
727 supposed to be output as an address mode. */
729 static void
730 print_with_operands (const struct cris_opcode *opcodep,
731 unsigned int insn,
732 unsigned char *buffer,
733 bfd_vma addr,
734 disassemble_info *info,
735 /* If a prefix insn was before this insn (and is supposed
736 to be output as an address), here is a description of
737 it. */
738 const struct cris_opcode *prefix_opcodep,
739 unsigned int prefix_insn,
740 unsigned char *prefix_buffer,
741 bfd_boolean with_reg_prefix)
743 /* Get a buffer of somewhat reasonable size where we store
744 intermediate parts of the insn. */
745 char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
746 char *tp = temp;
747 static const char mode_char[] = "bwd?";
748 const char *s;
749 const char *cs;
750 struct cris_disasm_data *disdata
751 = (struct cris_disasm_data *) info->private_data;
753 /* Print out the name first thing we do. */
754 (*info->fprintf_func) (info->stream, "%s", opcodep->name);
756 cs = opcodep->args;
757 s = cs;
759 /* Ignore any prefix indicator. */
760 if (*s == 'p')
761 s++;
763 if (*s == 'm' || *s == 'M' || *s == 'z')
765 *tp++ = '.';
767 /* Get the size-letter. */
768 *tp++ = *s == 'M'
769 ? (insn & 0x8000 ? 'd'
770 : insn & 0x4000 ? 'w' : 'b')
771 : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
773 /* Ignore the size and the space character that follows. */
774 s += 2;
777 /* Add a space if this isn't a long-branch, because for those will add
778 the condition part of the name later. */
779 if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
780 *tp++ = ' ';
782 /* Fill in the insn-type if deducible from the name (and there's no
783 better way). */
784 if (opcodep->name[0] == 'j')
786 if (strncmp (opcodep->name, "jsr", 3) == 0)
787 /* It's "jsr" or "jsrc". */
788 info->insn_type = dis_jsr;
789 else
790 /* Any other jump-type insn is considered a branch. */
791 info->insn_type = dis_branch;
794 /* We might know some more fields right now. */
795 info->branch_delay_insns = opcodep->delayed;
797 /* Handle operands. */
798 for (; *s; s++)
800 switch (*s)
802 case 'T':
803 tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
804 break;
806 case 'A':
807 if (with_reg_prefix)
808 *tp++ = REGISTER_PREFIX_CHAR;
809 *tp++ = 'a';
810 *tp++ = 'c';
811 *tp++ = 'r';
812 break;
814 case '[':
815 case ']':
816 case ',':
817 *tp++ = *s;
818 break;
820 case '!':
821 /* Ignore at this point; used at earlier stages to avoid
822 recognition if there's a prefix at something that in other
823 ways looks like a "pop". */
824 break;
826 case 'd':
827 /* Ignore. This is an optional ".d " on the large one of
828 relaxable insns. */
829 break;
831 case 'B':
832 /* This was the prefix that made this a "push". We've already
833 handled it by recognizing it, so signal that the prefix is
834 handled by setting it to NULL. */
835 prefix_opcodep = NULL;
836 break;
838 case 'D':
839 case 'r':
840 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
841 break;
843 case 'R':
844 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
845 break;
847 case 'n':
849 /* Like N but pc-relative to the start of the insn. */
850 unsigned long number
851 = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
852 + buffer[5] * 0x1000000 + addr);
854 /* Finish off and output previous formatted bytes. */
855 *tp = 0;
856 if (temp[0])
857 (*info->fprintf_func) (info->stream, "%s", temp);
858 tp = temp;
860 (*info->print_address_func) ((bfd_vma) number, info);
862 break;
864 case 'u':
866 /* Like n but the offset is bits <3:0> in the instruction. */
867 unsigned long number = (buffer[0] & 0xf) * 2 + addr;
869 /* Finish off and output previous formatted bytes. */
870 *tp = 0;
871 if (temp[0])
872 (*info->fprintf_func) (info->stream, "%s", temp);
873 tp = temp;
875 (*info->print_address_func) ((bfd_vma) number, info);
877 break;
879 case 'N':
880 case 'y':
881 case 'Y':
882 case 'S':
883 case 's':
884 /* Any "normal" memory operand. */
885 if ((insn & 0x400) && (insn & 15) == 15 && prefix_opcodep == NULL)
887 /* We're looking at [pc+], i.e. we need to output an immediate
888 number, where the size can depend on different things. */
889 long number;
890 int signedp
891 = ((*cs == 'z' && (insn & 0x20))
892 || opcodep->match == BDAP_QUICK_OPCODE);
893 int nbytes;
895 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
896 nbytes = 4;
897 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
899 const struct cris_spec_reg *sregp
900 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
902 /* A NULL return should have been as a non-match earlier,
903 so catch it as an internal error in the error-case
904 below. */
905 if (sregp == NULL)
906 /* Whatever non-valid size. */
907 nbytes = 42;
908 else
909 /* PC is always incremented by a multiple of two.
910 For CRISv32, immediates are always 4 bytes for
911 special registers. */
912 nbytes = disdata->distype == cris_dis_v32
913 ? 4 : (sregp->reg_size + 1) & ~1;
915 else
917 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
919 if (mode_size == 1)
920 nbytes = 2;
921 else
922 nbytes = mode_size;
925 switch (nbytes)
927 case 1:
928 number = buffer[2];
929 if (signedp && number > 127)
930 number -= 256;
931 break;
933 case 2:
934 number = buffer[2] + buffer[3] * 256;
935 if (signedp && number > 32767)
936 number -= 65536;
937 break;
939 case 4:
940 number
941 = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
942 + buffer[5] * 0x1000000;
943 break;
945 default:
946 strcpy (tp, "bug");
947 tp += 3;
948 number = 42;
951 if ((*cs == 'z' && (insn & 0x20))
952 || (opcodep->match == BDAP_QUICK_OPCODE
953 && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
954 tp = format_dec (number, tp, signedp);
955 else
957 unsigned int highbyte = (number >> 24) & 0xff;
959 /* Either output this as an address or as a number. If it's
960 a dword with the same high-byte as the address of the
961 insn, assume it's an address, and also if it's a non-zero
962 non-0xff high-byte. If this is a jsr or a jump, then
963 it's definitely an address. */
964 if (nbytes == 4
965 && (highbyte == ((addr >> 24) & 0xff)
966 || (highbyte != 0 && highbyte != 0xff)
967 || info->insn_type == dis_branch
968 || info->insn_type == dis_jsr))
970 /* Finish off and output previous formatted bytes. */
971 *tp = 0;
972 tp = temp;
973 if (temp[0])
974 (*info->fprintf_func) (info->stream, "%s", temp);
976 (*info->print_address_func) ((bfd_vma) number, info);
978 info->target = number;
980 else
981 tp = format_hex (number, tp, disdata);
984 else
986 /* Not an immediate number. Then this is a (possibly
987 prefixed) memory operand. */
988 if (info->insn_type != dis_nonbranch)
990 int mode_size
991 = 1 << ((insn >> 4)
992 & (opcodep->args[0] == 'z' ? 1 : 3));
993 int size;
994 info->insn_type = dis_dref;
995 info->flags |= CRIS_DIS_FLAG_MEMREF;
997 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
998 size = 4;
999 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
1001 const struct cris_spec_reg *sregp
1002 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1004 /* FIXME: Improve error handling; should have been caught
1005 earlier. */
1006 if (sregp == NULL)
1007 size = 4;
1008 else
1009 size = sregp->reg_size;
1011 else
1012 size = mode_size;
1014 info->data_size = size;
1017 *tp++ = '[';
1019 if (prefix_opcodep
1020 /* We don't match dip with a postincremented field
1021 as a side-effect address mode. */
1022 && ((insn & 0x400) == 0
1023 || prefix_opcodep->match != DIP_OPCODE))
1025 if (insn & 0x400)
1027 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1028 *tp++ = '=';
1032 /* We mainly ignore the prefix format string when the
1033 address-mode syntax is output. */
1034 switch (prefix_opcodep->match)
1036 case DIP_OPCODE:
1037 /* It's [r], [r+] or [pc+]. */
1038 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1040 /* It's [pc+]. This cannot possibly be anything
1041 but an address. */
1042 unsigned long number
1043 = prefix_buffer[2] + prefix_buffer[3] * 256
1044 + prefix_buffer[4] * 65536
1045 + prefix_buffer[5] * 0x1000000;
1047 info->target = (bfd_vma) number;
1049 /* Finish off and output previous formatted
1050 data. */
1051 *tp = 0;
1052 tp = temp;
1053 if (temp[0])
1054 (*info->fprintf_func) (info->stream, "%s", temp);
1056 (*info->print_address_func) ((bfd_vma) number, info);
1058 else
1060 /* For a memref in an address, we use target2.
1061 In this case, target is zero. */
1062 info->flags
1063 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1064 | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
1066 info->target2 = prefix_insn & 15;
1068 *tp++ = '[';
1069 tp = format_reg (disdata, prefix_insn & 15, tp,
1070 with_reg_prefix);
1071 if (prefix_insn & 0x400)
1072 *tp++ = '+';
1073 *tp++ = ']';
1075 break;
1077 case BDAP_QUICK_OPCODE:
1079 int number;
1081 number = prefix_buffer[0];
1082 if (number > 127)
1083 number -= 256;
1085 /* Output "reg+num" or, if num < 0, "reg-num". */
1086 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1087 with_reg_prefix);
1088 if (number >= 0)
1089 *tp++ = '+';
1090 tp = format_dec (number, tp, 1);
1092 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1093 info->target = (prefix_insn >> 12) & 15;
1094 info->target2 = (bfd_vma) number;
1095 break;
1098 case BIAP_OPCODE:
1099 /* Output "r+R.m". */
1100 tp = format_reg (disdata, prefix_insn & 15, tp,
1101 with_reg_prefix);
1102 *tp++ = '+';
1103 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1104 with_reg_prefix);
1105 *tp++ = '.';
1106 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1108 info->flags
1109 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1110 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1112 | ((prefix_insn & 0x8000)
1113 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1114 : ((prefix_insn & 0x8000)
1115 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
1117 /* Is it the casejump? It's a "adds.w [pc+r%d.w],pc". */
1118 if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
1119 /* Then start interpreting data as offsets. */
1120 case_offset_counter = no_of_case_offsets;
1121 break;
1123 case BDAP_INDIR_OPCODE:
1124 /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1125 "r-s". */
1126 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1127 with_reg_prefix);
1129 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1131 long number;
1132 unsigned int nbytes;
1134 /* It's a value. Get its size. */
1135 int mode_size = 1 << ((prefix_insn >> 4) & 3);
1137 if (mode_size == 1)
1138 nbytes = 2;
1139 else
1140 nbytes = mode_size;
1142 switch (nbytes)
1144 case 1:
1145 number = prefix_buffer[2];
1146 if (number > 127)
1147 number -= 256;
1148 break;
1150 case 2:
1151 number = prefix_buffer[2] + prefix_buffer[3] * 256;
1152 if (number > 32767)
1153 number -= 65536;
1154 break;
1156 case 4:
1157 number
1158 = prefix_buffer[2] + prefix_buffer[3] * 256
1159 + prefix_buffer[4] * 65536
1160 + prefix_buffer[5] * 0x1000000;
1161 break;
1163 default:
1164 strcpy (tp, "bug");
1165 tp += 3;
1166 number = 42;
1169 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1170 info->target2 = (bfd_vma) number;
1172 /* If the size is dword, then assume it's an
1173 address. */
1174 if (nbytes == 4)
1176 /* Finish off and output previous formatted
1177 bytes. */
1178 *tp++ = '+';
1179 *tp = 0;
1180 tp = temp;
1181 (*info->fprintf_func) (info->stream, "%s", temp);
1183 (*info->print_address_func) ((bfd_vma) number, info);
1185 else
1187 if (number >= 0)
1188 *tp++ = '+';
1189 tp = format_dec (number, tp, 1);
1192 else
1194 /* Output "r+[R].m" or "r+[R+].m". */
1195 *tp++ = '+';
1196 *tp++ = '[';
1197 tp = format_reg (disdata, prefix_insn & 15, tp,
1198 with_reg_prefix);
1199 if (prefix_insn & 0x400)
1200 *tp++ = '+';
1201 *tp++ = ']';
1202 *tp++ = '.';
1203 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1205 info->flags
1206 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1207 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1208 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1210 | (((prefix_insn >> 4) == 2)
1212 : (((prefix_insn >> 4) & 3) == 1
1213 ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1214 : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
1216 break;
1218 default:
1219 (*info->fprintf_func) (info->stream, "?prefix-bug");
1222 /* To mark that the prefix is used, reset it. */
1223 prefix_opcodep = NULL;
1225 else
1227 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1229 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1230 info->target = insn & 15;
1232 if (insn & 0x400)
1233 *tp++ = '+';
1235 *tp++ = ']';
1237 break;
1239 case 'x':
1240 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1241 *tp++ = '.';
1242 *tp++ = mode_char[(insn >> 4) & 3];
1243 break;
1245 case 'I':
1246 tp = format_dec (insn & 63, tp, 0);
1247 break;
1249 case 'b':
1251 int where = buffer[2] + buffer[3] * 256;
1253 if (where > 32767)
1254 where -= 65536;
1256 where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
1258 if (insn == BA_PC_INCR_OPCODE)
1259 info->insn_type = dis_branch;
1260 else
1261 info->insn_type = dis_condbranch;
1263 info->target = (bfd_vma) where;
1265 *tp = 0;
1266 tp = temp;
1267 (*info->fprintf_func) (info->stream, "%s%s ",
1268 temp, cris_cc_strings[insn >> 12]);
1270 (*info->print_address_func) ((bfd_vma) where, info);
1272 break;
1274 case 'c':
1275 tp = format_dec (insn & 31, tp, 0);
1276 break;
1278 case 'C':
1279 tp = format_dec (insn & 15, tp, 0);
1280 break;
1282 case 'o':
1284 long offset = insn & 0xfe;
1285 bfd_vma target;
1287 if (insn & 1)
1288 offset |= ~0xff;
1290 if (opcodep->match == BA_QUICK_OPCODE)
1291 info->insn_type = dis_branch;
1292 else
1293 info->insn_type = dis_condbranch;
1295 target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
1296 info->target = target;
1297 *tp = 0;
1298 tp = temp;
1299 (*info->fprintf_func) (info->stream, "%s", temp);
1300 (*info->print_address_func) (target, info);
1302 break;
1304 case 'Q':
1305 case 'O':
1307 long number = buffer[0];
1309 if (number > 127)
1310 number = number - 256;
1312 tp = format_dec (number, tp, 1);
1313 *tp++ = ',';
1314 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1316 break;
1318 case 'f':
1319 tp = print_flags (disdata, insn, tp);
1320 break;
1322 case 'i':
1323 tp = format_dec ((insn & 32) ? (insn & 31) | ~31L : insn & 31, tp, 1);
1324 break;
1326 case 'P':
1328 const struct cris_spec_reg *sregp
1329 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1331 if (sregp->name == NULL)
1332 /* Should have been caught as a non-match eariler. */
1333 *tp++ = '?';
1334 else
1336 if (with_reg_prefix)
1337 *tp++ = REGISTER_PREFIX_CHAR;
1338 strcpy (tp, sregp->name);
1339 tp += strlen (tp);
1342 break;
1344 default:
1345 strcpy (tp, "???");
1346 tp += 3;
1350 *tp = 0;
1352 if (prefix_opcodep)
1353 (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
1354 prefix_opcodep->name, prefix_opcodep->args);
1356 (*info->fprintf_func) (info->stream, "%s", temp);
1358 /* Get info for matching case-tables, if we don't have any active.
1359 We assume that the last constant seen is used; either in the insn
1360 itself or in a "move.d const,rN, sub.d rN,rM"-like sequence. */
1361 if (TRACE_CASE && case_offset_counter == 0)
1363 if (strncmp (opcodep->name, "sub", 3) == 0)
1364 case_offset = last_immediate;
1366 /* It could also be an "add", if there are negative case-values. */
1367 else if (strncmp (opcodep->name, "add", 3) == 0)
1368 /* The first case is the negated operand to the add. */
1369 case_offset = -last_immediate;
1371 /* A bound insn will tell us the number of cases. */
1372 else if (strncmp (opcodep->name, "bound", 5) == 0)
1373 no_of_case_offsets = last_immediate + 1;
1375 /* A jump or jsr or branch breaks the chain of insns for a
1376 case-table, so assume default first-case again. */
1377 else if (info->insn_type == dis_jsr
1378 || info->insn_type == dis_branch
1379 || info->insn_type == dis_condbranch)
1380 case_offset = 0;
1385 /* Print the CRIS instruction at address memaddr on stream. Returns
1386 length of the instruction, in bytes. Prefix register names with `$' if
1387 WITH_REG_PREFIX. */
1389 static int
1390 print_insn_cris_generic (bfd_vma memaddr,
1391 disassemble_info *info,
1392 bfd_boolean with_reg_prefix)
1394 int nbytes;
1395 unsigned int insn;
1396 const struct cris_opcode *matchedp;
1397 int advance = 0;
1398 struct cris_disasm_data *disdata
1399 = (struct cris_disasm_data *) info->private_data;
1401 /* No instruction will be disassembled as longer than this number of
1402 bytes; stacked prefixes will not be expanded. */
1403 unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
1404 unsigned char *bufp;
1405 int status = 0;
1406 bfd_vma addr;
1408 /* There will be an "out of range" error after the last instruction.
1409 Reading pairs of bytes in decreasing number, we hope that we will get
1410 at least the amount that we will consume.
1412 If we can't get any data, or we do not get enough data, we print
1413 the error message. */
1415 for (nbytes = MAX_BYTES_PER_CRIS_INSN; nbytes > 0; nbytes -= 2)
1417 status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
1418 if (status == 0)
1419 break;
1422 /* If we did not get all we asked for, then clear the rest.
1423 Hopefully this makes a reproducible result in case of errors. */
1424 if (nbytes != MAX_BYTES_PER_CRIS_INSN)
1425 memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
1427 addr = memaddr;
1428 bufp = buffer;
1430 /* Set some defaults for the insn info. */
1431 info->insn_info_valid = 1;
1432 info->branch_delay_insns = 0;
1433 info->data_size = 0;
1434 info->insn_type = dis_nonbranch;
1435 info->flags = 0;
1436 info->target = 0;
1437 info->target2 = 0;
1439 /* If we got any data, disassemble it. */
1440 if (nbytes != 0)
1442 matchedp = NULL;
1444 insn = bufp[0] + bufp[1] * 256;
1446 /* If we're in a case-table, don't disassemble the offsets. */
1447 if (TRACE_CASE && case_offset_counter != 0)
1449 info->insn_type = dis_noninsn;
1450 advance += 2;
1452 /* If to print data as offsets, then shortcut here. */
1453 (*info->fprintf_func) (info->stream, "case %ld%s: -> ",
1454 case_offset + no_of_case_offsets
1455 - case_offset_counter,
1456 case_offset_counter == 1 ? "/default" :
1457 "");
1459 (*info->print_address_func) ((bfd_vma)
1460 ((short) (insn)
1461 + (long) (addr
1462 - (no_of_case_offsets
1463 - case_offset_counter)
1464 * 2)), info);
1465 case_offset_counter--;
1467 /* The default case start (without a "sub" or "add") must be
1468 zero. */
1469 if (case_offset_counter == 0)
1470 case_offset = 0;
1472 else if (insn == 0)
1474 /* We're often called to disassemble zeroes. While this is a
1475 valid "bcc .+2" insn, it is also useless enough and enough
1476 of a nuiscance that we will just output "bcc .+2" for it
1477 and signal it as a noninsn. */
1478 (*info->fprintf_func) (info->stream,
1479 disdata->distype == cris_dis_v32
1480 ? "bcc ." : "bcc .+2");
1481 info->insn_type = dis_noninsn;
1482 advance += 2;
1484 else
1486 const struct cris_opcode *prefix_opcodep = NULL;
1487 unsigned char *prefix_buffer = bufp;
1488 unsigned int prefix_insn = insn;
1489 int prefix_size = 0;
1491 matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
1493 /* Check if we're supposed to write out prefixes as address
1494 modes and if this was a prefix. */
1495 if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
1497 /* If it's a prefix, put it into the prefix vars and get the
1498 main insn. */
1499 prefix_size = bytes_to_skip (prefix_insn, matchedp,
1500 disdata->distype, NULL);
1501 prefix_opcodep = matchedp;
1503 insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
1504 matchedp = get_opcode_entry (insn, prefix_insn, disdata);
1506 if (matchedp != NULL)
1508 addr += prefix_size;
1509 bufp += prefix_size;
1510 advance += prefix_size;
1512 else
1514 /* The "main" insn wasn't valid, at least not when
1515 prefixed. Put back things enough to output the
1516 prefix insn only, as a normal insn. */
1517 matchedp = prefix_opcodep;
1518 insn = prefix_insn;
1519 prefix_opcodep = NULL;
1523 if (matchedp == NULL)
1525 (*info->fprintf_func) (info->stream, "??0x%x", insn);
1526 advance += 2;
1528 info->insn_type = dis_noninsn;
1530 else
1532 advance
1533 += bytes_to_skip (insn, matchedp, disdata->distype,
1534 prefix_opcodep);
1536 /* The info_type and assorted fields will be set according
1537 to the operands. */
1538 print_with_operands (matchedp, insn, bufp, addr, info,
1539 prefix_opcodep, prefix_insn,
1540 prefix_buffer, with_reg_prefix);
1544 else
1545 info->insn_type = dis_noninsn;
1547 /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1548 status when reading that much, and the insn decoding indicated a
1549 length exceeding what we read, there is an error. */
1550 if (status != 0 && (nbytes == 0 || advance > nbytes))
1552 (*info->memory_error_func) (status, memaddr, info);
1553 return -1;
1556 /* Max supported insn size with one folded prefix insn. */
1557 info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
1559 /* I would like to set this to a fixed value larger than the actual
1560 number of bytes to print in order to avoid spaces between bytes,
1561 but objdump.c (2.9.1) does not like that, so we print 16-bit
1562 chunks, which is the next choice. */
1563 info->bytes_per_chunk = 2;
1565 /* Printing bytes in order of increasing addresses makes sense,
1566 especially on a little-endian target.
1567 This is completely the opposite of what you think; setting this to
1568 BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1569 we want. */
1570 info->display_endian = BFD_ENDIAN_BIG;
1572 return advance;
1575 /* Disassemble, prefixing register names with `$'. CRIS v0..v10. */
1577 static int
1578 print_insn_cris_with_register_prefix (bfd_vma vma,
1579 disassemble_info *info)
1581 if (info->private_data == NULL
1582 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1583 return -1;
1584 return print_insn_cris_generic (vma, info, TRUE);
1587 /* Disassemble, prefixing register names with `$'. CRIS v32. */
1589 static int
1590 print_insn_crisv32_with_register_prefix (bfd_vma vma,
1591 disassemble_info *info)
1593 if (info->private_data == NULL
1594 && !cris_parse_disassembler_options (info, cris_dis_v32))
1595 return -1;
1596 return print_insn_cris_generic (vma, info, TRUE);
1599 /* Disassemble, prefixing register names with `$'.
1600 Common v10 and v32 subset. */
1602 static int
1603 print_insn_crisv10_v32_with_register_prefix (bfd_vma vma,
1604 disassemble_info *info)
1606 if (info->private_data == NULL
1607 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1608 return -1;
1609 return print_insn_cris_generic (vma, info, TRUE);
1612 /* Disassemble, no prefixes on register names. CRIS v0..v10. */
1614 static int
1615 print_insn_cris_without_register_prefix (bfd_vma vma,
1616 disassemble_info *info)
1618 if (info->private_data == NULL
1619 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1620 return -1;
1621 return print_insn_cris_generic (vma, info, FALSE);
1624 /* Disassemble, no prefixes on register names. CRIS v32. */
1626 static int
1627 print_insn_crisv32_without_register_prefix (bfd_vma vma,
1628 disassemble_info *info)
1630 if (info->private_data == NULL
1631 && !cris_parse_disassembler_options (info, cris_dis_v32))
1632 return -1;
1633 return print_insn_cris_generic (vma, info, FALSE);
1636 /* Disassemble, no prefixes on register names.
1637 Common v10 and v32 subset. */
1639 static int
1640 print_insn_crisv10_v32_without_register_prefix (bfd_vma vma,
1641 disassemble_info *info)
1643 if (info->private_data == NULL
1644 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1645 return -1;
1646 return print_insn_cris_generic (vma, info, FALSE);
1649 /* Return a disassembler-function that prints registers with a `$' prefix,
1650 or one that prints registers without a prefix.
1651 FIXME: We should improve the solution to avoid the multitude of
1652 functions seen above. */
1654 disassembler_ftype
1655 cris_get_disassembler (bfd *abfd)
1657 /* If there's no bfd in sight, we return what is valid as input in all
1658 contexts if fed back to the assembler: disassembly *with* register
1659 prefix. Unfortunately this will be totally wrong for v32. */
1660 if (abfd == NULL)
1661 return print_insn_cris_with_register_prefix;
1663 if (bfd_get_symbol_leading_char (abfd) == 0)
1665 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1666 return print_insn_crisv32_with_register_prefix;
1667 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1668 return print_insn_crisv10_v32_with_register_prefix;
1670 /* We default to v10. This may be specifically specified in the
1671 bfd mach, but is also the default setting. */
1672 return print_insn_cris_with_register_prefix;
1675 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1676 return print_insn_crisv32_without_register_prefix;
1677 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1678 return print_insn_crisv10_v32_without_register_prefix;
1679 return print_insn_cris_without_register_prefix;
1682 /* Local variables:
1683 eval: (c-set-style "gnu")
1684 indent-tabs-mode: t
1685 End: */