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"
32 #include "common/gdb_optional.h"
34 /* Disassemble functions.
35 FIXME: We should get rid of all the duplicate code in gdb that does
36 the same thing: disassemble_command() and the gdbtk variation. */
38 /* This variable is used to hold the prospective disassembler_options value
39 which is set by the "set disassembler_options" command. */
40 static char *prospective_options = NULL;
42 /* This structure is used to store line number information for the
44 We need a different sort of line table from the normal one cuz we can't
45 depend upon implicit line-end pc's for lines to do the
46 reordering in this function. */
48 struct deprecated_dis_line_entry
55 /* This Structure is used to store line number information.
56 We need a different sort of line table from the normal one cuz we can't
57 depend upon implicit line-end pc's for lines to do the
58 reordering in this function. */
62 struct symtab *symtab;
66 /* Hash function for dis_line_entry. */
69 hash_dis_line_entry (const void *item)
71 const struct dis_line_entry *dle = (const struct dis_line_entry *) item;
73 return htab_hash_pointer (dle->symtab) + dle->line;
76 /* Equal function for dis_line_entry. */
79 eq_dis_line_entry (const void *item_lhs, const void *item_rhs)
81 const struct dis_line_entry *lhs = (const struct dis_line_entry *) item_lhs;
82 const struct dis_line_entry *rhs = (const struct dis_line_entry *) item_rhs;
84 return (lhs->symtab == rhs->symtab
85 && lhs->line == rhs->line);
88 /* Create the table to manage lines for mixed source/disassembly. */
91 allocate_dis_line_table (void)
93 return htab_create_alloc (41,
94 hash_dis_line_entry, eq_dis_line_entry,
95 xfree, xcalloc, xfree);
98 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE. */
101 add_dis_line_entry (htab_t table, struct symtab *symtab, int line)
104 struct dis_line_entry dle, *dlep;
108 slot = htab_find_slot (table, &dle, INSERT);
111 dlep = XNEW (struct dis_line_entry);
112 dlep->symtab = symtab;
118 /* Return non-zero if SYMTAB, LINE are in TABLE. */
121 line_has_code_p (htab_t table, struct symtab *symtab, int line)
123 struct dis_line_entry dle;
127 return htab_find (table, &dle) != NULL;
130 /* Wrapper of target_read_code. */
133 gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr,
135 struct disassemble_info *info)
137 return target_read_code (memaddr, myaddr, len);
140 /* Wrapper of memory_error. */
143 gdb_disassembler::dis_asm_memory_error (int err, bfd_vma memaddr,
144 struct disassemble_info *info)
146 gdb_disassembler *self
147 = static_cast<gdb_disassembler *>(info->application_data);
149 self->m_err_memaddr = memaddr;
152 /* Wrapper of print_address. */
155 gdb_disassembler::dis_asm_print_address (bfd_vma addr,
156 struct disassemble_info *info)
158 gdb_disassembler *self
159 = static_cast<gdb_disassembler *>(info->application_data);
161 print_address (self->arch (), addr, self->stream ());
165 compare_lines (const void *mle1p, const void *mle2p)
167 struct deprecated_dis_line_entry *mle1, *mle2;
170 mle1 = (struct deprecated_dis_line_entry *) mle1p;
171 mle2 = (struct deprecated_dis_line_entry *) mle2p;
173 /* End of sequence markers have a line number of 0 but don't want to
174 be sorted to the head of the list, instead sort by PC. */
175 if (mle1->line == 0 || mle2->line == 0)
177 val = mle1->start_pc - mle2->start_pc;
179 val = mle1->line - mle2->line;
183 val = mle1->line - mle2->line;
185 val = mle1->start_pc - mle2->start_pc;
193 gdb_pretty_print_disassembler::pretty_print_insn (struct ui_out *uiout,
194 const struct disasm_insn *insn,
195 gdb_disassembly_flags flags)
197 /* parts of the symbolic representation of the address */
202 char *filename = NULL;
205 struct gdbarch *gdbarch = arch ();
208 ui_out_emit_tuple tuple_emitter (uiout, NULL);
211 if (insn->number != 0)
213 uiout->field_fmt ("insn-number", "%u", insn->number);
217 if ((flags & DISASSEMBLY_SPECULATIVE) != 0)
219 if (insn->is_speculative)
221 uiout->field_string ("is-speculative", "?");
223 /* The speculative execution indication overwrites the first
224 character of the PC prefix.
225 We assume a PC prefix length of 3 characters. */
226 if ((flags & DISASSEMBLY_OMIT_PC) == 0)
227 uiout->text (pc_prefix (pc) + 1);
231 else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
232 uiout->text (pc_prefix (pc));
236 else if ((flags & DISASSEMBLY_OMIT_PC) == 0)
237 uiout->text (pc_prefix (pc));
238 uiout->field_core_addr ("address", gdbarch, pc);
240 if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename,
243 /* We don't care now about line, filename and unmapped. But we might in
246 if ((flags & DISASSEMBLY_OMIT_FNAME) == 0)
247 uiout->field_string ("func-name", name);
249 uiout->field_int ("offset", offset);
250 uiout->text (">:\t");
255 if (filename != NULL)
262 if (flags & DISASSEMBLY_RAW_INSN)
267 const char *spacer = "";
269 /* Build the opcodes using a temporary stream so we can
270 write them out in a single go for the MI. */
271 m_opcode_stb.clear ();
273 size = m_di.print_insn (pc);
276 for (;pc < end_pc; ++pc)
278 read_code (pc, &data, 1);
279 m_opcode_stb.printf ("%s%02x", spacer, (unsigned) data);
283 uiout->field_stream ("opcodes", m_opcode_stb);
287 size = m_di.print_insn (pc);
289 uiout->field_stream ("inst", m_insn_stb);
297 dump_insns (struct gdbarch *gdbarch,
298 struct ui_out *uiout, CORE_ADDR low, CORE_ADDR high,
299 int how_many, gdb_disassembly_flags flags, CORE_ADDR *end_pc)
301 struct disasm_insn insn;
302 int num_displayed = 0;
304 memset (&insn, 0, sizeof (insn));
307 gdb_pretty_print_disassembler disasm (gdbarch);
309 while (insn.addr < high && (how_many < 0 || num_displayed < how_many))
313 size = disasm.pretty_print_insn (uiout, &insn, flags);
320 /* Allow user to bail out with ^C. */
327 return num_displayed;
330 /* The idea here is to present a source-O-centric view of a
331 function to the user. This means that things are presented
332 in source order, with (possibly) out of order assembly
333 immediately following.
335 N.B. This view is deprecated. */
338 do_mixed_source_and_assembly_deprecated
339 (struct gdbarch *gdbarch, struct ui_out *uiout,
340 struct symtab *symtab,
341 CORE_ADDR low, CORE_ADDR high,
342 int how_many, gdb_disassembly_flags flags)
346 struct linetable_entry *le;
347 struct deprecated_dis_line_entry *mle;
348 struct symtab_and_line sal;
350 int out_of_order = 0;
352 int num_displayed = 0;
353 print_source_lines_flags psl_flags = 0;
355 gdb_assert (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL);
357 nlines = SYMTAB_LINETABLE (symtab)->nitems;
358 le = SYMTAB_LINETABLE (symtab)->item;
360 if (flags & DISASSEMBLY_FILENAME)
361 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
363 mle = (struct deprecated_dis_line_entry *)
364 alloca (nlines * sizeof (struct deprecated_dis_line_entry));
366 /* Copy linetable entries for this function into our data
367 structure, creating end_pc's and setting out_of_order as
370 /* First, skip all the preceding functions. */
372 for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
374 /* Now, copy all entries before the end of this function. */
376 for (; i < nlines - 1 && le[i].pc < high; i++)
378 if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
379 continue; /* Ignore duplicates. */
381 /* Skip any end-of-function markers. */
385 mle[newlines].line = le[i].line;
386 if (le[i].line > le[i + 1].line)
388 mle[newlines].start_pc = le[i].pc;
389 mle[newlines].end_pc = le[i + 1].pc;
393 /* If we're on the last line, and it's part of the function,
394 then we need to get the end pc in a special way. */
396 if (i == nlines - 1 && le[i].pc < high)
398 mle[newlines].line = le[i].line;
399 mle[newlines].start_pc = le[i].pc;
400 sal = find_pc_line (le[i].pc, 0);
401 mle[newlines].end_pc = sal.end;
405 /* Now, sort mle by line #s (and, then by addresses within lines). */
408 qsort (mle, newlines, sizeof (struct deprecated_dis_line_entry),
411 /* Now, for each line entry, emit the specified lines (unless
412 they have been emitted before), followed by the assembly code
415 ui_out_emit_list asm_insns_list (uiout, "asm_insns");
417 gdb::optional<ui_out_emit_tuple> outer_tuple_emitter;
418 gdb::optional<ui_out_emit_list> inner_list_emitter;
420 for (i = 0; i < newlines; i++)
422 /* Print out everything from next_line to the current line. */
423 if (mle[i].line >= next_line)
427 /* Just one line to print. */
428 if (next_line == mle[i].line)
430 outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
431 print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
435 /* Several source lines w/o asm instructions associated. */
436 for (; next_line < mle[i].line; next_line++)
438 ui_out_emit_tuple tuple_emitter (uiout,
440 print_source_lines (symtab, next_line, next_line + 1,
442 ui_out_emit_list inner_list_emitter (uiout,
445 /* Print the last line and leave list open for
446 asm instructions to be added. */
447 outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
448 print_source_lines (symtab, next_line, mle[i].line + 1, psl_flags);
453 outer_tuple_emitter.emplace (uiout, "src_and_asm_line");
454 print_source_lines (symtab, mle[i].line, mle[i].line + 1, psl_flags);
457 next_line = mle[i].line + 1;
458 inner_list_emitter.emplace (uiout, "line_asm_insn");
461 num_displayed += dump_insns (gdbarch, uiout,
462 mle[i].start_pc, mle[i].end_pc,
463 how_many, flags, NULL);
465 /* When we've reached the end of the mle array, or we've seen the last
466 assembly range for this source line, close out the list/tuple. */
467 if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
469 inner_list_emitter.reset ();
470 outer_tuple_emitter.reset ();
473 if (how_many >= 0 && num_displayed >= how_many)
478 /* The idea here is to present a source-O-centric view of a
479 function to the user. This means that things are presented
480 in source order, with (possibly) out of order assembly
481 immediately following. */
484 do_mixed_source_and_assembly (struct gdbarch *gdbarch,
485 struct ui_out *uiout,
486 struct symtab *main_symtab,
487 CORE_ADDR low, CORE_ADDR high,
488 int how_many, gdb_disassembly_flags flags)
490 const struct linetable_entry *le, *first_le;
492 int num_displayed = 0;
493 print_source_lines_flags psl_flags = 0;
495 struct symtab *last_symtab;
498 gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL);
500 /* First pass: collect the list of all source files and lines.
501 We do this so that we can only print lines containing code once.
502 We try to print the source text leading up to the next instruction,
503 but if that text is for code that will be disassembled later, then
504 we'll want to defer printing it until later with its associated code. */
506 htab_up dis_line_table (allocate_dis_line_table ());
510 /* The prologue may be empty, but there may still be a line number entry
511 for the opening brace which is distinct from the first line of code.
512 If the prologue has been eliminated find_pc_line may return the source
513 line after the opening brace. We still want to print this opening brace.
514 first_le is used to implement this. */
516 nlines = SYMTAB_LINETABLE (main_symtab)->nitems;
517 le = SYMTAB_LINETABLE (main_symtab)->item;
520 /* Skip all the preceding functions. */
521 for (i = 0; i < nlines && le[i].pc < low; i++)
524 if (i < nlines && le[i].pc < high)
527 /* Add lines for every pc value. */
530 struct symtab_and_line sal;
533 sal = find_pc_line (pc, 0);
534 length = gdb_insn_length (gdbarch, pc);
537 if (sal.symtab != NULL)
538 add_dis_line_entry (dis_line_table.get (), sal.symtab, sal.line);
541 /* Second pass: print the disassembly.
543 Output format, from an MI perspective:
544 The result is a ui_out list, field name "asm_insns", where elements have
545 name "src_and_asm_line".
546 Each element is a tuple of source line specs (field names line, file,
547 fullname), and field "line_asm_insn" which contains the disassembly.
548 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
551 CLI output works on top of this because MI ignores ui_out_text output,
552 which is where we put file name and source line contents output.
556 Handles the outer "asm_insns" list.
558 The tuples for each group of consecutive disassemblies.
560 List of consecutive source lines or disassembled insns. */
562 if (flags & DISASSEMBLY_FILENAME)
563 psl_flags |= PRINT_SOURCE_LINES_FILENAME;
565 ui_out_emit_list asm_insns_emitter (uiout, "asm_insns");
567 gdb::optional<ui_out_emit_tuple> tuple_emitter;
568 gdb::optional<ui_out_emit_list> list_emitter;
576 struct symtab_and_line sal;
578 int start_preceding_line_to_display = 0;
579 int end_preceding_line_to_display = 0;
580 int new_source_line = 0;
582 sal = find_pc_line (pc, 0);
584 if (sal.symtab != last_symtab)
586 /* New source file. */
589 /* If this is the first line of output, check for any preceding
593 && first_le->line < sal.line)
595 start_preceding_line_to_display = first_le->line;
596 end_preceding_line_to_display = sal.line;
601 /* Same source file as last time. */
602 if (sal.symtab != NULL)
604 if (sal.line > last_line + 1 && last_line != 0)
608 /* Several preceding source lines. Print the trailing ones
609 not associated with code that we'll print later. */
610 for (l = sal.line - 1; l > last_line; --l)
612 if (line_has_code_p (dis_line_table.get (),
616 if (l < sal.line - 1)
618 start_preceding_line_to_display = l + 1;
619 end_preceding_line_to_display = sal.line;
622 if (sal.line != last_line)
626 /* Same source line as last time. This can happen, depending
627 on the debug info. */
634 /* Skip the newline if this is the first instruction. */
637 if (tuple_emitter.has_value ())
639 gdb_assert (list_emitter.has_value ());
640 list_emitter.reset ();
641 tuple_emitter.reset ();
643 if (sal.symtab != last_symtab
644 && !(flags & DISASSEMBLY_FILENAME))
646 /* Remember MI ignores ui_out_text.
647 We don't have to do anything here for MI because MI
648 output includes the source specs for each line. */
649 if (sal.symtab != NULL)
651 uiout->text (symtab_to_filename_for_display (sal.symtab));
654 uiout->text ("unknown");
657 if (start_preceding_line_to_display > 0)
659 /* Several source lines w/o asm instructions associated.
660 We need to preserve the structure of the output, so output
661 a bunch of line tuples with no asm entries. */
664 gdb_assert (sal.symtab != NULL);
665 for (l = start_preceding_line_to_display;
666 l < end_preceding_line_to_display;
669 ui_out_emit_tuple tuple_emitter (uiout, "src_and_asm_line");
670 print_source_lines (sal.symtab, l, l + 1, psl_flags);
671 ui_out_emit_list chain_line_emitter (uiout, "line_asm_insn");
674 tuple_emitter.emplace (uiout, "src_and_asm_line");
675 if (sal.symtab != NULL)
676 print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags);
678 uiout->text (_("--- no source info for this pc ---\n"));
679 list_emitter.emplace (uiout, "line_asm_insn");
683 /* Here we're appending instructions to an existing line.
684 By construction the very first insn will have a symtab
685 and follow the new_source_line path above. */
686 gdb_assert (tuple_emitter.has_value ());
687 gdb_assert (list_emitter.has_value ());
691 end_pc = std::min (sal.end, high);
694 num_displayed += dump_insns (gdbarch, uiout, pc, end_pc,
695 how_many, flags, &end_pc);
698 if (how_many >= 0 && num_displayed >= how_many)
701 last_symtab = sal.symtab;
702 last_line = sal.line;
707 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
708 CORE_ADDR low, CORE_ADDR high,
709 int how_many, gdb_disassembly_flags flags)
711 ui_out_emit_list list_emitter (uiout, "asm_insns");
713 dump_insns (gdbarch, uiout, low, high, how_many, flags, NULL);
716 /* Initialize the disassemble info struct ready for the specified
719 static int ATTRIBUTE_PRINTF (2, 3)
720 fprintf_disasm (void *stream, const char *format, ...)
724 va_start (args, format);
725 vfprintf_filtered ((struct ui_file *) stream, format, args);
727 /* Something non -ve. */
731 gdb_disassembler::gdb_disassembler (struct gdbarch *gdbarch,
732 struct ui_file *file,
733 di_read_memory_ftype read_memory_func)
734 : m_gdbarch (gdbarch),
737 init_disassemble_info (&m_di, file, fprintf_disasm);
738 m_di.flavour = bfd_target_unknown_flavour;
739 m_di.memory_error_func = dis_asm_memory_error;
740 m_di.print_address_func = dis_asm_print_address;
741 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
742 disassembler had a local optomization here. By default it would
743 access the executable file, instead of the target memory (there
744 was a growing list of exceptions though). Unfortunately, the
745 heuristic was flawed. Commands like "disassemble &variable"
746 didn't work as they relied on the access going to the target.
747 Further, it has been supperseeded by trust-read-only-sections
748 (although that should be superseeded by target_trust..._p()). */
749 m_di.read_memory_func = read_memory_func;
750 m_di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
751 m_di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
752 m_di.endian = gdbarch_byte_order (gdbarch);
753 m_di.endian_code = gdbarch_byte_order_for_code (gdbarch);
754 m_di.application_data = this;
755 m_di.disassembler_options = get_disassembler_options (gdbarch);
756 disassemble_init_for_target (&m_di);
760 gdb_disassembler::print_insn (CORE_ADDR memaddr,
761 int *branch_delay_insns)
765 int length = gdbarch_print_insn (arch (), memaddr, &m_di);
768 memory_error (TARGET_XFER_E_IO, m_err_memaddr);
770 if (branch_delay_insns != NULL)
772 if (m_di.insn_info_valid)
773 *branch_delay_insns = m_di.branch_delay_insns;
775 *branch_delay_insns = 0;
781 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
782 gdb_disassembly_flags flags, int how_many,
783 CORE_ADDR low, CORE_ADDR high)
785 struct symtab *symtab;
788 /* Assume symtab is valid for whole PC range. */
789 symtab = find_pc_line_symtab (low);
791 if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL)
792 nlines = SYMTAB_LINETABLE (symtab)->nitems;
794 if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE))
796 do_assembly_only (gdbarch, uiout, low, high, how_many, flags);
798 else if (flags & DISASSEMBLY_SOURCE)
799 do_mixed_source_and_assembly (gdbarch, uiout, symtab, low, high,
802 else if (flags & DISASSEMBLY_SOURCE_DEPRECATED)
803 do_mixed_source_and_assembly_deprecated (gdbarch, uiout, symtab,
804 low, high, how_many, flags);
806 gdb_flush (gdb_stdout);
809 /* Print the instruction at address MEMADDR in debugged memory,
810 on STREAM. Returns the length of the instruction, in bytes,
811 and, if requested, the number of branch delay slot instructions. */
814 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
815 struct ui_file *stream, int *branch_delay_insns)
818 gdb_disassembler di (gdbarch, stream);
820 return di.print_insn (memaddr, branch_delay_insns);
823 /* Return the length in bytes of the instruction at address MEMADDR in
827 gdb_insn_length (struct gdbarch *gdbarch, CORE_ADDR addr)
829 return gdb_print_insn (gdbarch, addr, &null_stream, NULL);
832 /* fprintf-function for gdb_buffered_insn_length. This function is a
833 nop, we don't want to print anything, we just want to compute the
834 length of the insn. */
836 static int ATTRIBUTE_PRINTF (2, 3)
837 gdb_buffered_insn_length_fprintf (void *stream, const char *format, ...)
842 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
845 gdb_buffered_insn_length_init_dis (struct gdbarch *gdbarch,
846 struct disassemble_info *di,
847 const gdb_byte *insn, int max_len,
850 init_disassemble_info (di, NULL, gdb_buffered_insn_length_fprintf);
852 /* init_disassemble_info installs buffer_read_memory, etc.
853 so we don't need to do that here.
854 The cast is necessary until disassemble_info is const-ified. */
855 di->buffer = (gdb_byte *) insn;
856 di->buffer_length = max_len;
857 di->buffer_vma = addr;
859 di->arch = gdbarch_bfd_arch_info (gdbarch)->arch;
860 di->mach = gdbarch_bfd_arch_info (gdbarch)->mach;
861 di->endian = gdbarch_byte_order (gdbarch);
862 di->endian_code = gdbarch_byte_order_for_code (gdbarch);
864 di->disassembler_options = get_disassembler_options (gdbarch);
865 disassemble_init_for_target (di);
868 /* Return the length in bytes of INSN. MAX_LEN is the size of the
869 buffer containing INSN. */
872 gdb_buffered_insn_length (struct gdbarch *gdbarch,
873 const gdb_byte *insn, int max_len, CORE_ADDR addr)
875 struct disassemble_info di;
877 gdb_buffered_insn_length_init_dis (gdbarch, &di, insn, max_len, addr);
879 return gdbarch_print_insn (gdbarch, addr, &di);
883 get_disassembler_options (struct gdbarch *gdbarch)
885 char **disassembler_options = gdbarch_disassembler_options (gdbarch);
886 if (disassembler_options == NULL)
888 return *disassembler_options;
892 set_disassembler_options (char *prospective_options)
894 struct gdbarch *gdbarch = get_current_arch ();
895 char **disassembler_options = gdbarch_disassembler_options (gdbarch);
896 const disasm_options_t *valid_options;
897 char *options = remove_whitespace_and_extra_commas (prospective_options);
900 /* Allow all architectures, even ones that do not support 'set disassembler',
901 to reset their disassembler options to NULL. */
904 if (disassembler_options != NULL)
906 free (*disassembler_options);
907 *disassembler_options = NULL;
912 valid_options = gdbarch_valid_disassembler_options (gdbarch);
913 if (valid_options == NULL)
915 fprintf_filtered (gdb_stdlog, _("\
916 'set disassembler-options ...' is not supported on this architecture.\n"));
920 /* Verify we have valid disassembler options. */
921 FOR_EACH_DISASSEMBLER_OPTION (opt, options)
924 for (i = 0; valid_options->name[i] != NULL; i++)
925 if (disassembler_options_cmp (opt, valid_options->name[i]) == 0)
927 if (valid_options->name[i] == NULL)
929 fprintf_filtered (gdb_stdlog,
930 _("Invalid disassembler option value: '%s'.\n"),
936 free (*disassembler_options);
937 *disassembler_options = xstrdup (options);
941 set_disassembler_options_sfunc (const char *args, int from_tty,
942 struct cmd_list_element *c)
944 set_disassembler_options (prospective_options);
948 show_disassembler_options_sfunc (struct ui_file *file, int from_tty,
949 struct cmd_list_element *c, const char *value)
951 struct gdbarch *gdbarch = get_current_arch ();
952 const disasm_options_t *valid_options;
954 const char *options = get_disassembler_options (gdbarch);
958 fprintf_filtered (file, _("The current disassembler options are '%s'\n"),
961 valid_options = gdbarch_valid_disassembler_options (gdbarch);
963 if (valid_options == NULL)
966 fprintf_filtered (file, _("\n\
967 The following disassembler options are supported for use with the\n\
968 'set disassembler-options <option>[,<option>...]' command:\n"));
970 if (valid_options->description != NULL)
972 size_t i, max_len = 0;
974 /* Compute the length of the longest option name. */
975 for (i = 0; valid_options->name[i] != NULL; i++)
977 size_t len = strlen (valid_options->name[i]);
982 for (i = 0, max_len++; valid_options->name[i] != NULL; i++)
984 fprintf_filtered (file, " %s", valid_options->name[i]);
985 if (valid_options->description[i] != NULL)
986 fprintf_filtered (file, "%*c %s",
987 (int)(max_len - strlen (valid_options->name[i])), ' ',
988 valid_options->description[i]);
989 fprintf_filtered (file, "\n");
995 fprintf_filtered (file, " ");
996 for (i = 0; valid_options->name[i] != NULL; i++)
998 fprintf_filtered (file, "%s", valid_options->name[i]);
999 if (valid_options->name[i + 1] != NULL)
1000 fprintf_filtered (file, ", ");
1003 fprintf_filtered (file, "\n");
1007 /* A completion function for "set disassembler". */
1010 disassembler_options_completer (struct cmd_list_element *ignore,
1011 completion_tracker &tracker,
1012 const char *text, const char *word)
1014 struct gdbarch *gdbarch = get_current_arch ();
1015 const disasm_options_t *opts = gdbarch_valid_disassembler_options (gdbarch);
1019 /* Only attempt to complete on the last option text. */
1020 const char *separator = strrchr (text, ',');
1021 if (separator != NULL)
1022 text = separator + 1;
1023 text = skip_spaces (text);
1024 complete_on_enum (tracker, opts->name, text, word);
1029 /* Initialization code. */
1032 _initialize_disasm (void)
1034 struct cmd_list_element *cmd;
1036 /* Add the command that controls the disassembler options. */
1037 cmd = add_setshow_string_noescape_cmd ("disassembler-options", no_class,
1038 &prospective_options, _("\
1039 Set the disassembler options.\n\
1040 Usage: set disassembler-options <option>[,<option>...]\n\n\
1041 See: 'show disassembler-options' for valid option values.\n"), _("\
1042 Show the disassembler options."), NULL,
1043 set_disassembler_options_sfunc,
1044 show_disassembler_options_sfunc,
1045 &setlist, &showlist);
1046 set_cmd_completer (cmd, disassembler_options_completer);