2 Copyright (C) 1988-2022 Free Software Foundation, Inc.
3 Contributed by C-SKY Microsystems and Mentor Graphics.
5 This file is part of the GNU opcodes library.
7 This library is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 It is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
27 #include "disassemble.h"
29 #include "opcode/csky.h"
30 #include "libiberty.h"
32 #include "floatformat.h"
34 #define CSKY_INST_TYPE unsigned long
35 #define HAS_SUB_OPERAND (unsigned int)0xffffffff
36 #define CSKY_DEFAULT_ISA 0xffffffff
46 /* Mem to disassemble. */
48 /* Disassemble info. */
49 disassemble_info
*info
;
50 /* Opcode information. */
51 struct csky_opcode_info
const *opinfo
;
53 /* The value of operand to show. */
55 /* Whether to look up/print a symbol name. */
56 int need_output_symbol
;
60 enum sym_type last_type
;
62 bfd_vma last_map_addr
= 0;
65 /* Only for objdump tool. */
66 #define INIT_MACH_FLAG 0xffffffff
67 #define BINARY_MACH_FLAG 0x0
69 static unsigned int mach_flag
= INIT_MACH_FLAG
;
72 print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED
,
73 struct disassemble_info
*info
,
76 switch (info
->bytes_per_chunk
)
79 info
->fprintf_func (info
->stream
, ".byte\t0x%02lx", given
);
82 info
->fprintf_func (info
->stream
, ".short\t0x%04lx", given
);
85 info
->fprintf_func (info
->stream
, ".long\t0x%08lx", given
);
93 get_sym_code_type (struct disassemble_info
*info
,
95 enum sym_type
*sym_type
)
98 name
= bfd_asymbol_name (info
->symtab
[n
]);
99 if (name
[0] == '$' && (name
[1] == 't' || name
[1] == 'd')
100 && (name
[2] == 0 || name
[2] == '.'))
102 *sym_type
= ((name
[1] == 't') ? CUR_TEXT
: CUR_DATA
);
109 csky_get_operand_mask (struct operand
const *oprnd
)
112 if (oprnd
->mask
== HAS_SUB_OPERAND
)
114 struct soperand
*sop
= (struct soperand
*)oprnd
;
115 mask
|= csky_get_operand_mask (&sop
->subs
[0]);
116 mask
|= csky_get_operand_mask (&sop
->subs
[1]);
123 csky_get_mask (struct csky_opcode_info
const *pinfo
)
128 if (pinfo
->operand_num
== -1)
129 mask
|= csky_get_operand_mask (&pinfo
->oprnd
.oprnds
[i
]);
131 for (; i
< pinfo
->operand_num
; i
++)
132 mask
|= csky_get_operand_mask (&pinfo
->oprnd
.oprnds
[i
]);
139 csky_chars_to_number (unsigned char * buf
, int n
)
142 unsigned int val
= 0;
144 if (dis_info
.info
->endian
== BFD_ENDIAN_BIG
)
145 for (i
= 0; i
< n
; i
++)
146 val
= val
<< 8 | buf
[i
];
148 for (i
= n
- 1; i
>= 0; i
--)
149 val
= val
<< 8 | buf
[i
];
153 static struct csky_opcode
const *g_opcodeP
;
155 static struct csky_opcode
const *
156 csky_find_inst_info (struct csky_opcode_info
const **pinfo
,
157 CSKY_INST_TYPE inst
, int length
)
161 struct csky_opcode
const *p
;
166 if (!(p
->isa_flag16
& dis_info
.isa
)
167 && !(p
->isa_flag32
& dis_info
.isa
))
173 /* Get the opcode mask. */
174 for (i
= 0; i
< OP_TABLE_NUM
; i
++)
177 mask
= csky_get_mask (&p
->op16
[i
]);
178 if (mask
!= 0 && (inst
& mask
) == p
->op16
[i
].opcode
)
180 *pinfo
= &p
->op16
[i
];
185 else if (length
== 4)
187 mask
= csky_get_mask (&p
->op32
[i
]);
189 && ((unsigned long)(inst
& mask
)
190 == (unsigned long)p
->op32
[i
].opcode
))
192 *pinfo
= &p
->op32
[i
];
204 is_extern_symbol (struct disassemble_info
*info
, int addr
)
206 unsigned int rel_count
= 0;
208 if (info
->section
== NULL
)
210 if ((info
->section
->flags
& SEC_RELOC
) != 0) /* Fit .o file. */
212 struct reloc_cache_entry
*pt
= info
->section
->relocation
;
213 for (; rel_count
< info
->section
->reloc_count
; rel_count
++, pt
++)
214 if ((long unsigned int)addr
== pt
->address
)
222 /* Suppress printing of mapping symbols emitted by the assembler to mark
223 the beginning of code and data sequences. */
226 csky_symbol_is_valid (asymbol
*sym
,
227 struct disassemble_info
*info ATTRIBUTE_UNUSED
)
233 name
= bfd_asymbol_name (sym
);
234 return name
&& *name
!= '$';
238 csky_get_disassembler (bfd
*abfd
)
241 const char *sec_name
= NULL
;
242 if (!abfd
|| bfd_get_flavour (abfd
) != bfd_target_elf_flavour
)
243 dis_info
.isa
= CSKY_DEFAULT_ISA
;
246 mach_flag
= elf_elfheader (abfd
)->e_flags
;
248 sec_name
= get_elf_backend_data (abfd
)->obj_attrs_section
;
249 /* Skip any input that hasn't attribute section.
250 This enables to link object files without attribute section with
252 if (bfd_get_section_by_name (abfd
, sec_name
) != NULL
)
254 attr
= elf_known_obj_attributes_proc (abfd
);
255 dis_info
.isa
= attr
[Tag_CSKY_ISA_EXT_FLAGS
].i
;
257 dis_info
.isa
|= attr
[Tag_CSKY_ISA_FLAGS
].i
;
260 dis_info
.isa
= CSKY_DEFAULT_ISA
;
263 return print_insn_csky
;
266 /* Parse the string of disassembler options. */
268 parse_csky_dis_options (const char *opts_in
)
270 char *opts
= xstrdup (opts_in
);
272 char *opt_end
= opts
;
274 for (; opt_end
!= NULL
; opt
= opt_end
+ 1)
276 if ((opt_end
= strchr (opt
, ',')) != NULL
)
278 if (strcmp (opt
, "abi-names") == 0)
282 "unrecognized disassembler option: %s", opt
);
286 /* Get general register name. */
288 get_gr_name (int regno
)
290 return csky_get_general_reg_name (mach_flag
, regno
, using_abi
);
293 /* Get control register name. */
295 get_cr_name (unsigned int regno
, int bank
)
297 return csky_get_control_reg_name (mach_flag
, bank
, regno
, using_abi
);
301 csky_output_operand (char *str
, struct operand
const *oprnd
,
302 CSKY_INST_TYPE inst
, int reloc ATTRIBUTE_UNUSED
)
308 int mask
= oprnd
->mask
;
312 /* Get operand value with mask. */
314 for (; mask
; mask
>>= 1, value
>>=1)
317 result
|= ((value
& 0x1) << bit
);
323 /* Here is general instructions that have no reloc. */
326 case OPRND_TYPE_CTRLREG
:
327 if (IS_CSKY_V1(mach_flag
) && ((value
& 0x1f) == 0x1f))
329 strcat (str
, get_cr_name((value
& 0x1f), (value
>> 5)));
331 case OPRND_TYPE_DUMMY_REG
:
332 mask
= dis_info
.opinfo
->oprnd
.oprnds
[0].mask
;
334 for (; mask
; mask
>>= 1, value
>>=1)
337 result
|= ((value
& 0x1) << bit
);
341 strcat (str
, get_gr_name (value
));
343 case OPRND_TYPE_GREG0_7
:
344 case OPRND_TYPE_GREG0_15
:
345 case OPRND_TYPE_GREG16_31
:
346 case OPRND_TYPE_REGnsplr
:
347 case OPRND_TYPE_AREG
:
348 strcat (str
, get_gr_name (value
));
350 case OPRND_TYPE_CPREG
:
351 sprintf (buf
, "cpr%d", (int)value
);
354 case OPRND_TYPE_FREG
:
355 sprintf (buf
, "fr%d", (int)value
);
358 case OPRND_TYPE_VREG
:
359 dis_info
.value
= value
;
360 sprintf (buf
, "vr%d", (int)value
);
363 case OPRND_TYPE_CPCREG
:
364 sprintf (buf
, "cpcr%d", (int)value
);
367 case OPRND_TYPE_CPIDX
:
368 sprintf (buf
, "cp%d", (int)value
);
371 case OPRND_TYPE_IMM2b_JMPIX
:
372 value
= (value
+ 2) << 3;
373 sprintf (buf
, "%d", (int)value
);
376 case OPRND_TYPE_IMM_LDST
:
377 case OPRND_TYPE_IMM_FLDST
:
378 value
<<= oprnd
->shift
;
379 sprintf (buf
, "0x%x", (unsigned int)value
);
382 case OPRND_TYPE_IMM7b_LS2
:
383 case OPRND_TYPE_IMM8b_LS2
:
384 sprintf (buf
, "%d", (int)(value
<< 2));
388 case OPRND_TYPE_IMM5b_BMASKI
:
389 if ((value
!= 0) && (value
> 31 || value
< 8))
394 sprintf (buf
, "%d", (int)value
);
398 case OPRND_TYPE_IMM5b_1_31
:
399 if (value
> 31 || value
< 1)
404 sprintf (buf
, "%d", (int)value
);
408 case OPRND_TYPE_IMM5b_7_31
:
409 if (value
> 31 || value
< 7)
414 sprintf (buf
, "%d", (int)value
);
418 case OPRND_TYPE_IMM5b_VSH
:
421 value
= ((value
& 0x1) << 4) | (value
>> 1);
422 sprintf (num
, "%d", (int)value
);
427 case OPRND_TYPE_MSB2SIZE
:
428 case OPRND_TYPE_LSB2SIZE
:
431 if (oprnd
->type
== OPRND_TYPE_MSB2SIZE
)
435 str
[strlen (str
) - 2] = '\0';
436 sprintf (buf
, "%d, %d", (int)(size
+ value
), (int)value
);
441 case OPRND_TYPE_IMM1b
:
442 case OPRND_TYPE_IMM2b
:
443 case OPRND_TYPE_IMM4b
:
444 case OPRND_TYPE_IMM5b
:
445 case OPRND_TYPE_IMM5b_LS
:
446 case OPRND_TYPE_IMM7b
:
447 case OPRND_TYPE_IMM8b
:
448 case OPRND_TYPE_IMM12b
:
449 case OPRND_TYPE_IMM15b
:
450 case OPRND_TYPE_IMM16b
:
451 case OPRND_TYPE_IMM16b_MOVIH
:
452 case OPRND_TYPE_IMM16b_ORI
:
453 sprintf (buf
, "%d", (int)value
);
457 case OPRND_TYPE_OFF8b
:
458 case OPRND_TYPE_OFF16b
:
460 unsigned char ibytes
[4];
461 int shift
= oprnd
->shift
;
463 unsigned int mem_val
;
465 dis_info
.info
->stop_vma
= 0;
467 value
= ((dis_info
.mem
+ (value
<< shift
)
468 + ((IS_CSKY_V1 (mach_flag
)) ? 2 : 0))
470 status
= dis_info
.info
->read_memory_func (value
, ibytes
, 4,
474 dis_info
.info
->memory_error_func (status
, dis_info
.mem
,
478 mem_val
= csky_chars_to_number (ibytes
, 4);
479 /* Remove [] around literal value to match ABI syntax. */
480 sprintf (buf
, "0x%X", mem_val
);
482 /* For jmpi/jsri, we'll try to get a symbol for the target. */
483 if (dis_info
.info
->print_address_func
&& mem_val
!= 0)
485 dis_info
.value
= mem_val
;
486 dis_info
.need_output_symbol
= 1;
490 sprintf (buf
, "\t// from address pool at 0x%x",
491 (unsigned int)value
);
496 case OPRND_TYPE_BLOOP_OFF4b
:
497 case OPRND_TYPE_BLOOP_OFF12b
:
498 case OPRND_TYPE_OFF11b
:
499 case OPRND_TYPE_OFF16b_LSL1
:
500 case OPRND_TYPE_IMM_OFF18b
:
501 case OPRND_TYPE_OFF26b
:
503 int shift
= oprnd
->shift
;
504 if (value
& ((max
>> 1) + 1))
506 if (is_extern_symbol (dis_info
.info
, dis_info
.mem
))
508 else if (IS_CSKY_V1 (mach_flag
))
509 value
= dis_info
.mem
+ 2 + (value
<< shift
);
511 value
= dis_info
.mem
+ (value
<< shift
);
512 dis_info
.need_output_symbol
= 1;
513 dis_info
.value
= value
;
514 sprintf (buf
, "0x%x", (unsigned int)value
);
518 case OPRND_TYPE_CONSTANT
:
519 case OPRND_TYPE_FCONSTANT
:
521 int shift
= oprnd
->shift
;
527 dis_info
.info
->stop_vma
= 0;
530 if (IS_CSKY_V1 (mach_flag
))
531 addr
= (dis_info
.mem
+ 2 + value
) & 0xfffffffc;
533 addr
= (dis_info
.mem
+ value
) & 0xfffffffc;
535 if (oprnd
->type
== OPRND_TYPE_FCONSTANT
536 && dis_info
.opinfo
->opcode
!= CSKYV2_INST_FLRW
)
541 status
= dis_info
.info
->read_memory_func (addr
, (bfd_byte
*)ibytes
,
542 nbytes
, dis_info
.info
);
544 /* Address out of bounds. -> lrw rx, [pc, 0ffset]. */
545 sprintf (buf
, "[pc, %d]\t// from address pool at %x", (int)value
,
549 dis_info
.value
= addr
;
550 value
= csky_chars_to_number ((unsigned char *)ibytes
, 4);
553 if (oprnd
->type
== OPRND_TYPE_FCONSTANT
)
557 if (dis_info
.opinfo
->opcode
== CSKYV2_INST_FLRW
)
559 floatformat_to_double ((dis_info
.info
->endian
== BFD_ENDIAN_BIG
560 ? &floatformat_ieee_single_big
561 : &floatformat_ieee_single_little
),
564 floatformat_to_double ((dis_info
.info
->endian
== BFD_ENDIAN_BIG
565 ? &floatformat_ieee_double_big
566 : &floatformat_ieee_double_little
),
568 sprintf (buf
, "%.7g", f
);
572 dis_info
.need_output_symbol
= 1;
573 sprintf (buf
, "0x%x", (unsigned int)value
);
579 case OPRND_TYPE_ELRW_CONSTANT
:
581 int shift
= oprnd
->shift
;
585 dis_info
.info
->stop_vma
= 0;
587 value
= 0x80 + ((~value
) & 0x7f);
589 value
= value
<< shift
;
590 addr
= (dis_info
.mem
+ value
) & 0xfffffffc;
592 status
= dis_info
.info
->read_memory_func (addr
, (bfd_byte
*)ibytes
,
595 /* Address out of bounds. -> lrw rx, [pc, 0ffset]. */
596 sprintf (buf
, "[pc, %d]\t// from address pool at %x", (int) value
,
600 dis_info
.value
= addr
;
601 value
= csky_chars_to_number ((unsigned char *)ibytes
, 4);
602 dis_info
.need_output_symbol
= 1;
603 sprintf (buf
, "0x%x", (unsigned int)value
);
609 case OPRND_TYPE_SFLOAT
:
610 case OPRND_TYPE_DFLOAT
:
612 /* This is for fmovis/fmovid, which have an internal 13-bit
613 encoding that they convert to single/double precision
614 (respectively). We'll convert the 13-bit encoding to an IEEE
615 double and then to host double format to print it.
617 4-bit exponent: bits 19:16, biased by 11.
618 8-bit mantissa: split between 24:21 and 7:4. */
622 unsigned char valbytes
[8];
625 imm4
= ((inst
>> 16) & 0xf);
626 imm4
= (uint64_t)(1023 - (imm4
- 11)) << 52;
628 imm8
= (uint64_t)((inst
>> 4) & 0xf) << 44;
629 imm8
|= (uint64_t)((inst
>> 21) & 0xf) << 48;
631 dbnum
= (uint64_t)((inst
>> 20) & 1) << 63;
632 dbnum
|= imm4
| imm8
;
634 /* Do this a byte at a time so we don't have to
635 worry about the host's endianness. */
636 valbytes
[0] = dbnum
& 0xff;
637 valbytes
[1] = (dbnum
>> 8) & 0xff;
638 valbytes
[2] = (dbnum
>> 16) & 0xff;
639 valbytes
[3] = (dbnum
>> 24) & 0xff;
640 valbytes
[4] = (dbnum
>> 32) & 0xff;
641 valbytes
[5] = (dbnum
>> 40) & 0xff;
642 valbytes
[6] = (dbnum
>> 48) & 0xff;
643 valbytes
[7] = (dbnum
>> 56) & 0xff;
645 floatformat_to_double (&floatformat_ieee_double_little
, valbytes
,
648 sprintf (buf
, "%.7g", fvalue
);
652 case OPRND_TYPE_HFLOAT_FMOVI
:
653 case OPRND_TYPE_SFLOAT_FMOVI
:
657 imm4
= ((inst
>> 16) & 0xf);
658 imm4
= (138 - imm4
) << 23;
660 imm8
= ((inst
>> 8) & 0x3);
661 imm8
|= (((inst
>> 20) & 0x3f) << 2);
664 value
= ((inst
>> 5) & 1) << 31;
665 value
|= imm4
| imm8
;
667 imm4
= 138 - (imm4
>> 23);
675 memcpy (&f
, &value
, sizeof (float));
676 sprintf (buf
, "%.7g\t// imm9:%4d, imm4:%2d", f
, imm8
, imm4
);
682 case OPRND_TYPE_DFLOAT_FMOVI
:
687 imm4
= ((inst
>> 16) & 0xf);
688 imm4
= (1034 - imm4
) << 52;
690 imm8
= ((inst
>> 8) & 0x3);
691 imm8
|= (((inst
>> 20) & 0x3f) << 2);
694 dvalue
= (((uint64_t)inst
>> 5) & 1) << 63;
695 dvalue
|= imm4
| imm8
;
697 imm4
= 1034 - (imm4
>> 52);
704 memcpy (&d
, &dvalue
, sizeof (double));
705 sprintf (buf
, "%.7g\t// imm9:%4ld, imm4:%2ld", d
, (long) imm8
, (long) imm4
);
710 case OPRND_TYPE_LABEL_WITH_BRACKET
:
711 sprintf (buf
, "[0x%x]", (unsigned int)value
);
713 strcat (str
, "\t// the offset is based on .data");
715 case OPRND_TYPE_OIMM3b
:
716 case OPRND_TYPE_OIMM4b
:
717 case OPRND_TYPE_OIMM5b
:
718 case OPRND_TYPE_OIMM5b_IDLY
:
719 case OPRND_TYPE_OIMM8b
:
720 case OPRND_TYPE_OIMM12b
:
721 case OPRND_TYPE_OIMM16b
:
722 case OPRND_TYPE_OIMM18b
:
724 sprintf (buf
, "%d", (int)value
);
727 case OPRND_TYPE_OIMM5b_BMASKI
:
728 if (value
> 32 || value
< 16)
733 sprintf (buf
, "%d", (int)(value
+ 1));
737 case OPRND_TYPE_FREGLIST_DASH
:
738 if (IS_CSKY_V2 (mach_flag
))
742 if (dis_info
.isa
& CSKY_ISA_FLOAT_7E60
743 && (strstr (str
, "fstm") != NULL
744 || strstr (str
, "fldm") != NULL
))
747 vry
= vrx
+ (value
>> 5);
752 vry
= vrx
+ (value
>> 4);
754 sprintf (buf
, "fr%d-fr%d", vrx
, vry
);
758 case OPRND_TYPE_REGLIST_DASH
:
759 if (IS_CSKY_V1 (mach_flag
))
761 sprintf (buf
, "%s-r15", get_gr_name (value
));
766 if ((value
& 0x1f) + (value
>> 5) > 31)
771 strcat (str
, get_gr_name ((value
>> 5)));
773 strcat (str
, get_gr_name ((value
& 0x1f) + (value
>> 5)));
776 case OPRND_TYPE_PSR_BITS_LIST
:
778 struct psrbit
const *bits
;
779 int first_oprnd
= true;
781 if (IS_CSKY_V1 (mach_flag
))
788 bits
= cskyv1_psr_bits
;
791 bits
= cskyv2_psr_bits
;
792 while (value
!= 0 && bits
[i
].name
!= NULL
)
794 if (value
& bits
[i
].value
)
798 strcat (str
, bits
[i
].name
);
799 value
&= ~bits
[i
].value
;
806 case OPRND_TYPE_REGbsp
:
807 if (IS_CSKY_V1 (mach_flag
))
808 sprintf(buf
, "(%s)", get_gr_name (0));
810 sprintf(buf
, "(%s)", get_gr_name (14));
813 case OPRND_TYPE_REGsp
:
814 if (IS_CSKY_V1 (mach_flag
))
815 strcat (str
, get_gr_name (0));
817 strcat (str
, get_gr_name (14));
819 case OPRND_TYPE_REGnr4_r7
:
820 case OPRND_TYPE_AREG_WITH_BRACKET
:
822 strcat (str
, get_gr_name (value
));
825 case OPRND_TYPE_AREG_WITH_LSHIFT
:
826 strcat (str
, get_gr_name (value
>> 5));
827 strcat (str
, " << ");
828 if ((value
& 0x1f) == 0x1)
830 else if ((value
& 0x1f) == 0x2)
832 else if ((value
& 0x1f) == 0x4)
834 else if ((value
& 0x1f) == 0x8)
837 case OPRND_TYPE_AREG_WITH_LSHIFT_FPU
:
838 strcat (str
, get_gr_name (value
>> 2));
839 strcat (str
, " << ");
840 if ((value
& 0x3) == 0x0)
842 else if ((value
& 0x3) == 0x1)
844 else if ((value
& 0x3) == 0x2)
846 else if ((value
& 0x3) == 0x3)
849 case OPRND_TYPE_VREG_WITH_INDEX
:
851 unsigned freg_val
= value
& 0xf;
852 unsigned index_val
= (value
>> 4) & 0xf;
853 sprintf (buf
, "vr%d[%d]", freg_val
, index_val
);
857 case OPRND_TYPE_FREG_WITH_INDEX
:
859 unsigned freg_val
= value
& 0xf;
860 unsigned index_val
= (value
>> 4) & 0xf;
861 sprintf (buf
, "fr%d[%d]", freg_val
, index_val
);
865 case OPRND_TYPE_REGr4_r7
:
866 if (IS_CSKY_V1 (mach_flag
))
868 sprintf (buf
, "%s-%s", get_gr_name (4), get_gr_name (7));
872 case OPRND_TYPE_CONST1
:
875 case OPRND_TYPE_REG_r1a
:
876 case OPRND_TYPE_REG_r1b
:
877 strcat (str
, get_gr_name (1));
879 case OPRND_TYPE_REG_r28
:
880 strcat (str
, get_gr_name (28));
882 case OPRND_TYPE_REGLIST_DASH_COMMA
:
883 /* 16-bit reglist. */
886 strcat (str
, get_gr_name (4));
887 if ((value
& 0xf) > 1)
890 strcat (str
, get_gr_name ((value
& 0xf) + 3));
898 strcat (str
, get_gr_name (15));
902 if (dis_info
.opinfo
->oprnd
.oprnds
[0].mask
!= OPRND_MASK_0_4
)
904 /* 32bits reglist. */
908 strcat (str
, get_gr_name (16));
909 if ((value
& 0x7) > 1)
912 strcat (str
, get_gr_name ((value
& 0x7) + 15));
919 strcat (str
, get_gr_name (28));
922 case OPRND_TYPE_UNCOND10b
:
923 case OPRND_TYPE_UNCOND16b
:
924 case OPRND_TYPE_COND10b
:
925 case OPRND_TYPE_COND16b
:
927 int shift
= oprnd
->shift
;
929 if (value
& ((max
>> 1) + 1))
931 if (is_extern_symbol (dis_info
.info
, dis_info
.mem
))
934 value
= dis_info
.mem
+ (value
<< shift
);
935 sprintf (buf
, "0x%x", (unsigned int)value
);
937 dis_info
.need_output_symbol
= 1;
938 dis_info
.value
= value
;
950 csky_print_operand (char *str
, struct operand
const *oprnd
,
951 CSKY_INST_TYPE inst
, int reloc
)
956 if (oprnd
->mask
== HAS_SUB_OPERAND
)
958 struct soperand
*sop
= (struct soperand
*)oprnd
;
959 if (oprnd
->type
== OPRND_TYPE_BRACKET
)
964 else if (oprnd
->type
== OPRND_TYPE_ABRACKET
)
970 ret
= csky_print_operand (str
, &sop
->subs
[0], inst
, reloc
);
974 ret
= csky_print_operand (str
, &sop
->subs
[1], inst
, reloc
);
978 return csky_output_operand (str
, oprnd
, inst
, reloc
);
982 csky_print_operands (char *str
, struct csky_opcode_info
const *pinfo
,
983 struct disassemble_info
*info
, CSKY_INST_TYPE inst
,
988 if (pinfo
->operand_num
)
990 if (pinfo
->operand_num
== -1)
992 ret
= csky_print_operand (str
, &pinfo
->oprnd
.oprnds
[i
], inst
, reloc
);
997 for (; i
< pinfo
->operand_num
; i
++)
1001 ret
= csky_print_operand (str
, &pinfo
->oprnd
.oprnds
[i
], inst
, reloc
);
1005 info
->fprintf_func (info
->stream
, "%s", str
);
1006 if (dis_info
.need_output_symbol
)
1008 info
->fprintf_func (info
->stream
, "\t// ");
1009 info
->print_address_func (dis_info
.value
, dis_info
.info
);
1015 number_to_chars_littleendian (char *buf
, CSKY_INST_TYPE val
, int n
)
1021 *buf
++ = val
& 0xff;
1026 #define CSKY_READ_DATA() \
1028 status = info->read_memory_func (memaddr, buf, 2, info); \
1031 info->memory_error_func (status, memaddr, info); \
1034 if (info->endian == BFD_ENDIAN_BIG) \
1035 inst |= (buf[0] << 8) | buf[1]; \
1036 else if (info->endian == BFD_ENDIAN_LITTLE) \
1037 inst |= (buf[1] << 8) | buf[0]; \
1040 info->bytes_per_chunk += 2; \
1045 print_insn_csky (bfd_vma memaddr
, struct disassemble_info
*info
)
1047 unsigned char buf
[4];
1048 CSKY_INST_TYPE inst
= 0;
1051 unsigned long given
;
1052 int is_data
= false;
1053 void (*printer
) (bfd_vma
, struct disassemble_info
*, long);
1054 unsigned int size
= 4;
1056 memset (str
, 0, sizeof (str
));
1057 info
->bytes_per_chunk
= 0;
1058 info
->bytes_per_chunk
= 0;
1059 dis_info
.mem
= memaddr
;
1060 dis_info
.info
= info
;
1061 dis_info
.need_output_symbol
= 0;
1063 if (info
->disassembler_options
)
1065 parse_csky_dis_options (info
->disassembler_options
);
1066 info
->disassembler_options
= NULL
;
1069 if (mach_flag
!= INIT_MACH_FLAG
&& mach_flag
!= BINARY_MACH_FLAG
)
1070 info
->mach
= mach_flag
;
1071 else if (mach_flag
== INIT_MACH_FLAG
)
1073 mach_flag
= info
->mach
;
1074 dis_info
.isa
= CSKY_DEFAULT_ISA
;
1077 if (mach_flag
== BINARY_MACH_FLAG
&& info
->endian
== BFD_ENDIAN_UNKNOWN
)
1079 info
->endian
= BFD_ENDIAN_LITTLE
;
1080 dis_info
.isa
= CSKY_DEFAULT_ISA
;
1083 /* First check the full symtab for a mapping symbol, even if there
1084 are no usable non-mapping symbols for this address. */
1085 if (info
->symtab_size
!= 0
1086 && bfd_asymbol_flavour (*info
->symtab
) == bfd_target_elf_flavour
)
1091 enum sym_type type
= CUR_TEXT
;
1093 if (memaddr
<= last_map_addr
)
1095 /* Start scanning at the start of the function, or wherever
1096 we finished last time. */
1098 if (n
< last_map_sym
)
1101 /* Scan up to the location being disassembled. */
1102 for (; n
< info
->symtab_size
; n
++)
1104 addr
= bfd_asymbol_value (info
->symtab
[n
]);
1107 if ((info
->section
== NULL
1108 || info
->section
== info
->symtab
[n
]->section
)
1109 && get_sym_code_type (info
, n
, &type
))
1112 last_map_sym
= last_sym
;
1114 is_data
= (last_type
== CUR_DATA
);
1117 size
= 4 - ( memaddr
& 3);
1118 for (n
= last_sym
+ 1; n
< info
->symtab_size
; n
++)
1120 addr
= bfd_asymbol_value (info
->symtab
[n
]);
1123 if (addr
- memaddr
< size
)
1124 size
= addr
- memaddr
;
1128 /* If the next symbol is after three bytes, we need to
1129 print only part of the data, so that we can use either
1132 size
= (memaddr
& 1) ? 1 : 2;
1135 info
->bytes_per_line
= 4;
1141 /* Size was already set above. */
1142 info
->bytes_per_chunk
= size
;
1143 printer
= print_insn_data
;
1145 status
= info
->read_memory_func (memaddr
, (bfd_byte
*) buf
, size
, info
);
1147 if (info
->endian
== BFD_ENDIAN_LITTLE
)
1148 for (i
= size
- 1; i
>= 0; i
--)
1149 given
= buf
[i
] | (given
<< 8);
1151 for (i
= 0; i
< (int) size
; i
++)
1152 given
= buf
[i
] | (given
<< 8);
1154 printer (memaddr
, info
, given
);
1155 return info
->bytes_per_chunk
;
1158 /* Handle instructions. */
1160 if ((inst
& 0xc000) == 0xc000 && IS_CSKY_V2 (mach_flag
))
1162 /* It's a 32-bit instruction. */
1165 if (info
->buffer
&& (info
->endian
== BFD_ENDIAN_LITTLE
))
1167 char* src
= (char *)(info
->buffer
1168 + ((memaddr
- 4 - info
->buffer_vma
)
1169 * info
->octets_per_byte
));
1170 if (info
->endian
== BFD_ENDIAN_LITTLE
)
1171 number_to_chars_littleendian (src
, inst
, 4);
1175 if (IS_CSKY_V1 (mach_flag
))
1176 g_opcodeP
= csky_v1_opcodes
;
1178 g_opcodeP
= csky_v2_opcodes
;
1182 struct csky_opcode
const *op
;
1183 struct csky_opcode_info
const *pinfo
= NULL
;
1186 memset (str
, 0, sizeof (str
));
1187 op
= csky_find_inst_info (&pinfo
, inst
, info
->bytes_per_chunk
);
1190 if (IS_CSKY_V1 (mach_flag
))
1191 info
->fprintf_func (info
->stream
, ".short: 0x%04x",
1192 (unsigned short)inst
);
1194 info
->fprintf_func (info
->stream
, ".long: 0x%08x",
1195 (unsigned int)inst
);
1196 return info
->bytes_per_chunk
;
1199 if (info
->bytes_per_chunk
== 2)
1200 reloc
= op
->reloc16
;
1202 reloc
= op
->reloc32
;
1203 dis_info
.opinfo
= pinfo
;
1204 strcat (str
, op
->mnemonic
);
1206 if (csky_print_operands (str
, pinfo
, info
, inst
, reloc
))
1212 return info
->bytes_per_chunk
;