1 /* Disassemble support for GDB.
3 Copyright (C) 2000-2017 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"
33 /* Disassemble functions.
34 FIXME: We should get rid of all the duplicate code in gdb that does
35 the same thing: disassemble_command() and the gdbtk variation. */
37 /* This variable is used to hold the prospective disassembler_options value
38 which is set by the "set disassembler_options" command. */
39 static char *prospective_options
= NULL
;
41 /* This structure is used to store line number information for the
43 We need a different sort of line table from the normal one cuz we can't
44 depend upon implicit line-end pc's for lines to do the
45 reordering in this function. */
47 struct deprecated_dis_line_entry
54 /* This Structure is used to store line number information.
55 We need a different sort of line table from the normal one cuz we can't
56 depend upon implicit line-end pc's for lines to do the
57 reordering in this function. */
61 struct symtab
*symtab
;
65 /* Hash function for dis_line_entry. */
68 hash_dis_line_entry (const void *item
)
70 const struct dis_line_entry
*dle
= (const struct dis_line_entry
*) item
;
72 return htab_hash_pointer (dle
->symtab
) + dle
->line
;
75 /* Equal function for dis_line_entry. */
78 eq_dis_line_entry (const void *item_lhs
, const void *item_rhs
)
80 const struct dis_line_entry
*lhs
= (const struct dis_line_entry
*) item_lhs
;
81 const struct dis_line_entry
*rhs
= (const struct dis_line_entry
*) item_rhs
;
83 return (lhs
->symtab
== rhs
->symtab
84 && lhs
->line
== rhs
->line
);
87 /* Create the table to manage lines for mixed source/disassembly. */
90 allocate_dis_line_table (void)
92 return htab_create_alloc (41,
93 hash_dis_line_entry
, eq_dis_line_entry
,
94 xfree
, xcalloc
, xfree
);
97 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE. */
100 add_dis_line_entry (htab_t table
, struct symtab
*symtab
, int line
)
103 struct dis_line_entry dle
, *dlep
;
107 slot
= htab_find_slot (table
, &dle
, INSERT
);
110 dlep
= XNEW (struct dis_line_entry
);
111 dlep
->symtab
= symtab
;
117 /* Return non-zero if SYMTAB, LINE are in TABLE. */
120 line_has_code_p (htab_t table
, struct symtab
*symtab
, int line
)
122 struct dis_line_entry dle
;
126 return htab_find (table
, &dle
) != NULL
;
129 /* Wrapper of target_read_code. */
132 gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr
, gdb_byte
*myaddr
,
134 struct disassemble_info
*info
)
136 return target_read_code (memaddr
, myaddr
, len
);
139 /* Wrapper of memory_error. */
142 gdb_disassembler::dis_asm_memory_error (int err
, bfd_vma memaddr
,
143 struct disassemble_info
*info
)
145 gdb_disassembler
*self
146 = static_cast<gdb_disassembler
*>(info
->application_data
);
148 self
->m_err_memaddr
= memaddr
;
151 /* Wrapper of print_address. */
154 gdb_disassembler::dis_asm_print_address (bfd_vma addr
,
155 struct disassemble_info
*info
)
157 gdb_disassembler
*self
158 = static_cast<gdb_disassembler
*>(info
->application_data
);
160 print_address (self
->arch (), addr
, self
->stream ());
164 compare_lines (const void *mle1p
, const void *mle2p
)
166 struct deprecated_dis_line_entry
*mle1
, *mle2
;
169 mle1
= (struct deprecated_dis_line_entry
*) mle1p
;
170 mle2
= (struct deprecated_dis_line_entry
*) mle2p
;
172 /* End of sequence markers have a line number of 0 but don't want to
173 be sorted to the head of the list, instead sort by PC. */
174 if (mle1
->line
== 0 || mle2
->line
== 0)
176 val
= mle1
->start_pc
- mle2
->start_pc
;
178 val
= mle1
->line
- mle2
->line
;
182 val
= mle1
->line
- mle2
->line
;
184 val
= mle1
->start_pc
- mle2
->start_pc
;
192 gdb_pretty_print_disassembler::pretty_print_insn (struct ui_out
*uiout
,
193 const struct disasm_insn
*insn
,
196 /* parts of the symbolic representation of the address */
201 struct cleanup
*ui_out_chain
;
202 char *filename
= NULL
;
205 struct gdbarch
*gdbarch
= arch ();
207 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
210 if (insn
->number
!= 0)
212 uiout
->field_fmt ("insn-number", "%u", insn
->number
);
216 if ((flags
& DISASSEMBLY_SPECULATIVE
) != 0)
218 if (insn
->is_speculative
)
220 uiout
->field_string ("is-speculative", "?");
222 /* The speculative execution indication overwrites the first
223 character of the PC prefix.
224 We assume a PC prefix length of 3 characters. */
225 if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
226 uiout
->text (pc_prefix (pc
) + 1);
230 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
231 uiout
->text (pc_prefix (pc
));
235 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
236 uiout
->text (pc_prefix (pc
));
237 uiout
->field_core_addr ("address", gdbarch
, pc
);
239 if (!build_address_symbolic (gdbarch
, pc
, 0, &name
, &offset
, &filename
,
242 /* We don't care now about line, filename and unmapped. But we might in
245 if ((flags
& DISASSEMBLY_OMIT_FNAME
) == 0)
246 uiout
->field_string ("func-name", name
);
248 uiout
->field_int ("offset", offset
);
249 uiout
->text (">:\t");
254 if (filename
!= NULL
)
261 if (flags
& DISASSEMBLY_RAW_INSN
)
266 const char *spacer
= "";
268 /* Build the opcodes using a temporary stream so we can
269 write them out in a single go for the MI. */
270 m_opcode_stb
.clear ();
272 size
= m_di
.print_insn (pc
);
275 for (;pc
< end_pc
; ++pc
)
277 read_code (pc
, &data
, 1);
278 m_opcode_stb
.printf ("%s%02x", spacer
, (unsigned) data
);
282 uiout
->field_stream ("opcodes", m_opcode_stb
);
286 size
= m_di
.print_insn (pc
);
288 uiout
->field_stream ("inst", m_insn_stb
);
289 do_cleanups (ui_out_chain
);
296 dump_insns (struct gdbarch
*gdbarch
,
297 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
298 int how_many
, int flags
, CORE_ADDR
*end_pc
)
300 struct disasm_insn insn
;
301 int num_displayed
= 0;
303 memset (&insn
, 0, sizeof (insn
));
306 gdb_pretty_print_disassembler
disasm (gdbarch
);
308 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
312 size
= disasm
.pretty_print_insn (uiout
, &insn
, flags
);
319 /* Allow user to bail out with ^C. */
326 return num_displayed
;
329 /* The idea here is to present a source-O-centric view of a
330 function to the user. This means that things are presented
331 in source order, with (possibly) out of order assembly
332 immediately following.
334 N.B. This view is deprecated. */
337 do_mixed_source_and_assembly_deprecated
338 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
339 struct symtab
*symtab
,
340 CORE_ADDR low
, CORE_ADDR high
,
341 int how_many
, int flags
)
345 struct linetable_entry
*le
;
346 struct deprecated_dis_line_entry
*mle
;
347 struct symtab_and_line sal
;
349 int out_of_order
= 0;
351 int num_displayed
= 0;
352 print_source_lines_flags psl_flags
= 0;
353 struct cleanup
*ui_out_chain
;
354 struct cleanup
*ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
355 struct cleanup
*ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
357 gdb_assert (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
);
359 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
360 le
= SYMTAB_LINETABLE (symtab
)->item
;
362 if (flags
& DISASSEMBLY_FILENAME
)
363 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
365 mle
= (struct deprecated_dis_line_entry
*)
366 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
368 /* Copy linetable entries for this function into our data
369 structure, creating end_pc's and setting out_of_order as
372 /* First, skip all the preceding functions. */
374 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
376 /* Now, copy all entries before the end of this function. */
378 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
380 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
381 continue; /* Ignore duplicates. */
383 /* Skip any end-of-function markers. */
387 mle
[newlines
].line
= le
[i
].line
;
388 if (le
[i
].line
> le
[i
+ 1].line
)
390 mle
[newlines
].start_pc
= le
[i
].pc
;
391 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
395 /* If we're on the last line, and it's part of the function,
396 then we need to get the end pc in a special way. */
398 if (i
== nlines
- 1 && le
[i
].pc
< high
)
400 mle
[newlines
].line
= le
[i
].line
;
401 mle
[newlines
].start_pc
= le
[i
].pc
;
402 sal
= find_pc_line (le
[i
].pc
, 0);
403 mle
[newlines
].end_pc
= sal
.end
;
407 /* Now, sort mle by line #s (and, then by addresses within lines). */
410 qsort (mle
, newlines
, sizeof (struct deprecated_dis_line_entry
),
413 /* Now, for each line entry, emit the specified lines (unless
414 they have been emitted before), followed by the assembly code
417 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
419 for (i
= 0; i
< newlines
; i
++)
421 /* Print out everything from next_line to the current line. */
422 if (mle
[i
].line
>= next_line
)
426 /* Just one line to print. */
427 if (next_line
== mle
[i
].line
)
430 = make_cleanup_ui_out_tuple_begin_end (uiout
,
432 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
436 /* Several source lines w/o asm instructions associated. */
437 for (; next_line
< mle
[i
].line
; next_line
++)
439 struct cleanup
*ui_out_list_chain_line
;
440 struct cleanup
*ui_out_tuple_chain_line
;
442 ui_out_tuple_chain_line
443 = make_cleanup_ui_out_tuple_begin_end (uiout
,
445 print_source_lines (symtab
, next_line
, next_line
+ 1,
447 ui_out_list_chain_line
448 = make_cleanup_ui_out_list_begin_end (uiout
,
450 do_cleanups (ui_out_list_chain_line
);
451 do_cleanups (ui_out_tuple_chain_line
);
453 /* Print the last line and leave list open for
454 asm instructions to be added. */
456 = make_cleanup_ui_out_tuple_begin_end (uiout
,
458 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
464 = make_cleanup_ui_out_tuple_begin_end (uiout
,
466 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
469 next_line
= mle
[i
].line
+ 1;
471 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
474 num_displayed
+= dump_insns (gdbarch
, uiout
,
475 mle
[i
].start_pc
, mle
[i
].end_pc
,
476 how_many
, flags
, NULL
);
478 /* When we've reached the end of the mle array, or we've seen the last
479 assembly range for this source line, close out the list/tuple. */
480 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
482 do_cleanups (ui_out_list_chain
);
483 do_cleanups (ui_out_tuple_chain
);
484 ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
485 ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
488 if (how_many
>= 0 && num_displayed
>= how_many
)
491 do_cleanups (ui_out_chain
);
494 /* The idea here is to present a source-O-centric view of a
495 function to the user. This means that things are presented
496 in source order, with (possibly) out of order assembly
497 immediately following. */
500 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
501 struct ui_out
*uiout
,
502 struct symtab
*main_symtab
,
503 CORE_ADDR low
, CORE_ADDR high
,
504 int how_many
, int flags
)
506 const struct linetable_entry
*le
, *first_le
;
508 int num_displayed
= 0;
509 print_source_lines_flags psl_flags
= 0;
510 struct cleanup
*ui_out_chain
;
511 struct cleanup
*ui_out_tuple_chain
;
512 struct cleanup
*ui_out_list_chain
;
514 struct symtab
*last_symtab
;
517 gdb_assert (main_symtab
!= NULL
&& SYMTAB_LINETABLE (main_symtab
) != NULL
);
519 /* First pass: collect the list of all source files and lines.
520 We do this so that we can only print lines containing code once.
521 We try to print the source text leading up to the next instruction,
522 but if that text is for code that will be disassembled later, then
523 we'll want to defer printing it until later with its associated code. */
525 htab_up
dis_line_table (allocate_dis_line_table ());
529 /* The prologue may be empty, but there may still be a line number entry
530 for the opening brace which is distinct from the first line of code.
531 If the prologue has been eliminated find_pc_line may return the source
532 line after the opening brace. We still want to print this opening brace.
533 first_le is used to implement this. */
535 nlines
= SYMTAB_LINETABLE (main_symtab
)->nitems
;
536 le
= SYMTAB_LINETABLE (main_symtab
)->item
;
539 /* Skip all the preceding functions. */
540 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
543 if (i
< nlines
&& le
[i
].pc
< high
)
546 /* Add lines for every pc value. */
549 struct symtab_and_line sal
;
552 sal
= find_pc_line (pc
, 0);
553 length
= gdb_insn_length (gdbarch
, pc
);
556 if (sal
.symtab
!= NULL
)
557 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
560 /* Second pass: print the disassembly.
562 Output format, from an MI perspective:
563 The result is a ui_out list, field name "asm_insns", where elements have
564 name "src_and_asm_line".
565 Each element is a tuple of source line specs (field names line, file,
566 fullname), and field "line_asm_insn" which contains the disassembly.
567 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
570 CLI output works on top of this because MI ignores ui_out_text output,
571 which is where we put file name and source line contents output.
575 Handles the outer "asm_insns" list.
577 The tuples for each group of consecutive disassemblies.
579 List of consecutive source lines or disassembled insns. */
581 if (flags
& DISASSEMBLY_FILENAME
)
582 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
584 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
586 ui_out_tuple_chain
= NULL
;
587 ui_out_list_chain
= NULL
;
595 struct symtab_and_line sal
;
597 int start_preceding_line_to_display
= 0;
598 int end_preceding_line_to_display
= 0;
599 int new_source_line
= 0;
601 sal
= find_pc_line (pc
, 0);
603 if (sal
.symtab
!= last_symtab
)
605 /* New source file. */
608 /* If this is the first line of output, check for any preceding
612 && first_le
->line
< sal
.line
)
614 start_preceding_line_to_display
= first_le
->line
;
615 end_preceding_line_to_display
= sal
.line
;
620 /* Same source file as last time. */
621 if (sal
.symtab
!= NULL
)
623 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
627 /* Several preceding source lines. Print the trailing ones
628 not associated with code that we'll print later. */
629 for (l
= sal
.line
- 1; l
> last_line
; --l
)
631 if (line_has_code_p (dis_line_table
.get (),
635 if (l
< sal
.line
- 1)
637 start_preceding_line_to_display
= l
+ 1;
638 end_preceding_line_to_display
= sal
.line
;
641 if (sal
.line
!= last_line
)
645 /* Same source line as last time. This can happen, depending
646 on the debug info. */
653 /* Skip the newline if this is the first instruction. */
656 if (ui_out_tuple_chain
!= NULL
)
658 gdb_assert (ui_out_list_chain
!= NULL
);
659 do_cleanups (ui_out_list_chain
);
660 do_cleanups (ui_out_tuple_chain
);
662 if (sal
.symtab
!= last_symtab
663 && !(flags
& DISASSEMBLY_FILENAME
))
665 /* Remember MI ignores ui_out_text.
666 We don't have to do anything here for MI because MI
667 output includes the source specs for each line. */
668 if (sal
.symtab
!= NULL
)
670 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
673 uiout
->text ("unknown");
676 if (start_preceding_line_to_display
> 0)
678 /* Several source lines w/o asm instructions associated.
679 We need to preserve the structure of the output, so output
680 a bunch of line tuples with no asm entries. */
682 struct cleanup
*ui_out_list_chain_line
;
683 struct cleanup
*ui_out_tuple_chain_line
;
685 gdb_assert (sal
.symtab
!= NULL
);
686 for (l
= start_preceding_line_to_display
;
687 l
< end_preceding_line_to_display
;
690 ui_out_tuple_chain_line
691 = make_cleanup_ui_out_tuple_begin_end (uiout
,
693 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
694 ui_out_list_chain_line
695 = make_cleanup_ui_out_list_begin_end (uiout
,
697 do_cleanups (ui_out_list_chain_line
);
698 do_cleanups (ui_out_tuple_chain_line
);
702 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
703 if (sal
.symtab
!= NULL
)
704 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
706 uiout
->text (_("--- no source info for this pc ---\n"));
708 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
712 /* Here we're appending instructions to an existing line.
713 By construction the very first insn will have a symtab
714 and follow the new_source_line path above. */
715 gdb_assert (ui_out_tuple_chain
!= NULL
);
716 gdb_assert (ui_out_list_chain
!= NULL
);
720 end_pc
= std::min (sal
.end
, high
);
723 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
724 how_many
, flags
, &end_pc
);
727 if (how_many
>= 0 && num_displayed
>= how_many
)
730 last_symtab
= sal
.symtab
;
731 last_line
= sal
.line
;
734 do_cleanups (ui_out_chain
);
738 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
739 CORE_ADDR low
, CORE_ADDR high
,
740 int how_many
, int flags
)
742 struct cleanup
*ui_out_chain
;
744 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
746 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
748 do_cleanups (ui_out_chain
);
751 /* Initialize the disassemble info struct ready for the specified
754 static int ATTRIBUTE_PRINTF (2, 3)
755 fprintf_disasm (void *stream
, const char *format
, ...)
759 va_start (args
, format
);
760 vfprintf_filtered ((struct ui_file
*) stream
, format
, args
);
762 /* Something non -ve. */
766 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
767 struct ui_file
*file
,
768 di_read_memory_ftype read_memory_func
)
769 : m_gdbarch (gdbarch
),
772 init_disassemble_info (&m_di
, file
, fprintf_disasm
);
773 m_di
.flavour
= bfd_target_unknown_flavour
;
774 m_di
.memory_error_func
= dis_asm_memory_error
;
775 m_di
.print_address_func
= dis_asm_print_address
;
776 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
777 disassembler had a local optomization here. By default it would
778 access the executable file, instead of the target memory (there
779 was a growing list of exceptions though). Unfortunately, the
780 heuristic was flawed. Commands like "disassemble &variable"
781 didn't work as they relied on the access going to the target.
782 Further, it has been supperseeded by trust-read-only-sections
783 (although that should be superseeded by target_trust..._p()). */
784 m_di
.read_memory_func
= read_memory_func
;
785 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
786 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
787 m_di
.endian
= gdbarch_byte_order (gdbarch
);
788 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
789 m_di
.application_data
= this;
790 m_di
.disassembler_options
= get_disassembler_options (gdbarch
);
791 disassemble_init_for_target (&m_di
);
795 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
796 int *branch_delay_insns
)
800 int length
= gdbarch_print_insn (arch (), memaddr
, &m_di
);
803 memory_error (TARGET_XFER_E_IO
, m_err_memaddr
);
805 if (branch_delay_insns
!= NULL
)
807 if (m_di
.insn_info_valid
)
808 *branch_delay_insns
= m_di
.branch_delay_insns
;
810 *branch_delay_insns
= 0;
816 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
817 int flags
, int how_many
,
818 CORE_ADDR low
, CORE_ADDR high
)
820 struct symtab
*symtab
;
823 /* Assume symtab is valid for whole PC range. */
824 symtab
= find_pc_line_symtab (low
);
826 if (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
)
827 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
829 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
831 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
833 else if (flags
& DISASSEMBLY_SOURCE
)
834 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
837 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
838 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
839 low
, high
, how_many
, flags
);
841 gdb_flush (gdb_stdout
);
844 /* Print the instruction at address MEMADDR in debugged memory,
845 on STREAM. Returns the length of the instruction, in bytes,
846 and, if requested, the number of branch delay slot instructions. */
849 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
850 struct ui_file
*stream
, int *branch_delay_insns
)
853 gdb_disassembler
di (gdbarch
, stream
);
855 return di
.print_insn (memaddr
, branch_delay_insns
);
858 /* Return the length in bytes of the instruction at address MEMADDR in
862 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
864 return gdb_print_insn (gdbarch
, addr
, &null_stream
, NULL
);
867 /* fprintf-function for gdb_buffered_insn_length. This function is a
868 nop, we don't want to print anything, we just want to compute the
869 length of the insn. */
871 static int ATTRIBUTE_PRINTF (2, 3)
872 gdb_buffered_insn_length_fprintf (void *stream
, const char *format
, ...)
877 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
880 gdb_buffered_insn_length_init_dis (struct gdbarch
*gdbarch
,
881 struct disassemble_info
*di
,
882 const gdb_byte
*insn
, int max_len
,
885 init_disassemble_info (di
, NULL
, gdb_buffered_insn_length_fprintf
);
887 /* init_disassemble_info installs buffer_read_memory, etc.
888 so we don't need to do that here.
889 The cast is necessary until disassemble_info is const-ified. */
890 di
->buffer
= (gdb_byte
*) insn
;
891 di
->buffer_length
= max_len
;
892 di
->buffer_vma
= addr
;
894 di
->arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
895 di
->mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
896 di
->endian
= gdbarch_byte_order (gdbarch
);
897 di
->endian_code
= gdbarch_byte_order_for_code (gdbarch
);
899 di
->disassembler_options
= get_disassembler_options (gdbarch
);
900 disassemble_init_for_target (di
);
903 /* Return the length in bytes of INSN. MAX_LEN is the size of the
904 buffer containing INSN. */
907 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
908 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
910 struct disassemble_info di
;
912 gdb_buffered_insn_length_init_dis (gdbarch
, &di
, insn
, max_len
, addr
);
914 return gdbarch_print_insn (gdbarch
, addr
, &di
);
918 get_disassembler_options (struct gdbarch
*gdbarch
)
920 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
921 if (disassembler_options
== NULL
)
923 return *disassembler_options
;
927 set_disassembler_options (char *prospective_options
)
929 struct gdbarch
*gdbarch
= get_current_arch ();
930 char **disassembler_options
= gdbarch_disassembler_options (gdbarch
);
931 const disasm_options_t
*valid_options
;
932 char *options
= remove_whitespace_and_extra_commas (prospective_options
);
935 /* Allow all architectures, even ones that do not support 'set disassembler',
936 to reset their disassembler options to NULL. */
939 if (disassembler_options
!= NULL
)
941 free (*disassembler_options
);
942 *disassembler_options
= NULL
;
947 valid_options
= gdbarch_valid_disassembler_options (gdbarch
);
948 if (valid_options
== NULL
)
950 fprintf_filtered (gdb_stdlog
, _("\
951 'set disassembler-options ...' is not supported on this architecture.\n"));
955 /* Verify we have valid disassembler options. */
956 FOR_EACH_DISASSEMBLER_OPTION (opt
, options
)
959 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
960 if (disassembler_options_cmp (opt
, valid_options
->name
[i
]) == 0)
962 if (valid_options
->name
[i
] == NULL
)
964 fprintf_filtered (gdb_stdlog
,
965 _("Invalid disassembler option value: '%s'.\n"),
971 free (*disassembler_options
);
972 *disassembler_options
= xstrdup (options
);
976 set_disassembler_options_sfunc (char *args
, int from_tty
,
977 struct cmd_list_element
*c
)
979 set_disassembler_options (prospective_options
);
983 show_disassembler_options_sfunc (struct ui_file
*file
, int from_tty
,
984 struct cmd_list_element
*c
, const char *value
)
986 struct gdbarch
*gdbarch
= get_current_arch ();
987 const disasm_options_t
*valid_options
;
989 const char *options
= get_disassembler_options (gdbarch
);
993 fprintf_filtered (file
, _("The current disassembler options are '%s'\n"),
996 valid_options
= gdbarch_valid_disassembler_options (gdbarch
);
998 if (valid_options
== NULL
)
1001 fprintf_filtered (file
, _("\n\
1002 The following disassembler options are supported for use with the\n\
1003 'set disassembler-options <option>[,<option>...]' command:\n"));
1005 if (valid_options
->description
!= NULL
)
1007 size_t i
, max_len
= 0;
1009 /* Compute the length of the longest option name. */
1010 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1012 size_t len
= strlen (valid_options
->name
[i
]);
1017 for (i
= 0, max_len
++; valid_options
->name
[i
] != NULL
; i
++)
1019 fprintf_filtered (file
, " %s", valid_options
->name
[i
]);
1020 if (valid_options
->description
[i
] != NULL
)
1021 fprintf_filtered (file
, "%*c %s",
1022 (int)(max_len
- strlen (valid_options
->name
[i
])), ' ',
1023 valid_options
->description
[i
]);
1024 fprintf_filtered (file
, "\n");
1030 fprintf_filtered (file
, " ");
1031 for (i
= 0; valid_options
->name
[i
] != NULL
; i
++)
1033 fprintf_filtered (file
, "%s", valid_options
->name
[i
]);
1034 if (valid_options
->name
[i
+ 1] != NULL
)
1035 fprintf_filtered (file
, ", ");
1038 fprintf_filtered (file
, "\n");
1042 /* A completion function for "set disassembler". */
1044 static VEC (char_ptr
) *
1045 disassembler_options_completer (struct cmd_list_element
*ignore
,
1046 const char *text
, const char *word
)
1048 struct gdbarch
*gdbarch
= get_current_arch ();
1049 const disasm_options_t
*opts
= gdbarch_valid_disassembler_options (gdbarch
);
1053 /* Only attempt to complete on the last option text. */
1054 const char *separator
= strrchr (text
, ',');
1055 if (separator
!= NULL
)
1056 text
= separator
+ 1;
1057 text
= skip_spaces_const (text
);
1058 return complete_on_enum (opts
->name
, text
, word
);
1064 /* Initialization code. */
1066 /* -Wmissing-prototypes */
1067 extern initialize_file_ftype _initialize_disasm
;
1070 _initialize_disasm (void)
1072 struct cmd_list_element
*cmd
;
1074 /* Add the command that controls the disassembler options. */
1075 cmd
= add_setshow_string_noescape_cmd ("disassembler-options", no_class
,
1076 &prospective_options
, _("\
1077 Set the disassembler options.\n\
1078 Usage: set disassembler-options <option>[,<option>...]\n\n\
1079 See: 'show disassembler-options' for valid option values.\n"), _("\
1080 Show the disassembler options."), NULL
,
1081 set_disassembler_options_sfunc
,
1082 show_disassembler_options_sfunc
,
1083 &setlist
, &showlist
);
1084 set_cmd_completer (cmd
, disassembler_options_completer
);