1 /* Disassembler code for CRIS.
2 Copyright 2000, 2001, 2002 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 /* Obfuscate to avoid warning on 32-bit host, but properly truncate
452 negative numbers on >32-bit hosts. */
453 if (sizeof (number
) > 4)
454 number
&= (1 << (sizeof (number
) > 4 ? 32 : 1)) - 1;
456 sprintf (outbuffer
, "0x%lx", number
);
458 /* Save this value for the "case" support. */
460 last_immediate
= number
;
462 return outbuffer
+ strlen (outbuffer
);
465 /* Format number as decimal into outbuffer. Parameter signedp says
466 whether the number should be formatted as signed (!= 0) or
470 format_dec (number
, outbuffer
, signedp
)
475 last_immediate
= number
;
476 sprintf (outbuffer
, signedp
? "%ld" : "%lu", number
);
478 return outbuffer
+ strlen (outbuffer
);
481 /* Format the name of the general register regno into outbuffer. */
484 format_reg (disdata
, regno
, outbuffer_start
, with_reg_prefix
)
485 struct cris_disasm_data
*disdata
;
487 char *outbuffer_start
;
488 bfd_boolean with_reg_prefix
;
490 char *outbuffer
= outbuffer_start
;
493 *outbuffer
++ = REGISTER_PREFIX_CHAR
;
498 /* For v32, there is no context in which we output PC. */
499 if (disdata
->distype
== cris_dis_v32
)
500 strcpy (outbuffer
, "acr");
502 strcpy (outbuffer
, "pc");
506 strcpy (outbuffer
, "sp");
510 sprintf (outbuffer
, "r%d", regno
);
514 return outbuffer_start
+ strlen (outbuffer_start
);
517 /* Format the name of a support register into outbuffer. */
520 format_sup_reg (regno
, outbuffer_start
, with_reg_prefix
)
522 char *outbuffer_start
;
523 bfd_boolean with_reg_prefix
;
525 char *outbuffer
= outbuffer_start
;
529 *outbuffer
++ = REGISTER_PREFIX_CHAR
;
531 for (i
= 0; cris_support_regs
[i
].name
!= NULL
; i
++)
532 if (cris_support_regs
[i
].number
== regno
)
534 sprintf (outbuffer
, "%s", cris_support_regs
[i
].name
);
535 return outbuffer_start
+ strlen (outbuffer_start
);
538 /* There's supposed to be register names covering all numbers, though
539 some may be generic names. */
540 sprintf (outbuffer
, "format_sup_reg-BUG");
541 return outbuffer_start
+ strlen (outbuffer_start
);
544 /* Return -1 if the constraints of a bitwise-matched instruction say
545 that there is no match. Otherwise return a nonnegative number
546 indicating the confidence in the match (higher is better). */
549 cris_constraint (cs
, insn
, prefix_insn
, disdata
)
552 unsigned int prefix_insn
;
553 struct cris_disasm_data
*disdata
;
560 for (s
= cs
; *s
; s
++)
564 /* Do not recognize "pop" if there's a prefix and then only for
566 if (prefix_insn
!= NO_CRIS_PREFIX
567 || disdata
->distype
!= cris_dis_v0_v10
)
572 /* Not recognized at disassembly. */
576 /* Size modifier for "clear", i.e. special register 0, 4 or 8.
577 Check that it is one of them. Only special register 12 could
578 be mismatched, but checking for matches is more logical than
579 checking for mismatches when there are only a few cases. */
580 tmp
= ((insn
>> 12) & 0xf);
581 if (tmp
!= 0 && tmp
!= 4 && tmp
!= 8)
586 if ((insn
& 0x30) == 0x30)
591 /* A prefix operand without side-effect. */
592 if (prefix_insn
!= NO_CRIS_PREFIX
&& (insn
& 0x400) == 0)
603 /* If this is a prefixed insn with postincrement (side-effect),
604 the prefix must not be DIP. */
605 if (prefix_insn
!= NO_CRIS_PREFIX
)
609 const struct cris_opcode
*prefix_opcodep
610 = get_opcode_entry (prefix_insn
, NO_CRIS_PREFIX
, disdata
);
612 if (prefix_opcodep
->match
== DIP_OPCODE
)
621 /* If we don't fall through, then the prefix is ok. */
624 /* A "push" prefix. Check for valid "push" size.
625 In case of special register, it may be != 4. */
626 if (prefix_insn
!= NO_CRIS_PREFIX
)
628 /* Match the prefix insn to BDAPQ. */
629 const struct cris_opcode
*prefix_opcodep
630 = get_opcode_entry (prefix_insn
, NO_CRIS_PREFIX
, disdata
);
632 if (prefix_opcodep
->match
== BDAP_QUICK_OPCODE
)
634 int pushsize
= (prefix_insn
& 255);
641 unsigned int spec_reg
= (insn
>> 12) & 15;
642 const struct cris_spec_reg
*sregp
643 = spec_reg_info (spec_reg
, disdata
->distype
);
645 /* For a special-register, the "prefix size" must
646 match the size of the register. */
647 if (sregp
&& sregp
->reg_size
== (unsigned int) -pushsize
)
650 else if (s
[1] == 'R')
652 if ((insn
& 0x30) == 0x20 && pushsize
== -4)
655 /* FIXME: Should abort here; next constraint letter
656 *must* be 'P' or 'R'. */
662 retval
= (((insn
>> 12) & 15) == (insn
& 15));
671 const struct cris_spec_reg
*sregp
672 = spec_reg_info ((insn
>> 12) & 15, disdata
->distype
);
674 /* Since we match four bits, we will give a value of 4-1 = 3
675 in a match. If there is a corresponding exact match of a
676 special register in another pattern, it will get a value of
677 4, which will be higher. This should be correct in that an
678 exact pattern would match better than a general pattern.
680 Note that there is a reason for not returning zero; the
681 pattern for "clear" is partly matched in the bit-pattern
682 (the two lower bits must be zero), while the bit-pattern
683 for a move from a special register is matched in the
684 register constraint. */
696 if (prefix_insn
!= NO_CRIS_PREFIX
&& ! prefix_ok
)
702 /* Return the length of an instruction. */
705 bytes_to_skip (insn
, matchedp
, distype
)
707 const struct cris_opcode
*matchedp
;
708 enum cris_disass_family distype
;
710 /* Each insn is a word plus "immediate" operands. */
711 unsigned to_skip
= 2;
712 const char *template = matchedp
->args
;
715 for (s
= template; *s
; s
++)
716 if ((*s
== 's' || *s
== 'N' || *s
== 'Y')
717 && (insn
& 0x400) && (insn
& 15) == 15)
719 /* Immediate via [pc+], so we have to check the size of the
721 int mode_size
= 1 << ((insn
>> 4) & (*template == 'z' ? 1 : 3));
723 if (matchedp
->imm_oprnd_size
== SIZE_FIX_32
)
725 else if (matchedp
->imm_oprnd_size
== SIZE_SPEC_REG
)
727 const struct cris_spec_reg
*sregp
728 = spec_reg_info ((insn
>> 12) & 15, distype
);
730 /* FIXME: Improve error handling; should have been caught
735 /* PC is incremented by two, not one, for a byte. Except on
736 CRISv32, where constants are always DWORD-size for
737 special registers. */
739 distype
== cris_dis_v32
? 4 : (sregp
->reg_size
+ 1) & ~1;
742 to_skip
+= (mode_size
+ 1) & ~1;
752 /* Print condition code flags. */
755 print_flags (disdata
, insn
, cp
)
756 struct cris_disasm_data
*disdata
;
760 /* Use the v8 (Etrax 100) flag definitions for disassembly.
761 The differences with v0 (Etrax 1..4) vs. Svinto are:
764 FIXME: Emit v0..v3 flag names somehow. */
765 static const char v8_fnames
[] = "cvznxibm";
766 static const char v32_fnames
[] = "cvznxiup";
768 = disdata
->distype
== cris_dis_v32
? v32_fnames
: v8_fnames
;
770 unsigned char flagbits
= (((insn
>> 8) & 0xf0) | (insn
& 15));
773 for (i
= 0; i
< 8; i
++)
774 if (flagbits
& (1 << i
))
780 /* Print out an insn with its operands, and update the info->insn_type
781 fields. The prefix_opcodep and the rest hold a prefix insn that is
782 supposed to be output as an address mode. */
785 print_with_operands (opcodep
, insn
, buffer
, addr
, info
, prefix_opcodep
,
786 prefix_insn
, prefix_buffer
, with_reg_prefix
)
787 const struct cris_opcode
*opcodep
;
789 unsigned char *buffer
;
791 disassemble_info
*info
;
793 /* If a prefix insn was before this insn (and is supposed to be
794 output as an address), here is a description of it. */
795 const struct cris_opcode
*prefix_opcodep
;
796 unsigned int prefix_insn
;
797 unsigned char *prefix_buffer
;
798 bfd_boolean with_reg_prefix
;
800 /* Get a buffer of somewhat reasonable size where we store
801 intermediate parts of the insn. */
802 char temp
[sizeof (".d [$r13=$r12-2147483648],$r10") * 2];
804 static const char mode_char
[] = "bwd?";
807 struct cris_disasm_data
*disdata
808 = (struct cris_disasm_data
*) info
->private_data
;
810 /* Print out the name first thing we do. */
811 (*info
->fprintf_func
) (info
->stream
, "%s", opcodep
->name
);
816 /* Ignore any prefix indicator. */
820 if (*s
== 'm' || *s
== 'M' || *s
== 'z')
824 /* Get the size-letter. */
826 ? (insn
& 0x8000 ? 'd'
827 : insn
& 0x4000 ? 'w' : 'b')
828 : mode_char
[(insn
>> 4) & (*s
== 'z' ? 1 : 3)];
830 /* Ignore the size and the space character that follows. */
834 /* Add a space if this isn't a long-branch, because for those will add
835 the condition part of the name later. */
836 if (opcodep
->match
!= (BRANCH_PC_LOW
+ BRANCH_INCR_HIGH
* 256))
839 /* Fill in the insn-type if deducible from the name (and there's no
841 if (opcodep
->name
[0] == 'j')
843 if (strncmp (opcodep
->name
, "jsr", 3) == 0)
844 /* It's "jsr" or "jsrc". */
845 info
->insn_type
= dis_jsr
;
847 /* Any other jump-type insn is considered a branch. */
848 info
->insn_type
= dis_branch
;
851 /* We might know some more fields right now. */
852 info
->branch_delay_insns
= opcodep
->delayed
;
854 /* Handle operands. */
860 tp
= format_sup_reg ((insn
>> 12) & 15, tp
, with_reg_prefix
);
865 *tp
++ = REGISTER_PREFIX_CHAR
;
878 /* Ignore at this point; used at earlier stages to avoid
879 recognition if there's a prefix at something that in other
880 ways looks like a "pop". */
884 /* Ignore. This is an optional ".d " on the large one of
889 /* This was the prefix that made this a "push". We've already
890 handled it by recognizing it, so signal that the prefix is
891 handled by setting it to NULL. */
892 prefix_opcodep
= NULL
;
897 tp
= format_reg (disdata
, insn
& 15, tp
, with_reg_prefix
);
901 tp
= format_reg (disdata
, (insn
>> 12) & 15, tp
, with_reg_prefix
);
906 /* Like N but pc-relative to the start of the insn. */
908 = (buffer
[2] + buffer
[3] * 256 + buffer
[4] * 65536
909 + buffer
[5] * 0x1000000 + addr
);
911 /* Finish off and output previous formatted bytes. */
914 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
917 (*info
->print_address_func
) ((bfd_vma
) number
, info
);
923 /* Like n but the offset is bits <3:0> in the instruction. */
924 unsigned long number
= (buffer
[0] & 0xf) * 2 + addr
;
926 /* Finish off and output previous formatted bytes. */
929 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
932 (*info
->print_address_func
) ((bfd_vma
) number
, info
);
941 /* Any "normal" memory operand. */
942 if ((insn
& 0x400) && (insn
& 15) == 15)
944 /* We're looking at [pc+], i.e. we need to output an immediate
945 number, where the size can depend on different things. */
948 = ((*cs
== 'z' && (insn
& 0x20))
949 || opcodep
->match
== BDAP_QUICK_OPCODE
);
952 if (opcodep
->imm_oprnd_size
== SIZE_FIX_32
)
954 else if (opcodep
->imm_oprnd_size
== SIZE_SPEC_REG
)
956 const struct cris_spec_reg
*sregp
957 = spec_reg_info ((insn
>> 12) & 15, disdata
->distype
);
959 /* A NULL return should have been as a non-match earlier,
960 so catch it as an internal error in the error-case
963 /* Whatever non-valid size. */
966 /* PC is always incremented by a multiple of two.
967 For CRISv32, immediates are always 4 bytes for
968 special registers. */
969 nbytes
= disdata
->distype
== cris_dis_v32
970 ? 4 : (sregp
->reg_size
+ 1) & ~1;
974 int mode_size
= 1 << ((insn
>> 4) & (*cs
== 'z' ? 1 : 3));
986 if (signedp
&& number
> 127)
991 number
= buffer
[2] + buffer
[3] * 256;
992 if (signedp
&& number
> 32767)
998 = buffer
[2] + buffer
[3] * 256 + buffer
[4] * 65536
999 + buffer
[5] * 0x1000000;
1008 if ((*cs
== 'z' && (insn
& 0x20))
1009 || (opcodep
->match
== BDAP_QUICK_OPCODE
1010 && (nbytes
<= 2 || buffer
[1 + nbytes
] == 0)))
1011 tp
= format_dec (number
, tp
, signedp
);
1014 unsigned int highbyte
= (number
>> 24) & 0xff;
1016 /* Either output this as an address or as a number. If it's
1017 a dword with the same high-byte as the address of the
1018 insn, assume it's an address, and also if it's a non-zero
1019 non-0xff high-byte. If this is a jsr or a jump, then
1020 it's definitely an address. */
1022 && (highbyte
== ((addr
>> 24) & 0xff)
1023 || (highbyte
!= 0 && highbyte
!= 0xff)
1024 || info
->insn_type
== dis_branch
1025 || info
->insn_type
== dis_jsr
))
1027 /* Finish off and output previous formatted bytes. */
1031 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
1033 (*info
->print_address_func
) ((bfd_vma
) number
, info
);
1035 info
->target
= number
;
1038 tp
= format_hex (number
, tp
, disdata
);
1043 /* Not an immediate number. Then this is a (possibly
1044 prefixed) memory operand. */
1045 if (info
->insn_type
!= dis_nonbranch
)
1049 & (opcodep
->args
[0] == 'z' ? 1 : 3));
1051 info
->insn_type
= dis_dref
;
1052 info
->flags
|= CRIS_DIS_FLAG_MEMREF
;
1054 if (opcodep
->imm_oprnd_size
== SIZE_FIX_32
)
1056 else if (opcodep
->imm_oprnd_size
== SIZE_SPEC_REG
)
1058 const struct cris_spec_reg
*sregp
1059 = spec_reg_info ((insn
>> 12) & 15, disdata
->distype
);
1061 /* FIXME: Improve error handling; should have been caught
1066 size
= sregp
->reg_size
;
1071 info
->data_size
= size
;
1077 /* We don't match dip with a postincremented field
1078 as a side-effect address mode. */
1079 && ((insn
& 0x400) == 0
1080 || prefix_opcodep
->match
!= DIP_OPCODE
))
1084 tp
= format_reg (disdata
, insn
& 15, tp
, with_reg_prefix
);
1089 /* We mainly ignore the prefix format string when the
1090 address-mode syntax is output. */
1091 switch (prefix_opcodep
->match
)
1094 /* It's [r], [r+] or [pc+]. */
1095 if ((prefix_insn
& 0x400) && (prefix_insn
& 15) == 15)
1097 /* It's [pc+]. This cannot possibly be anything
1099 unsigned long number
1100 = prefix_buffer
[2] + prefix_buffer
[3] * 256
1101 + prefix_buffer
[4] * 65536
1102 + prefix_buffer
[5] * 0x1000000;
1104 info
->target
= (bfd_vma
) number
;
1106 /* Finish off and output previous formatted
1111 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
1113 (*info
->print_address_func
) ((bfd_vma
) number
, info
);
1117 /* For a memref in an address, we use target2.
1118 In this case, target is zero. */
1120 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1121 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
);
1123 info
->target2
= prefix_insn
& 15;
1126 tp
= format_reg (disdata
, prefix_insn
& 15, tp
,
1128 if (prefix_insn
& 0x400)
1134 case BDAP_QUICK_OPCODE
:
1138 number
= prefix_buffer
[0];
1142 /* Output "reg+num" or, if num < 0, "reg-num". */
1143 tp
= format_reg (disdata
, (prefix_insn
>> 12) & 15, tp
,
1147 tp
= format_dec (number
, tp
, 1);
1149 info
->flags
|= CRIS_DIS_FLAG_MEM_TARGET_IS_REG
;
1150 info
->target
= (prefix_insn
>> 12) & 15;
1151 info
->target2
= (bfd_vma
) number
;
1156 /* Output "r+R.m". */
1157 tp
= format_reg (disdata
, prefix_insn
& 15, tp
,
1160 tp
= format_reg (disdata
, (prefix_insn
>> 12) & 15, tp
,
1163 *tp
++ = mode_char
[(prefix_insn
>> 4) & 3];
1166 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1167 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1169 | ((prefix_insn
& 0x8000)
1170 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT4
1171 : ((prefix_insn
& 0x8000)
1172 ? CRIS_DIS_FLAG_MEM_TARGET2_MULT2
: 0)));
1174 /* Is it the casejump? It's a "adds.w [pc+r%d.w],pc". */
1175 if (insn
== 0xf83f && (prefix_insn
& ~0xf000) == 0x55f)
1176 /* Then start interpreting data as offsets. */
1177 case_offset_counter
= no_of_case_offsets
;
1180 case BDAP_INDIR_OPCODE
:
1181 /* Output "r+s.m", or, if "s" is [pc+], "r+s" or
1183 tp
= format_reg (disdata
, (prefix_insn
>> 12) & 15, tp
,
1186 if ((prefix_insn
& 0x400) && (prefix_insn
& 15) == 15)
1189 unsigned int nbytes
;
1191 /* It's a value. Get its size. */
1192 int mode_size
= 1 << ((prefix_insn
>> 4) & 3);
1202 number
= prefix_buffer
[2];
1208 number
= prefix_buffer
[2] + prefix_buffer
[3] * 256;
1215 = prefix_buffer
[2] + prefix_buffer
[3] * 256
1216 + prefix_buffer
[4] * 65536
1217 + prefix_buffer
[5] * 0x1000000;
1226 info
->flags
|= CRIS_DIS_FLAG_MEM_TARGET_IS_REG
;
1227 info
->target2
= (bfd_vma
) number
;
1229 /* If the size is dword, then assume it's an
1233 /* Finish off and output previous formatted
1238 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
1240 (*info
->print_address_func
) ((bfd_vma
) number
, info
);
1246 tp
= format_dec (number
, tp
, 1);
1251 /* Output "r+[R].m" or "r+[R+].m". */
1254 tp
= format_reg (disdata
, prefix_insn
& 15, tp
,
1256 if (prefix_insn
& 0x400)
1260 *tp
++ = mode_char
[(prefix_insn
>> 4) & 3];
1263 |= (CRIS_DIS_FLAG_MEM_TARGET2_IS_REG
1264 | CRIS_DIS_FLAG_MEM_TARGET2_MEM
1265 | CRIS_DIS_FLAG_MEM_TARGET_IS_REG
1267 | (((prefix_insn
>> 4) == 2)
1269 : (((prefix_insn
>> 4) & 3) == 1
1270 ? CRIS_DIS_FLAG_MEM_TARGET2_MEM_WORD
1271 : CRIS_DIS_FLAG_MEM_TARGET2_MEM_BYTE
)));
1276 (*info
->fprintf_func
) (info
->stream
, "?prefix-bug");
1279 /* To mark that the prefix is used, reset it. */
1280 prefix_opcodep
= NULL
;
1284 tp
= format_reg (disdata
, insn
& 15, tp
, with_reg_prefix
);
1286 info
->flags
|= CRIS_DIS_FLAG_MEM_TARGET_IS_REG
;
1287 info
->target
= insn
& 15;
1297 tp
= format_reg (disdata
, (insn
>> 12) & 15, tp
, with_reg_prefix
);
1299 *tp
++ = mode_char
[(insn
>> 4) & 3];
1303 tp
= format_dec (insn
& 63, tp
, 0);
1308 int where
= buffer
[2] + buffer
[3] * 256;
1313 where
+= addr
+ ((disdata
->distype
== cris_dis_v32
) ? 0 : 4);
1315 if (insn
== BA_PC_INCR_OPCODE
)
1316 info
->insn_type
= dis_branch
;
1318 info
->insn_type
= dis_condbranch
;
1320 info
->target
= (bfd_vma
) where
;
1324 (*info
->fprintf_func
) (info
->stream
, "%s%s ",
1325 temp
, cris_cc_strings
[insn
>> 12]);
1327 (*info
->print_address_func
) ((bfd_vma
) where
, info
);
1332 tp
= format_dec (insn
& 31, tp
, 0);
1336 tp
= format_dec (insn
& 15, tp
, 0);
1341 long offset
= insn
& 0xfe;
1347 if (opcodep
->match
== BA_QUICK_OPCODE
)
1348 info
->insn_type
= dis_branch
;
1350 info
->insn_type
= dis_condbranch
;
1352 target
= addr
+ ((disdata
->distype
== cris_dis_v32
) ? 0 : 2) + offset
;
1353 info
->target
= target
;
1356 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
1357 (*info
->print_address_func
) (target
, info
);
1364 long number
= buffer
[0];
1367 number
= number
- 256;
1369 tp
= format_dec (number
, tp
, 1);
1371 tp
= format_reg (disdata
, (insn
>> 12) & 15, tp
, with_reg_prefix
);
1376 tp
= print_flags (disdata
, insn
, tp
);
1380 tp
= format_dec ((insn
& 32) ? (insn
& 31) | ~31 : insn
& 31, tp
, 1);
1385 const struct cris_spec_reg
*sregp
1386 = spec_reg_info ((insn
>> 12) & 15, disdata
->distype
);
1388 if (sregp
->name
== NULL
)
1389 /* Should have been caught as a non-match eariler. */
1393 if (with_reg_prefix
)
1394 *tp
++ = REGISTER_PREFIX_CHAR
;
1395 strcpy (tp
, sregp
->name
);
1410 (*info
->fprintf_func
) (info
->stream
, " (OOPS unused prefix \"%s: %s\")",
1411 prefix_opcodep
->name
, prefix_opcodep
->args
);
1413 (*info
->fprintf_func
) (info
->stream
, "%s", temp
);
1415 /* Get info for matching case-tables, if we don't have any active.
1416 We assume that the last constant seen is used; either in the insn
1417 itself or in a "move.d const,rN, sub.d rN,rM"-like sequence. */
1418 if (TRACE_CASE
&& case_offset_counter
== 0)
1420 if (strncmp (opcodep
->name
, "sub", 3) == 0)
1421 case_offset
= last_immediate
;
1423 /* It could also be an "add", if there are negative case-values. */
1424 else if (strncmp (opcodep
->name
, "add", 3) == 0)
1426 /* The first case is the negated operand to the add. */
1427 case_offset
= -last_immediate
;
1429 /* A bound insn will tell us the number of cases. */
1430 else if (strncmp (opcodep
->name
, "bound", 5) == 0)
1432 no_of_case_offsets
= last_immediate
+ 1;
1434 /* A jump or jsr or branch breaks the chain of insns for a
1435 case-table, so assume default first-case again. */
1436 else if (info
->insn_type
== dis_jsr
1437 || info
->insn_type
== dis_branch
1438 || info
->insn_type
== dis_condbranch
)
1444 /* Print the CRIS instruction at address memaddr on stream. Returns
1445 length of the instruction, in bytes. Prefix register names with `$' if
1449 print_insn_cris_generic (memaddr
, info
, with_reg_prefix
)
1451 disassemble_info
*info
;
1452 bfd_boolean with_reg_prefix
;
1456 const struct cris_opcode
*matchedp
;
1458 struct cris_disasm_data
*disdata
1459 = (struct cris_disasm_data
*) info
->private_data
;
1461 /* No instruction will be disassembled as longer than this number of
1462 bytes; stacked prefixes will not be expanded. */
1463 unsigned char buffer
[MAX_BYTES_PER_CRIS_INSN
];
1464 unsigned char *bufp
;
1468 /* There will be an "out of range" error after the last instruction.
1469 Reading pairs of bytes in decreasing number, we hope that we will get
1470 at least the amount that we will consume.
1472 If we can't get any data, or we do not get enough data, we print
1473 the error message. */
1475 for (nbytes
= MAX_BYTES_PER_CRIS_INSN
; nbytes
> 0; nbytes
-= 2)
1477 status
= (*info
->read_memory_func
) (memaddr
, buffer
, nbytes
, info
);
1482 /* If we did not get all we asked for, then clear the rest.
1483 Hopefully this makes a reproducible result in case of errors. */
1484 if (nbytes
!= MAX_BYTES_PER_CRIS_INSN
)
1485 memset (buffer
+ nbytes
, 0, MAX_BYTES_PER_CRIS_INSN
- nbytes
);
1490 /* Set some defaults for the insn info. */
1491 info
->insn_info_valid
= 1;
1492 info
->branch_delay_insns
= 0;
1493 info
->data_size
= 0;
1494 info
->insn_type
= dis_nonbranch
;
1499 /* If we got any data, disassemble it. */
1504 insn
= bufp
[0] + bufp
[1] * 256;
1506 /* If we're in a case-table, don't disassemble the offsets. */
1507 if (TRACE_CASE
&& case_offset_counter
!= 0)
1509 info
->insn_type
= dis_noninsn
;
1512 /* If to print data as offsets, then shortcut here. */
1513 (*info
->fprintf_func
) (info
->stream
, "case %d%s: -> ",
1514 case_offset
+ no_of_case_offsets
1515 - case_offset_counter
,
1516 case_offset_counter
== 1 ? "/default" :
1519 (*info
->print_address_func
) ((bfd_vma
)
1522 - (no_of_case_offsets
1523 - case_offset_counter
)
1525 case_offset_counter
--;
1527 /* The default case start (without a "sub" or "add") must be
1529 if (case_offset_counter
== 0)
1534 /* We're often called to disassemble zeroes. While this is a
1535 valid "bcc .+2" insn, it is also useless enough and enough
1536 of a nuiscance that we will just output "bcc .+2" for it
1537 and signal it as a noninsn. */
1538 (*info
->fprintf_func
) (info
->stream
,
1539 disdata
->distype
== cris_dis_v32
1540 ? "bcc ." : "bcc .+2");
1541 info
->insn_type
= dis_noninsn
;
1546 const struct cris_opcode
*prefix_opcodep
= NULL
;
1547 unsigned char *prefix_buffer
= bufp
;
1548 unsigned int prefix_insn
= insn
;
1549 int prefix_size
= 0;
1551 matchedp
= get_opcode_entry (insn
, NO_CRIS_PREFIX
, disdata
);
1553 /* Check if we're supposed to write out prefixes as address
1554 modes and if this was a prefix. */
1555 if (matchedp
!= NULL
&& PARSE_PREFIX
&& matchedp
->args
[0] == 'p')
1557 /* If it's a prefix, put it into the prefix vars and get the
1559 prefix_size
= bytes_to_skip (prefix_insn
, matchedp
,
1561 prefix_opcodep
= matchedp
;
1563 insn
= bufp
[prefix_size
] + bufp
[prefix_size
+ 1] * 256;
1564 matchedp
= get_opcode_entry (insn
, prefix_insn
, disdata
);
1566 if (matchedp
!= NULL
)
1568 addr
+= prefix_size
;
1569 bufp
+= prefix_size
;
1570 advance
+= prefix_size
;
1574 /* The "main" insn wasn't valid, at least not when
1575 prefixed. Put back things enough to output the
1576 prefix insn only, as a normal insn. */
1577 matchedp
= prefix_opcodep
;
1579 prefix_opcodep
= NULL
;
1583 if (matchedp
== NULL
)
1585 (*info
->fprintf_func
) (info
->stream
, "??0x%lx", insn
);
1588 info
->insn_type
= dis_noninsn
;
1592 advance
+= bytes_to_skip (insn
, matchedp
, disdata
->distype
);
1594 /* The info_type and assorted fields will be set according
1596 print_with_operands (matchedp
, insn
, bufp
, addr
, info
,
1597 prefix_opcodep
, prefix_insn
,
1598 prefix_buffer
, with_reg_prefix
);
1603 info
->insn_type
= dis_noninsn
;
1605 /* If we read less than MAX_BYTES_PER_CRIS_INSN, i.e. we got an error
1606 status when reading that much, and the insn decoding indicated a
1607 length exceeding what we read, there is an error. */
1608 if (status
!= 0 && (nbytes
== 0 || advance
> nbytes
))
1610 (*info
->memory_error_func
) (status
, memaddr
, info
);
1614 /* Max supported insn size with one folded prefix insn. */
1615 info
->bytes_per_line
= MAX_BYTES_PER_CRIS_INSN
;
1617 /* I would like to set this to a fixed value larger than the actual
1618 number of bytes to print in order to avoid spaces between bytes,
1619 but objdump.c (2.9.1) does not like that, so we print 16-bit
1620 chunks, which is the next choice. */
1621 info
->bytes_per_chunk
= 2;
1623 /* Printing bytes in order of increasing addresses makes sense,
1624 especially on a little-endian target.
1625 This is completely the opposite of what you think; setting this to
1626 BFD_ENDIAN_LITTLE will print bytes in order N..0 rather than the 0..N
1628 info
->display_endian
= BFD_ENDIAN_BIG
;
1633 /* Disassemble, prefixing register names with `$'. CRIS v0..v10. */
1636 print_insn_cris_with_register_prefix (vma
, info
)
1638 disassemble_info
*info
;
1640 if (info
->private_data
== NULL
1641 && !cris_parse_disassembler_options (info
, cris_dis_v0_v10
))
1643 return print_insn_cris_generic (vma
, info
, TRUE
);
1646 /* Disassemble, prefixing register names with `$'. CRIS v32. */
1649 print_insn_crisv32_with_register_prefix (vma
, info
)
1651 disassemble_info
*info
;
1653 if (info
->private_data
== NULL
1654 && !cris_parse_disassembler_options (info
, cris_dis_v32
))
1656 return print_insn_cris_generic (vma
, info
, TRUE
);
1659 /* Disassemble, prefixing register names with `$'.
1660 Common v10 and v32 subset. */
1663 print_insn_crisv10_v32_with_register_prefix (vma
, info
)
1665 disassemble_info
*info
;
1667 if (info
->private_data
== NULL
1668 && !cris_parse_disassembler_options (info
, cris_dis_common_v10_v32
))
1670 return print_insn_cris_generic (vma
, info
, TRUE
);
1673 /* Disassemble, no prefixes on register names. CRIS v0..v10. */
1676 print_insn_cris_without_register_prefix (vma
, info
)
1678 disassemble_info
*info
;
1680 if (info
->private_data
== NULL
1681 && !cris_parse_disassembler_options (info
, cris_dis_v0_v10
))
1683 return print_insn_cris_generic (vma
, info
, FALSE
);
1686 /* Disassemble, no prefixes on register names. CRIS v32. */
1689 print_insn_crisv32_without_register_prefix (vma
, info
)
1691 disassemble_info
*info
;
1693 if (info
->private_data
== NULL
1694 && !cris_parse_disassembler_options (info
, cris_dis_v32
))
1696 return print_insn_cris_generic (vma
, info
, FALSE
);
1699 /* Disassemble, no prefixes on register names.
1700 Common v10 and v32 subset. */
1703 print_insn_crisv10_v32_without_register_prefix (vma
, info
)
1705 disassemble_info
*info
;
1707 if (info
->private_data
== NULL
1708 && !cris_parse_disassembler_options (info
, cris_dis_common_v10_v32
))
1710 return print_insn_cris_generic (vma
, info
, FALSE
);
1713 /* Return a disassembler-function that prints registers with a `$' prefix,
1714 or one that prints registers without a prefix.
1715 FIXME: We should improve the solution to avoid the multitude of
1716 functions seen above. */
1719 cris_get_disassembler (abfd
)
1722 /* If there's no bfd in sight, we return what is valid as input in all
1723 contexts if fed back to the assembler: disassembly *with* register
1724 prefix. Unfortunately this will be totally wrong for v32. */
1726 return print_insn_cris_with_register_prefix
;
1728 if (bfd_get_symbol_leading_char (abfd
) == 0)
1730 if (bfd_get_mach (abfd
) == bfd_mach_cris_v32
)
1731 return print_insn_crisv32_with_register_prefix
;
1732 if (bfd_get_mach (abfd
) == bfd_mach_cris_v10_v32
)
1733 return print_insn_crisv10_v32_with_register_prefix
;
1735 /* We default to v10. This may be specifically specified in the
1736 bfd mach, but is also the default setting. */
1737 return print_insn_cris_with_register_prefix
;
1740 if (bfd_get_mach (abfd
) == bfd_mach_cris_v32
)
1741 return print_insn_crisv32_without_register_prefix
;
1742 if (bfd_get_mach (abfd
) == bfd_mach_cris_v10_v32
)
1743 return print_insn_crisv10_v32_without_register_prefix
;
1744 return print_insn_cris_without_register_prefix
;
1749 * eval: (c-set-style "gnu")
1750 * indent-tabs-mode: t