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,
194 gdb_disassembly_flags flags)
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, gdb_disassembly_flags 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, gdb_disassembly_flags 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;
441 ui_out_emit_tuple tuple_emitter (uiout,
443 print_source_lines (symtab, next_line, next_line + 1,
445 ui_out_list_chain_line
446 = make_cleanup_ui_out_list_begin_end (uiout,
448 do_cleanups (ui_out_list_chain_line);
450 /* Print the last line and leave list open for
451 asm instructions to be added. */
453 = make_cleanup_ui_out_tuple_begin_end (uiout,
455 print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
461 = make_cleanup_ui_out_tuple_begin_end (uiout,
463 print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
466 next_line = mle[i].line + 1;
468 = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
471 num_displayed += dump_insns (gdbarch, uiout,
472 mle[i].start_pc, mle[i].end_pc,
473 how_many, flags, NULL);
475 /* When we've reached the end of the mle array, or we've seen the last
476 assembly range for this source line, close out the list/tuple. */
477 if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
479 do_cleanups (ui_out_list_chain);
480 do_cleanups (ui_out_tuple_chain);
481 ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
482 ui_out_list_chain = make_cleanup (null_cleanup, 0);
485 if (how_many >= 0 && num_displayed >= how_many)
488 do_cleanups (ui_out_chain);
491 /* The idea here is to present a source-O-centric view of a
492 function to the user. This means that things are presented
493 in source order, with (possibly) out of order assembly
494 immediately following. */
497 do_mixed_source_and_assembly (struct gdbarch *gdbarch,
498 struct ui_out *uiout,
499 struct symtab *main_symtab,
500 CORE_ADDR low, CORE_ADDR high,
501 int how_many, gdb_disassembly_flags flags)
503 const struct linetable_entry *le, *first_le;
505 int num_displayed = 0;
506 print_source_lines_flags psl_flags = 0;
507 struct cleanup *ui_out_chain;
508 struct cleanup *ui_out_tuple_chain;
509 struct cleanup *ui_out_list_chain;
511 struct symtab *last_symtab;
514 gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL);
516 /* First pass: collect the list of all source files and lines.
517 We do this so that we can only print lines containing code once.
518 We try to print the source text leading up to the next instruction,
519 but if that text is for code that will be disassembled later, then
520 we'll want to defer printing it until later with its associated code. */
522 htab_up dis_line_table (allocate_dis_line_table ());
526 /* The prologue may be empty, but there may still be a line number entry
527 for the opening brace which is distinct from the first line of code.
528 If the prologue has been eliminated find_pc_line may return the source
529 line after the opening brace. We still want to print this opening brace.
530 first_le is used to implement this. */
532 nlines = SYMTAB_LINETABLE (main_symtab)->nitems;
533 le = SYMTAB_LINETABLE (main_symtab)->item;
536 /* Skip all the preceding functions. */
537 for (i = 0; i < nlines && le[i].pc < low; i++)
540 if (i < nlines && le[i].pc < high)
543 /* Add lines for every pc value. */
546 struct symtab_and_line sal;
549 sal = find_pc_line (pc, 0);
550 length = gdb_insn_length (gdbarch, pc);
553 if (sal.symtab != NULL)
554 add_dis_line_entry (dis_line_table.get (), sal.symtab, sal.line);
557 /* Second pass: print the disassembly.
559 Output format, from an MI perspective:
560 The result is a ui_out list, field name "asm_insns", where elements have
561 name "src_and_asm_line".
562 Each element is a tuple of source line specs (field names line, file,
563 fullname), and field "line_asm_insn" which contains the disassembly.
564 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
567 CLI output works on top of this because MI ignores ui_out_text output,
568 which is where we put file name and source line contents output.
572 Handles the outer "asm_insns" list.
574 The tuples for each group of consecutive disassemblies.
576 List of consecutive source lines or disassembled insns. */
578 if (flags & DISASSEMBLY_FILENAME)
579 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
581 ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
583 ui_out_tuple_chain = NULL;
584 ui_out_list_chain = NULL;
592 struct symtab_and_line sal;
594 int start_preceding_line_to_display = 0;
595 int end_preceding_line_to_display = 0;
596 int new_source_line = 0;
598 sal = find_pc_line (pc, 0);
600 if (sal.symtab != last_symtab)
602 /* New source file. */
605 /* If this is the first line of output, check for any preceding
609 && first_le->line < sal.line)
611 start_preceding_line_to_display = first_le->line;
612 end_preceding_line_to_display = sal.line;
617 /* Same source file as last time. */
618 if (sal.symtab != NULL)
620 if (sal.line > last_line + 1 && last_line != 0)
624 /* Several preceding source lines. Print the trailing ones
625 not associated with code that we'll print later. */
626 for (l = sal.line - 1; l > last_line; --l)
628 if (line_has_code_p (dis_line_table.get (),
632 if (l < sal.line - 1)
634 start_preceding_line_to_display = l + 1;
635 end_preceding_line_to_display = sal.line;
638 if (sal.line != last_line)
642 /* Same source line as last time. This can happen, depending
643 on the debug info. */
650 /* Skip the newline if this is the first instruction. */
653 if (ui_out_tuple_chain != NULL)
655 gdb_assert (ui_out_list_chain != NULL);
656 do_cleanups (ui_out_list_chain);
657 do_cleanups (ui_out_tuple_chain);
659 if (sal.symtab != last_symtab
660 && !(flags & DISASSEMBLY_FILENAME))
662 /* Remember MI ignores ui_out_text.
663 We don't have to do anything here for MI because MI
664 output includes the source specs for each line. */
665 if (sal.symtab != NULL)
667 uiout->text (symtab_to_filename_for_display (sal.symtab));
670 uiout->text ("unknown");
673 if (start_preceding_line_to_display > 0)
675 /* Several source lines w/o asm instructions associated.
676 We need to preserve the structure of the output, so output
677 a bunch of line tuples with no asm entries. */
679 struct cleanup *ui_out_list_chain_line;
681 gdb_assert (sal.symtab != NULL);
682 for (l = start_preceding_line_to_display;
683 l < end_preceding_line_to_display;
686 ui_out_emit_tuple tuple_emitter (uiout, "src_and_asm_line");
687 print_source_lines (sal.symtab, l, l + 1, psl_flags);
688 ui_out_list_chain_line
689 = make_cleanup_ui_out_list_begin_end (uiout,
691 do_cleanups (ui_out_list_chain_line);
695 = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
696 if (sal.symtab != NULL)
697 print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags);
699 uiout->text (_("--- no source info for this pc ---\n"));
701 = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
705 /* Here we're appending instructions to an existing line.
706 By construction the very first insn will have a symtab
707 and follow the new_source_line path above. */
708 gdb_assert (ui_out_tuple_chain != NULL);
709 gdb_assert (ui_out_list_chain != NULL);
713 end_pc = std::min (sal.end, high);
716 num_displayed += dump_insns (gdbarch, uiout, pc, end_pc,
717 how_many, flags, &end_pc);
720 if (how_many >= 0 && num_displayed >= how_many)
723 last_symtab = sal.symtab;
724 last_line = sal.line;
727 do_cleanups (ui_out_chain);
731 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
732 CORE_ADDR low, CORE_ADDR high,
733 int how_many, gdb_disassembly_flags flags)
735 ui_out_emit_list list_emitter (uiout, "asm_insns");
737 dump_insns (gdbarch, uiout, low, high, how_many, flags, NULL);
740 /* Initialize the disassemble info struct ready for the specified
743 static int ATTRIBUTE_PRINTF (2, 3)
744 fprintf_disasm (void *stream, const char *format, ...)
748 va_start (args, format);
749 vfprintf_filtered ((struct ui_file *) stream, format, args);
751 /* Something non -ve. */
755 gdb_disassembler::gdb_disassembler (struct gdbarch *gdbarch,
756 struct ui_file *file,
757 di_read_memory_ftype read_memory_func)
758 : m_gdbarch (gdbarch),
761 init_disassemble_info (&m_di, file, fprintf_disasm);
762 m_di.flavour = bfd_target_unknown_flavour;
763 m_di.memory_error_func = dis_asm_memory_error;
764 m_di.print_address_func = dis_asm_print_address;
765 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
766 disassembler had a local optomization here. By default it would
767 access the executable file, instead of the target memory (there
768 was a growing list of exceptions though). Unfortunately, the
769 heuristic was flawed. Commands like "disassemble &variable"
770 didn't work as they relied on the access going to the target.
771 Further, it has been supperseeded by trust-read-only-sections
772 (although that should be superseeded by target_trust..._p()). */
773 m_di.read_memory_func = read_memory_func;
774 m_di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
775 m_di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
776 m_di.endian = gdbarch_byte_order (gdbarch);
777 m_di.endian_code = gdbarch_byte_order_for_code (gdbarch);
778 m_di.application_data = this;
779 m_di.disassembler_options = get_disassembler_options (gdbarch);
780 disassemble_init_for_target (&m_di);
784 gdb_disassembler::print_insn (CORE_ADDR memaddr,
785 int *branch_delay_insns)
789 int length = gdbarch_print_insn (arch (), memaddr, &m_di);
792 memory_error (TARGET_XFER_E_IO, m_err_memaddr);
794 if (branch_delay_insns != NULL)
796 if (m_di.insn_info_valid)
797 *branch_delay_insns = m_di.branch_delay_insns;
799 *branch_delay_insns = 0;
805 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
806 gdb_disassembly_flags flags, int how_many,
807 CORE_ADDR low, CORE_ADDR high)
809 struct symtab *symtab;
812 /* Assume symtab is valid for whole PC range. */
813 symtab = find_pc_line_symtab (low);
815 if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
816 nlines = SYMTAB_LINETABLE (symtab)->nitems;
818 if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
820 do_assembly_only (gdbarch, uiout, low, high, how_many, flags);
822 else if (flags & DISASSEMBLY_SOURCE)
823 do_mixed_source_and_assembly (gdbarch, uiout, symtab, low, high,
826 else if (flags & DISASSEMBLY_SOURCE_DEPRECATED)
827 do_mixed_source_and_assembly_deprecated (gdbarch, uiout, symtab,
828 low, high, how_many, flags);
830 gdb_flush (gdb_stdout);
833 /* Print the instruction at address MEMADDR in debugged memory,
834 on STREAM. Returns the length of the instruction, in bytes,
835 and, if requested, the number of branch delay slot instructions. */
838 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
839 struct ui_file *stream, int *branch_delay_insns)
842 gdb_disassembler di (gdbarch, stream);
844 return di.print_insn (memaddr, branch_delay_insns);
847 /* Return the length in bytes of the instruction at address MEMADDR in
851 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
853 return gdb_print_insn (gdbarch, addr, &null_stream, NULL);
856 /* fprintf-function for gdb_buffered_insn_length. This function is a
857 nop, we don't want to print anything, we just want to compute the
858 length of the insn. */
860 static int ATTRIBUTE_PRINTF (2, 3)
861 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
866 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
869 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
870 struct disassemble_info *di,
871 const gdb_byte *insn, int max_len,
874 init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
876 /* init_disassemble_info installs buffer_read_memory, etc.
877 so we don't need to do that here.
878 The cast is necessary until disassemble_info is const-ified. */
879 di->buffer = (gdb_byte *) insn;
880 di->buffer_length = max_len;
881 di->buffer_vma = addr;
883 di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
884 di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
885 di->endian = gdbarch_byte_order (gdbarch);
886 di->endian_code = gdbarch_byte_order_for_code (gdbarch);
888 di->disassembler_options = get_disassembler_options (gdbarch);
889 disassemble_init_for_target (di);
892 /* Return the length in bytes of INSN. MAX_LEN is the size of the
893 buffer containing INSN. */
896 gdb_buffered_insn_length (struct gdbarch *gdbarch,
897 const gdb_byte *insn, int max_len, CORE_ADDR addr)
899 struct disassemble_info di;
901 gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
903 return gdbarch_print_insn (gdbarch, addr, &di);
907 get_disassembler_options (struct gdbarch *gdbarch)
909 char **disassembler_options = gdbarch_disassembler_options (gdbarch);
910 if (disassembler_options == NULL)
912 return *disassembler_options;
916 set_disassembler_options (char *prospective_options)
918 struct gdbarch *gdbarch = get_current_arch ();
919 char **disassembler_options = gdbarch_disassembler_options (gdbarch);
920 const disasm_options_t *valid_options;
921 char *options = remove_whitespace_and_extra_commas (prospective_options);
924 /* Allow all architectures, even ones that do not support 'set disassembler',
925 to reset their disassembler options to NULL. */
928 if (disassembler_options != NULL)
930 free (*disassembler_options);
931 *disassembler_options = NULL;
936 valid_options = gdbarch_valid_disassembler_options (gdbarch);
937 if (valid_options == NULL)
939 fprintf_filtered (gdb_stdlog, _("\
940 'set disassembler-options ...' is not supported on this architecture.\n"));
944 /* Verify we have valid disassembler options. */
945 FOR_EACH_DISASSEMBLER_OPTION (opt, options)
948 for (i = 0; valid_options->name[i] != NULL; i++)
949 if (disassembler_options_cmp (opt, valid_options->name[i]) == 0)
951 if (valid_options->name[i] == NULL)
953 fprintf_filtered (gdb_stdlog,
954 _("Invalid disassembler option value: '%s'.\n"),
960 free (*disassembler_options);
961 *disassembler_options = xstrdup (options);
965 set_disassembler_options_sfunc (char *args, int from_tty,
966 struct cmd_list_element *c)
968 set_disassembler_options (prospective_options);
972 show_disassembler_options_sfunc (struct ui_file *file, int from_tty,
973 struct cmd_list_element *c, const char *value)
975 struct gdbarch *gdbarch = get_current_arch ();
976 const disasm_options_t *valid_options;
978 const char *options = get_disassembler_options (gdbarch);
982 fprintf_filtered (file, _("The current disassembler options are '%s'\n"),
985 valid_options = gdbarch_valid_disassembler_options (gdbarch);
987 if (valid_options == NULL)
990 fprintf_filtered (file, _("\n\
991 The following disassembler options are supported for use with the\n\
992 'set disassembler-options <option>[,<option>...]' command:\n"));
994 if (valid_options->description != NULL)
996 size_t i, max_len = 0;
998 /* Compute the length of the longest option name. */
999 for (i = 0; valid_options->name[i] != NULL; i++)
1001 size_t len = strlen (valid_options->name[i]);
1006 for (i = 0, max_len++; valid_options->name[i] != NULL; i++)
1008 fprintf_filtered (file, " %s", valid_options->name[i]);
1009 if (valid_options->description[i] != NULL)
1010 fprintf_filtered (file, "%*c %s",
1011 (int)(max_len - strlen (valid_options->name[i])), ' ',
1012 valid_options->description[i]);
1013 fprintf_filtered (file, "\n");
1019 fprintf_filtered (file, " ");
1020 for (i = 0; valid_options->name[i] != NULL; i++)
1022 fprintf_filtered (file, "%s", valid_options->name[i]);
1023 if (valid_options->name[i + 1] != NULL)
1024 fprintf_filtered (file, ", ");
1027 fprintf_filtered (file, "\n");
1031 /* A completion function for "set disassembler". */
1034 disassembler_options_completer (struct cmd_list_element *ignore,
1035 completion_tracker &tracker,
1036 const char *text, const char *word)
1038 struct gdbarch *gdbarch = get_current_arch ();
1039 const disasm_options_t *opts = gdbarch_valid_disassembler_options (gdbarch);
1043 /* Only attempt to complete on the last option text. */
1044 const char *separator = strrchr (text, ',');
1045 if (separator != NULL)
1046 text = separator + 1;
1047 text = skip_spaces_const (text);
1048 complete_on_enum (tracker, opts->name, text, word);
1053 /* Initialization code. */
1056 _initialize_disasm (void)
1058 struct cmd_list_element *cmd;
1060 /* Add the command that controls the disassembler options. */
1061 cmd = add_setshow_string_noescape_cmd ("disassembler-options", no_class,
1062 &prospective_options, _("\
1063 Set the disassembler options.\n\
1064 Usage: set disassembler-options <option>[,<option>...]\n\n\
1065 See: 'show disassembler-options' for valid option values.\n"), _("\
1066 Show the disassembler options."), NULL,
1067 set_disassembler_options_sfunc,
1068 show_disassembler_options_sfunc,
1069 &setlist, &showlist);
1070 set_cmd_completer (cmd, disassembler_options_completer);