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 /* 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_printing_disassembler::fprintf_func (void *stream
,
170 const char *format
, ...)
174 va_start (args
, format
);
175 gdb_vprintf ((struct ui_file
*) stream
, format
, args
);
177 /* Something non -ve. */
184 gdb_printing_disassembler::fprintf_styled_func (void *stream
,
185 enum disassembler_style style
,
186 const char *format
, ...)
190 va_start (args
, format
);
191 gdb_vprintf ((struct ui_file
*) stream
, format
, args
);
193 /* Something non -ve. */
198 line_is_less_than (const deprecated_dis_line_entry
&mle1
,
199 const deprecated_dis_line_entry
&mle2
)
203 /* End of sequence markers have a line number of 0 but don't want to
204 be sorted to the head of the list, instead sort by PC. */
205 if (mle1
.line
== 0 || mle2
.line
== 0)
207 if (mle1
.start_pc
!= mle2
.start_pc
)
208 val
= mle1
.start_pc
< mle2
.start_pc
;
210 val
= mle1
.line
< mle2
.line
;
214 if (mle1
.line
!= mle2
.line
)
215 val
= mle1
.line
< mle2
.line
;
217 val
= mle1
.start_pc
< mle2
.start_pc
;
225 gdb_pretty_print_disassembler::pretty_print_insn (const struct disasm_insn
*insn
,
226 gdb_disassembly_flags flags
)
228 /* parts of the symbolic representation of the address */
234 struct gdbarch
*gdbarch
= arch ();
237 ui_out_emit_tuple
tuple_emitter (m_uiout
, NULL
);
240 if (insn
->number
!= 0)
242 m_uiout
->field_unsigned ("insn-number", insn
->number
);
243 m_uiout
->text ("\t");
246 if ((flags
& DISASSEMBLY_SPECULATIVE
) != 0)
248 if (insn
->is_speculative
)
250 m_uiout
->field_string ("is-speculative", "?");
252 /* The speculative execution indication overwrites the first
253 character of the PC prefix.
254 We assume a PC prefix length of 3 characters. */
255 if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
256 m_uiout
->text (pc_prefix (pc
) + 1);
260 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
261 m_uiout
->text (pc_prefix (pc
));
265 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
266 m_uiout
->text (pc_prefix (pc
));
267 m_uiout
->field_core_addr ("address", gdbarch
, pc
);
269 std::string name
, filename
;
270 bool omit_fname
= ((flags
& DISASSEMBLY_OMIT_FNAME
) != 0);
271 if (!build_address_symbolic (gdbarch
, pc
, false, omit_fname
, &name
,
272 &offset
, &filename
, &line
, &unmapped
))
274 /* We don't care now about line, filename and unmapped. But we might in
276 m_uiout
->text (" <");
278 m_uiout
->field_string ("func-name", name
,
279 function_name_style
.style ());
280 /* For negative offsets, avoid displaying them as +-N; the sign of
281 the offset takes the place of the "+" here. */
284 m_uiout
->field_signed ("offset", offset
);
285 m_uiout
->text (">:\t");
288 m_uiout
->text (":\t");
290 /* Clear the buffer into which we will disassemble the instruction. */
293 /* A helper function to write the M_INSN_STB buffer, followed by a
294 newline. This can be called in a couple of situations. */
295 auto write_out_insn_buffer
= [&] ()
297 m_uiout
->field_stream ("inst", m_insn_stb
);
298 m_uiout
->text ("\n");
303 /* Now we can disassemble the instruction. If the disassembler
304 returns a negative value this indicates an error and is handled
305 within the print_insn call, resulting in an exception being
306 thrown. Returning zero makes no sense, as this indicates we
307 disassembled something successfully, but it was something of no
309 size
= m_di
.print_insn (pc
);
310 gdb_assert (size
> 0);
312 catch (const gdb_exception
&ex
)
314 /* An exception was thrown while disassembling the instruction.
315 However, the disassembler might still have written something
316 out, so ensure that we flush the instruction buffer before
317 rethrowing the exception. We can't perform this write from an
318 object destructor as the write itself might throw an exception
319 if the pager kicks in, and the user selects quit. */
320 write_out_insn_buffer ();
324 if (flags
& DISASSEMBLY_RAW_INSN
)
328 const char *spacer
= "";
330 /* Build the opcodes using a temporary stream so we can
331 write them out in a single go for the MI. */
332 m_opcode_stb
.clear ();
336 for (;pc
< end_pc
; ++pc
)
338 read_code (pc
, &data
, 1);
339 m_opcode_stb
.printf ("%s%02x", spacer
, (unsigned) data
);
343 m_uiout
->field_stream ("opcodes", m_opcode_stb
);
344 m_uiout
->text ("\t");
347 /* Disassembly was a success, write out the instruction buffer. */
348 write_out_insn_buffer ();
355 dump_insns (struct gdbarch
*gdbarch
,
356 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
357 int how_many
, gdb_disassembly_flags flags
, CORE_ADDR
*end_pc
)
359 struct disasm_insn insn
;
360 int num_displayed
= 0;
362 memset (&insn
, 0, sizeof (insn
));
365 gdb_pretty_print_disassembler
disasm (gdbarch
, uiout
);
367 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
371 size
= disasm
.pretty_print_insn (&insn
, flags
);
378 /* Allow user to bail out with ^C. */
385 return num_displayed
;
388 /* The idea here is to present a source-O-centric view of a
389 function to the user. This means that things are presented
390 in source order, with (possibly) out of order assembly
391 immediately following.
393 N.B. This view is deprecated. */
396 do_mixed_source_and_assembly_deprecated
397 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
398 struct symtab
*symtab
,
399 CORE_ADDR low
, CORE_ADDR high
,
400 int how_many
, gdb_disassembly_flags flags
)
404 struct linetable_entry
*le
;
405 struct deprecated_dis_line_entry
*mle
;
406 struct symtab_and_line sal
;
408 int out_of_order
= 0;
410 int num_displayed
= 0;
411 print_source_lines_flags psl_flags
= 0;
413 gdb_assert (symtab
!= nullptr && symtab
->linetable () != nullptr);
415 nlines
= symtab
->linetable ()->nitems
;
416 le
= symtab
->linetable ()->item
;
418 if (flags
& DISASSEMBLY_FILENAME
)
419 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
421 mle
= (struct deprecated_dis_line_entry
*)
422 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
424 /* Copy linetable entries for this function into our data
425 structure, creating end_pc's and setting out_of_order as
428 /* First, skip all the preceding functions. */
430 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
432 /* Now, copy all entries before the end of this function. */
434 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
436 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
437 continue; /* Ignore duplicates. */
439 /* Skip any end-of-function markers. */
443 mle
[newlines
].line
= le
[i
].line
;
444 if (le
[i
].line
> le
[i
+ 1].line
)
446 mle
[newlines
].start_pc
= le
[i
].pc
;
447 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
451 /* If we're on the last line, and it's part of the function,
452 then we need to get the end pc in a special way. */
454 if (i
== nlines
- 1 && le
[i
].pc
< high
)
456 mle
[newlines
].line
= le
[i
].line
;
457 mle
[newlines
].start_pc
= le
[i
].pc
;
458 sal
= find_pc_line (le
[i
].pc
, 0);
459 mle
[newlines
].end_pc
= sal
.end
;
463 /* Now, sort mle by line #s (and, then by addresses within lines). */
466 std::sort (mle
, mle
+ newlines
, line_is_less_than
);
468 /* Now, for each line entry, emit the specified lines (unless
469 they have been emitted before), followed by the assembly code
472 ui_out_emit_list
asm_insns_list (uiout
, "asm_insns");
474 gdb::optional
<ui_out_emit_tuple
> outer_tuple_emitter
;
475 gdb::optional
<ui_out_emit_list
> inner_list_emitter
;
477 for (i
= 0; i
< newlines
; i
++)
479 /* Print out everything from next_line to the current line. */
480 if (mle
[i
].line
>= next_line
)
484 /* Just one line to print. */
485 if (next_line
== mle
[i
].line
)
487 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
488 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
492 /* Several source lines w/o asm instructions associated. */
493 for (; next_line
< mle
[i
].line
; next_line
++)
495 ui_out_emit_tuple
tuple_emitter (uiout
,
497 print_source_lines (symtab
, next_line
, next_line
+ 1,
499 ui_out_emit_list
temp_list_emitter (uiout
,
502 /* Print the last line and leave list open for
503 asm instructions to be added. */
504 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
505 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
510 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
511 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
514 next_line
= mle
[i
].line
+ 1;
515 inner_list_emitter
.emplace (uiout
, "line_asm_insn");
518 num_displayed
+= dump_insns (gdbarch
, uiout
,
519 mle
[i
].start_pc
, mle
[i
].end_pc
,
520 how_many
, flags
, NULL
);
522 /* When we've reached the end of the mle array, or we've seen the last
523 assembly range for this source line, close out the list/tuple. */
524 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
526 inner_list_emitter
.reset ();
527 outer_tuple_emitter
.reset ();
530 if (how_many
>= 0 && num_displayed
>= how_many
)
535 /* The idea here is to present a source-O-centric view of a
536 function to the user. This means that things are presented
537 in source order, with (possibly) out of order assembly
538 immediately following. */
541 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
542 struct ui_out
*uiout
,
543 struct symtab
*main_symtab
,
544 CORE_ADDR low
, CORE_ADDR high
,
545 int how_many
, gdb_disassembly_flags flags
)
547 const struct linetable_entry
*le
, *first_le
;
549 int num_displayed
= 0;
550 print_source_lines_flags psl_flags
= 0;
552 struct symtab
*last_symtab
;
555 gdb_assert (main_symtab
!= NULL
&& main_symtab
->linetable () != NULL
);
557 /* First pass: collect the list of all source files and lines.
558 We do this so that we can only print lines containing code once.
559 We try to print the source text leading up to the next instruction,
560 but if that text is for code that will be disassembled later, then
561 we'll want to defer printing it until later with its associated code. */
563 htab_up
dis_line_table (allocate_dis_line_table ());
567 /* The prologue may be empty, but there may still be a line number entry
568 for the opening brace which is distinct from the first line of code.
569 If the prologue has been eliminated find_pc_line may return the source
570 line after the opening brace. We still want to print this opening brace.
571 first_le is used to implement this. */
573 nlines
= main_symtab
->linetable ()->nitems
;
574 le
= main_symtab
->linetable ()->item
;
577 /* Skip all the preceding functions. */
578 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
581 if (i
< nlines
&& le
[i
].pc
< high
)
584 /* Add lines for every pc value. */
587 struct symtab_and_line sal
;
590 sal
= find_pc_line (pc
, 0);
591 length
= gdb_insn_length (gdbarch
, pc
);
594 if (sal
.symtab
!= NULL
)
595 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
598 /* Second pass: print the disassembly.
600 Output format, from an MI perspective:
601 The result is a ui_out list, field name "asm_insns", where elements have
602 name "src_and_asm_line".
603 Each element is a tuple of source line specs (field names line, file,
604 fullname), and field "line_asm_insn" which contains the disassembly.
605 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
608 CLI output works on top of this because MI ignores ui_out_text output,
609 which is where we put file name and source line contents output.
613 Handles the outer "asm_insns" list.
615 The tuples for each group of consecutive disassemblies.
617 List of consecutive source lines or disassembled insns. */
619 if (flags
& DISASSEMBLY_FILENAME
)
620 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
622 ui_out_emit_list
asm_insns_emitter (uiout
, "asm_insns");
624 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
625 gdb::optional
<ui_out_emit_list
> list_emitter
;
633 struct symtab_and_line sal
;
635 int start_preceding_line_to_display
= 0;
636 int end_preceding_line_to_display
= 0;
637 int new_source_line
= 0;
639 sal
= find_pc_line (pc
, 0);
641 if (sal
.symtab
!= last_symtab
)
643 /* New source file. */
646 /* If this is the first line of output, check for any preceding
650 && first_le
->line
< sal
.line
)
652 start_preceding_line_to_display
= first_le
->line
;
653 end_preceding_line_to_display
= sal
.line
;
658 /* Same source file as last time. */
659 if (sal
.symtab
!= NULL
)
661 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
665 /* Several preceding source lines. Print the trailing ones
666 not associated with code that we'll print later. */
667 for (l
= sal
.line
- 1; l
> last_line
; --l
)
669 if (line_has_code_p (dis_line_table
.get (),
673 if (l
< sal
.line
- 1)
675 start_preceding_line_to_display
= l
+ 1;
676 end_preceding_line_to_display
= sal
.line
;
679 if (sal
.line
!= last_line
)
683 /* Same source line as last time. This can happen, depending
684 on the debug info. */
691 /* Skip the newline if this is the first instruction. */
694 if (tuple_emitter
.has_value ())
696 gdb_assert (list_emitter
.has_value ());
697 list_emitter
.reset ();
698 tuple_emitter
.reset ();
700 if (sal
.symtab
!= last_symtab
701 && !(flags
& DISASSEMBLY_FILENAME
))
703 /* Remember MI ignores ui_out_text.
704 We don't have to do anything here for MI because MI
705 output includes the source specs for each line. */
706 if (sal
.symtab
!= NULL
)
708 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
711 uiout
->text ("unknown");
714 if (start_preceding_line_to_display
> 0)
716 /* Several source lines w/o asm instructions associated.
717 We need to preserve the structure of the output, so output
718 a bunch of line tuples with no asm entries. */
721 gdb_assert (sal
.symtab
!= NULL
);
722 for (l
= start_preceding_line_to_display
;
723 l
< end_preceding_line_to_display
;
726 ui_out_emit_tuple
line_tuple_emitter (uiout
,
728 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
729 ui_out_emit_list
chain_line_emitter (uiout
, "line_asm_insn");
732 tuple_emitter
.emplace (uiout
, "src_and_asm_line");
733 if (sal
.symtab
!= NULL
)
734 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
736 uiout
->text (_("--- no source info for this pc ---\n"));
737 list_emitter
.emplace (uiout
, "line_asm_insn");
741 /* Here we're appending instructions to an existing line.
742 By construction the very first insn will have a symtab
743 and follow the new_source_line path above. */
744 gdb_assert (tuple_emitter
.has_value ());
745 gdb_assert (list_emitter
.has_value ());
749 end_pc
= std::min (sal
.end
, high
);
752 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
753 how_many
, flags
, &end_pc
);
756 if (how_many
>= 0 && num_displayed
>= how_many
)
759 last_symtab
= sal
.symtab
;
760 last_line
= sal
.line
;
765 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
766 CORE_ADDR low
, CORE_ADDR high
,
767 int how_many
, gdb_disassembly_flags flags
)
769 ui_out_emit_list
list_emitter (uiout
, "asm_insns");
771 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
774 /* Combine implicit and user disassembler options and return them
775 in a newly-created string. */
778 get_all_disassembler_options (struct gdbarch
*gdbarch
)
780 const char *implicit
= gdbarch_disassembler_options_implicit (gdbarch
);
781 const char *options
= get_disassembler_options (gdbarch
);
782 const char *comma
= ",";
784 if (implicit
== nullptr)
790 if (options
== nullptr)
796 return string_printf ("%s%s%s", implicit
, comma
, options
);
799 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
800 struct ui_file
*file
,
801 read_memory_ftype func
)
802 : gdb_printing_disassembler (gdbarch
, &m_buffer
, func
,
803 dis_asm_memory_error
, dis_asm_print_address
),
804 m_buffer (!use_ext_lang_colorization_p
&& disassembler_styling
805 && file
->can_emit_style_escape ()),
811 gdb_disassemble_info::gdb_disassemble_info
812 (struct gdbarch
*gdbarch
, struct ui_file
*stream
,
813 read_memory_ftype read_memory_func
, memory_error_ftype memory_error_func
,
814 print_address_ftype print_address_func
, fprintf_ftype fprintf_func
,
815 fprintf_styled_ftype fprintf_styled_func
)
816 : m_gdbarch (gdbarch
)
818 gdb_assert (fprintf_func
!= nullptr);
819 gdb_assert (fprintf_styled_func
!= nullptr);
820 init_disassemble_info (&m_di
, stream
, fprintf_func
,
821 fprintf_styled_func
);
822 m_di
.flavour
= bfd_target_unknown_flavour
;
824 /* The memory_error_func, print_address_func, and read_memory_func are
825 all initialized to a default (non-nullptr) value by the call to
826 init_disassemble_info above. If the user is overriding these fields
827 (by passing non-nullptr values) then do that now, otherwise, leave
828 these fields as the defaults. */
829 if (memory_error_func
!= nullptr)
830 m_di
.memory_error_func
= memory_error_func
;
831 if (print_address_func
!= nullptr)
832 m_di
.print_address_func
= print_address_func
;
833 if (read_memory_func
!= nullptr)
834 m_di
.read_memory_func
= read_memory_func
;
836 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
837 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
838 m_di
.endian
= gdbarch_byte_order (gdbarch
);
839 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
840 m_di
.application_data
= this;
841 m_disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
842 if (!m_disassembler_options_holder
.empty ())
843 m_di
.disassembler_options
= m_disassembler_options_holder
.c_str ();
844 disassemble_init_for_target (&m_di
);
849 gdb_disassemble_info::~gdb_disassemble_info ()
851 disassemble_free_target (&m_di
);
854 /* Wrapper around calling gdbarch_print_insn. This function takes care of
855 first calling the extension language hooks for print_insn, and, if none
856 of the extension languages can print this instruction, calls
857 gdbarch_print_insn to do the work.
859 GDBARCH is the architecture to disassemble in, VMA is the address of the
860 instruction being disassembled, and INFO is the libopcodes disassembler
861 related information. */
864 gdb_print_insn_1 (struct gdbarch
*gdbarch
, CORE_ADDR vma
,
865 struct disassemble_info
*info
)
867 /* Call into the extension languages to do the disassembly. */
868 gdb::optional
<int> length
= ext_lang_print_insn (gdbarch
, vma
, info
);
869 if (length
.has_value ())
872 /* No extension language wanted to do the disassembly, so do it
874 return gdbarch_print_insn (gdbarch
, vma
, info
);
879 bool gdb_disassembler::use_ext_lang_colorization_p
= true;
884 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
885 int *branch_delay_insns
)
887 m_err_memaddr
.reset ();
890 int length
= gdb_print_insn_1 (arch (), memaddr
, &m_di
);
892 /* If we have successfully disassembled an instruction, styling is on, we
893 think that the extension language might be able to perform styling for
894 us, and the destination can support styling, then lets call into the
895 extension languages in order to style this output. */
896 if (length
> 0 && disassembler_styling
897 && use_ext_lang_colorization_p
898 && m_dest
->can_emit_style_escape ())
900 gdb::optional
<std::string
> ext_contents
;
901 ext_contents
= ext_lang_colorize_disasm (m_buffer
.string (), arch ());
902 if (ext_contents
.has_value ())
903 m_buffer
= std::move (*ext_contents
);
906 /* The extension language failed to add styling to the
907 disassembly output. Set the static flag so that next time we
908 disassemble we don't even bother attempting to use the
909 extension language for styling. */
910 use_ext_lang_colorization_p
= false;
912 /* The instruction we just disassembled, and the extension
913 languages failed to style, might have otherwise had some
914 minimal styling applied by GDB. To regain that styling we
915 need to recreate m_buffer, but this time with styling support.
917 To do this we perform an in-place new, but this time turn on
918 the styling support, then we can re-disassembly the
919 instruction, and gain any minimal styling GDB might add. */
920 gdb_static_assert ((std::is_same
<decltype (m_buffer
),
921 string_file
>::value
));
922 gdb_assert (!m_buffer
.term_out ());
923 m_buffer
.~string_file ();
924 new (&m_buffer
) string_file (true);
925 length
= gdb_print_insn_1 (arch (), memaddr
, &m_di
);
926 gdb_assert (length
> 0);
930 /* Push any disassemble output to the real destination stream. We do
931 this even if the disassembler reported failure (-1) as the
932 disassembler may have printed something to its output stream. */
933 m_di
.fprintf_func (m_dest
, "%s", m_buffer
.c_str ());
935 /* If the disassembler failed then report an appropriate error. */
938 if (m_err_memaddr
.has_value ())
939 memory_error (TARGET_XFER_E_IO
, *m_err_memaddr
);
941 error (_("unknown disassembler error (error = %d)"), length
);
944 if (branch_delay_insns
!= NULL
)
946 if (m_di
.insn_info_valid
)
947 *branch_delay_insns
= m_di
.branch_delay_insns
;
949 *branch_delay_insns
= 0;
955 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
956 gdb_disassembly_flags flags
, int how_many
,
957 CORE_ADDR low
, CORE_ADDR high
)
959 struct symtab
*symtab
;
962 /* Assume symtab is valid for whole PC range. */
963 symtab
= find_pc_line_symtab (low
);
965 if (symtab
!= NULL
&& symtab
->linetable () != NULL
)
966 nlines
= symtab
->linetable ()->nitems
;
968 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
970 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
972 else if (flags
& DISASSEMBLY_SOURCE
)
973 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
976 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
977 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
978 low
, high
, how_many
, flags
);
980 gdb_flush (gdb_stdout
);
983 /* Print the instruction at address MEMADDR in debugged memory,
984 on STREAM. Returns the length of the instruction, in bytes,
985 and, if requested, the number of branch delay slot instructions. */
988 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
989 struct ui_file
*stream
, int *branch_delay_insns
)
992 gdb_disassembler
di (gdbarch
, stream
);
994 return di
.print_insn (memaddr
, branch_delay_insns
);
997 /* Return the length in bytes of the instruction at address MEMADDR in
1001 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
1003 return gdb_print_insn (gdbarch
, addr
, &null_stream
, NULL
);
1006 /* An fprintf-function for use by the disassembler when we know we don't
1007 want to print anything. Always returns success. */
1009 static int ATTRIBUTE_PRINTF (2, 3)
1010 gdb_disasm_null_printf (void *stream
, const char *format
, ...)
1015 /* An fprintf-function for use by the disassembler when we know we don't
1016 want to print anything, and the disassembler is using style. Always
1019 static int ATTRIBUTE_PRINTF (3, 4)
1020 gdb_disasm_null_styled_printf (void *stream
,
1021 enum disassembler_style style
,
1022 const char *format
, ...)
1030 init_disassemble_info_for_no_printing (struct disassemble_info
*dinfo
)
1032 init_disassemble_info (dinfo
, nullptr, gdb_disasm_null_printf
,
1033 gdb_disasm_null_styled_printf
);
1036 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.
1037 Upon return, *DISASSEMBLER_OPTIONS_HOLDER owns the string pointed
1038 to by DI.DISASSEMBLER_OPTIONS. */
1041 gdb_buffered_insn_length_init_dis (struct gdbarch
*gdbarch
,
1042 struct disassemble_info
*di
,
1043 const gdb_byte
*insn
, int max_len
,
1045 std::string
*disassembler_options_holder
)
1047 init_disassemble_info_for_no_printing (di
);
1049 /* init_disassemble_info installs buffer_read_memory, etc.
1050 so we don't need to do that here.
1051 The cast is necessary until disassemble_info is const-ified. */
1052 di
->buffer
= (gdb_byte
*) insn
;
1053 di
->buffer_length
= max_len
;
1054 di
->buffer_vma
= addr
;
1056 di
->arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
1057 di
->mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
1058 di
->endian
= gdbarch_byte_order (gdbarch
);
1059 di
->endian_code
= gdbarch_byte_order_for_code (gdbarch
);
1061 *disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
1062 if (!disassembler_options_holder
->empty ())
1063 di
->disassembler_options
= disassembler_options_holder
->c_str ();
1064 disassemble_init_for_target (di
);
1067 /* Return the length in bytes of INSN. MAX_LEN is the size of the
1068 buffer containing INSN. */
1071 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
1072 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
1074 struct disassemble_info di
;
1075 std::string disassembler_options_holder
;
1077 gdb_buffered_insn_length_init_dis (gdbarch
, &di
, insn
, max_len
, addr
,
1078 &disassembler_options_holder
);
1080 int result
= gdb_print_insn_1 (gdbarch
, addr
, &di
);
1081 disassemble_free_target (&di
);
1086 get_disassembler_options (struct gdbarch
*gdbarch
)
1088 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
1089 if (disassembler_options
== NULL
)
1091 return *disassembler_options
;
1095 set_disassembler_options (const char *prospective_options
)
1097 struct gdbarch
*gdbarch
= get_current_arch ();
1098 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
1099 const disasm_options_and_args_t
*valid_options_and_args
;
1100 const disasm_options_t
*valid_options
;
1101 gdb::unique_xmalloc_ptr
<char> prospective_options_local
1102 = make_unique_xstrdup (prospective_options
);
1103 char *options
= remove_whitespace_and_extra_commas
1104 (prospective_options_local
.get ());
1107 /* Allow all architectures, even ones that do not support 'set disassembler',
1108 to reset their disassembler options to NULL. */
1109 if (options
== NULL
)
1111 if (disassembler_options
!= NULL
)
1113 free (*disassembler_options
);
1114 *disassembler_options
= NULL
;
1119 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1120 if (valid_options_and_args
== NULL
)
1122 gdb_printf (gdb_stderr
, _("\
1123 'set disassembler-options ...' is not supported on this architecture.\n"));
1127 valid_options
= &valid_options_and_args
->options
;
1129 /* Verify we have valid disassembler options. */
1130 FOR_EACH_DISASSEMBLER_OPTION (opt
, options
)
1133 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1134 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1136 size_t len
= strlen (valid_options
->name
[i
]);
1141 if (memcmp (opt
, valid_options
->name
[i
], len
) != 0)
1144 for (j
= 0; valid_options
->arg
[i
]->values
[j
] != NULL
; j
++)
1145 if (disassembler_options_cmp
1146 (arg
, valid_options
->arg
[i
]->values
[j
]) == 0)
1154 else if (disassembler_options_cmp (opt
, valid_options
->name
[i
]) == 0)
1156 if (valid_options
->name
[i
] == NULL
)
1158 gdb_printf (gdb_stderr
,
1159 _("Invalid disassembler option value: '%s'.\n"),
1165 free (*disassembler_options
);
1166 *disassembler_options
= xstrdup (options
);
1170 set_disassembler_options_sfunc (const char *args
, int from_tty
,
1171 struct cmd_list_element
*c
)
1173 set_disassembler_options (prospective_options
.c_str ());
1177 show_disassembler_options_sfunc (struct ui_file
*file
, int from_tty
,
1178 struct cmd_list_element
*c
, const char *value
)
1180 struct gdbarch
*gdbarch
= get_current_arch ();
1181 const disasm_options_and_args_t
*valid_options_and_args
;
1182 const disasm_option_arg_t
*valid_args
;
1183 const disasm_options_t
*valid_options
;
1185 const char *options
= get_disassembler_options (gdbarch
);
1186 if (options
== NULL
)
1189 gdb_printf (file
, _("The current disassembler options are '%s'\n\n"),
1192 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1194 if (valid_options_and_args
== NULL
)
1196 gdb_puts (_("There are no disassembler options available "
1197 "for this architecture.\n"),
1202 valid_options
= &valid_options_and_args
->options
;
1204 gdb_printf (file
, _("\
1205 The following disassembler options are supported for use with the\n\
1206 'set disassembler-options OPTION [,OPTION]...' command:\n"));
1208 if (valid_options
->description
!= NULL
)
1210 size_t i
, max_len
= 0;
1212 gdb_printf (file
, "\n");
1214 /* Compute the length of the longest option name. */
1215 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1217 size_t len
= strlen (valid_options
->name
[i
]);
1219 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1220 len
+= strlen (valid_options
->arg
[i
]->name
);
1225 for (i
= 0, max_len
++; valid_options
->name
[i
] != NULL
; i
++)
1227 gdb_printf (file
, " %s", valid_options
->name
[i
]);
1228 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1229 gdb_printf (file
, "%s", valid_options
->arg
[i
]->name
);
1230 if (valid_options
->description
[i
] != NULL
)
1232 size_t len
= strlen (valid_options
->name
[i
]);
1234 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1235 len
+= strlen (valid_options
->arg
[i
]->name
);
1236 gdb_printf (file
, "%*c %s", (int) (max_len
- len
), ' ',
1237 valid_options
->description
[i
]);
1239 gdb_printf (file
, "\n");
1245 gdb_printf (file
, " ");
1246 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1248 gdb_printf (file
, "%s", valid_options
->name
[i
]);
1249 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1250 gdb_printf (file
, "%s", valid_options
->arg
[i
]->name
);
1251 if (valid_options
->name
[i
+ 1] != NULL
)
1252 gdb_printf (file
, ", ");
1253 file
->wrap_here (2);
1255 gdb_printf (file
, "\n");
1258 valid_args
= valid_options_and_args
->args
;
1259 if (valid_args
!= NULL
)
1263 for (i
= 0; valid_args
[i
].name
!= NULL
; i
++)
1265 gdb_printf (file
, _("\n\
1266 For the options above, the following values are supported for \"%s\":\n "),
1267 valid_args
[i
].name
);
1268 for (j
= 0; valid_args
[i
].values
[j
] != NULL
; j
++)
1270 gdb_printf (file
, " %s", valid_args
[i
].values
[j
]);
1271 file
->wrap_here (3);
1273 gdb_printf (file
, "\n");
1278 /* A completion function for "set disassembler". */
1281 disassembler_options_completer (struct cmd_list_element
*ignore
,
1282 completion_tracker
&tracker
,
1283 const char *text
, const char *word
)
1285 struct gdbarch
*gdbarch
= get_current_arch ();
1286 const disasm_options_and_args_t
*opts_and_args
1287 = gdbarch_valid_disassembler_options (gdbarch
);
1289 if (opts_and_args
!= NULL
)
1291 const disasm_options_t
*opts
= &opts_and_args
->options
;
1293 /* Only attempt to complete on the last option text. */
1294 const char *separator
= strrchr (text
, ',');
1295 if (separator
!= NULL
)
1296 text
= separator
+ 1;
1297 text
= skip_spaces (text
);
1298 complete_on_enum (tracker
, opts
->name
, text
, word
);
1303 /* Initialization code. */
1305 void _initialize_disasm ();
1307 _initialize_disasm ()
1309 /* Add the command that controls the disassembler options. */
1310 set_show_commands set_show_disas_opts
1311 = add_setshow_string_noescape_cmd ("disassembler-options", no_class
,
1312 &prospective_options
, _("\
1313 Set the disassembler options.\n\
1314 Usage: set disassembler-options OPTION [,OPTION]...\n\n\
1315 See: 'show disassembler-options' for valid option values."), _("\
1316 Show the disassembler options."), NULL
,
1317 set_disassembler_options_sfunc
,
1318 show_disassembler_options_sfunc
,
1319 &setlist
, &showlist
);
1320 set_cmd_completer (set_show_disas_opts
.set
, disassembler_options_completer
);