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 under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option)
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
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 #include "opcode/cris.h"
25 #include "libiberty.h"
27 /* No instruction will be disassembled longer than this. In theory, and
28 in silicon, address prefixes can be cascaded. In practice, cascading
29 is not used by GCC, and not supported by the assembler. */
30 #ifndef MAX_BYTES_PER_CRIS_INSN
31 #define MAX_BYTES_PER_CRIS_INSN 8
34 /* Whether or not to decode prefixes, folding it into the following
35 instruction. FIXME: Make this optional later. */
37 #define PARSE_PREFIX 1
40 /* Sometimes we prefix all registers with this character. */
41 #define REGISTER_PREFIX_CHAR '$'
43 /* Whether or not to trace the following sequence:
48 This is the assembly form of a switch-statement in C.
49 The "sub is optional. If there is none, then X will be zero.
50 X is the value of the first case,
51 Y is the number of cases (including default).
53 This results in case offsets printed on the form:
54 case N: -> case_address
55 where N is an estimation on the corresponding 'case' operand in C,
56 and case_address is where execution of that case continues after the
57 sequence presented above.
59 The old style of output was to print the offsets as instructions,
60 which made it hard to follow "case"-constructs in the disassembly,
61 and caused a lot of annoying warnings about undefined instructions.
63 FIXME: Make this optional later. */
65 #define TRACE_CASE (disdata->trace_case)
68 enum cris_disass_family
69 { cris_dis_v0_v10, cris_dis_common_v10_v32, cris_dis_v32 };
71 /* Stored in the disasm_info->private_data member. */
72 struct cris_disasm_data
74 /* Whether to print something less confusing if we find something
75 matching a switch-construct. */
76 bfd_boolean trace_case;
78 /* Whether this code is flagged as crisv32. FIXME: Should be an enum
79 that includes "compatible". */
80 enum cris_disass_family distype;
83 /* Value of first element in switch. */
84 static long case_offset = 0;
86 /* How many more case-offsets to print. */
87 static long case_offset_counter = 0;
89 /* Number of case offsets. */
90 static long no_of_case_offsets = 0;
92 /* Candidate for next case_offset. */
93 static long last_immediate = 0;
95 static int number_of_bits
96 PARAMS ((unsigned int));
97 static char *format_hex
98 PARAMS ((unsigned long, char *, struct cris_disasm_data *));
99 static char *format_dec
100 PARAMS ((long, char *, int));
101 static char *format_reg
102 PARAMS ((struct cris_disasm_data *, int, char *, bfd_boolean));
103 static char *format_sup_reg
104 PARAMS ((unsigned int, char *, bfd_boolean));
105 static int cris_constraint
106 PARAMS ((const char *, unsigned int, unsigned int,
107 struct cris_disasm_data *));
108 static unsigned bytes_to_skip
109 PARAMS ((unsigned int, const struct cris_opcode *,
110 enum cris_disass_family));
111 static char *print_flags
112 PARAMS ((struct cris_disasm_data *, unsigned int, char *));
113 static void print_with_operands
114 PARAMS ((const struct cris_opcode *, unsigned int, unsigned char *,
115 bfd_vma, disassemble_info *, const struct cris_opcode *,
116 unsigned int, unsigned char *, bfd_boolean));
117 static const struct cris_spec_reg *spec_reg_info
118 PARAMS ((unsigned int, enum cris_disass_family));
119 static int print_insn_cris_generic
120 PARAMS ((bfd_vma, disassemble_info *, bfd_boolean));
121 static int print_insn_cris_with_register_prefix
122 PARAMS ((bfd_vma, disassemble_info *));
123 static int print_insn_cris_without_register_prefix
124 PARAMS ((bfd_vma, disassemble_info *));
125 static int print_insn_crisv32_with_register_prefix
126 PARAMS ((bfd_vma, disassemble_info *));
127 static int print_insn_crisv32_without_register_prefix
128 PARAMS ((bfd_vma, disassemble_info *));
129 static int print_insn_crisv10_v32_with_register_prefix
130 PARAMS ((bfd_vma, disassemble_info *));
131 static int print_insn_crisv10_v32_without_register_prefix
132 PARAMS ((bfd_vma, disassemble_info *));
133 static bfd_boolean cris_parse_disassembler_options
134 PARAMS ((disassemble_info *, enum cris_disass_family));
135 static const struct cris_opcode *get_opcode_entry
136 PARAMS ((unsigned int, unsigned int, struct cris_disasm_data *));
138 /* Parse disassembler options and store state in info. FIXME: For the
139 time being, we abuse static variables. */
142 cris_parse_disassembler_options (info, distype)
143 disassemble_info *info;
144 enum cris_disass_family distype;
146 struct cris_disasm_data *disdata;
148 info->private_data = calloc (1, sizeof (struct cris_disasm_data));
149 disdata = (struct cris_disasm_data *) info->private_data;
155 = (info->disassembler_options == NULL
156 || (strcmp (info->disassembler_options, "nocase") != 0));
158 disdata->distype = distype;
163 static const struct cris_spec_reg *
164 spec_reg_info (sreg, distype)
166 enum cris_disass_family distype;
169 for (i = 0; cris_spec_regs[i].name != NULL; i++)
171 if (cris_spec_regs[i].number == sreg)
173 if (distype == cris_dis_v32)
174 switch (cris_spec_regs[i].applicable_version)
176 case cris_ver_warning:
177 case cris_ver_version_all:
182 /* No ambiguous sizes or register names with CRISv32. */
183 if (cris_spec_regs[i].warning == NULL)
184 return &cris_spec_regs[i];
188 else if (cris_spec_regs[i].applicable_version != cris_ver_v32p)
189 return &cris_spec_regs[i];
196 /* Return the number of bits in the argument. */
204 for (bits = 0; val != 0; val &= val - 1)
210 /* Get an entry in the opcode-table. */
212 static const struct cris_opcode *
213 get_opcode_entry (insn, prefix_insn, disdata)
215 unsigned int prefix_insn;
216 struct cris_disasm_data *disdata;
218 /* For non-prefixed insns, we keep a table of pointers, indexed by the
219 insn code. Each entry is initialized when found to be NULL. */
220 static const struct cris_opcode **opc_table = NULL;
222 const struct cris_opcode *max_matchedp = NULL;
223 const struct cris_opcode **prefix_opc_table = NULL;
225 /* We hold a table for each prefix that need to be handled differently. */
226 static const struct cris_opcode **dip_prefixes = NULL;
227 static const struct cris_opcode **bdapq_m1_prefixes = NULL;
228 static const struct cris_opcode **bdapq_m2_prefixes = NULL;
229 static const struct cris_opcode **bdapq_m4_prefixes = NULL;
230 static const struct cris_opcode **rest_prefixes = NULL;
232 /* Allocate and clear the opcode-table. */
233 if (opc_table == NULL)
235 opc_table = malloc (65536 * sizeof (opc_table[0]));
236 if (opc_table == NULL)
239 memset (opc_table, 0, 65536 * sizeof (const struct cris_opcode *));
242 = malloc (65536 * sizeof (const struct cris_opcode **));
243 if (dip_prefixes == NULL)
246 memset (dip_prefixes, 0, 65536 * sizeof (dip_prefixes[0]));
249 = malloc (65536 * sizeof (const struct cris_opcode **));
250 if (bdapq_m1_prefixes == NULL)
253 memset (bdapq_m1_prefixes, 0, 65536 * sizeof (bdapq_m1_prefixes[0]));
256 = malloc (65536 * sizeof (const struct cris_opcode **));
257 if (bdapq_m2_prefixes == NULL)
260 memset (bdapq_m2_prefixes, 0, 65536 * sizeof (bdapq_m2_prefixes[0]));
263 = malloc (65536 * sizeof (const struct cris_opcode **));
264 if (bdapq_m4_prefixes == NULL)
267 memset (bdapq_m4_prefixes, 0, 65536 * sizeof (bdapq_m4_prefixes[0]));
270 = malloc (65536 * sizeof (const struct cris_opcode **));
271 if (rest_prefixes == NULL)
274 memset (rest_prefixes, 0, 65536 * sizeof (rest_prefixes[0]));
277 /* Get the right table if this is a prefix.
278 This code is connected to cris_constraints in that it knows what
279 prefixes play a role in recognition of patterns; the necessary
280 state is reflected by which table is used. If constraints
281 involving match or non-match of prefix insns are changed, then this
282 probably needs changing too. */
283 if (prefix_insn != NO_CRIS_PREFIX)
285 const struct cris_opcode *popcodep
286 = (opc_table[prefix_insn] != NULL
287 ? opc_table[prefix_insn]
288 : get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata));
290 if (popcodep == NULL)
293 if (popcodep->match == BDAP_QUICK_OPCODE)
295 /* Since some offsets are recognized with "push" macros, we
296 have to have different tables for them. */
297 int offset = (prefix_insn & 255);
305 prefix_opc_table = bdapq_m4_prefixes;
309 prefix_opc_table = bdapq_m2_prefixes;
313 prefix_opc_table = bdapq_m1_prefixes;
317 prefix_opc_table = rest_prefixes;
321 else if (popcodep->match == DIP_OPCODE)
322 /* We don't allow postincrement when the prefix is DIP, so use a
323 different table for DIP. */
324 prefix_opc_table = dip_prefixes;
326 prefix_opc_table = rest_prefixes;
329 if (prefix_insn != NO_CRIS_PREFIX
330 && prefix_opc_table[insn] != NULL)
331 max_matchedp = prefix_opc_table[insn];
332 else if (prefix_insn == NO_CRIS_PREFIX && opc_table[insn] != NULL)
333 max_matchedp = opc_table[insn];
336 const struct cris_opcode *opcodep;
337 int max_level_of_match = -1;
339 for (opcodep = cris_opcodes;
340 opcodep->name != NULL;
345 if (disdata->distype == cris_dis_v32)
347 switch (opcodep->applicable_version)
349 case cris_ver_version_all:
355 case cris_ver_sim_v0_10:
358 case cris_ver_warning:
375 switch (opcodep->applicable_version)
377 case cris_ver_version_all:
384 case cris_ver_sim_v0_10:
386 case cris_ver_warning:
399 /* We give a double lead for bits matching the template in
400 cris_opcodes. Not even, because then "move p8,r10" would
401 be given 2 bits lead over "clear.d r10". When there's a
402 tie, the first entry in the table wins. This is
403 deliberate, to avoid a more complicated recognition
405 if ((opcodep->match & insn) == opcodep->match
406 && (opcodep->lose & insn) == 0
408 = cris_constraint (opcodep->args,
414 += 2 * number_of_bits (opcodep->match
416 > max_level_of_match))
418 max_matchedp = opcodep;
419 max_level_of_match = level_of_match;
421 /* If there was a full match, never mind looking
423 if (level_of_match >= 2 * 16)
427 /* Fill in the new entry.
429 If there are changes to the opcode-table involving prefixes, and
430 disassembly then does not work correctly, try removing the
431 else-clause below that fills in the prefix-table. If that
432 helps, you need to change the prefix_opc_table setting above, or
433 something related. */
434 if (prefix_insn == NO_CRIS_PREFIX)
435 opc_table[insn] = max_matchedp;
437 prefix_opc_table[insn] = max_matchedp;
443 /* Format number as hex with a leading "0x" into outbuffer. */
446 format_hex (number, outbuffer, disdata)
447 unsigned long number;
449 struct cris_disasm_data *disdata;
451 /* Truncate negative numbers on >32-bit hosts. */
452 number &= 0xffffffff;
454 sprintf (outbuffer, "0x%lx", number);
456 /* Save this value for the "case" support. */
458 last_immediate = number;
460 return outbuffer + strlen (outbuffer);
463 /* Format number as decimal into outbuffer. Parameter signedp says
464 whether the number should be formatted as signed (!= 0) or
468 format_dec (number, outbuffer, signedp)
473 last_immediate = number;
474 sprintf (outbuffer, signedp ? "%ld" : "%lu", number);
476 return outbuffer + strlen (outbuffer);
479 /* Format the name of the general register regno into outbuffer. */
482 format_reg (disdata, regno, outbuffer_start, with_reg_prefix)
483 struct cris_disasm_data *disdata;
485 char *outbuffer_start;
486 bfd_boolean with_reg_prefix;
488 char *outbuffer = outbuffer_start;
491 *outbuffer++ = REGISTER_PREFIX_CHAR;
496 /* For v32, there is no context in which we output PC. */
497 if (disdata->distype == cris_dis_v32)
498 strcpy (outbuffer, "acr");
500 strcpy (outbuffer, "pc");
504 strcpy (outbuffer, "sp");
508 sprintf (outbuffer, "r%d", regno);
512 return outbuffer_start + strlen (outbuffer_start);
515 /* Format the name of a support register into outbuffer. */
518 format_sup_reg (regno, outbuffer_start, with_reg_prefix)
520 char *outbuffer_start;
521 bfd_boolean with_reg_prefix;
523 char *outbuffer = outbuffer_start;
527 *outbuffer++ = REGISTER_PREFIX_CHAR;
529 for (i = 0; cris_support_regs[i].name != NULL; i++)
530 if (cris_support_regs[i].number == regno)
532 sprintf (outbuffer, "%s", cris_support_regs[i].name);
533 return outbuffer_start + strlen (outbuffer_start);
536 /* There's supposed to be register names covering all numbers, though
537 some may be generic names. */
538 sprintf (outbuffer, "format_sup_reg-BUG");
539 return outbuffer_start + strlen (outbuffer_start);
542 /* Return -1 if the constraints of a bitwise-matched instruction say
543 that there is no match. Otherwise return a nonnegative number
544 indicating the confidence in the match (higher is better). */
547 cris_constraint (cs, insn, prefix_insn, disdata)
550 unsigned int prefix_insn;
551 struct cris_disasm_data *disdata;
558 for (s = cs; *s; s++)
562 /* Do not recognize "pop" if there's a prefix and then only for
564 if (prefix_insn != NO_CRIS_PREFIX
565 || disdata->distype != cris_dis_v0_v10)
570 /* Not recognized at disassembly. */
574 /* Size modifier for "clear", i.e. special register 0, 4 or 8.
575 Check that it is one of them. Only special register 12 could
576 be mismatched, but checking for matches is more logical than
577 checking for mismatches when there are only a few cases. */
578 tmp = ((insn >> 12) & 0xf);
579 if (tmp != 0 && tmp != 4 && tmp != 8)
584 if ((insn & 0x30) == 0x30)
589 /* A prefix operand without side-effect. */
590 if (prefix_insn != NO_CRIS_PREFIX && (insn & 0x400) == 0)
601 /* If this is a prefixed insn with postincrement (side-effect),
602 the prefix must not be DIP. */
603 if (prefix_insn != NO_CRIS_PREFIX)
607 const struct cris_opcode *prefix_opcodep
608 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
610 if (prefix_opcodep->match == DIP_OPCODE)
619 /* If we don't fall through, then the prefix is ok. */
622 /* A "push" prefix. Check for valid "push" size.
623 In case of special register, it may be != 4. */
624 if (prefix_insn != NO_CRIS_PREFIX)
626 /* Match the prefix insn to BDAPQ. */
627 const struct cris_opcode *prefix_opcodep
628 = get_opcode_entry (prefix_insn, NO_CRIS_PREFIX, disdata);
630 if (prefix_opcodep->match == BDAP_QUICK_OPCODE)
632 int pushsize = (prefix_insn & 255);
639 unsigned int spec_reg = (insn >> 12) & 15;
640 const struct cris_spec_reg *sregp
641 = spec_reg_info (spec_reg, disdata->distype);
643 /* For a special-register, the "prefix size" must
644 match the size of the register. */
645 if (sregp && sregp->reg_size == (unsigned int) -pushsize)
648 else if (s[1] == 'R')
650 if ((insn & 0x30) == 0x20 && pushsize == -4)
653 /* FIXME: Should abort here; next constraint letter
654 *must* be 'P' or 'R'. */
660 retval = (((insn >> 12) & 15) == (insn & 15));
669 const struct cris_spec_reg *sregp
670 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
672 /* Since we match four bits, we will give a value of 4-1 = 3
673 in a match. If there is a corresponding exact match of a
674 special register in another pattern, it will get a value of
675 4, which will be higher. This should be correct in that an
676 exact pattern would match better than a general pattern.
678 Note that there is a reason for not returning zero; the
679 pattern for "clear" is partly matched in the bit-pattern
680 (the two lower bits must be zero), while the bit-pattern
681 for a move from a special register is matched in the
682 register constraint. */
694 if (prefix_insn != NO_CRIS_PREFIX && ! prefix_ok)
700 /* Return the length of an instruction. */
703 bytes_to_skip (insn, matchedp, distype)
705 const struct cris_opcode *matchedp;
706 enum cris_disass_family distype;
708 /* Each insn is a word plus "immediate" operands. */
709 unsigned to_skip = 2;
710 const char *template = matchedp->args;
713 for (s = template; *s; s++)
714 if ((*s == 's' || *s == 'N' || *s == 'Y')
715 && (insn & 0x400) && (insn & 15) == 15)
717 /* Immediate via [pc+], so we have to check the size of the
719 int mode_size = 1 << ((insn >> 4) & (*template == 'z' ? 1 : 3));
721 if (matchedp->imm_oprnd_size == SIZE_FIX_32)
723 else if (matchedp->imm_oprnd_size == SIZE_SPEC_REG)
725 const struct cris_spec_reg *sregp
726 = spec_reg_info ((insn >> 12) & 15, distype);
728 /* FIXME: Improve error handling; should have been caught
733 /* PC is incremented by two, not one, for a byte. Except on
734 CRISv32, where constants are always DWORD-size for
735 special registers. */
737 distype == cris_dis_v32 ? 4 : (sregp->reg_size + 1) & ~1;
740 to_skip += (mode_size + 1) & ~1;
750 /* Print condition code flags. */
753 print_flags (disdata, insn, cp)
754 struct cris_disasm_data *disdata;
758 /* Use the v8 (Etrax 100) flag definitions for disassembly.
759 The differences with v0 (Etrax 1..4) vs. Svinto are:
762 FIXME: Emit v0..v3 flag names somehow. */
763 static const char v8_fnames[] = "cvznxibm";
764 static const char v32_fnames[] = "cvznxiup";
766 = disdata->distype == cris_dis_v32 ? v32_fnames : v8_fnames;
768 unsigned char flagbits = (((insn >> 8) & 0xf0) | (insn & 15));
771 for (i = 0; i < 8; i++)
772 if (flagbits & (1 << i))
778 /* Print out an insn with its operands, and update the info->insn_type
779 fields. The prefix_opcodep and the rest hold a prefix insn that is
780 supposed to be output as an address mode. */
783 print_with_operands (opcodep, insn, buffer, addr, info, prefix_opcodep,
784 prefix_insn, prefix_buffer, with_reg_prefix)
785 const struct cris_opcode *opcodep;
787 unsigned char *buffer;
789 disassemble_info *info;
791 /* If a prefix insn was before this insn (and is supposed to be
792 output as an address), here is a description of it. */
793 const struct cris_opcode *prefix_opcodep;
794 unsigned int prefix_insn;
795 unsigned char *prefix_buffer;
796 bfd_boolean with_reg_prefix;
798 /* Get a buffer of somewhat reasonable size where we store
799 intermediate parts of the insn. */
800 char temp[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
802 static const char mode_char[] = "bwd?";
805 struct cris_disasm_data *disdata
806 = (struct cris_disasm_data *) info->private_data;
808 /* Print out the name first thing we do. */
809 (*info->fprintf_func) (info->stream, "%s", opcodep->name);
814 /* Ignore any prefix indicator. */
818 if (*s == 'm' || *s == 'M' || *s == 'z')
822 /* Get the size-letter. */
824 ? (insn & 0x8000 ? 'd'
825 : insn & 0x4000 ? 'w' : 'b')
826 : mode_char[(insn >> 4) & (*s == 'z' ? 1 : 3)];
828 /* Ignore the size and the space character that follows. */
832 /* Add a space if this isn't a long-branch, because for those will add
833 the condition part of the name later. */
834 if (opcodep->match != (BRANCH_PC_LOW + BRANCH_INCR_HIGH * 256))
837 /* Fill in the insn-type if deducible from the name (and there's no
839 if (opcodep->name[0] == 'j')
841 if (strncmp (opcodep->name, "jsr", 3) == 0)
842 /* It's "jsr" or "jsrc". */
843 info->insn_type = dis_jsr;
845 /* Any other jump-type insn is considered a branch. */
846 info->insn_type = dis_branch;
849 /* We might know some more fields right now. */
850 info->branch_delay_insns = opcodep->delayed;
852 /* Handle operands. */
858 tp = format_sup_reg ((insn >> 12) & 15, tp, with_reg_prefix);
863 *tp++ = REGISTER_PREFIX_CHAR;
876 /* Ignore at this point; used at earlier stages to avoid
877 recognition if there's a prefix at something that in other
878 ways looks like a "pop". */
882 /* Ignore. This is an optional ".d " on the large one of
887 /* This was the prefix that made this a "push". We've already
888 handled it by recognizing it, so signal that the prefix is
889 handled by setting it to NULL. */
890 prefix_opcodep = NULL;
895 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
899 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
904 /* Like N but pc-relative to the start of the insn. */
906 = (buffer[2] + buffer[3] * 256 + buffer[4] * 65536
907 + buffer[5] * 0x1000000 + addr);
909 /* Finish off and output previous formatted bytes. */
912 (*info->fprintf_func) (info->stream, "%s", temp);
915 (*info->print_address_func) ((bfd_vma) number, info);
921 /* Like n but the offset is bits <3:0> in the instruction. */
922 unsigned long number = (buffer[0] & 0xf) * 2 + addr;
924 /* Finish off and output previous formatted bytes. */
927 (*info->fprintf_func) (info->stream, "%s", temp);
930 (*info->print_address_func) ((bfd_vma) number, info);
939 /* Any "normal" memory operand. */
940 if ((insn & 0x400) && (insn & 15) == 15)
942 /* We're looking at [pc+], i.e. we need to output an immediate
943 number, where the size can depend on different things. */
946 = ((*cs == 'z' && (insn & 0x20))
947 || opcodep->match == BDAP_QUICK_OPCODE);
950 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
952 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
954 const struct cris_spec_reg *sregp
955 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
957 /* A NULL return should have been as a non-match earlier,
958 so catch it as an internal error in the error-case
961 /* Whatever non-valid size. */
964 /* PC is always incremented by a multiple of two.
965 For CRISv32, immediates are always 4 bytes for
966 special registers. */
967 nbytes = disdata->distype == cris_dis_v32
968 ? 4 : (sregp->reg_size + 1) & ~1;
972 int mode_size = 1 << ((insn >> 4) & (*cs == 'z' ? 1 : 3));
984 if (signedp && number > 127)
989 number = buffer[2] + buffer[3] * 256;
990 if (signedp && number > 32767)
996 = buffer[2] + buffer[3] * 256 + buffer[4] * 65536
997 + buffer[5] * 0x1000000;
1006 if ((*cs == 'z' && (insn & 0x20))
1007 || (opcodep->match == BDAP_QUICK_OPCODE
1008 && (nbytes <= 2 || buffer[1 + nbytes] == 0)))
1009 tp = format_dec (number, tp, signedp);
1012 unsigned int highbyte = (number >> 24) & 0xff;
1014 /* Either output this as an address or as a number. If it's
1015 a dword with the same high-byte as the address of the
1016 insn, assume it's an address, and also if it's a non-zero
1017 non-0xff high-byte. If this is a jsr or a jump, then
1018 it's definitely an address. */
1020 && (highbyte == ((addr >> 24) & 0xff)
1021 || (highbyte != 0 && highbyte != 0xff)
1022 || info->insn_type == dis_branch
1023 || info->insn_type == dis_jsr))
1025 /* Finish off and output previous formatted bytes. */
1029 (*info->fprintf_func) (info->stream, "%s", temp);
1031 (*info->print_address_func) ((bfd_vma) number, info);
1033 info->target = number;
1036 tp = format_hex (number, tp, disdata);
1041 /* Not an immediate number. Then this is a (possibly
1042 prefixed) memory operand. */
1043 if (info->insn_type != dis_nonbranch)
1047 & (opcodep->args[0] == 'z' ? 1 : 3));
1049 info->insn_type = dis_dref;
1050 info->flags |= CRIS_DIS_FLAG_MEMREF;
1052 if (opcodep->imm_oprnd_size == SIZE_FIX_32)
1054 else if (opcodep->imm_oprnd_size == SIZE_SPEC_REG)
1056 const struct cris_spec_reg *sregp
1057 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1059 /* FIXME: Improve error handling; should have been caught
1064 size = sregp->reg_size;
1069 info->data_size = size;
1075 /* We don't match dip with a postincremented field
1076 as a side-effect address mode. */
1077 && ((insn & 0x400) == 0
1078 || prefix_opcodep->match != DIP_OPCODE))
1082 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1087 /* We mainly ignore the prefix format string when the
1088 address-mode syntax is output. */
1089 switch (prefix_opcodep->match)
1092 /* It's [r], [r+] or [pc+]. */
1093 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1095 /* It's [pc+]. This cannot possibly be anything
1097 unsigned long number
1098 = prefix_buffer[2] + prefix_buffer[3] * 256
1099 + prefix_buffer[4] * 65536
1100 + prefix_buffer[5] * 0x1000000;
1102 info->target = (bfd_vma) number;
1104 /* Finish off and output previous formatted
1109 (*info->fprintf_func) (info->stream, "%s", temp);
1111 (*info->print_address_func) ((bfd_vma) number, info);
1115 /* For a memref in an address, we use target2.
1116 In this case, target is zero. */
1118 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1119 | CRIS_DIS_FLAG_MEM_TARGET2_MEM);
1121 info->target2 = prefix_insn & 15;
1124 tp = format_reg (disdata, prefix_insn & 15, tp,
1126 if (prefix_insn & 0x400)
1132 case BDAP_QUICK_OPCODE:
1136 number = prefix_buffer[0];
1140 /* Output "reg+num" or, if num < 0, "reg-num". */
1141 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1145 tp = format_dec (number, tp, 1);
1147 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1148 info->target = (prefix_insn >> 12) & 15;
1149 info->target2 = (bfd_vma) number;
1154 /* Output "r+R.m". */
1155 tp = format_reg (disdata, prefix_insn & 15, tp,
1158 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1161 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1164 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1165 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1167 | ((prefix_insn & 0x8000)
1168 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1169 : ((prefix_insn & 0x8000)
1170 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2 : 0)));
1172 /* Is it the casejump? It's a "adds.w [pc+r%d.w],pc". */
1173 if (insn == 0xf83f && (prefix_insn & ~0xf000) == 0x55f)
1174 /* Then start interpreting data as offsets. */
1175 case_offset_counter = no_of_case_offsets;
1178 case BDAP_INDIR_OPCODE:
1179 /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1181 tp = format_reg (disdata, (prefix_insn >> 12) & 15, tp,
1184 if ((prefix_insn & 0x400) && (prefix_insn & 15) == 15)
1187 unsigned int nbytes;
1189 /* It's a value. Get its size. */
1190 int mode_size = 1 << ((prefix_insn >> 4) & 3);
1200 number = prefix_buffer[2];
1206 number = prefix_buffer[2] + prefix_buffer[3] * 256;
1213 = prefix_buffer[2] + prefix_buffer[3] * 256
1214 + prefix_buffer[4] * 65536
1215 + prefix_buffer[5] * 0x1000000;
1224 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1225 info->target2 = (bfd_vma) number;
1227 /* If the size is dword, then assume it's an
1231 /* Finish off and output previous formatted
1236 (*info->fprintf_func) (info->stream, "%s", temp);
1238 (*info->print_address_func) ((bfd_vma) number, info);
1244 tp = format_dec (number, tp, 1);
1249 /* Output "r+[R].m" or "r+[R+].m". */
1252 tp = format_reg (disdata, prefix_insn & 15, tp,
1254 if (prefix_insn & 0x400)
1258 *tp++ = mode_char[(prefix_insn >> 4) & 3];
1261 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1262 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1263 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1265 | (((prefix_insn >> 4) == 2)
1267 : (((prefix_insn >> 4) & 3) == 1
1268 ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1269 : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE)));
1274 (*info->fprintf_func) (info->stream, "?prefix-bug");
1277 /* To mark that the prefix is used, reset it. */
1278 prefix_opcodep = NULL;
1282 tp = format_reg (disdata, insn & 15, tp, with_reg_prefix);
1284 info->flags |= CRIS_DIS_FLAG_MEM_TARGET_IS_REG;
1285 info->target = insn & 15;
1295 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1297 *tp++ = mode_char[(insn >> 4) & 3];
1301 tp = format_dec (insn & 63, tp, 0);
1306 int where = buffer[2] + buffer[3] * 256;
1311 where += addr + ((disdata->distype == cris_dis_v32) ? 0 : 4);
1313 if (insn == BA_PC_INCR_OPCODE)
1314 info->insn_type = dis_branch;
1316 info->insn_type = dis_condbranch;
1318 info->target = (bfd_vma) where;
1322 (*info->fprintf_func) (info->stream, "%s%s ",
1323 temp, cris_cc_strings[insn >> 12]);
1325 (*info->print_address_func) ((bfd_vma) where, info);
1330 tp = format_dec (insn & 31, tp, 0);
1334 tp = format_dec (insn & 15, tp, 0);
1339 long offset = insn & 0xfe;
1345 if (opcodep->match == BA_QUICK_OPCODE)
1346 info->insn_type = dis_branch;
1348 info->insn_type = dis_condbranch;
1350 target = addr + ((disdata->distype == cris_dis_v32) ? 0 : 2) + offset;
1351 info->target = target;
1354 (*info->fprintf_func) (info->stream, "%s", temp);
1355 (*info->print_address_func) (target, info);
1362 long number = buffer[0];
1365 number = number - 256;
1367 tp = format_dec (number, tp, 1);
1369 tp = format_reg (disdata, (insn >> 12) & 15, tp, with_reg_prefix);
1374 tp = print_flags (disdata, insn, tp);
1378 tp = format_dec ((insn & 32) ? (insn & 31) | ~31 : insn & 31, tp, 1);
1383 const struct cris_spec_reg *sregp
1384 = spec_reg_info ((insn >> 12) & 15, disdata->distype);
1386 if (sregp->name == NULL)
1387 /* Should have been caught as a non-match eariler. */
1391 if (with_reg_prefix)
1392 *tp++ = REGISTER_PREFIX_CHAR;
1393 strcpy (tp, sregp->name);
1408 (*info->fprintf_func) (info->stream, " (OOPS unused prefix \"%s: %s\")",
1409 prefix_opcodep->name, prefix_opcodep->args);
1411 (*info->fprintf_func) (info->stream, "%s", temp);
1413 /* Get info for matching case-tables, if we don't have any active.
1414 We assume that the last constant seen is used; either in the insn
1415 itself or in a "move.d const,rN, sub.d rN,rM"-like sequence. */
1416 if (TRACE_CASE && case_offset_counter == 0)
1418 if (strncmp (opcodep->name, "sub", 3) == 0)
1419 case_offset = last_immediate;
1421 /* It could also be an "add", if there are negative case-values. */
1422 else if (strncmp (opcodep->name, "add", 3) == 0)
1424 /* The first case is the negated operand to the add. */
1425 case_offset = -last_immediate;
1427 /* A bound insn will tell us the number of cases. */
1428 else if (strncmp (opcodep->name, "bound", 5) == 0)
1430 no_of_case_offsets = last_immediate + 1;
1432 /* A jump or jsr or branch breaks the chain of insns for a
1433 case-table, so assume default first-case again. */
1434 else if (info->insn_type == dis_jsr
1435 || info->insn_type == dis_branch
1436 || info->insn_type == dis_condbranch)
1442 /* Print the CRIS instruction at address memaddr on stream. Returns
1443 length of the instruction, in bytes. Prefix register names with `$' if
1447 print_insn_cris_generic (memaddr, info, with_reg_prefix)
1449 disassemble_info *info;
1450 bfd_boolean with_reg_prefix;
1454 const struct cris_opcode *matchedp;
1456 struct cris_disasm_data *disdata
1457 = (struct cris_disasm_data *) info->private_data;
1459 /* No instruction will be disassembled as longer than this number of
1460 bytes; stacked prefixes will not be expanded. */
1461 unsigned char buffer[MAX_BYTES_PER_CRIS_INSN];
1462 unsigned char *bufp;
1466 /* There will be an "out of range" error after the last instruction.
1467 Reading pairs of bytes in decreasing number, we hope that we will get
1468 at least the amount that we will consume.
1470 If we can't get any data, or we do not get enough data, we print
1471 the error message. */
1473 for (nbytes = MAX_BYTES_PER_CRIS_INSN; nbytes > 0; nbytes -= 2)
1475 status = (*info->read_memory_func) (memaddr, buffer, nbytes, info);
1480 /* If we did not get all we asked for, then clear the rest.
1481 Hopefully this makes a reproducible result in case of errors. */
1482 if (nbytes != MAX_BYTES_PER_CRIS_INSN)
1483 memset (buffer + nbytes, 0, MAX_BYTES_PER_CRIS_INSN - nbytes);
1488 /* Set some defaults for the insn info. */
1489 info->insn_info_valid = 1;
1490 info->branch_delay_insns = 0;
1491 info->data_size = 0;
1492 info->insn_type = dis_nonbranch;
1497 /* If we got any data, disassemble it. */
1502 insn = bufp[0] + bufp[1] * 256;
1504 /* If we're in a case-table, don't disassemble the offsets. */
1505 if (TRACE_CASE && case_offset_counter != 0)
1507 info->insn_type = dis_noninsn;
1510 /* If to print data as offsets, then shortcut here. */
1511 (*info->fprintf_func) (info->stream, "case %d%s: -> ",
1512 case_offset + no_of_case_offsets
1513 - case_offset_counter,
1514 case_offset_counter == 1 ? "/default" :
1517 (*info->print_address_func) ((bfd_vma)
1520 - (no_of_case_offsets
1521 - case_offset_counter)
1523 case_offset_counter--;
1525 /* The default case start (without a "sub" or "add") must be
1527 if (case_offset_counter == 0)
1532 /* We're often called to disassemble zeroes. While this is a
1533 valid "bcc .+2" insn, it is also useless enough and enough
1534 of a nuiscance that we will just output "bcc .+2" for it
1535 and signal it as a noninsn. */
1536 (*info->fprintf_func) (info->stream,
1537 disdata->distype == cris_dis_v32
1538 ? "bcc ." : "bcc .+2");
1539 info->insn_type = dis_noninsn;
1544 const struct cris_opcode *prefix_opcodep = NULL;
1545 unsigned char *prefix_buffer = bufp;
1546 unsigned int prefix_insn = insn;
1547 int prefix_size = 0;
1549 matchedp = get_opcode_entry (insn, NO_CRIS_PREFIX, disdata);
1551 /* Check if we're supposed to write out prefixes as address
1552 modes and if this was a prefix. */
1553 if (matchedp != NULL && PARSE_PREFIX && matchedp->args[0] == 'p')
1555 /* If it's a prefix, put it into the prefix vars and get the
1557 prefix_size = bytes_to_skip (prefix_insn, matchedp,
1559 prefix_opcodep = matchedp;
1561 insn = bufp[prefix_size] + bufp[prefix_size + 1] * 256;
1562 matchedp = get_opcode_entry (insn, prefix_insn, disdata);
1564 if (matchedp != NULL)
1566 addr += prefix_size;
1567 bufp += prefix_size;
1568 advance += prefix_size;
1572 /* The "main" insn wasn't valid, at least not when
1573 prefixed. Put back things enough to output the
1574 prefix insn only, as a normal insn. */
1575 matchedp = prefix_opcodep;
1577 prefix_opcodep = NULL;
1581 if (matchedp == NULL)
1583 (*info->fprintf_func) (info->stream, "??0x%lx", insn);
1586 info->insn_type = dis_noninsn;
1590 advance += bytes_to_skip (insn, matchedp, disdata->distype);
1592 /* The info_type and assorted fields will be set according
1594 print_with_operands (matchedp, insn, bufp, addr, info,
1595 prefix_opcodep, prefix_insn,
1596 prefix_buffer, with_reg_prefix);
1601 info->insn_type = dis_noninsn;
1603 /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1604 status when reading that much, and the insn decoding indicated a
1605 length exceeding what we read, there is an error. */
1606 if (status != 0 && (nbytes == 0 || advance > nbytes))
1608 (*info->memory_error_func) (status, memaddr, info);
1612 /* Max supported insn size with one folded prefix insn. */
1613 info->bytes_per_line = MAX_BYTES_PER_CRIS_INSN;
1615 /* I would like to set this to a fixed value larger than the actual
1616 number of bytes to print in order to avoid spaces between bytes,
1617 but objdump.c (2.9.1) does not like that, so we print 16-bit
1618 chunks, which is the next choice. */
1619 info->bytes_per_chunk = 2;
1621 /* Printing bytes in order of increasing addresses makes sense,
1622 especially on a little-endian target.
1623 This is completely the opposite of what you think; setting this to
1624 BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1626 info->display_endian = BFD_ENDIAN_BIG;
1631 /* Disassemble, prefixing register names with `$'. CRIS v0..v10. */
1634 print_insn_cris_with_register_prefix (vma, info)
1636 disassemble_info *info;
1638 if (info->private_data == NULL
1639 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1641 return print_insn_cris_generic (vma, info, TRUE);
1644 /* Disassemble, prefixing register names with `$'. CRIS v32. */
1647 print_insn_crisv32_with_register_prefix (vma, info)
1649 disassemble_info *info;
1651 if (info->private_data == NULL
1652 && !cris_parse_disassembler_options (info, cris_dis_v32))
1654 return print_insn_cris_generic (vma, info, TRUE);
1657 /* Disassemble, prefixing register names with `$'.
1658 Common v10 and v32 subset. */
1661 print_insn_crisv10_v32_with_register_prefix (vma, info)
1663 disassemble_info *info;
1665 if (info->private_data == NULL
1666 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1668 return print_insn_cris_generic (vma, info, TRUE);
1671 /* Disassemble, no prefixes on register names. CRIS v0..v10. */
1674 print_insn_cris_without_register_prefix (vma, info)
1676 disassemble_info *info;
1678 if (info->private_data == NULL
1679 && !cris_parse_disassembler_options (info, cris_dis_v0_v10))
1681 return print_insn_cris_generic (vma, info, FALSE);
1684 /* Disassemble, no prefixes on register names. CRIS v32. */
1687 print_insn_crisv32_without_register_prefix (vma, info)
1689 disassemble_info *info;
1691 if (info->private_data == NULL
1692 && !cris_parse_disassembler_options (info, cris_dis_v32))
1694 return print_insn_cris_generic (vma, info, FALSE);
1697 /* Disassemble, no prefixes on register names.
1698 Common v10 and v32 subset. */
1701 print_insn_crisv10_v32_without_register_prefix (vma, info)
1703 disassemble_info *info;
1705 if (info->private_data == NULL
1706 && !cris_parse_disassembler_options (info, cris_dis_common_v10_v32))
1708 return print_insn_cris_generic (vma, info, FALSE);
1711 /* Return a disassembler-function that prints registers with a `$' prefix,
1712 or one that prints registers without a prefix.
1713 FIXME: We should improve the solution to avoid the multitude of
1714 functions seen above. */
1717 cris_get_disassembler (abfd)
1720 /* If there's no bfd in sight, we return what is valid as input in all
1721 contexts if fed back to the assembler: disassembly *with* register
1722 prefix. Unfortunately this will be totally wrong for v32. */
1724 return print_insn_cris_with_register_prefix;
1726 if (bfd_get_symbol_leading_char (abfd) == 0)
1728 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1729 return print_insn_crisv32_with_register_prefix;
1730 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1731 return print_insn_crisv10_v32_with_register_prefix;
1733 /* We default to v10. This may be specifically specified in the
1734 bfd mach, but is also the default setting. */
1735 return print_insn_cris_with_register_prefix;
1738 if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
1739 return print_insn_crisv32_without_register_prefix;
1740 if (bfd_get_mach (abfd) == bfd_mach_cris_v10_v32)
1741 return print_insn_crisv10_v32_without_register_prefix;
1742 return print_insn_cris_without_register_prefix;
1747 * eval: (c-set-style "gnu")
1748 * indent-tabs-mode: t