1 /* Disassemble support for GDB.
3 Copyright (C) 2000-2022 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 /* When this is true we will try to use libopcodes to provide styling to
45 the disassembler output. */
47 static bool use_libopcodes_styling
= true;
49 /* To support the set_use_libopcodes_styling function we have a second
50 variable which is connected to the actual set/show option. */
52 static bool use_libopcodes_styling_option
= use_libopcodes_styling
;
54 /* The "maint show libopcodes-styling enabled" command. */
57 show_use_libopcodes_styling (struct ui_file
*file
, int from_tty
,
58 struct cmd_list_element
*c
,
61 gdb_non_printing_memory_disassembler
dis (target_gdbarch ());
62 bool supported
= dis
.disasm_info ()->created_styled_output
;
64 if (supported
|| !use_libopcodes_styling
)
65 gdb_printf (file
, _("Use of libopcodes styling support is \"%s\".\n"),
69 /* Use of libopcodes styling is not supported, and the user has this
71 gdb_printf (file
, _("Use of libopcodes styling support is \"off\""
72 " (not supported on architecture \"%s\")\n"),
73 gdbarch_bfd_arch_info (target_gdbarch ())->printable_name
);
77 /* The "maint set libopcodes-styling enabled" command. */
80 set_use_libopcodes_styling (const char *args
, int from_tty
,
81 struct cmd_list_element
*c
)
83 gdb_non_printing_memory_disassembler
dis (target_gdbarch ());
84 bool supported
= dis
.disasm_info ()->created_styled_output
;
86 /* If the current architecture doesn't support libopcodes styling then we
87 give an error here, but leave the underlying setting enabled. This
88 means that if the user switches to an architecture that does support
89 libopcodes styling the setting will be enabled. */
91 if (use_libopcodes_styling_option
&& !supported
)
93 use_libopcodes_styling_option
= use_libopcodes_styling
;
94 error (_("Use of libopcodes styling not supported on architecture \"%s\"."),
95 gdbarch_bfd_arch_info (target_gdbarch ())->printable_name
);
98 use_libopcodes_styling
= use_libopcodes_styling_option
;
101 /* This structure is used to store line number information for the
102 deprecated /m option.
103 We need a different sort of line table from the normal one cuz we can't
104 depend upon implicit line-end pc's for lines to do the
105 reordering in this function. */
107 struct deprecated_dis_line_entry
114 /* This Structure is used to store line number information.
115 We need a different sort of line table from the normal one cuz we can't
116 depend upon implicit line-end pc's for lines to do the
117 reordering in this function. */
119 struct dis_line_entry
121 struct symtab
*symtab
;
125 /* Hash function for dis_line_entry. */
128 hash_dis_line_entry (const void *item
)
130 const struct dis_line_entry
*dle
= (const struct dis_line_entry
*) item
;
132 return htab_hash_pointer (dle
->symtab
) + dle
->line
;
135 /* Equal function for dis_line_entry. */
138 eq_dis_line_entry (const void *item_lhs
, const void *item_rhs
)
140 const struct dis_line_entry
*lhs
= (const struct dis_line_entry
*) item_lhs
;
141 const struct dis_line_entry
*rhs
= (const struct dis_line_entry
*) item_rhs
;
143 return (lhs
->symtab
== rhs
->symtab
144 && lhs
->line
== rhs
->line
);
147 /* Create the table to manage lines for mixed source/disassembly. */
150 allocate_dis_line_table (void)
152 return htab_create_alloc (41,
153 hash_dis_line_entry
, eq_dis_line_entry
,
154 xfree
, xcalloc
, xfree
);
157 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE. */
160 add_dis_line_entry (htab_t table
, struct symtab
*symtab
, int line
)
163 struct dis_line_entry dle
, *dlep
;
167 slot
= htab_find_slot (table
, &dle
, INSERT
);
170 dlep
= XNEW (struct dis_line_entry
);
171 dlep
->symtab
= symtab
;
177 /* Return non-zero if SYMTAB, LINE are in TABLE. */
180 line_has_code_p (htab_t table
, struct symtab
*symtab
, int line
)
182 struct dis_line_entry dle
;
186 return htab_find (table
, &dle
) != NULL
;
189 /* Wrapper of target_read_code. */
192 gdb_disassembler_memory_reader::dis_asm_read_memory
193 (bfd_vma memaddr
, gdb_byte
*myaddr
, unsigned int len
,
194 struct disassemble_info
*info
)
196 return target_read_code (memaddr
, myaddr
, len
);
199 /* Wrapper of memory_error. */
202 gdb_disassembler::dis_asm_memory_error (int err
, bfd_vma memaddr
,
203 struct disassemble_info
*info
)
205 gdb_disassembler
*self
206 = static_cast<gdb_disassembler
*>(info
->application_data
);
208 self
->m_err_memaddr
.emplace (memaddr
);
211 /* Wrapper of print_address. */
214 gdb_disassembler::dis_asm_print_address (bfd_vma addr
,
215 struct disassemble_info
*info
)
217 gdb_disassembler
*self
218 = static_cast<gdb_disassembler
*>(info
->application_data
);
220 if (self
->in_comment_p ())
222 /* Calling 'print_address' might add styling to the output (based on
223 the properties of the stream we're writing too). This is usually
224 fine, but if we are in an assembler comment then we'd prefer to
225 have the comment style, rather than the default address style.
227 Print the address into a temporary buffer which doesn't support
228 styling, then reprint this unstyled address with the default text
231 As we are inside a comment right now, the standard print routine
232 will ensure that the comment is printed to the user with a
233 suitable comment style. */
235 print_address (self
->arch (), addr
, &tmp
);
236 self
->fprintf_styled_func (self
, dis_style_text
, "%s", tmp
.c_str ());
239 print_address (self
->arch (), addr
, self
->stream ());
245 gdb_printing_disassembler::stream_from_gdb_disassemble_info (void *dis_info
)
247 gdb_disassemble_info
*di
= (gdb_disassemble_info
*) dis_info
;
248 gdb_printing_disassembler
*dis
249 = gdb::checked_static_cast
<gdb_printing_disassembler
*> (di
);
250 ui_file
*stream
= dis
->stream ();
251 gdb_assert (stream
!= nullptr);
255 /* Format disassembler output to STREAM. */
258 gdb_printing_disassembler::fprintf_func (void *dis_info
,
259 const char *format
, ...)
261 ui_file
*stream
= stream_from_gdb_disassemble_info (dis_info
);
264 va_start (args
, format
);
265 gdb_vprintf (stream
, format
, args
);
268 /* Something non -ve. */
275 gdb_printing_disassembler::fprintf_styled_func (void *dis_info
,
276 enum disassembler_style style
,
277 const char *format
, ...)
279 ui_file
*stream
= stream_from_gdb_disassemble_info (dis_info
);
280 gdb_printing_disassembler
*dis
= (gdb_printing_disassembler
*) dis_info
;
283 va_start (args
, format
);
284 std::string content
= string_vprintf (format
, args
);
287 /* Once in a comment then everything should be styled as a comment. */
288 if (style
== dis_style_comment_start
)
289 dis
->set_in_comment (true);
290 if (dis
->in_comment_p ())
291 style
= dis_style_comment_start
;
293 /* Now print the content with the correct style. */
294 const char *txt
= content
.c_str ();
297 case dis_style_mnemonic
:
298 case dis_style_sub_mnemonic
:
299 case dis_style_assembler_directive
:
300 fputs_styled (txt
, disasm_mnemonic_style
.style (), stream
);
303 case dis_style_register
:
304 fputs_styled (txt
, disasm_register_style
.style (), stream
);
307 case dis_style_immediate
:
308 case dis_style_address_offset
:
309 fputs_styled (txt
, disasm_immediate_style
.style (), stream
);
312 case dis_style_address
:
313 fputs_styled (txt
, address_style
.style (), stream
);
316 case dis_style_symbol
:
317 fputs_styled (txt
, function_name_style
.style (), stream
);
320 case dis_style_comment_start
:
321 fputs_styled (txt
, disasm_comment_style
.style (), stream
);
325 gdb_puts (txt
, stream
);
329 /* Something non -ve. */
334 line_is_less_than (const deprecated_dis_line_entry
&mle1
,
335 const deprecated_dis_line_entry
&mle2
)
339 /* End of sequence markers have a line number of 0 but don't want to
340 be sorted to the head of the list, instead sort by PC. */
341 if (mle1
.line
== 0 || mle2
.line
== 0)
343 if (mle1
.start_pc
!= mle2
.start_pc
)
344 val
= mle1
.start_pc
< mle2
.start_pc
;
346 val
= mle1
.line
< mle2
.line
;
350 if (mle1
.line
!= mle2
.line
)
351 val
= mle1
.line
< mle2
.line
;
353 val
= mle1
.start_pc
< mle2
.start_pc
;
361 gdb_pretty_print_disassembler::pretty_print_insn (const struct disasm_insn
*insn
,
362 gdb_disassembly_flags flags
)
364 /* parts of the symbolic representation of the address */
370 struct gdbarch
*gdbarch
= arch ();
373 ui_out_emit_tuple
tuple_emitter (m_uiout
, NULL
);
376 if (insn
->number
!= 0)
378 m_uiout
->field_unsigned ("insn-number", insn
->number
);
379 m_uiout
->text ("\t");
382 if ((flags
& DISASSEMBLY_SPECULATIVE
) != 0)
384 if (insn
->is_speculative
)
386 m_uiout
->field_string ("is-speculative", "?");
388 /* The speculative execution indication overwrites the first
389 character of the PC prefix.
390 We assume a PC prefix length of 3 characters. */
391 if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
392 m_uiout
->text (pc_prefix (pc
) + 1);
396 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
397 m_uiout
->text (pc_prefix (pc
));
401 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
402 m_uiout
->text (pc_prefix (pc
));
403 m_uiout
->field_core_addr ("address", gdbarch
, pc
);
405 std::string name
, filename
;
406 bool omit_fname
= ((flags
& DISASSEMBLY_OMIT_FNAME
) != 0);
407 if (!build_address_symbolic (gdbarch
, pc
, false, omit_fname
, &name
,
408 &offset
, &filename
, &line
, &unmapped
))
410 /* We don't care now about line, filename and unmapped. But we might in
412 m_uiout
->text (" <");
414 m_uiout
->field_string ("func-name", name
,
415 function_name_style
.style ());
416 /* For negative offsets, avoid displaying them as +-N; the sign of
417 the offset takes the place of the "+" here. */
420 m_uiout
->field_signed ("offset", offset
);
421 m_uiout
->text (">:\t");
424 m_uiout
->text (":\t");
426 /* Clear the buffer into which we will disassemble the instruction. */
429 /* A helper function to write the M_INSN_STB buffer, followed by a
430 newline. This can be called in a couple of situations. */
431 auto write_out_insn_buffer
= [&] ()
433 m_uiout
->field_stream ("inst", m_insn_stb
);
434 m_uiout
->text ("\n");
439 /* Now we can disassemble the instruction. If the disassembler
440 returns a negative value this indicates an error and is handled
441 within the print_insn call, resulting in an exception being
442 thrown. Returning zero makes no sense, as this indicates we
443 disassembled something successfully, but it was something of no
445 size
= m_di
.print_insn (pc
);
446 gdb_assert (size
> 0);
448 catch (const gdb_exception
&ex
)
450 /* An exception was thrown while disassembling the instruction.
451 However, the disassembler might still have written something
452 out, so ensure that we flush the instruction buffer before
453 rethrowing the exception. We can't perform this write from an
454 object destructor as the write itself might throw an exception
455 if the pager kicks in, and the user selects quit. */
456 write_out_insn_buffer ();
460 if ((flags
& (DISASSEMBLY_RAW_INSN
| DISASSEMBLY_RAW_BYTES
)) != 0)
462 /* Build the opcodes using a temporary stream so we can
463 write them out in a single go for the MI. */
464 m_opcode_stb
.clear ();
466 /* Read the instruction opcode data. */
467 m_opcode_data
.resize (size
);
468 read_code (pc
, m_opcode_data
.data (), size
);
470 /* The disassembler provides information about the best way to
471 display the instruction bytes to the user. We provide some sane
472 defaults in case the disassembler gets it wrong. */
473 const struct disassemble_info
*di
= m_di
.disasm_info ();
474 int bytes_per_line
= std::max (di
->bytes_per_line
, size
);
475 int bytes_per_chunk
= std::max (di
->bytes_per_chunk
, 1);
477 /* If the user has requested the instruction bytes be displayed
478 byte at a time, then handle that here. Also, if the instruction
479 is not a multiple of the chunk size (which probably indicates a
480 disassembler problem) then avoid that causing display problems
481 by switching to byte at a time mode. */
482 if ((flags
& DISASSEMBLY_RAW_BYTES
) != 0
483 || (size
% bytes_per_chunk
) != 0)
486 /* Print the instruction opcodes bytes, grouped into chunks. */
487 for (int i
= 0; i
< size
; i
+= bytes_per_chunk
)
490 m_opcode_stb
.puts (" ");
492 if (di
->display_endian
== BFD_ENDIAN_LITTLE
)
494 for (int k
= bytes_per_chunk
; k
-- != 0; )
495 m_opcode_stb
.printf ("%02x", (unsigned) m_opcode_data
[i
+ k
]);
499 for (int k
= 0; k
< bytes_per_chunk
; k
++)
500 m_opcode_stb
.printf ("%02x", (unsigned) m_opcode_data
[i
+ k
]);
504 /* Calculate required padding. */
506 for (int i
= size
; i
< bytes_per_line
; i
+= bytes_per_chunk
)
510 nspaces
+= bytes_per_chunk
* 2;
513 m_uiout
->field_stream ("opcodes", m_opcode_stb
);
514 m_uiout
->spaces (nspaces
);
515 m_uiout
->text ("\t");
518 /* Disassembly was a success, write out the instruction buffer. */
519 write_out_insn_buffer ();
526 dump_insns (struct gdbarch
*gdbarch
,
527 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
528 int how_many
, gdb_disassembly_flags flags
, CORE_ADDR
*end_pc
)
530 struct disasm_insn insn
;
531 int num_displayed
= 0;
533 memset (&insn
, 0, sizeof (insn
));
536 gdb_pretty_print_disassembler
disasm (gdbarch
, uiout
);
538 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
542 size
= disasm
.pretty_print_insn (&insn
, flags
);
549 /* Allow user to bail out with ^C. */
556 return num_displayed
;
559 /* The idea here is to present a source-O-centric view of a
560 function to the user. This means that things are presented
561 in source order, with (possibly) out of order assembly
562 immediately following.
564 N.B. This view is deprecated. */
567 do_mixed_source_and_assembly_deprecated
568 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
569 struct symtab
*symtab
,
570 CORE_ADDR low
, CORE_ADDR high
,
571 int how_many
, gdb_disassembly_flags flags
)
575 struct linetable_entry
*le
;
576 struct deprecated_dis_line_entry
*mle
;
577 struct symtab_and_line sal
;
579 int out_of_order
= 0;
581 int num_displayed
= 0;
582 print_source_lines_flags psl_flags
= 0;
584 gdb_assert (symtab
!= nullptr && symtab
->linetable () != nullptr);
586 nlines
= symtab
->linetable ()->nitems
;
587 le
= symtab
->linetable ()->item
;
589 if (flags
& DISASSEMBLY_FILENAME
)
590 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
592 mle
= (struct deprecated_dis_line_entry
*)
593 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
595 /* Copy linetable entries for this function into our data
596 structure, creating end_pc's and setting out_of_order as
599 /* First, skip all the preceding functions. */
601 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
603 /* Now, copy all entries before the end of this function. */
605 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
607 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
608 continue; /* Ignore duplicates. */
610 /* Skip any end-of-function markers. */
614 mle
[newlines
].line
= le
[i
].line
;
615 if (le
[i
].line
> le
[i
+ 1].line
)
617 mle
[newlines
].start_pc
= le
[i
].pc
;
618 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
622 /* If we're on the last line, and it's part of the function,
623 then we need to get the end pc in a special way. */
625 if (i
== nlines
- 1 && le
[i
].pc
< high
)
627 mle
[newlines
].line
= le
[i
].line
;
628 mle
[newlines
].start_pc
= le
[i
].pc
;
629 sal
= find_pc_line (le
[i
].pc
, 0);
630 mle
[newlines
].end_pc
= sal
.end
;
634 /* Now, sort mle by line #s (and, then by addresses within lines). */
637 std::sort (mle
, mle
+ newlines
, line_is_less_than
);
639 /* Now, for each line entry, emit the specified lines (unless
640 they have been emitted before), followed by the assembly code
643 ui_out_emit_list
asm_insns_list (uiout
, "asm_insns");
645 gdb::optional
<ui_out_emit_tuple
> outer_tuple_emitter
;
646 gdb::optional
<ui_out_emit_list
> inner_list_emitter
;
648 for (i
= 0; i
< newlines
; i
++)
650 /* Print out everything from next_line to the current line. */
651 if (mle
[i
].line
>= next_line
)
655 /* Just one line to print. */
656 if (next_line
== mle
[i
].line
)
658 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
659 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
663 /* Several source lines w/o asm instructions associated. */
664 for (; next_line
< mle
[i
].line
; next_line
++)
666 ui_out_emit_tuple
tuple_emitter (uiout
,
668 print_source_lines (symtab
, next_line
, next_line
+ 1,
670 ui_out_emit_list
temp_list_emitter (uiout
,
673 /* Print the last line and leave list open for
674 asm instructions to be added. */
675 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
676 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
681 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
682 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
685 next_line
= mle
[i
].line
+ 1;
686 inner_list_emitter
.emplace (uiout
, "line_asm_insn");
689 num_displayed
+= dump_insns (gdbarch
, uiout
,
690 mle
[i
].start_pc
, mle
[i
].end_pc
,
691 how_many
, flags
, NULL
);
693 /* When we've reached the end of the mle array, or we've seen the last
694 assembly range for this source line, close out the list/tuple. */
695 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
697 inner_list_emitter
.reset ();
698 outer_tuple_emitter
.reset ();
701 if (how_many
>= 0 && num_displayed
>= how_many
)
706 /* The idea here is to present a source-O-centric view of a
707 function to the user. This means that things are presented
708 in source order, with (possibly) out of order assembly
709 immediately following. */
712 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
713 struct ui_out
*uiout
,
714 struct symtab
*main_symtab
,
715 CORE_ADDR low
, CORE_ADDR high
,
716 int how_many
, gdb_disassembly_flags flags
)
718 const struct linetable_entry
*le
, *first_le
;
720 int num_displayed
= 0;
721 print_source_lines_flags psl_flags
= 0;
723 struct symtab
*last_symtab
;
726 gdb_assert (main_symtab
!= NULL
&& main_symtab
->linetable () != NULL
);
728 /* First pass: collect the list of all source files and lines.
729 We do this so that we can only print lines containing code once.
730 We try to print the source text leading up to the next instruction,
731 but if that text is for code that will be disassembled later, then
732 we'll want to defer printing it until later with its associated code. */
734 htab_up
dis_line_table (allocate_dis_line_table ());
738 /* The prologue may be empty, but there may still be a line number entry
739 for the opening brace which is distinct from the first line of code.
740 If the prologue has been eliminated find_pc_line may return the source
741 line after the opening brace. We still want to print this opening brace.
742 first_le is used to implement this. */
744 nlines
= main_symtab
->linetable ()->nitems
;
745 le
= main_symtab
->linetable ()->item
;
748 /* Skip all the preceding functions. */
749 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
752 if (i
< nlines
&& le
[i
].pc
< high
)
755 /* Add lines for every pc value. */
758 struct symtab_and_line sal
;
761 sal
= find_pc_line (pc
, 0);
762 length
= gdb_insn_length (gdbarch
, pc
);
765 if (sal
.symtab
!= NULL
)
766 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
769 /* Second pass: print the disassembly.
771 Output format, from an MI perspective:
772 The result is a ui_out list, field name "asm_insns", where elements have
773 name "src_and_asm_line".
774 Each element is a tuple of source line specs (field names line, file,
775 fullname), and field "line_asm_insn" which contains the disassembly.
776 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
779 CLI output works on top of this because MI ignores ui_out_text output,
780 which is where we put file name and source line contents output.
784 Handles the outer "asm_insns" list.
786 The tuples for each group of consecutive disassemblies.
788 List of consecutive source lines or disassembled insns. */
790 if (flags
& DISASSEMBLY_FILENAME
)
791 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
793 ui_out_emit_list
asm_insns_emitter (uiout
, "asm_insns");
795 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
796 gdb::optional
<ui_out_emit_list
> list_emitter
;
804 struct symtab_and_line sal
;
806 int start_preceding_line_to_display
= 0;
807 int end_preceding_line_to_display
= 0;
808 int new_source_line
= 0;
810 sal
= find_pc_line (pc
, 0);
812 if (sal
.symtab
!= last_symtab
)
814 /* New source file. */
817 /* If this is the first line of output, check for any preceding
821 && first_le
->line
< sal
.line
)
823 start_preceding_line_to_display
= first_le
->line
;
824 end_preceding_line_to_display
= sal
.line
;
829 /* Same source file as last time. */
830 if (sal
.symtab
!= NULL
)
832 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
836 /* Several preceding source lines. Print the trailing ones
837 not associated with code that we'll print later. */
838 for (l
= sal
.line
- 1; l
> last_line
; --l
)
840 if (line_has_code_p (dis_line_table
.get (),
844 if (l
< sal
.line
- 1)
846 start_preceding_line_to_display
= l
+ 1;
847 end_preceding_line_to_display
= sal
.line
;
850 if (sal
.line
!= last_line
)
854 /* Same source line as last time. This can happen, depending
855 on the debug info. */
862 /* Skip the newline if this is the first instruction. */
865 if (tuple_emitter
.has_value ())
867 gdb_assert (list_emitter
.has_value ());
868 list_emitter
.reset ();
869 tuple_emitter
.reset ();
871 if (sal
.symtab
!= last_symtab
872 && !(flags
& DISASSEMBLY_FILENAME
))
874 /* Remember MI ignores ui_out_text.
875 We don't have to do anything here for MI because MI
876 output includes the source specs for each line. */
877 if (sal
.symtab
!= NULL
)
879 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
882 uiout
->text ("unknown");
885 if (start_preceding_line_to_display
> 0)
887 /* Several source lines w/o asm instructions associated.
888 We need to preserve the structure of the output, so output
889 a bunch of line tuples with no asm entries. */
892 gdb_assert (sal
.symtab
!= NULL
);
893 for (l
= start_preceding_line_to_display
;
894 l
< end_preceding_line_to_display
;
897 ui_out_emit_tuple
line_tuple_emitter (uiout
,
899 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
900 ui_out_emit_list
chain_line_emitter (uiout
, "line_asm_insn");
903 tuple_emitter
.emplace (uiout
, "src_and_asm_line");
904 if (sal
.symtab
!= NULL
)
905 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
907 uiout
->text (_("--- no source info for this pc ---\n"));
908 list_emitter
.emplace (uiout
, "line_asm_insn");
912 /* Here we're appending instructions to an existing line.
913 By construction the very first insn will have a symtab
914 and follow the new_source_line path above. */
915 gdb_assert (tuple_emitter
.has_value ());
916 gdb_assert (list_emitter
.has_value ());
920 end_pc
= std::min (sal
.end
, high
);
923 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
924 how_many
, flags
, &end_pc
);
927 if (how_many
>= 0 && num_displayed
>= how_many
)
930 last_symtab
= sal
.symtab
;
931 last_line
= sal
.line
;
936 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
937 CORE_ADDR low
, CORE_ADDR high
,
938 int how_many
, gdb_disassembly_flags flags
)
940 ui_out_emit_list
list_emitter (uiout
, "asm_insns");
942 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
945 /* Combine implicit and user disassembler options and return them
946 in a newly-created string. */
949 get_all_disassembler_options (struct gdbarch
*gdbarch
)
951 const char *implicit
= gdbarch_disassembler_options_implicit (gdbarch
);
952 const char *options
= get_disassembler_options (gdbarch
);
953 const char *comma
= ",";
955 if (implicit
== nullptr)
961 if (options
== nullptr)
967 return string_printf ("%s%s%s", implicit
, comma
, options
);
970 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
971 struct ui_file
*file
,
972 read_memory_ftype func
)
973 : gdb_printing_disassembler (gdbarch
, &m_buffer
, func
,
974 dis_asm_memory_error
, dis_asm_print_address
),
975 /* The use of m_di.created_styled_output here is a bit of a cheat, but
976 it works fine for now. Currently, for all targets that support
977 libopcodes styling, this field is set during the call to
978 disassemble_init_for_target, which was called as part of the
979 initialization of gdb_printing_disassembler. And so, we are able to
980 spot if a target supports libopcodes styling, and create m_buffer in
981 the correct styling mode.
983 If there's ever a target that only sets created_styled_output during
984 the actual disassemble phase, then the logic here will have to
986 m_buffer ((!use_ext_lang_colorization_p
987 || (use_libopcodes_styling
&& m_di
.created_styled_output
))
988 && disassembler_styling
989 && file
->can_emit_style_escape ()),
995 gdb_disassemble_info::gdb_disassemble_info
996 (struct gdbarch
*gdbarch
,
997 read_memory_ftype read_memory_func
, memory_error_ftype memory_error_func
,
998 print_address_ftype print_address_func
, fprintf_ftype fprintf_func
,
999 fprintf_styled_ftype fprintf_styled_func
)
1000 : m_gdbarch (gdbarch
)
1002 gdb_assert (fprintf_func
!= nullptr);
1003 gdb_assert (fprintf_styled_func
!= nullptr);
1004 init_disassemble_info (&m_di
, (void *) this, fprintf_func
,
1005 fprintf_styled_func
);
1006 m_di
.flavour
= bfd_target_unknown_flavour
;
1008 /* The memory_error_func, print_address_func, and read_memory_func are
1009 all initialized to a default (non-nullptr) value by the call to
1010 init_disassemble_info above. If the user is overriding these fields
1011 (by passing non-nullptr values) then do that now, otherwise, leave
1012 these fields as the defaults. */
1013 if (memory_error_func
!= nullptr)
1014 m_di
.memory_error_func
= memory_error_func
;
1015 if (print_address_func
!= nullptr)
1016 m_di
.print_address_func
= print_address_func
;
1017 if (read_memory_func
!= nullptr)
1018 m_di
.read_memory_func
= read_memory_func
;
1020 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1021 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
1022 m_di
.endian
= gdbarch_byte_order (gdbarch
);
1023 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
1024 m_di
.application_data
= this;
1025 m_disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
1026 if (!m_disassembler_options_holder
.empty ())
1027 m_di
.disassembler_options
= m_disassembler_options_holder
.c_str ();
1028 disassemble_init_for_target (&m_di
);
1033 gdb_disassemble_info::~gdb_disassemble_info ()
1035 disassemble_free_target (&m_di
);
1038 /* Wrapper around calling gdbarch_print_insn. This function takes care of
1039 first calling the extension language hooks for print_insn, and, if none
1040 of the extension languages can print this instruction, calls
1041 gdbarch_print_insn to do the work.
1043 GDBARCH is the architecture to disassemble in, VMA is the address of the
1044 instruction being disassembled, and INFO is the libopcodes disassembler
1045 related information. */
1048 gdb_print_insn_1 (struct gdbarch
*gdbarch
, CORE_ADDR vma
,
1049 struct disassemble_info
*info
)
1051 /* Call into the extension languages to do the disassembly. */
1052 gdb::optional
<int> length
= ext_lang_print_insn (gdbarch
, vma
, info
);
1053 if (length
.has_value ())
1056 /* No extension language wanted to do the disassembly, so do it
1058 return gdbarch_print_insn (gdbarch
, vma
, info
);
1063 bool gdb_disassembler::use_ext_lang_colorization_p
= true;
1068 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
1069 int *branch_delay_insns
)
1071 m_err_memaddr
.reset ();
1073 this->set_in_comment (false);
1075 int length
= gdb_print_insn_1 (arch (), memaddr
, &m_di
);
1077 /* If we have successfully disassembled an instruction, disassembler
1078 styling using the extension language is on, and libopcodes hasn't
1079 already styled the output for us, and, if the destination can support
1080 styling, then lets call into the extension languages in order to style
1082 if (length
> 0 && disassembler_styling
1083 && (!m_di
.created_styled_output
|| !use_libopcodes_styling
)
1084 && use_ext_lang_colorization_p
1085 && m_dest
->can_emit_style_escape ())
1087 gdb::optional
<std::string
> ext_contents
;
1088 ext_contents
= ext_lang_colorize_disasm (m_buffer
.string (), arch ());
1089 if (ext_contents
.has_value ())
1090 m_buffer
= std::move (*ext_contents
);
1093 /* The extension language failed to add styling to the
1094 disassembly output. Set the static flag so that next time we
1095 disassemble we don't even bother attempting to use the
1096 extension language for styling. */
1097 use_ext_lang_colorization_p
= false;
1099 /* The instruction we just disassembled, and the extension
1100 languages failed to style, might have otherwise had some
1101 minimal styling applied by GDB. To regain that styling we
1102 need to recreate m_buffer, but this time with styling support.
1104 To do this we perform an in-place new, but this time turn on
1105 the styling support, then we can re-disassembly the
1106 instruction, and gain any minimal styling GDB might add. */
1107 gdb_static_assert ((std::is_same
<decltype (m_buffer
),
1108 string_file
>::value
));
1109 gdb_assert (!m_buffer
.term_out ());
1110 m_buffer
.~string_file ();
1111 new (&m_buffer
) string_file (true);
1112 length
= gdb_print_insn_1 (arch (), memaddr
, &m_di
);
1113 gdb_assert (length
> 0);
1117 /* Push any disassemble output to the real destination stream. We do
1118 this even if the disassembler reported failure (-1) as the
1119 disassembler may have printed something to its output stream. */
1120 gdb_printf (m_dest
, "%s", m_buffer
.c_str ());
1122 /* If the disassembler failed then report an appropriate error. */
1125 if (m_err_memaddr
.has_value ())
1126 memory_error (TARGET_XFER_E_IO
, *m_err_memaddr
);
1128 error (_("unknown disassembler error (error = %d)"), length
);
1131 if (branch_delay_insns
!= NULL
)
1133 if (m_di
.insn_info_valid
)
1134 *branch_delay_insns
= m_di
.branch_delay_insns
;
1136 *branch_delay_insns
= 0;
1142 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
1143 gdb_disassembly_flags flags
, int how_many
,
1144 CORE_ADDR low
, CORE_ADDR high
)
1146 struct symtab
*symtab
;
1149 /* Assume symtab is valid for whole PC range. */
1150 symtab
= find_pc_line_symtab (low
);
1152 if (symtab
!= NULL
&& symtab
->linetable () != NULL
)
1153 nlines
= symtab
->linetable ()->nitems
;
1155 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
1157 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
1159 else if (flags
& DISASSEMBLY_SOURCE
)
1160 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
1163 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
1164 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
1165 low
, high
, how_many
, flags
);
1167 gdb_flush (gdb_stdout
);
1170 /* Print the instruction at address MEMADDR in debugged memory,
1171 on STREAM. Returns the length of the instruction, in bytes,
1172 and, if requested, the number of branch delay slot instructions. */
1175 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
1176 struct ui_file
*stream
, int *branch_delay_insns
)
1179 gdb_disassembler
di (gdbarch
, stream
);
1181 return di
.print_insn (memaddr
, branch_delay_insns
);
1184 /* Return the length in bytes of the instruction at address MEMADDR in
1188 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1190 return gdb_print_insn (gdbarch
, addr
, &null_stream
, NULL
);
1196 gdb_non_printing_disassembler::null_fprintf_func (void *stream
,
1197 const char *format
, ...)
1205 gdb_non_printing_disassembler::null_fprintf_styled_func
1206 (void *stream
, enum disassembler_style style
, const char *format
, ...)
1211 /* A non-printing disassemble_info management class. The disassemble_info
1212 setup by this class will not print anything to the output stream (there
1213 is no output stream), and the instruction to be disassembled will be
1214 read from a buffer passed to the constructor. */
1216 struct gdb_non_printing_buffer_disassembler
1217 : public gdb_non_printing_disassembler
1219 /* Constructor. GDBARCH is the architecture to disassemble for, BUFFER
1220 contains the instruction to disassemble, and INSN_ADDRESS is the
1221 address (in target memory) of the instruction to disassemble. */
1222 gdb_non_printing_buffer_disassembler (struct gdbarch
*gdbarch
,
1223 gdb::array_view
<const gdb_byte
> buffer
,
1224 CORE_ADDR insn_address
)
1225 : gdb_non_printing_disassembler (gdbarch
, nullptr)
1227 /* The cast is necessary until disassemble_info is const-ified. */
1228 m_di
.buffer
= (gdb_byte
*) buffer
.data ();
1229 m_di
.buffer_length
= buffer
.size ();
1230 m_di
.buffer_vma
= insn_address
;
1234 /* Return the length in bytes of INSN. MAX_LEN is the size of the
1235 buffer containing INSN. */
1238 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
1239 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
1241 gdb::array_view
<const gdb_byte
> buffer
1242 = gdb::make_array_view (insn
, max_len
);
1243 gdb_non_printing_buffer_disassembler
dis (gdbarch
, buffer
, addr
);
1244 int result
= gdb_print_insn_1 (gdbarch
, addr
, dis
.disasm_info ());
1249 get_disassembler_options (struct gdbarch
*gdbarch
)
1251 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
1252 if (disassembler_options
== NULL
)
1254 return *disassembler_options
;
1258 set_disassembler_options (const char *prospective_options
)
1260 struct gdbarch
*gdbarch
= get_current_arch ();
1261 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
1262 const disasm_options_and_args_t
*valid_options_and_args
;
1263 const disasm_options_t
*valid_options
;
1264 gdb::unique_xmalloc_ptr
<char> prospective_options_local
1265 = make_unique_xstrdup (prospective_options
);
1266 char *options
= remove_whitespace_and_extra_commas
1267 (prospective_options_local
.get ());
1270 /* Allow all architectures, even ones that do not support 'set disassembler',
1271 to reset their disassembler options to NULL. */
1272 if (options
== NULL
)
1274 if (disassembler_options
!= NULL
)
1276 free (*disassembler_options
);
1277 *disassembler_options
= NULL
;
1282 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1283 if (valid_options_and_args
== NULL
)
1285 gdb_printf (gdb_stderr
, _("\
1286 'set disassembler-options ...' is not supported on this architecture.\n"));
1290 valid_options
= &valid_options_and_args
->options
;
1292 /* Verify we have valid disassembler options. */
1293 FOR_EACH_DISASSEMBLER_OPTION (opt
, options
)
1296 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1297 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1299 size_t len
= strlen (valid_options
->name
[i
]);
1304 if (memcmp (opt
, valid_options
->name
[i
], len
) != 0)
1307 if (valid_options
->arg
[i
]->values
== NULL
)
1309 for (j
= 0; valid_options
->arg
[i
]->values
[j
] != NULL
; j
++)
1310 if (disassembler_options_cmp
1311 (arg
, valid_options
->arg
[i
]->values
[j
]) == 0)
1319 else if (disassembler_options_cmp (opt
, valid_options
->name
[i
]) == 0)
1321 if (valid_options
->name
[i
] == NULL
)
1323 gdb_printf (gdb_stderr
,
1324 _("Invalid disassembler option value: '%s'.\n"),
1330 free (*disassembler_options
);
1331 *disassembler_options
= xstrdup (options
);
1335 set_disassembler_options_sfunc (const char *args
, int from_tty
,
1336 struct cmd_list_element
*c
)
1338 set_disassembler_options (prospective_options
.c_str ());
1342 show_disassembler_options_sfunc (struct ui_file
*file
, int from_tty
,
1343 struct cmd_list_element
*c
, const char *value
)
1345 struct gdbarch
*gdbarch
= get_current_arch ();
1346 const disasm_options_and_args_t
*valid_options_and_args
;
1347 const disasm_option_arg_t
*valid_args
;
1348 const disasm_options_t
*valid_options
;
1350 const char *options
= get_disassembler_options (gdbarch
);
1351 if (options
== NULL
)
1354 gdb_printf (file
, _("The current disassembler options are '%s'\n\n"),
1357 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1359 if (valid_options_and_args
== NULL
)
1361 gdb_puts (_("There are no disassembler options available "
1362 "for this architecture.\n"),
1367 valid_options
= &valid_options_and_args
->options
;
1369 gdb_printf (file
, _("\
1370 The following disassembler options are supported for use with the\n\
1371 'set disassembler-options OPTION [,OPTION]...' command:\n"));
1373 if (valid_options
->description
!= NULL
)
1375 size_t i
, max_len
= 0;
1377 gdb_printf (file
, "\n");
1379 /* Compute the length of the longest option name. */
1380 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1382 size_t len
= strlen (valid_options
->name
[i
]);
1384 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1385 len
+= strlen (valid_options
->arg
[i
]->name
);
1390 for (i
= 0, max_len
++; valid_options
->name
[i
] != NULL
; i
++)
1392 gdb_printf (file
, " %s", valid_options
->name
[i
]);
1393 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1394 gdb_printf (file
, "%s", valid_options
->arg
[i
]->name
);
1395 if (valid_options
->description
[i
] != NULL
)
1397 size_t len
= strlen (valid_options
->name
[i
]);
1399 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1400 len
+= strlen (valid_options
->arg
[i
]->name
);
1401 gdb_printf (file
, "%*c %s", (int) (max_len
- len
), ' ',
1402 valid_options
->description
[i
]);
1404 gdb_printf (file
, "\n");
1410 gdb_printf (file
, " ");
1411 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1413 gdb_printf (file
, "%s", valid_options
->name
[i
]);
1414 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1415 gdb_printf (file
, "%s", valid_options
->arg
[i
]->name
);
1416 if (valid_options
->name
[i
+ 1] != NULL
)
1417 gdb_printf (file
, ", ");
1418 file
->wrap_here (2);
1420 gdb_printf (file
, "\n");
1423 valid_args
= valid_options_and_args
->args
;
1424 if (valid_args
!= NULL
)
1428 for (i
= 0; valid_args
[i
].name
!= NULL
; i
++)
1430 if (valid_args
[i
].values
== NULL
)
1432 gdb_printf (file
, _("\n\
1433 For the options above, the following values are supported for \"%s\":\n "),
1434 valid_args
[i
].name
);
1435 for (j
= 0; valid_args
[i
].values
[j
] != NULL
; j
++)
1437 gdb_printf (file
, " %s", valid_args
[i
].values
[j
]);
1438 file
->wrap_here (3);
1440 gdb_printf (file
, "\n");
1445 /* A completion function for "set disassembler". */
1448 disassembler_options_completer (struct cmd_list_element
*ignore
,
1449 completion_tracker
&tracker
,
1450 const char *text
, const char *word
)
1452 struct gdbarch
*gdbarch
= get_current_arch ();
1453 const disasm_options_and_args_t
*opts_and_args
1454 = gdbarch_valid_disassembler_options (gdbarch
);
1456 if (opts_and_args
!= NULL
)
1458 const disasm_options_t
*opts
= &opts_and_args
->options
;
1460 /* Only attempt to complete on the last option text. */
1461 const char *separator
= strrchr (text
, ',');
1462 if (separator
!= NULL
)
1463 text
= separator
+ 1;
1464 text
= skip_spaces (text
);
1465 complete_on_enum (tracker
, opts
->name
, text
, word
);
1470 /* Initialization code. */
1472 void _initialize_disasm ();
1474 _initialize_disasm ()
1476 /* Add the command that controls the disassembler options. */
1477 set_show_commands set_show_disas_opts
1478 = add_setshow_string_noescape_cmd ("disassembler-options", no_class
,
1479 &prospective_options
, _("\
1480 Set the disassembler options.\n\
1481 Usage: set disassembler-options OPTION [,OPTION]...\n\n\
1482 See: 'show disassembler-options' for valid option values."), _("\
1483 Show the disassembler options."), NULL
,
1484 set_disassembler_options_sfunc
,
1485 show_disassembler_options_sfunc
,
1486 &setlist
, &showlist
);
1487 set_cmd_completer (set_show_disas_opts
.set
, disassembler_options_completer
);
1490 /* All the 'maint set|show libopcodes-styling' sub-commands. */
1491 static struct cmd_list_element
*maint_set_libopcodes_styling_cmdlist
;
1492 static struct cmd_list_element
*maint_show_libopcodes_styling_cmdlist
;
1494 /* Adds 'maint set|show libopcodes-styling'. */
1495 add_setshow_prefix_cmd ("libopcodes-styling", class_maintenance
,
1496 _("Set libopcodes-styling specific variables."),
1497 _("Show libopcodes-styling specific variables."),
1498 &maint_set_libopcodes_styling_cmdlist
,
1499 &maint_show_libopcodes_styling_cmdlist
,
1500 &maintenance_set_cmdlist
,
1501 &maintenance_show_cmdlist
);
1503 /* Adds 'maint set|show gnu-source-highlight enabled'. */
1504 add_setshow_boolean_cmd ("enabled", class_maintenance
,
1505 &use_libopcodes_styling_option
, _("\
1506 Set whether the libopcodes styling support should be used."), _("\
1507 Show whether the libopcodes styling support should be used."),_("\
1508 When enabled, GDB will try to make use of the builtin libopcodes styling\n\
1509 support, to style the disassembler output. Not every architecture has\n\
1510 styling support within libopcodes, so enabling this is not a guarantee\n\
1511 that libopcodes styling will be available.\n\
1513 When this option is disabled, GDB will make use of the Python Pygments\n\
1514 package (if available) to style the disassembler output.\n\
1516 All disassembler styling can be disabled with:\n\
1518 set style disassembler enabled off"),
1519 set_use_libopcodes_styling
,
1520 show_use_libopcodes_styling
,
1521 &maint_set_libopcodes_styling_cmdlist
,
1522 &maint_show_libopcodes_styling_cmdlist
);