1 /* Disassemble support for GDB.
3 Copyright (C) 2000-2021 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program 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 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
30 #include "safe-ctype.h"
32 #include "gdbsupport/gdb_optional.h"
34 #include "cli/cli-style.h"
36 /* Disassemble functions.
37 FIXME: We should get rid of all the duplicate code in gdb that does
38 the same thing: disassemble_command() and the gdbtk variation. */
40 /* This variable is used to hold the prospective disassembler_options value
41 which is set by the "set disassembler_options" command. */
42 static std::string prospective_options
;
44 /* This structure is used to store line number information for the
46 We need a different sort of line table from the normal one cuz we can't
47 depend upon implicit line-end pc's for lines to do the
48 reordering in this function. */
50 struct deprecated_dis_line_entry
57 /* This Structure is used to store line number information.
58 We need a different sort of line table from the normal one cuz we can't
59 depend upon implicit line-end pc's for lines to do the
60 reordering in this function. */
64 struct symtab
*symtab
;
68 /* Hash function for dis_line_entry. */
71 hash_dis_line_entry (const void *item
)
73 const struct dis_line_entry
*dle
= (const struct dis_line_entry
*) item
;
75 return htab_hash_pointer (dle
->symtab
) + dle
->line
;
78 /* Equal function for dis_line_entry. */
81 eq_dis_line_entry (const void *item_lhs
, const void *item_rhs
)
83 const struct dis_line_entry
*lhs
= (const struct dis_line_entry
*) item_lhs
;
84 const struct dis_line_entry
*rhs
= (const struct dis_line_entry
*) item_rhs
;
86 return (lhs
->symtab
== rhs
->symtab
87 && lhs
->line
== rhs
->line
);
90 /* Create the table to manage lines for mixed source/disassembly. */
93 allocate_dis_line_table (void)
95 return htab_create_alloc (41,
96 hash_dis_line_entry
, eq_dis_line_entry
,
97 xfree
, xcalloc
, xfree
);
100 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE. */
103 add_dis_line_entry (htab_t table
, struct symtab
*symtab
, int line
)
106 struct dis_line_entry dle
, *dlep
;
110 slot
= htab_find_slot (table
, &dle
, INSERT
);
113 dlep
= XNEW (struct dis_line_entry
);
114 dlep
->symtab
= symtab
;
120 /* Return non-zero if SYMTAB, LINE are in TABLE. */
123 line_has_code_p (htab_t table
, struct symtab
*symtab
, int line
)
125 struct dis_line_entry dle
;
129 return htab_find (table
, &dle
) != NULL
;
132 /* Wrapper of target_read_code. */
135 gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr
, gdb_byte
*myaddr
,
137 struct disassemble_info
*info
)
139 return target_read_code (memaddr
, myaddr
, len
);
142 /* Wrapper of memory_error. */
145 gdb_disassembler::dis_asm_memory_error (int err
, bfd_vma memaddr
,
146 struct disassemble_info
*info
)
148 gdb_disassembler
*self
149 = static_cast<gdb_disassembler
*>(info
->application_data
);
151 self
->m_err_memaddr
.emplace (memaddr
);
154 /* Wrapper of print_address. */
157 gdb_disassembler::dis_asm_print_address (bfd_vma addr
,
158 struct disassemble_info
*info
)
160 gdb_disassembler
*self
161 = static_cast<gdb_disassembler
*>(info
->application_data
);
163 print_address (self
->arch (), addr
, self
->stream ());
166 /* Format disassembler output to STREAM. */
169 gdb_disassembler::dis_asm_fprintf (void *stream
, const char *format
, ...)
173 va_start (args
, format
);
174 vfprintf_filtered ((struct ui_file
*) stream
, format
, args
);
176 /* Something non -ve. */
181 line_is_less_than (const deprecated_dis_line_entry
&mle1
,
182 const deprecated_dis_line_entry
&mle2
)
186 /* End of sequence markers have a line number of 0 but don't want to
187 be sorted to the head of the list, instead sort by PC. */
188 if (mle1
.line
== 0 || mle2
.line
== 0)
190 if (mle1
.start_pc
!= mle2
.start_pc
)
191 val
= mle1
.start_pc
< mle2
.start_pc
;
193 val
= mle1
.line
< mle2
.line
;
197 if (mle1
.line
!= mle2
.line
)
198 val
= mle1
.line
< mle2
.line
;
200 val
= mle1
.start_pc
< mle2
.start_pc
;
208 gdb_pretty_print_disassembler::pretty_print_insn (const struct disasm_insn
*insn
,
209 gdb_disassembly_flags flags
)
211 /* parts of the symbolic representation of the address */
217 struct gdbarch
*gdbarch
= arch ();
220 ui_out_emit_tuple
tuple_emitter (m_uiout
, NULL
);
223 if (insn
->number
!= 0)
225 m_uiout
->field_unsigned ("insn-number", insn
->number
);
226 m_uiout
->text ("\t");
229 if ((flags
& DISASSEMBLY_SPECULATIVE
) != 0)
231 if (insn
->is_speculative
)
233 m_uiout
->field_string ("is-speculative", "?");
235 /* The speculative execution indication overwrites the first
236 character of the PC prefix.
237 We assume a PC prefix length of 3 characters. */
238 if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
239 m_uiout
->text (pc_prefix (pc
) + 1);
243 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
244 m_uiout
->text (pc_prefix (pc
));
248 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
249 m_uiout
->text (pc_prefix (pc
));
250 m_uiout
->field_core_addr ("address", gdbarch
, pc
);
252 std::string name
, filename
;
253 bool omit_fname
= ((flags
& DISASSEMBLY_OMIT_FNAME
) != 0);
254 if (!build_address_symbolic (gdbarch
, pc
, false, omit_fname
, &name
,
255 &offset
, &filename
, &line
, &unmapped
))
257 /* We don't care now about line, filename and unmapped. But we might in
259 m_uiout
->text (" <");
261 m_uiout
->field_string ("func-name", name
,
262 function_name_style
.style ());
263 /* For negative offsets, avoid displaying them as +-N; the sign of
264 the offset takes the place of the "+" here. */
267 m_uiout
->field_signed ("offset", offset
);
268 m_uiout
->text (">:\t");
271 m_uiout
->text (":\t");
275 if (flags
& DISASSEMBLY_RAW_INSN
)
279 const char *spacer
= "";
281 /* Build the opcodes using a temporary stream so we can
282 write them out in a single go for the MI. */
283 m_opcode_stb
.clear ();
285 size
= m_di
.print_insn (pc
);
288 for (;pc
< end_pc
; ++pc
)
290 read_code (pc
, &data
, 1);
291 m_opcode_stb
.printf ("%s%02x", spacer
, (unsigned) data
);
295 m_uiout
->field_stream ("opcodes", m_opcode_stb
);
296 m_uiout
->text ("\t");
299 size
= m_di
.print_insn (pc
);
301 m_uiout
->field_stream ("inst", m_insn_stb
);
303 m_uiout
->text ("\n");
309 dump_insns (struct gdbarch
*gdbarch
,
310 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
311 int how_many
, gdb_disassembly_flags flags
, CORE_ADDR
*end_pc
)
313 struct disasm_insn insn
;
314 int num_displayed
= 0;
316 memset (&insn
, 0, sizeof (insn
));
319 gdb_pretty_print_disassembler
disasm (gdbarch
, uiout
);
321 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
325 size
= disasm
.pretty_print_insn (&insn
, flags
);
332 /* Allow user to bail out with ^C. */
339 return num_displayed
;
342 /* The idea here is to present a source-O-centric view of a
343 function to the user. This means that things are presented
344 in source order, with (possibly) out of order assembly
345 immediately following.
347 N.B. This view is deprecated. */
350 do_mixed_source_and_assembly_deprecated
351 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
352 struct symtab
*symtab
,
353 CORE_ADDR low
, CORE_ADDR high
,
354 int how_many
, gdb_disassembly_flags flags
)
358 struct linetable_entry
*le
;
359 struct deprecated_dis_line_entry
*mle
;
360 struct symtab_and_line sal
;
362 int out_of_order
= 0;
364 int num_displayed
= 0;
365 print_source_lines_flags psl_flags
= 0;
367 gdb_assert (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
);
369 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
370 le
= SYMTAB_LINETABLE (symtab
)->item
;
372 if (flags
& DISASSEMBLY_FILENAME
)
373 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
375 mle
= (struct deprecated_dis_line_entry
*)
376 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
378 /* Copy linetable entries for this function into our data
379 structure, creating end_pc's and setting out_of_order as
382 /* First, skip all the preceding functions. */
384 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
386 /* Now, copy all entries before the end of this function. */
388 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
390 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
391 continue; /* Ignore duplicates. */
393 /* Skip any end-of-function markers. */
397 mle
[newlines
].line
= le
[i
].line
;
398 if (le
[i
].line
> le
[i
+ 1].line
)
400 mle
[newlines
].start_pc
= le
[i
].pc
;
401 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
405 /* If we're on the last line, and it's part of the function,
406 then we need to get the end pc in a special way. */
408 if (i
== nlines
- 1 && le
[i
].pc
< high
)
410 mle
[newlines
].line
= le
[i
].line
;
411 mle
[newlines
].start_pc
= le
[i
].pc
;
412 sal
= find_pc_line (le
[i
].pc
, 0);
413 mle
[newlines
].end_pc
= sal
.end
;
417 /* Now, sort mle by line #s (and, then by addresses within lines). */
420 std::sort (mle
, mle
+ newlines
, line_is_less_than
);
422 /* Now, for each line entry, emit the specified lines (unless
423 they have been emitted before), followed by the assembly code
426 ui_out_emit_list
asm_insns_list (uiout
, "asm_insns");
428 gdb::optional
<ui_out_emit_tuple
> outer_tuple_emitter
;
429 gdb::optional
<ui_out_emit_list
> inner_list_emitter
;
431 for (i
= 0; i
< newlines
; i
++)
433 /* Print out everything from next_line to the current line. */
434 if (mle
[i
].line
>= next_line
)
438 /* Just one line to print. */
439 if (next_line
== mle
[i
].line
)
441 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
442 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
446 /* Several source lines w/o asm instructions associated. */
447 for (; next_line
< mle
[i
].line
; next_line
++)
449 ui_out_emit_tuple
tuple_emitter (uiout
,
451 print_source_lines (symtab
, next_line
, next_line
+ 1,
453 ui_out_emit_list
temp_list_emitter (uiout
,
456 /* Print the last line and leave list open for
457 asm instructions to be added. */
458 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
459 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
464 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
465 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
468 next_line
= mle
[i
].line
+ 1;
469 inner_list_emitter
.emplace (uiout
, "line_asm_insn");
472 num_displayed
+= dump_insns (gdbarch
, uiout
,
473 mle
[i
].start_pc
, mle
[i
].end_pc
,
474 how_many
, flags
, NULL
);
476 /* When we've reached the end of the mle array, or we've seen the last
477 assembly range for this source line, close out the list/tuple. */
478 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
480 inner_list_emitter
.reset ();
481 outer_tuple_emitter
.reset ();
484 if (how_many
>= 0 && num_displayed
>= how_many
)
489 /* The idea here is to present a source-O-centric view of a
490 function to the user. This means that things are presented
491 in source order, with (possibly) out of order assembly
492 immediately following. */
495 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
496 struct ui_out
*uiout
,
497 struct symtab
*main_symtab
,
498 CORE_ADDR low
, CORE_ADDR high
,
499 int how_many
, gdb_disassembly_flags flags
)
501 const struct linetable_entry
*le
, *first_le
;
503 int num_displayed
= 0;
504 print_source_lines_flags psl_flags
= 0;
506 struct symtab
*last_symtab
;
509 gdb_assert (main_symtab
!= NULL
&& SYMTAB_LINETABLE (main_symtab
) != NULL
);
511 /* First pass: collect the list of all source files and lines.
512 We do this so that we can only print lines containing code once.
513 We try to print the source text leading up to the next instruction,
514 but if that text is for code that will be disassembled later, then
515 we'll want to defer printing it until later with its associated code. */
517 htab_up
dis_line_table (allocate_dis_line_table ());
521 /* The prologue may be empty, but there may still be a line number entry
522 for the opening brace which is distinct from the first line of code.
523 If the prologue has been eliminated find_pc_line may return the source
524 line after the opening brace. We still want to print this opening brace.
525 first_le is used to implement this. */
527 nlines
= SYMTAB_LINETABLE (main_symtab
)->nitems
;
528 le
= SYMTAB_LINETABLE (main_symtab
)->item
;
531 /* Skip all the preceding functions. */
532 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
535 if (i
< nlines
&& le
[i
].pc
< high
)
538 /* Add lines for every pc value. */
541 struct symtab_and_line sal
;
544 sal
= find_pc_line (pc
, 0);
545 length
= gdb_insn_length (gdbarch
, pc
);
548 if (sal
.symtab
!= NULL
)
549 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
552 /* Second pass: print the disassembly.
554 Output format, from an MI perspective:
555 The result is a ui_out list, field name "asm_insns", where elements have
556 name "src_and_asm_line".
557 Each element is a tuple of source line specs (field names line, file,
558 fullname), and field "line_asm_insn" which contains the disassembly.
559 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
562 CLI output works on top of this because MI ignores ui_out_text output,
563 which is where we put file name and source line contents output.
567 Handles the outer "asm_insns" list.
569 The tuples for each group of consecutive disassemblies.
571 List of consecutive source lines or disassembled insns. */
573 if (flags
& DISASSEMBLY_FILENAME
)
574 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
576 ui_out_emit_list
asm_insns_emitter (uiout
, "asm_insns");
578 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
579 gdb::optional
<ui_out_emit_list
> list_emitter
;
587 struct symtab_and_line sal
;
589 int start_preceding_line_to_display
= 0;
590 int end_preceding_line_to_display
= 0;
591 int new_source_line
= 0;
593 sal
= find_pc_line (pc
, 0);
595 if (sal
.symtab
!= last_symtab
)
597 /* New source file. */
600 /* If this is the first line of output, check for any preceding
604 && first_le
->line
< sal
.line
)
606 start_preceding_line_to_display
= first_le
->line
;
607 end_preceding_line_to_display
= sal
.line
;
612 /* Same source file as last time. */
613 if (sal
.symtab
!= NULL
)
615 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
619 /* Several preceding source lines. Print the trailing ones
620 not associated with code that we'll print later. */
621 for (l
= sal
.line
- 1; l
> last_line
; --l
)
623 if (line_has_code_p (dis_line_table
.get (),
627 if (l
< sal
.line
- 1)
629 start_preceding_line_to_display
= l
+ 1;
630 end_preceding_line_to_display
= sal
.line
;
633 if (sal
.line
!= last_line
)
637 /* Same source line as last time. This can happen, depending
638 on the debug info. */
645 /* Skip the newline if this is the first instruction. */
648 if (tuple_emitter
.has_value ())
650 gdb_assert (list_emitter
.has_value ());
651 list_emitter
.reset ();
652 tuple_emitter
.reset ();
654 if (sal
.symtab
!= last_symtab
655 && !(flags
& DISASSEMBLY_FILENAME
))
657 /* Remember MI ignores ui_out_text.
658 We don't have to do anything here for MI because MI
659 output includes the source specs for each line. */
660 if (sal
.symtab
!= NULL
)
662 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
665 uiout
->text ("unknown");
668 if (start_preceding_line_to_display
> 0)
670 /* Several source lines w/o asm instructions associated.
671 We need to preserve the structure of the output, so output
672 a bunch of line tuples with no asm entries. */
675 gdb_assert (sal
.symtab
!= NULL
);
676 for (l
= start_preceding_line_to_display
;
677 l
< end_preceding_line_to_display
;
680 ui_out_emit_tuple
line_tuple_emitter (uiout
,
682 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
683 ui_out_emit_list
chain_line_emitter (uiout
, "line_asm_insn");
686 tuple_emitter
.emplace (uiout
, "src_and_asm_line");
687 if (sal
.symtab
!= NULL
)
688 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
690 uiout
->text (_("--- no source info for this pc ---\n"));
691 list_emitter
.emplace (uiout
, "line_asm_insn");
695 /* Here we're appending instructions to an existing line.
696 By construction the very first insn will have a symtab
697 and follow the new_source_line path above. */
698 gdb_assert (tuple_emitter
.has_value ());
699 gdb_assert (list_emitter
.has_value ());
703 end_pc
= std::min (sal
.end
, high
);
706 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
707 how_many
, flags
, &end_pc
);
710 if (how_many
>= 0 && num_displayed
>= how_many
)
713 last_symtab
= sal
.symtab
;
714 last_line
= sal
.line
;
719 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
720 CORE_ADDR low
, CORE_ADDR high
,
721 int how_many
, gdb_disassembly_flags flags
)
723 ui_out_emit_list
list_emitter (uiout
, "asm_insns");
725 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
728 /* Combine implicit and user disassembler options and return them
729 in a newly-created string. */
732 get_all_disassembler_options (struct gdbarch
*gdbarch
)
734 const char *implicit
= gdbarch_disassembler_options_implicit (gdbarch
);
735 const char *options
= get_disassembler_options (gdbarch
);
736 const char *comma
= ",";
738 if (implicit
== nullptr)
744 if (options
== nullptr)
750 return string_printf ("%s%s%s", implicit
, comma
, options
);
753 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
754 struct ui_file
*file
,
755 di_read_memory_ftype read_memory_func
)
756 : m_gdbarch (gdbarch
)
758 init_disassemble_info (&m_di
, file
, dis_asm_fprintf
);
759 m_di
.flavour
= bfd_target_unknown_flavour
;
760 m_di
.memory_error_func
= dis_asm_memory_error
;
761 m_di
.print_address_func
= dis_asm_print_address
;
762 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
763 disassembler had a local optimization here. By default it would
764 access the executable file, instead of the target memory (there
765 was a growing list of exceptions though). Unfortunately, the
766 heuristic was flawed. Commands like "disassemble &variable"
767 didn't work as they relied on the access going to the target.
768 Further, it has been superseeded by trust-read-only-sections
769 (although that should be superseeded by target_trust..._p()). */
770 m_di
.read_memory_func
= read_memory_func
;
771 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
772 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
773 m_di
.endian
= gdbarch_byte_order (gdbarch
);
774 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
775 m_di
.application_data
= this;
776 m_disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
777 if (!m_disassembler_options_holder
.empty ())
778 m_di
.disassembler_options
= m_disassembler_options_holder
.c_str ();
779 disassemble_init_for_target (&m_di
);
782 gdb_disassembler::~gdb_disassembler ()
784 disassemble_free_target (&m_di
);
788 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
789 int *branch_delay_insns
)
791 m_err_memaddr
.reset ();
793 int length
= gdbarch_print_insn (arch (), memaddr
, &m_di
);
797 if (m_err_memaddr
.has_value ())
798 memory_error (TARGET_XFER_E_IO
, *m_err_memaddr
);
800 error (_("unknown disassembler error (error = %d)"), length
);
803 if (branch_delay_insns
!= NULL
)
805 if (m_di
.insn_info_valid
)
806 *branch_delay_insns
= m_di
.branch_delay_insns
;
808 *branch_delay_insns
= 0;
814 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
815 gdb_disassembly_flags flags
, int how_many
,
816 CORE_ADDR low
, CORE_ADDR high
)
818 struct symtab
*symtab
;
821 /* Assume symtab is valid for whole PC range. */
822 symtab
= find_pc_line_symtab (low
);
824 if (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
)
825 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
827 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
829 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
831 else if (flags
& DISASSEMBLY_SOURCE
)
832 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
835 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
836 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
837 low
, high
, how_many
, flags
);
839 gdb_flush (gdb_stdout
);
842 /* Print the instruction at address MEMADDR in debugged memory,
843 on STREAM. Returns the length of the instruction, in bytes,
844 and, if requested, the number of branch delay slot instructions. */
847 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
848 struct ui_file
*stream
, int *branch_delay_insns
)
851 gdb_disassembler
di (gdbarch
, stream
);
853 return di
.print_insn (memaddr
, branch_delay_insns
);
856 /* Return the length in bytes of the instruction at address MEMADDR in
860 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
862 return gdb_print_insn (gdbarch
, addr
, &null_stream
, NULL
);
865 /* fprintf-function for gdb_buffered_insn_length. This function is a
866 nop, we don't want to print anything, we just want to compute the
867 length of the insn. */
869 static int ATTRIBUTE_PRINTF (2, 3)
870 gdb_buffered_insn_length_fprintf (void *stream
, const char *format
, ...)
875 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.
876 Upon return, *DISASSEMBLER_OPTIONS_HOLDER owns the string pointed
877 to by DI.DISASSEMBLER_OPTIONS. */
880 gdb_buffered_insn_length_init_dis (struct gdbarch
*gdbarch
,
881 struct disassemble_info
*di
,
882 const gdb_byte
*insn
, int max_len
,
884 std::string
*disassembler_options_holder
)
886 init_disassemble_info (di
, NULL
, gdb_buffered_insn_length_fprintf
);
888 /* init_disassemble_info installs buffer_read_memory, etc.
889 so we don't need to do that here.
890 The cast is necessary until disassemble_info is const-ified. */
891 di
->buffer
= (gdb_byte
*) insn
;
892 di
->buffer_length
= max_len
;
893 di
->buffer_vma
= addr
;
895 di
->arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
896 di
->mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
897 di
->endian
= gdbarch_byte_order (gdbarch
);
898 di
->endian_code
= gdbarch_byte_order_for_code (gdbarch
);
900 *disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
901 if (!disassembler_options_holder
->empty ())
902 di
->disassembler_options
= disassembler_options_holder
->c_str ();
903 disassemble_init_for_target (di
);
906 /* Return the length in bytes of INSN. MAX_LEN is the size of the
907 buffer containing INSN. */
910 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
911 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
913 struct disassemble_info di
;
914 std::string disassembler_options_holder
;
916 gdb_buffered_insn_length_init_dis (gdbarch
, &di
, insn
, max_len
, addr
,
917 &disassembler_options_holder
);
919 int result
= gdbarch_print_insn (gdbarch
, addr
, &di
);
920 disassemble_free_target (&di
);
925 get_disassembler_options (struct gdbarch
*gdbarch
)
927 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
928 if (disassembler_options
== NULL
)
930 return *disassembler_options
;
934 set_disassembler_options (const char *prospective_options
)
936 struct gdbarch
*gdbarch
= get_current_arch ();
937 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
938 const disasm_options_and_args_t
*valid_options_and_args
;
939 const disasm_options_t
*valid_options
;
940 gdb::unique_xmalloc_ptr
<char> prospective_options_local
941 = make_unique_xstrdup (prospective_options
);
942 char *options
= remove_whitespace_and_extra_commas
943 (prospective_options_local
.get ());
946 /* Allow all architectures, even ones that do not support 'set disassembler',
947 to reset their disassembler options to NULL. */
950 if (disassembler_options
!= NULL
)
952 free (*disassembler_options
);
953 *disassembler_options
= NULL
;
958 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
959 if (valid_options_and_args
== NULL
)
961 fprintf_filtered (gdb_stderr
, _("\
962 'set disassembler-options ...' is not supported on this architecture.\n"));
966 valid_options
= &valid_options_and_args
->options
;
968 /* Verify we have valid disassembler options. */
969 FOR_EACH_DISASSEMBLER_OPTION (opt
, options
)
972 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
973 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
975 size_t len
= strlen (valid_options
->name
[i
]);
980 if (memcmp (opt
, valid_options
->name
[i
], len
) != 0)
983 for (j
= 0; valid_options
->arg
[i
]->values
[j
] != NULL
; j
++)
984 if (disassembler_options_cmp
985 (arg
, valid_options
->arg
[i
]->values
[j
]) == 0)
993 else if (disassembler_options_cmp (opt
, valid_options
->name
[i
]) == 0)
995 if (valid_options
->name
[i
] == NULL
)
997 fprintf_filtered (gdb_stderr
,
998 _("Invalid disassembler option value: '%s'.\n"),
1004 free (*disassembler_options
);
1005 *disassembler_options
= xstrdup (options
);
1009 set_disassembler_options_sfunc (const char *args
, int from_tty
,
1010 struct cmd_list_element
*c
)
1012 set_disassembler_options (prospective_options
.c_str ());
1016 show_disassembler_options_sfunc (struct ui_file
*file
, int from_tty
,
1017 struct cmd_list_element
*c
, const char *value
)
1019 struct gdbarch
*gdbarch
= get_current_arch ();
1020 const disasm_options_and_args_t
*valid_options_and_args
;
1021 const disasm_option_arg_t
*valid_args
;
1022 const disasm_options_t
*valid_options
;
1024 const char *options
= get_disassembler_options (gdbarch
);
1025 if (options
== NULL
)
1028 fprintf_filtered (file
, _("The current disassembler options are '%s'\n\n"),
1031 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1033 if (valid_options_and_args
== NULL
)
1035 fputs_filtered (_("There are no disassembler options available "
1036 "for this architecture.\n"),
1041 valid_options
= &valid_options_and_args
->options
;
1043 fprintf_filtered (file
, _("\
1044 The following disassembler options are supported for use with the\n\
1045 'set disassembler-options OPTION [,OPTION]...' command:\n"));
1047 if (valid_options
->description
!= NULL
)
1049 size_t i
, max_len
= 0;
1051 fprintf_filtered (file
, "\n");
1053 /* Compute the length of the longest option name. */
1054 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1056 size_t len
= strlen (valid_options
->name
[i
]);
1058 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1059 len
+= strlen (valid_options
->arg
[i
]->name
);
1064 for (i
= 0, max_len
++; valid_options
->name
[i
] != NULL
; i
++)
1066 fprintf_filtered (file
, " %s", valid_options
->name
[i
]);
1067 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1068 fprintf_filtered (file
, "%s", valid_options
->arg
[i
]->name
);
1069 if (valid_options
->description
[i
] != NULL
)
1071 size_t len
= strlen (valid_options
->name
[i
]);
1073 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1074 len
+= strlen (valid_options
->arg
[i
]->name
);
1075 fprintf_filtered (file
, "%*c %s", (int) (max_len
- len
), ' ',
1076 valid_options
->description
[i
]);
1078 fprintf_filtered (file
, "\n");
1084 fprintf_filtered (file
, " ");
1085 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1087 fprintf_filtered (file
, "%s", valid_options
->name
[i
]);
1088 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1089 fprintf_filtered (file
, "%s", valid_options
->arg
[i
]->name
);
1090 if (valid_options
->name
[i
+ 1] != NULL
)
1091 fprintf_filtered (file
, ", ");
1094 fprintf_filtered (file
, "\n");
1097 valid_args
= valid_options_and_args
->args
;
1098 if (valid_args
!= NULL
)
1102 for (i
= 0; valid_args
[i
].name
!= NULL
; i
++)
1104 fprintf_filtered (file
, _("\n\
1105 For the options above, the following values are supported for \"%s\":\n "),
1106 valid_args
[i
].name
);
1107 for (j
= 0; valid_args
[i
].values
[j
] != NULL
; j
++)
1109 fprintf_filtered (file
, " %s", valid_args
[i
].values
[j
]);
1112 fprintf_filtered (file
, "\n");
1117 /* A completion function for "set disassembler". */
1120 disassembler_options_completer (struct cmd_list_element
*ignore
,
1121 completion_tracker
&tracker
,
1122 const char *text
, const char *word
)
1124 struct gdbarch
*gdbarch
= get_current_arch ();
1125 const disasm_options_and_args_t
*opts_and_args
1126 = gdbarch_valid_disassembler_options (gdbarch
);
1128 if (opts_and_args
!= NULL
)
1130 const disasm_options_t
*opts
= &opts_and_args
->options
;
1132 /* Only attempt to complete on the last option text. */
1133 const char *separator
= strrchr (text
, ',');
1134 if (separator
!= NULL
)
1135 text
= separator
+ 1;
1136 text
= skip_spaces (text
);
1137 complete_on_enum (tracker
, opts
->name
, text
, word
);
1142 /* Initialization code. */
1144 void _initialize_disasm ();
1146 _initialize_disasm ()
1148 /* Add the command that controls the disassembler options. */
1149 set_show_commands set_show_disas_opts
1150 = add_setshow_string_noescape_cmd ("disassembler-options", no_class
,
1151 &prospective_options
, _("\
1152 Set the disassembler options.\n\
1153 Usage: set disassembler-options OPTION [,OPTION]...\n\n\
1154 See: 'show disassembler-options' for valid option values."), _("\
1155 Show the disassembler options."), NULL
,
1156 set_disassembler_options_sfunc
,
1157 show_disassembler_options_sfunc
,
1158 &setlist
, &showlist
);
1159 set_cmd_completer (set_show_disas_opts
.set
, disassembler_options_completer
);