2 Copyright (C) 2011-2022 Free Software Foundation, Inc.
4 Contributed by Andrew Waterman (andrew@sifive.com).
7 This file is part of the GNU opcodes library.
9 This library is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 It is distributed in the hope that it will be useful, but WITHOUT
15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
17 License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING3. If not,
21 see <http://www.gnu.org/licenses/>. */
24 #include "disassemble.h"
25 #include "libiberty.h"
26 #include "opcode/riscv.h"
29 #include "elf/riscv.h"
30 #include "elfxx-riscv.h"
35 static enum riscv_spec_class default_isa_spec
= ISA_SPEC_CLASS_DRAFT
- 1;
36 static enum riscv_spec_class default_priv_spec
= PRIV_SPEC_CLASS_NONE
;
40 static riscv_subset_list_t riscv_subsets
;
41 static riscv_parse_subset_t riscv_rps_dis
=
43 &riscv_subsets
, /* subset_list. */
44 opcodes_error_handler
,/* error_handler. */
46 &default_isa_spec
, /* isa_spec. */
47 false, /* check_unknown_prefixed_ext. */
50 struct riscv_private_data
54 bfd_vma hi_addr
[OP_MASK_RD
+ 1];
59 /* Used for mapping symbols. */
60 static int last_map_symbol
= -1;
61 static bfd_vma last_stop_offset
= 0;
62 enum riscv_seg_mstate last_map_state
;
64 static const char * const *riscv_gpr_names
;
65 static const char * const *riscv_fpr_names
;
67 /* If set, disassemble as most general instruction. */
68 static int no_aliases
;
71 set_default_riscv_dis_options (void)
73 riscv_gpr_names
= riscv_gpr_names_abi
;
74 riscv_fpr_names
= riscv_fpr_names_abi
;
79 parse_riscv_dis_option_without_args (const char *option
)
81 if (strcmp (option
, "no-aliases") == 0)
83 else if (strcmp (option
, "numeric") == 0)
85 riscv_gpr_names
= riscv_gpr_names_numeric
;
86 riscv_fpr_names
= riscv_fpr_names_numeric
;
94 parse_riscv_dis_option (const char *option
)
98 if (parse_riscv_dis_option_without_args (option
))
101 equal
= strchr (option
, '=');
104 /* The option without '=' should be defined above. */
105 opcodes_error_handler (_("unrecognized disassembler option: %s"), option
);
109 || *(equal
+ 1) == '\0')
111 /* Invalid options with '=', no option name before '=',
112 and no value after '='. */
113 opcodes_error_handler (_("unrecognized disassembler option with '=': %s"),
120 if (strcmp (option
, "priv-spec") == 0)
122 enum riscv_spec_class priv_spec
= PRIV_SPEC_CLASS_NONE
;
123 const char *name
= NULL
;
125 RISCV_GET_PRIV_SPEC_CLASS (value
, priv_spec
);
126 if (priv_spec
== PRIV_SPEC_CLASS_NONE
)
127 opcodes_error_handler (_("unknown privileged spec set by %s=%s"),
129 else if (default_priv_spec
== PRIV_SPEC_CLASS_NONE
)
130 default_priv_spec
= priv_spec
;
131 else if (default_priv_spec
!= priv_spec
)
133 RISCV_GET_PRIV_SPEC_NAME (name
, default_priv_spec
);
134 opcodes_error_handler (_("mis-matched privilege spec set by %s=%s, "
135 "the elf privilege attribute is %s"),
136 option
, value
, name
);
141 /* xgettext:c-format */
142 opcodes_error_handler (_("unrecognized disassembler option: %s"), option
);
147 parse_riscv_dis_options (const char *opts_in
)
149 char *opts
= xstrdup (opts_in
), *opt
= opts
, *opt_end
= opts
;
151 set_default_riscv_dis_options ();
153 for ( ; opt_end
!= NULL
; opt
= opt_end
+ 1)
155 if ((opt_end
= strchr (opt
, ',')) != NULL
)
157 parse_riscv_dis_option (opt
);
163 /* Print one argument from an array. */
166 arg_print (struct disassemble_info
*info
, unsigned long val
,
167 const char* const* array
, size_t size
)
169 const char *s
= val
>= size
|| array
[val
] == NULL
? "unknown" : array
[val
];
170 (*info
->fprintf_styled_func
) (info
->stream
, dis_style_text
, "%s", s
);
174 maybe_print_address (struct riscv_private_data
*pd
, int base_reg
, int offset
,
177 if (pd
->hi_addr
[base_reg
] != (bfd_vma
)-1)
179 pd
->print_addr
= (base_reg
!= 0 ? pd
->hi_addr
[base_reg
] : 0) + offset
;
180 pd
->hi_addr
[base_reg
] = -1;
182 else if (base_reg
== X_GP
&& pd
->has_gp
)
183 pd
->print_addr
= pd
->gp
+ offset
;
184 else if (base_reg
== X_TP
|| base_reg
== 0)
185 pd
->print_addr
= offset
;
187 return; /* Don't print the address. */
188 pd
->to_print_addr
= true;
190 /* Sign-extend a 32-bit value to a 64-bit value. */
192 pd
->print_addr
= (bfd_vma
)(int32_t) pd
->print_addr
;
194 /* Fit into a 32-bit value on RV32. */
196 pd
->print_addr
= (bfd_vma
)(uint32_t)pd
->print_addr
;
199 /* Print insn arguments for 32/64-bit code. */
202 print_insn_args (const char *oparg
, insn_t l
, bfd_vma pc
, disassemble_info
*info
)
204 struct riscv_private_data
*pd
= info
->private_data
;
205 int rs1
= (l
>> OP_SH_RS1
) & OP_MASK_RS1
;
206 int rd
= (l
>> OP_SH_RD
) & OP_MASK_RD
;
207 fprintf_styled_ftype print
= info
->fprintf_styled_func
;
208 const char *opargStart
;
211 print (info
->stream
, dis_style_text
, "\t");
213 for (; *oparg
!= '\0'; oparg
++)
221 case 's': /* RS1 x8-x15. */
222 case 'w': /* RS1 x8-x15. */
223 print (info
->stream
, dis_style_register
, "%s",
224 riscv_gpr_names
[EXTRACT_OPERAND (CRS1S
, l
) + 8]);
226 case 't': /* RS2 x8-x15. */
227 case 'x': /* RS2 x8-x15. */
228 print (info
->stream
, dis_style_register
, "%s",
229 riscv_gpr_names
[EXTRACT_OPERAND (CRS2S
, l
) + 8]);
231 case 'U': /* RS1, constrained to equal RD. */
232 print (info
->stream
, dis_style_register
,
233 "%s", riscv_gpr_names
[rd
]);
235 case 'c': /* RS1, constrained to equal sp. */
236 print (info
->stream
, dis_style_register
, "%s",
237 riscv_gpr_names
[X_SP
]);
240 print (info
->stream
, dis_style_register
, "%s",
241 riscv_gpr_names
[EXTRACT_OPERAND (CRS2
, l
)]);
245 if (((l
& MASK_C_ADDI
) == MATCH_C_ADDI
) && rd
!= 0)
246 maybe_print_address (pd
, rd
, EXTRACT_CITYPE_IMM (l
), 0);
247 if (info
->mach
== bfd_mach_riscv64
248 && ((l
& MASK_C_ADDIW
) == MATCH_C_ADDIW
) && rd
!= 0)
249 maybe_print_address (pd
, rd
, EXTRACT_CITYPE_IMM (l
), 1);
250 print (info
->stream
, dis_style_immediate
, "%d",
251 (int)EXTRACT_CITYPE_IMM (l
));
254 print (info
->stream
, dis_style_address_offset
, "%d",
255 (int)EXTRACT_CLTYPE_LW_IMM (l
));
258 print (info
->stream
, dis_style_address_offset
, "%d",
259 (int)EXTRACT_CLTYPE_LD_IMM (l
));
262 print (info
->stream
, dis_style_address_offset
, "%d",
263 (int)EXTRACT_CITYPE_LWSP_IMM (l
));
266 print (info
->stream
, dis_style_address_offset
, "%d",
267 (int)EXTRACT_CITYPE_LDSP_IMM (l
));
270 print (info
->stream
, dis_style_immediate
, "%d",
271 (int)EXTRACT_CIWTYPE_ADDI4SPN_IMM (l
));
274 print (info
->stream
, dis_style_immediate
, "%d",
275 (int)EXTRACT_CITYPE_ADDI16SP_IMM (l
));
278 print (info
->stream
, dis_style_address_offset
, "%d",
279 (int)EXTRACT_CSSTYPE_SWSP_IMM (l
));
282 print (info
->stream
, dis_style_address_offset
, "%d",
283 (int)EXTRACT_CSSTYPE_SDSP_IMM (l
));
286 info
->target
= EXTRACT_CBTYPE_IMM (l
) + pc
;
287 (*info
->print_address_func
) (info
->target
, info
);
290 info
->target
= EXTRACT_CJTYPE_IMM (l
) + pc
;
291 (*info
->print_address_func
) (info
->target
, info
);
294 print (info
->stream
, dis_style_immediate
, "0x%x",
295 (int)(EXTRACT_CITYPE_IMM (l
) & (RISCV_BIGIMM_REACH
-1)));
298 print (info
->stream
, dis_style_immediate
, "0x%x",
299 (int)EXTRACT_CITYPE_IMM (l
) & 0x3f);
302 print (info
->stream
, dis_style_immediate
, "0x%x",
303 (int)EXTRACT_CITYPE_IMM (l
) & 0x1f);
305 case 'T': /* Floating-point RS2. */
306 print (info
->stream
, dis_style_register
, "%s",
307 riscv_fpr_names
[EXTRACT_OPERAND (CRS2
, l
)]);
309 case 'D': /* Floating-point RS2 x8-x15. */
310 print (info
->stream
, dis_style_register
, "%s",
311 riscv_fpr_names
[EXTRACT_OPERAND (CRS2S
, l
) + 8]);
321 print (info
->stream
, dis_style_register
, "%s",
322 riscv_vecr_names_numeric
[EXTRACT_OPERAND (VD
, l
)]);
325 if (!EXTRACT_OPERAND (VWD
, l
))
326 print (info
->stream
, dis_style_register
, "%s",
329 print (info
->stream
, dis_style_register
, "%s",
330 riscv_vecr_names_numeric
[EXTRACT_OPERAND (VD
, l
)]);
333 print (info
->stream
, dis_style_register
, "%s",
334 riscv_vecr_names_numeric
[EXTRACT_OPERAND (VS1
, l
)]);
337 case 'u': /* VS1 == VS2 already verified at this point. */
338 case 'v': /* VD == VS1 == VS2 already verified at this point. */
339 print (info
->stream
, dis_style_register
, "%s",
340 riscv_vecr_names_numeric
[EXTRACT_OPERAND (VS2
, l
)]);
343 print (info
->stream
, dis_style_register
, "%s",
344 riscv_vecr_names_numeric
[0]);
349 int imm
= (*oparg
== 'b') ? EXTRACT_RVV_VB_IMM (l
)
350 : EXTRACT_RVV_VC_IMM (l
);
351 unsigned int imm_vlmul
= EXTRACT_OPERAND (VLMUL
, imm
);
352 unsigned int imm_vsew
= EXTRACT_OPERAND (VSEW
, imm
);
353 unsigned int imm_vta
= EXTRACT_OPERAND (VTA
, imm
);
354 unsigned int imm_vma
= EXTRACT_OPERAND (VMA
, imm
);
355 unsigned int imm_vtype_res
= (imm
>> 8);
357 if (imm_vsew
< ARRAY_SIZE (riscv_vsew
)
358 && imm_vlmul
< ARRAY_SIZE (riscv_vlmul
)
359 && imm_vta
< ARRAY_SIZE (riscv_vta
)
360 && imm_vma
< ARRAY_SIZE (riscv_vma
)
362 && riscv_vsew
[imm_vsew
] != NULL
363 && riscv_vlmul
[imm_vlmul
] != NULL
)
364 print (info
->stream
, dis_style_text
, "%s,%s,%s,%s",
365 riscv_vsew
[imm_vsew
],
366 riscv_vlmul
[imm_vlmul
], riscv_vta
[imm_vta
],
369 print (info
->stream
, dis_style_immediate
, "%d", imm
);
373 print (info
->stream
, dis_style_immediate
, "%d",
374 (int)EXTRACT_RVV_VI_IMM (l
));
377 print (info
->stream
, dis_style_immediate
, "%d",
378 (int)EXTRACT_RVV_VI_UIMM (l
));
381 print (info
->stream
, dis_style_immediate
, "%d",
382 (int)EXTRACT_RVV_OFFSET (l
));
385 if (! EXTRACT_OPERAND (VMASK
, l
))
386 print (info
->stream
, dis_style_register
, ",%s",
387 riscv_vecm_names_numeric
[0]);
397 print (info
->stream
, dis_style_text
, "%c", *oparg
);
401 /* Only print constant 0 if it is the last argument. */
403 print (info
->stream
, dis_style_immediate
, "0");
407 if ((l
& MASK_JALR
) == MATCH_JALR
)
408 maybe_print_address (pd
, rs1
, EXTRACT_ITYPE_IMM (l
), 0);
409 print (info
->stream
, dis_style_register
, "%s", riscv_gpr_names
[rs1
]);
413 print (info
->stream
, dis_style_register
, "%s",
414 riscv_gpr_names
[EXTRACT_OPERAND (RS2
, l
)]);
418 print (info
->stream
, dis_style_immediate
, "0x%x",
419 (unsigned)EXTRACT_UTYPE_IMM (l
) >> RISCV_IMM_BITS
);
423 arg_print (info
, EXTRACT_OPERAND (RM
, l
),
424 riscv_rm
, ARRAY_SIZE (riscv_rm
));
428 arg_print (info
, EXTRACT_OPERAND (PRED
, l
),
429 riscv_pred_succ
, ARRAY_SIZE (riscv_pred_succ
));
433 arg_print (info
, EXTRACT_OPERAND (SUCC
, l
),
434 riscv_pred_succ
, ARRAY_SIZE (riscv_pred_succ
));
438 maybe_print_address (pd
, rs1
, EXTRACT_ITYPE_IMM (l
), 0);
441 if (((l
& MASK_ADDI
) == MATCH_ADDI
&& rs1
!= 0)
442 || (l
& MASK_JALR
) == MATCH_JALR
)
443 maybe_print_address (pd
, rs1
, EXTRACT_ITYPE_IMM (l
), 0);
444 if (info
->mach
== bfd_mach_riscv64
445 && ((l
& MASK_ADDIW
) == MATCH_ADDIW
) && rs1
!= 0)
446 maybe_print_address (pd
, rs1
, EXTRACT_ITYPE_IMM (l
), 1);
447 print (info
->stream
, dis_style_immediate
, "%d",
448 (int)EXTRACT_ITYPE_IMM (l
));
452 maybe_print_address (pd
, rs1
, EXTRACT_STYPE_IMM (l
), 0);
453 print (info
->stream
, dis_style_address_offset
, "%d",
454 (int)EXTRACT_STYPE_IMM (l
));
458 print (info
->stream
, dis_style_address_offset
, "%d",
459 (int)EXTRACT_STYPE_IMM (l
));
463 info
->target
= EXTRACT_JTYPE_IMM (l
) + pc
;
464 (*info
->print_address_func
) (info
->target
, info
);
468 info
->target
= EXTRACT_BTYPE_IMM (l
) + pc
;
469 (*info
->print_address_func
) (info
->target
, info
);
473 if ((l
& MASK_AUIPC
) == MATCH_AUIPC
)
474 pd
->hi_addr
[rd
] = pc
+ EXTRACT_UTYPE_IMM (l
);
475 else if ((l
& MASK_LUI
) == MATCH_LUI
)
476 pd
->hi_addr
[rd
] = EXTRACT_UTYPE_IMM (l
);
477 else if ((l
& MASK_C_LUI
) == MATCH_C_LUI
)
478 pd
->hi_addr
[rd
] = EXTRACT_CITYPE_LUI_IMM (l
);
479 print (info
->stream
, dis_style_register
, "%s", riscv_gpr_names
[rd
]);
483 print (info
->stream
, dis_style_text
, "0x%x",
484 (int)EXTRACT_OPERAND (BS
, l
));
488 print (info
->stream
, dis_style_register
, "%s", riscv_gpr_names
[0]);
492 print (info
->stream
, dis_style_immediate
, "0x%x",
493 (int)EXTRACT_OPERAND (SHAMT
, l
));
497 print (info
->stream
, dis_style_immediate
, "0x%x",
498 (int)EXTRACT_OPERAND (SHAMTW
, l
));
503 print (info
->stream
, dis_style_register
, "%s", riscv_fpr_names
[rs1
]);
507 print (info
->stream
, dis_style_register
, "%s",
508 riscv_fpr_names
[EXTRACT_OPERAND (RS2
, l
)]);
512 print (info
->stream
, dis_style_register
, "%s", riscv_fpr_names
[rd
]);
516 print (info
->stream
, dis_style_register
, "%s",
517 riscv_fpr_names
[EXTRACT_OPERAND (RS3
, l
)]);
522 static const char *riscv_csr_hash
[4096]; /* Total 2^12 CSRs. */
523 static bool init_csr
= false;
524 unsigned int csr
= EXTRACT_OPERAND (CSR
, l
);
529 for (i
= 0; i
< 4096; i
++)
530 riscv_csr_hash
[i
] = NULL
;
532 /* Set to the newest privileged version. */
533 if (default_priv_spec
== PRIV_SPEC_CLASS_NONE
)
534 default_priv_spec
= PRIV_SPEC_CLASS_DRAFT
- 1;
536 #define DECLARE_CSR(name, num, class, define_version, abort_version) \
537 if (riscv_csr_hash[num] == NULL \
538 && ((define_version == PRIV_SPEC_CLASS_NONE \
539 && abort_version == PRIV_SPEC_CLASS_NONE) \
540 || (default_priv_spec >= define_version \
541 && default_priv_spec < abort_version))) \
542 riscv_csr_hash[num] = #name;
543 #define DECLARE_CSR_ALIAS(name, num, class, define_version, abort_version) \
544 DECLARE_CSR (name, num, class, define_version, abort_version)
545 #include "opcode/riscv-opc.h"
549 if (riscv_csr_hash
[csr
] != NULL
)
550 print (info
->stream
, dis_style_text
, "%s", riscv_csr_hash
[csr
]);
552 print (info
->stream
, dis_style_text
, "0x%x", csr
);
557 print (info
->stream
, dis_style_text
, "0x%x",
558 (int) EXTRACT_OPERAND (RNUM
, l
));
562 print (info
->stream
, dis_style_text
, "%d", rs1
);
565 case 'X': /* Integer immediate. */
573 case 'l': /* Literal. */
575 while (*oparg
&& *oparg
!= ',')
577 print (info
->stream
, dis_style_text
, "%c", *oparg
);
582 case 's': /* 'XsN@S' ... N-bit signed immediate at bit S. */
585 case 'u': /* 'XuN@S' ... N-bit unsigned immediate at bit S. */
589 n
= strtol (oparg
+ 1, (char **)&oparg
, 10);
591 goto undefined_modifier
;
592 s
= strtol (oparg
+ 1, (char **)&oparg
, 10);
596 print (info
->stream
, dis_style_immediate
, "%u",
597 (unsigned)EXTRACT_U_IMM (n
, s
, l
));
599 print (info
->stream
, dis_style_immediate
, "%i",
600 (unsigned)EXTRACT_S_IMM (n
, s
, l
));
603 goto undefined_modifier
;
609 /* xgettext:c-format */
610 print (info
->stream
, dis_style_text
,
611 _("# internal error, undefined modifier (%c)"),
618 /* Print the RISC-V instruction at address MEMADDR in debugged memory,
619 on using INFO. Returns length of the instruction, in bytes.
620 BIGENDIAN must be 1 if this is big-endian code, 0 if
621 this is little-endian code. */
624 riscv_disassemble_insn (bfd_vma memaddr
, insn_t word
, disassemble_info
*info
)
626 const struct riscv_opcode
*op
;
627 static bool init
= 0;
628 static const struct riscv_opcode
*riscv_hash
[OP_MASK_OP
+ 1];
629 struct riscv_private_data
*pd
;
632 #define OP_HASH_IDX(i) ((i) & (riscv_insn_length (i) == 2 ? 0x3 : OP_MASK_OP))
634 /* Build a hash table to shorten the search time. */
637 for (op
= riscv_opcodes
; op
->name
; op
++)
638 if (!riscv_hash
[OP_HASH_IDX (op
->match
)])
639 riscv_hash
[OP_HASH_IDX (op
->match
)] = op
;
644 if (info
->private_data
== NULL
)
648 pd
= info
->private_data
= xcalloc (1, sizeof (struct riscv_private_data
));
651 for (i
= 0; i
< (int)ARRAY_SIZE (pd
->hi_addr
); i
++)
653 pd
->to_print_addr
= false;
656 for (i
= 0; i
< info
->symtab_size
; i
++)
657 if (strcmp (bfd_asymbol_name (info
->symtab
[i
]), RISCV_GP_SYMBOL
) == 0)
659 pd
->gp
= bfd_asymbol_value (info
->symtab
[i
]);
664 pd
= info
->private_data
;
666 insnlen
= riscv_insn_length (word
);
668 /* RISC-V instructions are always little-endian. */
669 info
->endian_code
= BFD_ENDIAN_LITTLE
;
671 info
->bytes_per_chunk
= insnlen
% 4 == 0 ? 4 : 2;
672 info
->bytes_per_line
= 8;
673 /* We don't support constant pools, so this must be code. */
674 info
->display_endian
= info
->endian_code
;
675 info
->insn_info_valid
= 1;
676 info
->branch_delay_insns
= 0;
678 info
->insn_type
= dis_nonbranch
;
682 op
= riscv_hash
[OP_HASH_IDX (word
)];
685 /* If XLEN is not known, get its value from the ELF class. */
686 if (info
->mach
== bfd_mach_riscv64
)
688 else if (info
->mach
== bfd_mach_riscv32
)
690 else if (info
->section
!= NULL
)
692 Elf_Internal_Ehdr
*ehdr
= elf_elfheader (info
->section
->owner
);
693 xlen
= ehdr
->e_ident
[EI_CLASS
] == ELFCLASS64
? 64 : 32;
696 /* If arch has ZFINX flags, use gpr for disassemble. */
697 if(riscv_subset_supports (&riscv_rps_dis
, "zfinx"))
698 riscv_fpr_names
= riscv_gpr_names
;
700 for (; op
->name
; op
++)
702 /* Does the opcode match? */
703 if (! (op
->match_func
) (op
, word
))
705 /* Is this a pseudo-instruction and may we print it as such? */
706 if (no_aliases
&& (op
->pinfo
& INSN_ALIAS
))
708 /* Is this instruction restricted to a certain value of XLEN? */
709 if ((op
->xlen_requirement
!= 0) && (op
->xlen_requirement
!= xlen
))
712 if (!riscv_multi_subset_supports (&riscv_rps_dis
, op
->insn_class
))
716 (*info
->fprintf_styled_func
) (info
->stream
, dis_style_mnemonic
,
718 print_insn_args (op
->args
, word
, memaddr
, info
);
720 /* Try to disassemble multi-instruction addressing sequences. */
721 if (pd
->to_print_addr
)
723 info
->target
= pd
->print_addr
;
724 (*info
->fprintf_styled_func
)
725 (info
->stream
, dis_style_comment_start
, " # ");
726 (*info
->print_address_func
) (info
->target
, info
);
727 pd
->to_print_addr
= false;
730 /* Finish filling out insn_info fields. */
731 switch (op
->pinfo
& INSN_TYPE
)
734 info
->insn_type
= dis_branch
;
736 case INSN_CONDBRANCH
:
737 info
->insn_type
= dis_condbranch
;
740 info
->insn_type
= dis_jsr
;
743 info
->insn_type
= dis_dref
;
749 if (op
->pinfo
& INSN_DATA_SIZE
)
751 int size
= ((op
->pinfo
& INSN_DATA_SIZE
)
752 >> INSN_DATA_SIZE_SHIFT
);
753 info
->data_size
= 1 << (size
- 1);
760 /* We did not find a match, so just print the instruction bits. */
761 info
->insn_type
= dis_noninsn
;
767 (*info
->fprintf_styled_func
)
768 (info
->stream
, dis_style_assembler_directive
, ".%dbyte\t", insnlen
);
769 (*info
->fprintf_styled_func
) (info
->stream
, dis_style_immediate
,
770 "0x%llx", (unsigned long long) word
);
775 (*info
->fprintf_styled_func
)
776 (info
->stream
, dis_style_assembler_directive
, ".byte\t");
777 for (i
= 0; i
< insnlen
; ++i
)
780 (*info
->fprintf_styled_func
) (info
->stream
, dis_style_text
,
782 (*info
->fprintf_styled_func
) (info
->stream
, dis_style_immediate
,
784 (unsigned int) (word
& 0xff));
793 /* Return true if we find the suitable mapping symbol,
794 and also update the STATE. Otherwise, return false. */
797 riscv_get_map_state (int n
,
798 enum riscv_seg_mstate
*state
,
799 struct disassemble_info
*info
)
803 /* If the symbol is in a different section, ignore it. */
804 if (info
->section
!= NULL
805 && info
->section
!= info
->symtab
[n
]->section
)
808 name
= bfd_asymbol_name(info
->symtab
[n
]);
809 if (strcmp (name
, "$x") == 0)
811 else if (strcmp (name
, "$d") == 0)
819 /* Check the sorted symbol table (sorted by the symbol value), find the
820 suitable mapping symbols. */
822 static enum riscv_seg_mstate
823 riscv_search_mapping_symbol (bfd_vma memaddr
,
824 struct disassemble_info
*info
)
826 enum riscv_seg_mstate mstate
;
827 bool from_last_map_symbol
;
832 /* Decide whether to print the data or instruction by default, in case
833 we can not find the corresponding mapping symbols. */
836 && info
->section
->flags
& SEC_CODE
)
840 if (info
->symtab_size
== 0
841 || bfd_asymbol_flavour (*info
->symtab
) != bfd_target_elf_flavour
)
844 /* Reset the last_map_symbol if we start to dump a new section. */
846 last_map_symbol
= -1;
848 /* If the last stop offset is different from the current one, then
849 don't use the last_map_symbol to search. We usually reset the
850 info->stop_offset when handling a new section. */
851 from_last_map_symbol
= (last_map_symbol
>= 0
852 && info
->stop_offset
== last_stop_offset
);
854 /* Start scanning at the start of the function, or wherever
855 we finished last time. */
856 n
= info
->symtab_pos
+ 1;
857 if (from_last_map_symbol
&& n
>= last_map_symbol
)
860 /* Find the suitable mapping symbol to dump. */
861 for (; n
< info
->symtab_size
; n
++)
863 bfd_vma addr
= bfd_asymbol_value (info
->symtab
[n
]);
864 /* We have searched all possible symbols in the range. */
867 if (riscv_get_map_state (n
, &mstate
, info
))
871 /* Do not stop searching, in case there are some mapping
872 symbols have the same value, but have different names.
877 /* We can not find the suitable mapping symbol above. Therefore, we
878 look forwards and try to find it again, but don't go pass the start
879 of the section. Otherwise a data section without mapping symbols
880 can pick up a text mapping symbol of a preceeding section. */
883 n
= info
->symtab_pos
;
884 if (from_last_map_symbol
&& n
>= last_map_symbol
)
889 bfd_vma addr
= bfd_asymbol_value (info
->symtab
[n
]);
890 /* We have searched all possible symbols in the range. */
891 if (addr
< (info
->section
? info
->section
->vma
: 0))
893 /* Stop searching once we find the closed mapping symbol. */
894 if (riscv_get_map_state (n
, &mstate
, info
))
903 /* Save the information for next use. */
904 last_map_symbol
= symbol
;
905 last_stop_offset
= info
->stop_offset
;
910 /* Decide which data size we should print. */
913 riscv_data_length (bfd_vma memaddr
,
914 disassemble_info
*info
)
920 if (info
->symtab_size
!= 0
921 && bfd_asymbol_flavour (*info
->symtab
) == bfd_target_elf_flavour
922 && last_map_symbol
>= 0)
925 enum riscv_seg_mstate m
= MAP_NONE
;
926 for (n
= last_map_symbol
+ 1; n
< info
->symtab_size
; n
++)
928 bfd_vma addr
= bfd_asymbol_value (info
->symtab
[n
]);
930 && riscv_get_map_state (n
, &m
, info
))
932 if (addr
- memaddr
< length
)
933 length
= addr
- memaddr
;
941 /* Do not set the length which exceeds the section size. */
942 bfd_vma offset
= info
->section
->vma
+ info
->section
->size
;
944 length
= (offset
< length
) ? offset
: length
;
946 length
= length
== 3 ? 2 : length
;
950 /* Dump the data contents. */
953 riscv_disassemble_data (bfd_vma memaddr ATTRIBUTE_UNUSED
,
955 disassemble_info
*info
)
957 info
->display_endian
= info
->endian
;
959 switch (info
->bytes_per_chunk
)
962 info
->bytes_per_line
= 6;
963 (*info
->fprintf_styled_func
)
964 (info
->stream
, dis_style_assembler_directive
, ".byte\t");
965 (*info
->fprintf_styled_func
)
966 (info
->stream
, dis_style_assembler_directive
, "0x%02llx",
967 (unsigned long long) data
);
970 info
->bytes_per_line
= 8;
971 (*info
->fprintf_styled_func
)
972 (info
->stream
, dis_style_assembler_directive
, ".short\t");
973 (*info
->fprintf_styled_func
)
974 (info
->stream
, dis_style_immediate
, "0x%04llx",
975 (unsigned long long) data
);
978 info
->bytes_per_line
= 8;
979 (*info
->fprintf_styled_func
)
980 (info
->stream
, dis_style_assembler_directive
, ".word\t");
981 (*info
->fprintf_styled_func
)
982 (info
->stream
, dis_style_immediate
, "0x%08llx",
983 (unsigned long long) data
);
986 info
->bytes_per_line
= 8;
987 (*info
->fprintf_styled_func
)
988 (info
->stream
, dis_style_assembler_directive
, ".dword\t");
989 (*info
->fprintf_styled_func
)
990 (info
->stream
, dis_style_immediate
, "0x%016llx",
991 (unsigned long long) data
);
996 return info
->bytes_per_chunk
;
1000 print_insn_riscv (bfd_vma memaddr
, struct disassemble_info
*info
)
1006 enum riscv_seg_mstate mstate
;
1007 int (*riscv_disassembler
) (bfd_vma
, insn_t
, struct disassemble_info
*);
1009 if (info
->disassembler_options
!= NULL
)
1011 parse_riscv_dis_options (info
->disassembler_options
);
1012 /* Avoid repeatedly parsing the options. */
1013 info
->disassembler_options
= NULL
;
1015 else if (riscv_gpr_names
== NULL
)
1016 set_default_riscv_dis_options ();
1018 mstate
= riscv_search_mapping_symbol (memaddr
, info
);
1019 /* Save the last mapping state. */
1020 last_map_state
= mstate
;
1022 /* Set the size to dump. */
1023 if (mstate
== MAP_DATA
1024 && (info
->flags
& DISASSEMBLE_DATA
) == 0)
1026 dump_size
= riscv_data_length (memaddr
, info
);
1027 info
->bytes_per_chunk
= dump_size
;
1028 riscv_disassembler
= riscv_disassemble_data
;
1032 /* Get the first 2-bytes to check the lenghth of instruction. */
1033 status
= (*info
->read_memory_func
) (memaddr
, packet
, 2, info
);
1036 (*info
->memory_error_func
) (status
, memaddr
, info
);
1039 insn
= (insn_t
) bfd_getl16 (packet
);
1040 dump_size
= riscv_insn_length (insn
);
1041 riscv_disassembler
= riscv_disassemble_insn
;
1044 /* Fetch the instruction to dump. */
1045 status
= (*info
->read_memory_func
) (memaddr
, packet
, dump_size
, info
);
1048 (*info
->memory_error_func
) (status
, memaddr
, info
);
1051 insn
= (insn_t
) bfd_get_bits (packet
, dump_size
* 8, false);
1053 return (*riscv_disassembler
) (memaddr
, insn
, info
);
1057 riscv_get_disassembler (bfd
*abfd
)
1059 const char *default_arch
= "rv64gc";
1061 if (abfd
&& bfd_get_flavour (abfd
) == bfd_target_elf_flavour
)
1063 const char *sec_name
= get_elf_backend_data (abfd
)->obj_attrs_section
;
1064 if (bfd_get_section_by_name (abfd
, sec_name
) != NULL
)
1066 obj_attribute
*attr
= elf_known_obj_attributes_proc (abfd
);
1067 unsigned int Tag_a
= Tag_RISCV_priv_spec
;
1068 unsigned int Tag_b
= Tag_RISCV_priv_spec_minor
;
1069 unsigned int Tag_c
= Tag_RISCV_priv_spec_revision
;
1070 riscv_get_priv_spec_class_from_numbers (attr
[Tag_a
].i
,
1073 &default_priv_spec
);
1074 default_arch
= attr
[Tag_RISCV_arch
].s
;
1078 riscv_release_subset_list (&riscv_subsets
);
1079 riscv_parse_subset (&riscv_rps_dis
, default_arch
);
1080 return print_insn_riscv
;
1083 /* Prevent use of the fake labels that are generated as part of the DWARF
1084 and for relaxable relocations in the assembler. */
1087 riscv_symbol_is_valid (asymbol
* sym
,
1088 struct disassemble_info
* info ATTRIBUTE_UNUSED
)
1095 name
= bfd_asymbol_name (sym
);
1097 return (strcmp (name
, RISCV_FAKE_LABEL_NAME
) != 0
1098 && !riscv_elf_is_mapping_symbols (name
));
1102 /* Indices into option argument vector for options accepting an argument.
1103 Use RISCV_OPTION_ARG_NONE for options accepting no argument. */
1107 RISCV_OPTION_ARG_NONE
= -1,
1108 RISCV_OPTION_ARG_PRIV_SPEC
,
1110 RISCV_OPTION_ARG_COUNT
1111 } riscv_option_arg_t
;
1113 /* Valid RISCV disassembler options. */
1118 const char *description
;
1119 riscv_option_arg_t arg
;
1123 N_("Print numeric register names, rather than ABI names."),
1124 RISCV_OPTION_ARG_NONE
},
1126 N_("Disassemble only into canonical instructions."),
1127 RISCV_OPTION_ARG_NONE
},
1129 N_("Print the CSR according to the chosen privilege spec."),
1130 RISCV_OPTION_ARG_PRIV_SPEC
}
1133 /* Build the structure representing valid RISCV disassembler options.
1134 This is done dynamically for maintenance ease purpose; a static
1135 initializer would be unreadable. */
1137 const disasm_options_and_args_t
*
1138 disassembler_options_riscv (void)
1140 static disasm_options_and_args_t
*opts_and_args
;
1142 if (opts_and_args
== NULL
)
1144 size_t num_options
= ARRAY_SIZE (riscv_options
);
1145 size_t num_args
= RISCV_OPTION_ARG_COUNT
;
1146 disasm_option_arg_t
*args
;
1147 disasm_options_t
*opts
;
1148 size_t i
, priv_spec_count
;
1150 args
= XNEWVEC (disasm_option_arg_t
, num_args
+ 1);
1152 args
[RISCV_OPTION_ARG_PRIV_SPEC
].name
= "SPEC";
1153 priv_spec_count
= PRIV_SPEC_CLASS_DRAFT
- PRIV_SPEC_CLASS_NONE
- 1;
1154 args
[RISCV_OPTION_ARG_PRIV_SPEC
].values
1155 = XNEWVEC (const char *, priv_spec_count
+ 1);
1156 for (i
= 0; i
< priv_spec_count
; i
++)
1157 args
[RISCV_OPTION_ARG_PRIV_SPEC
].values
[i
]
1158 = riscv_priv_specs
[i
].name
;
1159 /* The array we return must be NULL terminated. */
1160 args
[RISCV_OPTION_ARG_PRIV_SPEC
].values
[i
] = NULL
;
1162 /* The array we return must be NULL terminated. */
1163 args
[num_args
].name
= NULL
;
1164 args
[num_args
].values
= NULL
;
1166 opts_and_args
= XNEW (disasm_options_and_args_t
);
1167 opts_and_args
->args
= args
;
1169 opts
= &opts_and_args
->options
;
1170 opts
->name
= XNEWVEC (const char *, num_options
+ 1);
1171 opts
->description
= XNEWVEC (const char *, num_options
+ 1);
1172 opts
->arg
= XNEWVEC (const disasm_option_arg_t
*, num_options
+ 1);
1173 for (i
= 0; i
< num_options
; i
++)
1175 opts
->name
[i
] = riscv_options
[i
].name
;
1176 opts
->description
[i
] = _(riscv_options
[i
].description
);
1177 if (riscv_options
[i
].arg
!= RISCV_OPTION_ARG_NONE
)
1178 opts
->arg
[i
] = &args
[riscv_options
[i
].arg
];
1180 opts
->arg
[i
] = NULL
;
1182 /* The array we return must be NULL terminated. */
1183 opts
->name
[i
] = NULL
;
1184 opts
->description
[i
] = NULL
;
1185 opts
->arg
[i
] = NULL
;
1188 return opts_and_args
;
1192 print_riscv_disassembler_options (FILE *stream
)
1194 const disasm_options_and_args_t
*opts_and_args
;
1195 const disasm_option_arg_t
*args
;
1196 const disasm_options_t
*opts
;
1201 opts_and_args
= disassembler_options_riscv ();
1202 opts
= &opts_and_args
->options
;
1203 args
= opts_and_args
->args
;
1205 fprintf (stream
, _("\n\
1206 The following RISC-V specific disassembler options are supported for use\n\
1207 with the -M switch (multiple options should be separated by commas):\n"));
1208 fprintf (stream
, "\n");
1210 /* Compute the length of the longest option name. */
1211 for (i
= 0; opts
->name
[i
] != NULL
; i
++)
1213 size_t len
= strlen (opts
->name
[i
]);
1215 if (opts
->arg
[i
] != NULL
)
1216 len
+= strlen (opts
->arg
[i
]->name
);
1221 for (i
= 0, max_len
++; opts
->name
[i
] != NULL
; i
++)
1223 fprintf (stream
, " %s", opts
->name
[i
]);
1224 if (opts
->arg
[i
] != NULL
)
1225 fprintf (stream
, "%s", opts
->arg
[i
]->name
);
1226 if (opts
->description
[i
] != NULL
)
1228 size_t len
= strlen (opts
->name
[i
]);
1230 if (opts
->arg
!= NULL
&& opts
->arg
[i
] != NULL
)
1231 len
+= strlen (opts
->arg
[i
]->name
);
1232 fprintf (stream
, "%*c %s", (int) (max_len
- len
), ' ',
1233 opts
->description
[i
]);
1235 fprintf (stream
, "\n");
1238 for (i
= 0; args
[i
].name
!= NULL
; i
++)
1240 if (args
[i
].values
== NULL
)
1242 fprintf (stream
, _("\n\
1243 For the options above, the following values are supported for \"%s\":\n "),
1245 for (j
= 0; args
[i
].values
[j
] != NULL
; j
++)
1246 fprintf (stream
, " %s", args
[i
].values
[j
]);
1247 fprintf (stream
, _("\n"));
1250 fprintf (stream
, _("\n"));