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");
273 /* Clear the buffer into which we will disassemble the instruction. */
276 /* A helper function to write the M_INSN_STB buffer, followed by a
277 newline. This can be called in a couple of situations. */
278 auto write_out_insn_buffer
= [&] ()
280 m_uiout
->field_stream ("inst", m_insn_stb
);
281 m_uiout
->text ("\n");
286 /* Now we can disassemble the instruction. If the disassembler
287 returns a negative value this indicates an error and is handled
288 within the print_insn call, resulting in an exception being
289 thrown. Returning zero makes no sense, as this indicates we
290 disassembled something successfully, but it was something of no
292 size
= m_di
.print_insn (pc
);
293 gdb_assert (size
> 0);
295 catch (const gdb_exception
&ex
)
297 /* An exception was thrown while disassembling the instruction.
298 However, the disassembler might still have written something
299 out, so ensure that we flush the instruction buffer before
300 rethrowing the exception. We can't perform this write from an
301 object destructor as the write itself might throw an exception
302 if the pager kicks in, and the user selects quit. */
303 write_out_insn_buffer ();
307 if (flags
& DISASSEMBLY_RAW_INSN
)
311 const char *spacer
= "";
313 /* Build the opcodes using a temporary stream so we can
314 write them out in a single go for the MI. */
315 m_opcode_stb
.clear ();
319 for (;pc
< end_pc
; ++pc
)
321 read_code (pc
, &data
, 1);
322 m_opcode_stb
.printf ("%s%02x", spacer
, (unsigned) data
);
326 m_uiout
->field_stream ("opcodes", m_opcode_stb
);
327 m_uiout
->text ("\t");
330 /* Disassembly was a success, write out the instruction buffer. */
331 write_out_insn_buffer ();
338 dump_insns (struct gdbarch
*gdbarch
,
339 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
340 int how_many
, gdb_disassembly_flags flags
, CORE_ADDR
*end_pc
)
342 struct disasm_insn insn
;
343 int num_displayed
= 0;
345 memset (&insn
, 0, sizeof (insn
));
348 gdb_pretty_print_disassembler
disasm (gdbarch
, uiout
);
350 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
354 size
= disasm
.pretty_print_insn (&insn
, flags
);
361 /* Allow user to bail out with ^C. */
368 return num_displayed
;
371 /* The idea here is to present a source-O-centric view of a
372 function to the user. This means that things are presented
373 in source order, with (possibly) out of order assembly
374 immediately following.
376 N.B. This view is deprecated. */
379 do_mixed_source_and_assembly_deprecated
380 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
381 struct symtab
*symtab
,
382 CORE_ADDR low
, CORE_ADDR high
,
383 int how_many
, gdb_disassembly_flags flags
)
387 struct linetable_entry
*le
;
388 struct deprecated_dis_line_entry
*mle
;
389 struct symtab_and_line sal
;
391 int out_of_order
= 0;
393 int num_displayed
= 0;
394 print_source_lines_flags psl_flags
= 0;
396 gdb_assert (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
);
398 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
399 le
= SYMTAB_LINETABLE (symtab
)->item
;
401 if (flags
& DISASSEMBLY_FILENAME
)
402 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
404 mle
= (struct deprecated_dis_line_entry
*)
405 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
407 /* Copy linetable entries for this function into our data
408 structure, creating end_pc's and setting out_of_order as
411 /* First, skip all the preceding functions. */
413 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
415 /* Now, copy all entries before the end of this function. */
417 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
419 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
420 continue; /* Ignore duplicates. */
422 /* Skip any end-of-function markers. */
426 mle
[newlines
].line
= le
[i
].line
;
427 if (le
[i
].line
> le
[i
+ 1].line
)
429 mle
[newlines
].start_pc
= le
[i
].pc
;
430 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
434 /* If we're on the last line, and it's part of the function,
435 then we need to get the end pc in a special way. */
437 if (i
== nlines
- 1 && le
[i
].pc
< high
)
439 mle
[newlines
].line
= le
[i
].line
;
440 mle
[newlines
].start_pc
= le
[i
].pc
;
441 sal
= find_pc_line (le
[i
].pc
, 0);
442 mle
[newlines
].end_pc
= sal
.end
;
446 /* Now, sort mle by line #s (and, then by addresses within lines). */
449 std::sort (mle
, mle
+ newlines
, line_is_less_than
);
451 /* Now, for each line entry, emit the specified lines (unless
452 they have been emitted before), followed by the assembly code
455 ui_out_emit_list
asm_insns_list (uiout
, "asm_insns");
457 gdb::optional
<ui_out_emit_tuple
> outer_tuple_emitter
;
458 gdb::optional
<ui_out_emit_list
> inner_list_emitter
;
460 for (i
= 0; i
< newlines
; i
++)
462 /* Print out everything from next_line to the current line. */
463 if (mle
[i
].line
>= next_line
)
467 /* Just one line to print. */
468 if (next_line
== mle
[i
].line
)
470 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
471 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
475 /* Several source lines w/o asm instructions associated. */
476 for (; next_line
< mle
[i
].line
; next_line
++)
478 ui_out_emit_tuple
tuple_emitter (uiout
,
480 print_source_lines (symtab
, next_line
, next_line
+ 1,
482 ui_out_emit_list
temp_list_emitter (uiout
,
485 /* Print the last line and leave list open for
486 asm instructions to be added. */
487 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
488 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
493 outer_tuple_emitter
.emplace (uiout
, "src_and_asm_line");
494 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
497 next_line
= mle
[i
].line
+ 1;
498 inner_list_emitter
.emplace (uiout
, "line_asm_insn");
501 num_displayed
+= dump_insns (gdbarch
, uiout
,
502 mle
[i
].start_pc
, mle
[i
].end_pc
,
503 how_many
, flags
, NULL
);
505 /* When we've reached the end of the mle array, or we've seen the last
506 assembly range for this source line, close out the list/tuple. */
507 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
509 inner_list_emitter
.reset ();
510 outer_tuple_emitter
.reset ();
513 if (how_many
>= 0 && num_displayed
>= how_many
)
518 /* The idea here is to present a source-O-centric view of a
519 function to the user. This means that things are presented
520 in source order, with (possibly) out of order assembly
521 immediately following. */
524 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
525 struct ui_out
*uiout
,
526 struct symtab
*main_symtab
,
527 CORE_ADDR low
, CORE_ADDR high
,
528 int how_many
, gdb_disassembly_flags flags
)
530 const struct linetable_entry
*le
, *first_le
;
532 int num_displayed
= 0;
533 print_source_lines_flags psl_flags
= 0;
535 struct symtab
*last_symtab
;
538 gdb_assert (main_symtab
!= NULL
&& SYMTAB_LINETABLE (main_symtab
) != NULL
);
540 /* First pass: collect the list of all source files and lines.
541 We do this so that we can only print lines containing code once.
542 We try to print the source text leading up to the next instruction,
543 but if that text is for code that will be disassembled later, then
544 we'll want to defer printing it until later with its associated code. */
546 htab_up
dis_line_table (allocate_dis_line_table ());
550 /* The prologue may be empty, but there may still be a line number entry
551 for the opening brace which is distinct from the first line of code.
552 If the prologue has been eliminated find_pc_line may return the source
553 line after the opening brace. We still want to print this opening brace.
554 first_le is used to implement this. */
556 nlines
= SYMTAB_LINETABLE (main_symtab
)->nitems
;
557 le
= SYMTAB_LINETABLE (main_symtab
)->item
;
560 /* Skip all the preceding functions. */
561 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
564 if (i
< nlines
&& le
[i
].pc
< high
)
567 /* Add lines for every pc value. */
570 struct symtab_and_line sal
;
573 sal
= find_pc_line (pc
, 0);
574 length
= gdb_insn_length (gdbarch
, pc
);
577 if (sal
.symtab
!= NULL
)
578 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
581 /* Second pass: print the disassembly.
583 Output format, from an MI perspective:
584 The result is a ui_out list, field name "asm_insns", where elements have
585 name "src_and_asm_line".
586 Each element is a tuple of source line specs (field names line, file,
587 fullname), and field "line_asm_insn" which contains the disassembly.
588 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
591 CLI output works on top of this because MI ignores ui_out_text output,
592 which is where we put file name and source line contents output.
596 Handles the outer "asm_insns" list.
598 The tuples for each group of consecutive disassemblies.
600 List of consecutive source lines or disassembled insns. */
602 if (flags
& DISASSEMBLY_FILENAME
)
603 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
605 ui_out_emit_list
asm_insns_emitter (uiout
, "asm_insns");
607 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
608 gdb::optional
<ui_out_emit_list
> list_emitter
;
616 struct symtab_and_line sal
;
618 int start_preceding_line_to_display
= 0;
619 int end_preceding_line_to_display
= 0;
620 int new_source_line
= 0;
622 sal
= find_pc_line (pc
, 0);
624 if (sal
.symtab
!= last_symtab
)
626 /* New source file. */
629 /* If this is the first line of output, check for any preceding
633 && first_le
->line
< sal
.line
)
635 start_preceding_line_to_display
= first_le
->line
;
636 end_preceding_line_to_display
= sal
.line
;
641 /* Same source file as last time. */
642 if (sal
.symtab
!= NULL
)
644 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
648 /* Several preceding source lines. Print the trailing ones
649 not associated with code that we'll print later. */
650 for (l
= sal
.line
- 1; l
> last_line
; --l
)
652 if (line_has_code_p (dis_line_table
.get (),
656 if (l
< sal
.line
- 1)
658 start_preceding_line_to_display
= l
+ 1;
659 end_preceding_line_to_display
= sal
.line
;
662 if (sal
.line
!= last_line
)
666 /* Same source line as last time. This can happen, depending
667 on the debug info. */
674 /* Skip the newline if this is the first instruction. */
677 if (tuple_emitter
.has_value ())
679 gdb_assert (list_emitter
.has_value ());
680 list_emitter
.reset ();
681 tuple_emitter
.reset ();
683 if (sal
.symtab
!= last_symtab
684 && !(flags
& DISASSEMBLY_FILENAME
))
686 /* Remember MI ignores ui_out_text.
687 We don't have to do anything here for MI because MI
688 output includes the source specs for each line. */
689 if (sal
.symtab
!= NULL
)
691 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
694 uiout
->text ("unknown");
697 if (start_preceding_line_to_display
> 0)
699 /* Several source lines w/o asm instructions associated.
700 We need to preserve the structure of the output, so output
701 a bunch of line tuples with no asm entries. */
704 gdb_assert (sal
.symtab
!= NULL
);
705 for (l
= start_preceding_line_to_display
;
706 l
< end_preceding_line_to_display
;
709 ui_out_emit_tuple
line_tuple_emitter (uiout
,
711 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
712 ui_out_emit_list
chain_line_emitter (uiout
, "line_asm_insn");
715 tuple_emitter
.emplace (uiout
, "src_and_asm_line");
716 if (sal
.symtab
!= NULL
)
717 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
719 uiout
->text (_("--- no source info for this pc ---\n"));
720 list_emitter
.emplace (uiout
, "line_asm_insn");
724 /* Here we're appending instructions to an existing line.
725 By construction the very first insn will have a symtab
726 and follow the new_source_line path above. */
727 gdb_assert (tuple_emitter
.has_value ());
728 gdb_assert (list_emitter
.has_value ());
732 end_pc
= std::min (sal
.end
, high
);
735 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
736 how_many
, flags
, &end_pc
);
739 if (how_many
>= 0 && num_displayed
>= how_many
)
742 last_symtab
= sal
.symtab
;
743 last_line
= sal
.line
;
748 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
749 CORE_ADDR low
, CORE_ADDR high
,
750 int how_many
, gdb_disassembly_flags flags
)
752 ui_out_emit_list
list_emitter (uiout
, "asm_insns");
754 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
757 /* Combine implicit and user disassembler options and return them
758 in a newly-created string. */
761 get_all_disassembler_options (struct gdbarch
*gdbarch
)
763 const char *implicit
= gdbarch_disassembler_options_implicit (gdbarch
);
764 const char *options
= get_disassembler_options (gdbarch
);
765 const char *comma
= ",";
767 if (implicit
== nullptr)
773 if (options
== nullptr)
779 return string_printf ("%s%s%s", implicit
, comma
, options
);
782 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
783 struct ui_file
*file
,
784 di_read_memory_ftype read_memory_func
)
785 : m_gdbarch (gdbarch
)
787 init_disassemble_info (&m_di
, file
, dis_asm_fprintf
);
788 m_di
.flavour
= bfd_target_unknown_flavour
;
789 m_di
.memory_error_func
= dis_asm_memory_error
;
790 m_di
.print_address_func
= dis_asm_print_address
;
791 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
792 disassembler had a local optimization here. By default it would
793 access the executable file, instead of the target memory (there
794 was a growing list of exceptions though). Unfortunately, the
795 heuristic was flawed. Commands like "disassemble &variable"
796 didn't work as they relied on the access going to the target.
797 Further, it has been superseeded by trust-read-only-sections
798 (although that should be superseeded by target_trust..._p()). */
799 m_di
.read_memory_func
= read_memory_func
;
800 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
801 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
802 m_di
.endian
= gdbarch_byte_order (gdbarch
);
803 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
804 m_di
.application_data
= this;
805 m_disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
806 if (!m_disassembler_options_holder
.empty ())
807 m_di
.disassembler_options
= m_disassembler_options_holder
.c_str ();
808 disassemble_init_for_target (&m_di
);
811 gdb_disassembler::~gdb_disassembler ()
813 disassemble_free_target (&m_di
);
817 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
818 int *branch_delay_insns
)
820 m_err_memaddr
.reset ();
822 int length
= gdbarch_print_insn (arch (), memaddr
, &m_di
);
826 if (m_err_memaddr
.has_value ())
827 memory_error (TARGET_XFER_E_IO
, *m_err_memaddr
);
829 error (_("unknown disassembler error (error = %d)"), length
);
832 if (branch_delay_insns
!= NULL
)
834 if (m_di
.insn_info_valid
)
835 *branch_delay_insns
= m_di
.branch_delay_insns
;
837 *branch_delay_insns
= 0;
843 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
844 gdb_disassembly_flags flags
, int how_many
,
845 CORE_ADDR low
, CORE_ADDR high
)
847 struct symtab
*symtab
;
850 /* Assume symtab is valid for whole PC range. */
851 symtab
= find_pc_line_symtab (low
);
853 if (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
)
854 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
856 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
858 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
860 else if (flags
& DISASSEMBLY_SOURCE
)
861 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
864 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
865 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
866 low
, high
, how_many
, flags
);
868 gdb_flush (gdb_stdout
);
871 /* Print the instruction at address MEMADDR in debugged memory,
872 on STREAM. Returns the length of the instruction, in bytes,
873 and, if requested, the number of branch delay slot instructions. */
876 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
877 struct ui_file
*stream
, int *branch_delay_insns
)
880 gdb_disassembler
di (gdbarch
, stream
);
882 return di
.print_insn (memaddr
, branch_delay_insns
);
885 /* Return the length in bytes of the instruction at address MEMADDR in
889 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
891 return gdb_print_insn (gdbarch
, addr
, &null_stream
, NULL
);
894 /* fprintf-function for gdb_buffered_insn_length. This function is a
895 nop, we don't want to print anything, we just want to compute the
896 length of the insn. */
898 static int ATTRIBUTE_PRINTF (2, 3)
899 gdb_buffered_insn_length_fprintf (void *stream
, const char *format
, ...)
904 /* Initialize a struct disassemble_info for gdb_buffered_insn_length.
905 Upon return, *DISASSEMBLER_OPTIONS_HOLDER owns the string pointed
906 to by DI.DISASSEMBLER_OPTIONS. */
909 gdb_buffered_insn_length_init_dis (struct gdbarch
*gdbarch
,
910 struct disassemble_info
*di
,
911 const gdb_byte
*insn
, int max_len
,
913 std::string
*disassembler_options_holder
)
915 init_disassemble_info (di
, NULL
, gdb_buffered_insn_length_fprintf
);
917 /* init_disassemble_info installs buffer_read_memory, etc.
918 so we don't need to do that here.
919 The cast is necessary until disassemble_info is const-ified. */
920 di
->buffer
= (gdb_byte
*) insn
;
921 di
->buffer_length
= max_len
;
922 di
->buffer_vma
= addr
;
924 di
->arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
925 di
->mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
926 di
->endian
= gdbarch_byte_order (gdbarch
);
927 di
->endian_code
= gdbarch_byte_order_for_code (gdbarch
);
929 *disassembler_options_holder
= get_all_disassembler_options (gdbarch
);
930 if (!disassembler_options_holder
->empty ())
931 di
->disassembler_options
= disassembler_options_holder
->c_str ();
932 disassemble_init_for_target (di
);
935 /* Return the length in bytes of INSN. MAX_LEN is the size of the
936 buffer containing INSN. */
939 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
940 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
942 struct disassemble_info di
;
943 std::string disassembler_options_holder
;
945 gdb_buffered_insn_length_init_dis (gdbarch
, &di
, insn
, max_len
, addr
,
946 &disassembler_options_holder
);
948 int result
= gdbarch_print_insn (gdbarch
, addr
, &di
);
949 disassemble_free_target (&di
);
954 get_disassembler_options (struct gdbarch
*gdbarch
)
956 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
957 if (disassembler_options
== NULL
)
959 return *disassembler_options
;
963 set_disassembler_options (const char *prospective_options
)
965 struct gdbarch
*gdbarch
= get_current_arch ();
966 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
967 const disasm_options_and_args_t
*valid_options_and_args
;
968 const disasm_options_t
*valid_options
;
969 gdb::unique_xmalloc_ptr
<char> prospective_options_local
970 = make_unique_xstrdup (prospective_options
);
971 char *options
= remove_whitespace_and_extra_commas
972 (prospective_options_local
.get ());
975 /* Allow all architectures, even ones that do not support 'set disassembler',
976 to reset their disassembler options to NULL. */
979 if (disassembler_options
!= NULL
)
981 free (*disassembler_options
);
982 *disassembler_options
= NULL
;
987 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
988 if (valid_options_and_args
== NULL
)
990 fprintf_filtered (gdb_stderr
, _("\
991 'set disassembler-options ...' is not supported on this architecture.\n"));
995 valid_options
= &valid_options_and_args
->options
;
997 /* Verify we have valid disassembler options. */
998 FOR_EACH_DISASSEMBLER_OPTION (opt
, options
)
1001 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1002 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1004 size_t len
= strlen (valid_options
->name
[i
]);
1009 if (memcmp (opt
, valid_options
->name
[i
], len
) != 0)
1012 for (j
= 0; valid_options
->arg
[i
]->values
[j
] != NULL
; j
++)
1013 if (disassembler_options_cmp
1014 (arg
, valid_options
->arg
[i
]->values
[j
]) == 0)
1022 else if (disassembler_options_cmp (opt
, valid_options
->name
[i
]) == 0)
1024 if (valid_options
->name
[i
] == NULL
)
1026 fprintf_filtered (gdb_stderr
,
1027 _("Invalid disassembler option value: '%s'.\n"),
1033 free (*disassembler_options
);
1034 *disassembler_options
= xstrdup (options
);
1038 set_disassembler_options_sfunc (const char *args
, int from_tty
,
1039 struct cmd_list_element
*c
)
1041 set_disassembler_options (prospective_options
.c_str ());
1045 show_disassembler_options_sfunc (struct ui_file
*file
, int from_tty
,
1046 struct cmd_list_element
*c
, const char *value
)
1048 struct gdbarch
*gdbarch
= get_current_arch ();
1049 const disasm_options_and_args_t
*valid_options_and_args
;
1050 const disasm_option_arg_t
*valid_args
;
1051 const disasm_options_t
*valid_options
;
1053 const char *options
= get_disassembler_options (gdbarch
);
1054 if (options
== NULL
)
1057 fprintf_filtered (file
, _("The current disassembler options are '%s'\n\n"),
1060 valid_options_and_args
= gdbarch_valid_disassembler_options (gdbarch
);
1062 if (valid_options_and_args
== NULL
)
1064 fputs_filtered (_("There are no disassembler options available "
1065 "for this architecture.\n"),
1070 valid_options
= &valid_options_and_args
->options
;
1072 fprintf_filtered (file
, _("\
1073 The following disassembler options are supported for use with the\n\
1074 'set disassembler-options OPTION [,OPTION]...' command:\n"));
1076 if (valid_options
->description
!= NULL
)
1078 size_t i
, max_len
= 0;
1080 fprintf_filtered (file
, "\n");
1082 /* Compute the length of the longest option name. */
1083 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1085 size_t len
= strlen (valid_options
->name
[i
]);
1087 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1088 len
+= strlen (valid_options
->arg
[i
]->name
);
1093 for (i
= 0, max_len
++; valid_options
->name
[i
] != NULL
; i
++)
1095 fprintf_filtered (file
, " %s", valid_options
->name
[i
]);
1096 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1097 fprintf_filtered (file
, "%s", valid_options
->arg
[i
]->name
);
1098 if (valid_options
->description
[i
] != NULL
)
1100 size_t len
= strlen (valid_options
->name
[i
]);
1102 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1103 len
+= strlen (valid_options
->arg
[i
]->name
);
1104 fprintf_filtered (file
, "%*c %s", (int) (max_len
- len
), ' ',
1105 valid_options
->description
[i
]);
1107 fprintf_filtered (file
, "\n");
1113 fprintf_filtered (file
, " ");
1114 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1116 fprintf_filtered (file
, "%s", valid_options
->name
[i
]);
1117 if (valid_options
->arg
!= NULL
&& valid_options
->arg
[i
] != NULL
)
1118 fprintf_filtered (file
, "%s", valid_options
->arg
[i
]->name
);
1119 if (valid_options
->name
[i
+ 1] != NULL
)
1120 fprintf_filtered (file
, ", ");
1123 fprintf_filtered (file
, "\n");
1126 valid_args
= valid_options_and_args
->args
;
1127 if (valid_args
!= NULL
)
1131 for (i
= 0; valid_args
[i
].name
!= NULL
; i
++)
1133 fprintf_filtered (file
, _("\n\
1134 For the options above, the following values are supported for \"%s\":\n "),
1135 valid_args
[i
].name
);
1136 for (j
= 0; valid_args
[i
].values
[j
] != NULL
; j
++)
1138 fprintf_filtered (file
, " %s", valid_args
[i
].values
[j
]);
1141 fprintf_filtered (file
, "\n");
1146 /* A completion function for "set disassembler". */
1149 disassembler_options_completer (struct cmd_list_element
*ignore
,
1150 completion_tracker
&tracker
,
1151 const char *text
, const char *word
)
1153 struct gdbarch
*gdbarch
= get_current_arch ();
1154 const disasm_options_and_args_t
*opts_and_args
1155 = gdbarch_valid_disassembler_options (gdbarch
);
1157 if (opts_and_args
!= NULL
)
1159 const disasm_options_t
*opts
= &opts_and_args
->options
;
1161 /* Only attempt to complete on the last option text. */
1162 const char *separator
= strrchr (text
, ',');
1163 if (separator
!= NULL
)
1164 text
= separator
+ 1;
1165 text
= skip_spaces (text
);
1166 complete_on_enum (tracker
, opts
->name
, text
, word
);
1171 /* Initialization code. */
1173 void _initialize_disasm ();
1175 _initialize_disasm ()
1177 /* Add the command that controls the disassembler options. */
1178 set_show_commands set_show_disas_opts
1179 = add_setshow_string_noescape_cmd ("disassembler-options", no_class
,
1180 &prospective_options
, _("\
1181 Set the disassembler options.\n\
1182 Usage: set disassembler-options OPTION [,OPTION]...\n\n\
1183 See: 'show disassembler-options' for valid option values."), _("\
1184 Show the disassembler options."), NULL
,
1185 set_disassembler_options_sfunc
,
1186 show_disassembler_options_sfunc
,
1187 &setlist
, &showlist
);
1188 set_cmd_completer (set_show_disas_opts
.set
, disassembler_options_completer
);