30#include "gdbsupport/gdb-safe-ctype.h"
32#include "gdbsupport/gdb_optional.h"
63 bool supported = dis.
disasm_info ()->created_styled_output;
66 gdb_printf (file, _(
"Use of libopcodes styling support is \"%s\".\n"),
72 gdb_printf (file, _(
"Use of libopcodes styling support is \"off\""
73 " (not supported on architecture \"%s\")\n"),
85 bool supported = dis.
disasm_info ()->created_styled_output;
95 error (_(
"Use of libopcodes styling not supported on architecture \"%s\"."),
133 return htab_hash_pointer (dle->
symtab) + dle->
line;
153 return htab_create_alloc (41,
168 slot = htab_find_slot (table, &dle, INSERT);
187 return htab_find (table, &dle) != NULL;
194 (bfd_vma memaddr, gdb_byte *myaddr,
unsigned int len,
195 struct disassemble_info *info)
noexcept
204 (
int err, bfd_vma memaddr,
struct disassemble_info *info)
noexcept
216 (bfd_vma addr,
struct disassemble_info *info)
noexcept
250 = gdb::checked_static_cast<gdb_printing_disassembler *> (di);
252 gdb_assert (
stream !=
nullptr);
260 const char *format, ...) noexcept
265 va_start (args, format);
277 (
void *dis_info,
enum disassembler_style style,
278 const char *format, ...) noexcept
284 va_start (args, format);
285 std::string content = string_vprintf (format, args);
289 if (style == dis_style_comment_start)
292 style = dis_style_comment_start;
295 const char *txt = content.c_str ();
298 case dis_style_mnemonic:
299 case dis_style_sub_mnemonic:
300 case dis_style_assembler_directive:
304 case dis_style_register:
308 case dis_style_immediate:
309 case dis_style_address_offset:
313 case dis_style_address:
317 case dis_style_symbol:
321 case dis_style_comment_start:
342 if (mle1.
line == 0 || mle2.
line == 0)
363 gdb_disassembly_flags
flags)
406 std::string
name, filename;
409 &offset, &filename, &line, &unmapped))
432 auto write_out_insn_buffer = [&] ()
447 gdb_assert (
size > 0);
449 catch (
const gdb_exception &)
457 write_out_insn_buffer ();
475 int bytes_per_line = std::max (di->bytes_per_line,
size);
476 int bytes_per_chunk = std::max (di->bytes_per_chunk, 1);
484 || (
size % bytes_per_chunk) != 0)
488 for (
int i = 0; i <
size; i += bytes_per_chunk)
493 if (di->display_endian == BFD_ENDIAN_LITTLE)
495 for (
int k = bytes_per_chunk; k-- != 0; )
500 for (
int k = 0; k < bytes_per_chunk; k++)
507 for (
int i =
size; i < bytes_per_line; i += bytes_per_chunk)
511 nspaces += bytes_per_chunk * 2;
520 write_out_insn_buffer ();
528 struct ui_out *uiout, CORE_ADDR low, CORE_ADDR high,
529 int how_many, gdb_disassembly_flags
flags, CORE_ADDR *end_pc)
532 int num_displayed = 0;
534 memset (&insn, 0,
sizeof (insn));
539 while (insn.
addr < high && (how_many < 0 || num_displayed < how_many))
557 return num_displayed;
571 CORE_ADDR low, CORE_ADDR high,
572 int how_many, gdb_disassembly_flags
flags)
580 int out_of_order = 0;
582 int num_displayed = 0;
583 print_source_lines_flags psl_flags = 0;
598 unrelocated_addr unrel_low
600 unrelocated_addr unrel_high
609 for (i = 0; i < nlines - 1 && le[i].
unrelocated_pc () < unrel_low; i++);
613 for (; i < nlines - 1 && le[i].
unrelocated_pc () < unrel_high; i++)
615 if (le[i] == le[i + 1])
623 if (le[i].line > le[i + 1].line)
633 if (i == nlines - 1 && le[i].unrelocated_pc () < unrel_high)
653 gdb::optional<ui_out_emit_tuple> outer_tuple_emitter;
654 gdb::optional<ui_out_emit_list> inner_list_emitter;
656 for (i = 0; i < newlines; i++)
659 if (mle[i].line >= next_line)
664 if (next_line == mle[i].line)
666 outer_tuple_emitter.emplace (uiout,
"src_and_asm_line");
672 for (; next_line < mle[i].
line; next_line++)
683 outer_tuple_emitter.emplace (uiout,
"src_and_asm_line");
689 outer_tuple_emitter.emplace (uiout,
"src_and_asm_line");
693 next_line = mle[i].
line + 1;
694 inner_list_emitter.emplace (uiout,
"line_asm_insn");
698 mle[i].start_pc, mle[i].end_pc,
699 how_many,
flags, NULL);
703 if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
705 inner_list_emitter.reset ();
706 outer_tuple_emitter.reset ();
709 if (how_many >= 0 && num_displayed >= how_many)
722 struct symtab *main_symtab,
723 CORE_ADDR low, CORE_ADDR high,
724 int how_many, gdb_disassembly_flags
flags)
728 int num_displayed = 0;
729 print_source_lines_flags psl_flags = 0;
731 struct symtab *last_symtab;
734 gdb_assert (main_symtab != NULL && main_symtab->
linetable () != NULL);
746 unrelocated_addr unrel_low
748 unrelocated_addr unrel_high
764 for (i = 0; i < nlines && le[i].
unrelocated_pc () < unrel_low; i++)
767 if (i < nlines && le[i].unrelocated_pc () < unrel_high)
810 gdb::optional<ui_out_emit_tuple> tuple_emitter;
811 gdb::optional<ui_out_emit_list> list_emitter;
821 int start_preceding_line_to_display = 0;
822 int end_preceding_line_to_display = 0;
823 int new_source_line = 0;
827 if (sal.
symtab != last_symtab)
838 start_preceding_line_to_display = first_le->
line;
839 end_preceding_line_to_display = sal.
line;
847 if (sal.
line > last_line + 1 && last_line != 0)
853 for (l = sal.
line - 1; l > last_line; --l)
859 if (l < sal.
line - 1)
861 start_preceding_line_to_display = l + 1;
862 end_preceding_line_to_display = sal.
line;
865 if (sal.
line != last_line)
880 if (tuple_emitter.has_value ())
882 gdb_assert (list_emitter.has_value ());
883 list_emitter.reset ();
884 tuple_emitter.reset ();
886 if (sal.
symtab != last_symtab
897 uiout->
text (
"unknown");
900 if (start_preceding_line_to_display > 0)
907 gdb_assert (sal.
symtab != NULL);
908 for (l = start_preceding_line_to_display;
909 l < end_preceding_line_to_display;
918 tuple_emitter.emplace (uiout,
"src_and_asm_line");
922 uiout->
text (_(
"--- no source info for this pc ---\n"));
923 list_emitter.emplace (uiout,
"line_asm_insn");
930 gdb_assert (tuple_emitter.has_value ());
931 gdb_assert (list_emitter.has_value ());
935 end_pc = std::min (sal.
end, high);
939 how_many,
flags, &end_pc);
942 if (how_many >= 0 && num_displayed >= how_many)
946 last_line = sal.
line;
952 CORE_ADDR low, CORE_ADDR high,
953 int how_many, gdb_disassembly_flags
flags)
968 const char *comma =
",";
970 if (implicit ==
nullptr)
976 if (options ==
nullptr)
982 return string_printf (
"%s%s%s", implicit, comma, options);
989 dis_asm_memory_error, dis_asm_print_address),
991 m_buffer (!use_ext_lang_for_styling () && use_libopcodes_for_styling ())
1029 &&
m_di.created_styled_output
1043 gdb_assert (fprintf_func !=
nullptr);
1044 gdb_assert (fprintf_styled_func !=
nullptr);
1045 init_disassemble_info (&
m_di, (
void *)
this, fprintf_func,
1046 fprintf_styled_func);
1047 m_di.flavour = bfd_target_unknown_flavour;
1054 if (memory_error_func !=
nullptr)
1055 m_di.memory_error_func = memory_error_func;
1056 if (print_address_func !=
nullptr)
1057 m_di.print_address_func = print_address_func;
1058 if (read_memory_func !=
nullptr)
1059 m_di.read_memory_func = read_memory_func;
1065 m_di.application_data =
this;
1069 disassemble_init_for_target (&
m_di);
1076 disassemble_free_target (&
m_di);
1090 struct disassemble_info *info)
1094 if (length.has_value ())
1125 gdb::optional<std::string> ext_contents;
1127 if (ext_contents.has_value ())
1128 m_buffer = std::move (*ext_contents);
1155 gdb_assert (length > 0);
1170 error (_(
"unknown disassembler error (error = %d)"), length);
1175 if (
m_di.insn_info_valid)
1185 gdb_disassembly_flags
flags,
int how_many,
1186 CORE_ADDR low, CORE_ADDR high)
1207 low, high, how_many,
flags);
1239 (
void *stream,
const char *format, ...) noexcept
1248 (
void *stream,
enum disassembler_style style,
1249 const char *format, ...) noexcept
1266 gdb::array_view<const gdb_byte> buffer,
1267 CORE_ADDR insn_address)
1271 m_di.buffer = (gdb_byte *) buffer.data ();
1272 m_di.buffer_length = buffer.size ();
1273 m_di.buffer_vma = insn_address;
1282 const gdb_byte *insn,
int max_len, CORE_ADDR addr)
1284 gdb::array_view<const gdb_byte> buffer
1285 = gdb::make_array_view (insn, max_len);
1295 if (disassembler_options == NULL)
1297 return *disassembler_options;
1305 const disasm_options_and_args_t *valid_options_and_args;
1306 const disasm_options_t *valid_options;
1307 gdb::unique_xmalloc_ptr<char> prospective_options_local
1309 char *options = remove_whitespace_and_extra_commas
1310 (prospective_options_local.get ());
1315 if (options == NULL)
1317 if (disassembler_options != NULL)
1319 free (*disassembler_options);
1320 *disassembler_options = NULL;
1326 if (valid_options_and_args == NULL)
1329'set disassembler-options ...' is not supported on this architecture.\n"));
1333 valid_options = &valid_options_and_args->options;
1336 FOR_EACH_DISASSEMBLER_OPTION (opt, options)
1339 for (i = 0; valid_options->name[i] != NULL; i++)
1340 if (valid_options->arg != NULL && valid_options->arg[i] != NULL)
1342 size_t len = strlen (valid_options->name[i]);
1347 if (memcmp (opt, valid_options->name[i], len) != 0)
1350 if (valid_options->arg[i]->values == NULL)
1352 for (j = 0; valid_options->arg[i]->values[j] != NULL; j++)
1353 if (disassembler_options_cmp
1354 (arg, valid_options->arg[i]->values[j]) == 0)
1362 else if (disassembler_options_cmp (opt, valid_options->name[i]) == 0)
1364 if (valid_options->name[i] == NULL)
1367 _(
"Invalid disassembler option value: '%s'.\n"),
1373 free (*disassembler_options);
1374 *disassembler_options = xstrdup (options);
1389 const disasm_options_and_args_t *valid_options_and_args;
1390 const disasm_option_arg_t *valid_args;
1391 const disasm_options_t *valid_options;
1394 if (options == NULL)
1397 gdb_printf (file, _(
"The current disassembler options are '%s'\n\n"),
1402 if (valid_options_and_args == NULL)
1404 gdb_puts (_(
"There are no disassembler options available "
1405 "for this architecture.\n"),
1410 valid_options = &valid_options_and_args->options;
1413The following disassembler options are supported for use with the\n\
1414'set disassembler-options OPTION [,OPTION]...' command:\n"));
1416 if (valid_options->description != NULL)
1418 size_t i, max_len = 0;
1423 for (i = 0; valid_options->name[i] != NULL; i++)
1425 size_t len = strlen (valid_options->name[i]);
1427 if (valid_options->arg != NULL && valid_options->arg[i] != NULL)
1428 len += strlen (valid_options->arg[i]->name);
1433 for (i = 0, max_len++; valid_options->name[i] != NULL; i++)
1435 gdb_printf (file,
" %s", valid_options->name[i]);
1436 if (valid_options->arg != NULL && valid_options->arg[i] != NULL)
1437 gdb_printf (file,
"%s", valid_options->arg[i]->name);
1438 if (valid_options->description[i] != NULL)
1440 size_t len = strlen (valid_options->name[i]);
1442 if (valid_options->arg != NULL && valid_options->arg[i] != NULL)
1443 len += strlen (valid_options->arg[i]->name);
1444 gdb_printf (file,
"%*c %s", (
int) (max_len - len),
' ',
1445 valid_options->description[i]);
1454 for (i = 0; valid_options->name[i] != NULL; i++)
1456 gdb_printf (file,
"%s", valid_options->name[i]);
1457 if (valid_options->arg != NULL && valid_options->arg[i] != NULL)
1458 gdb_printf (file,
"%s", valid_options->arg[i]->name);
1459 if (valid_options->name[i + 1] != NULL)
1461 file->wrap_here (2);
1466 valid_args = valid_options_and_args->args;
1467 if (valid_args != NULL)
1471 for (i = 0; valid_args[i].name != NULL; i++)
1473 if (valid_args[i].values == NULL)
1476 For the options above, the following values are supported for \"%s\":\n "),
1477 valid_args[i].
name);
1478 for (j = 0; valid_args[i].values[j] != NULL; j++)
1480 gdb_printf (file,
" %s", valid_args[i].values[j]);
1481 file->wrap_here (3);
1493 const char *text,
const char *word)
1496 const disasm_options_and_args_t *opts_and_args
1499 if (opts_and_args != NULL)
1501 const disasm_options_t *opts = &opts_and_args->options;
1504 const char *separator = strrchr (text,
',');
1505 if (separator != NULL)
1506 text = separator + 1;
1507 text = skip_spaces (text);
1523Set the disassembler options.\n\
1524Usage: set disassembler-options OPTION [,OPTION]...\n\n\
1525See: 'show disassembler-options' for valid option values."), _(
"\
1526Show the disassembler options."), NULL,
1539 _(
"Set libopcodes-styling specific variables."),
1540 _(
"Show libopcodes-styling specific variables."),
1541 &maint_set_libopcodes_styling_cmdlist,
1542 &maint_show_libopcodes_styling_cmdlist,
1549Set whether the libopcodes styling support should be used."), _(
"\
1550Show whether the libopcodes styling support should be used."),_(
"\
1551When enabled, GDB will try to make use of the builtin libopcodes styling\n\
1552support, to style the disassembler output. Not every architecture has\n\
1553styling support within libopcodes, so enabling this is not a guarantee\n\
1554that libopcodes styling will be available.\n\
1556When this option is disabled, GDB will make use of the Python Pygments\n\
1557package (if available) to style the disassembler output.\n\
1559All disassembler styling can be disabled with:\n\
1561 set style disassembler enabled off"),
1564 &maint_set_libopcodes_styling_cmdlist,
1565 &maint_show_libopcodes_styling_cmdlist);
gdb_static_assert(sizeof(splay_tree_key) >=sizeof(CORE_ADDR *))
void * xcalloc(size_t number, size_t size)
struct gdbarch * get_current_arch(void)
struct gdbarch * target_gdbarch(void)
ui_file_style style() const
gdb::byte_vector m_opcode_data
int pretty_print_insn(const struct disasm_insn *insn, gdb_disassembly_flags flags)
const char * c_str() const
const std::string & string()
virtual bool can_emit_style_escape()
virtual void puts(const char *str)
void printf(const char *,...) ATTRIBUTE_PRINTF(2
void void void spaces(int numspaces)
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
void field_signed(const char *fldname, LONGEST value)
void text(const char *string)
void field_stream(const char *fldname, string_file &stream, const ui_file_style &style=ui_file_style())
void field_unsigned(const char *fldname, ULONGEST value)
struct cmd_list_element * showlist
struct cmd_list_element * setlist
struct cmd_list_element * maintenance_show_cmdlist
struct cmd_list_element * maintenance_set_cmdlist
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
set_show_commands add_setshow_prefix_cmd(const char *name, command_class theclass, const char *set_doc, const char *show_doc, cmd_list_element **set_subcommands_list, cmd_list_element **show_subcommands_list, cmd_list_element **set_list, cmd_list_element **show_list)
set_show_commands add_setshow_boolean_cmd(const char *name, enum command_class theclass, bool *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
set_show_commands add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
bool disassembler_styling
cli_style_option address_style
cli_style_option function_name_style
cli_style_option disasm_mnemonic_style
cli_style_option disasm_register_style
cli_style_option disasm_immediate_style
cli_style_option disasm_comment_style
void read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
const char * pc_prefix(CORE_ADDR)
void print_address(struct gdbarch *, CORE_ADDR, struct ui_file *)
@ DISASSEMBLY_SOURCE_DEPRECATED
@ DISASSEMBLY_SPECULATIVE
static bool line_is_less_than(const deprecated_dis_line_entry &mle1, const deprecated_dis_line_entry &mle2)
void gdb_disassembly(struct gdbarch *gdbarch, struct ui_out *uiout, gdb_disassembly_flags flags, int how_many, CORE_ADDR low, CORE_ADDR high)
static htab_t allocate_dis_line_table(void)
static int dump_insns(struct gdbarch *gdbarch, struct ui_out *uiout, CORE_ADDR low, CORE_ADDR high, int how_many, gdb_disassembly_flags flags, CORE_ADDR *end_pc)
void _initialize_disasm()
int gdb_print_insn(struct gdbarch *gdbarch, CORE_ADDR memaddr, struct ui_file *stream, int *branch_delay_insns)
int gdb_buffered_insn_length(struct gdbarch *gdbarch, const gdb_byte *insn, int max_len, CORE_ADDR addr)
static int line_has_code_p(htab_t table, struct symtab *symtab, int line)
static void do_mixed_source_and_assembly_deprecated(struct gdbarch *gdbarch, struct ui_out *uiout, struct symtab *symtab, CORE_ADDR low, CORE_ADDR high, int how_many, gdb_disassembly_flags flags)
static void add_dis_line_entry(htab_t table, struct symtab *symtab, int line)
char * get_disassembler_options(struct gdbarch *gdbarch)
static int eq_dis_line_entry(const void *item_lhs, const void *item_rhs)
static void set_use_libopcodes_styling(const char *args, int from_tty, struct cmd_list_element *c)
static bool use_libopcodes_styling
static hashval_t hash_dis_line_entry(const void *item)
static void do_assembly_only(struct gdbarch *gdbarch, struct ui_out *uiout, CORE_ADDR low, CORE_ADDR high, int how_many, gdb_disassembly_flags flags)
static std::string prospective_options
int gdb_insn_length(struct gdbarch *gdbarch, CORE_ADDR addr)
static void show_disassembler_options_sfunc(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
static void set_disassembler_options_sfunc(const char *args, int from_tty, struct cmd_list_element *c)
static std::string get_all_disassembler_options(struct gdbarch *gdbarch)
static void disassembler_options_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
static int gdb_print_insn_1(struct gdbarch *gdbarch, CORE_ADDR vma, struct disassemble_info *info)
void set_disassembler_options(const char *prospective_options)
static bool use_libopcodes_styling_option
static void do_mixed_source_and_assembly(struct gdbarch *gdbarch, struct ui_out *uiout, struct symtab *main_symtab, CORE_ADDR low, CORE_ADDR high, int how_many, gdb_disassembly_flags flags)
static void show_use_libopcodes_styling(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
gdb::optional< int > ext_lang_print_insn(struct gdbarch *gdbarch, CORE_ADDR address, struct disassemble_info *info)
gdb::optional< std::string > ext_lang_colorize_disasm(const std::string &content, gdbarch *gdbarch)
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
enum bfd_endian gdbarch_byte_order_for_code(struct gdbarch *gdbarch)
char ** gdbarch_disassembler_options(struct gdbarch *gdbarch)
const char * gdbarch_disassembler_options_implicit(struct gdbarch *gdbarch)
int gdbarch_print_insn(struct gdbarch *gdbarch, bfd_vma vma, struct disassemble_info *info)
const disasm_options_and_args_t * gdbarch_valid_disassembler_options(struct gdbarch *gdbarch)
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
mach_port_t kern_return_t mach_port_t mach_msg_type_name_t msgportsPoly mach_port_t kern_return_t pid_t pid mach_port_t kern_return_t mach_port_t task mach_port_t kern_return_t int flags
int build_address_symbolic(struct gdbarch *gdbarch, CORE_ADDR addr, bool do_demangle, bool prefer_sym_over_minsym, std::string *name, int *offset, std::string *filename, int *line, int *unmapped)
static int branch_delay_insns
void(* func)(remote_target *remote, char *)
const char * symtab_to_filename_for_display(struct symtab *symtab)
void print_source_lines(struct symtab *s, int line, int stopline, print_source_lines_flags flags)
@ PRINT_SOURCE_LINES_FILENAME
struct objfile * objfile() const
unsigned int is_speculative
std::string m_disassembler_options_holder
int(*)(bfd_vma, bfd_byte *, unsigned int, struct disassemble_info *) LIBOPCODE_CALLBACK_NOEXCEPT read_memory_ftype
void(*)(bfd_vma, struct disassemble_info *) LIBOPCODE_CALLBACK_NOEXCEPT print_address_ftype
gdb_disassemble_info(struct gdbarch *gdbarch, read_memory_ftype read_memory_func, memory_error_ftype memory_error_func, print_address_ftype print_address_func, fprintf_ftype fprintf_func, fprintf_styled_ftype fprintf_styled_func)
virtual ~gdb_disassemble_info()
int(*)(void *, const char *,...) LIBOPCODE_CALLBACK_NOEXCEPT fprintf_ftype
void(*)(int, bfd_vma, struct disassemble_info *) LIBOPCODE_CALLBACK_NOEXCEPT memory_error_ftype
int(*)(void *, enum disassembler_style, const char *,...) LIBOPCODE_CALLBACK_NOEXCEPT fprintf_styled_ftype
struct disassemble_info * disasm_info()
struct disassemble_info m_di
static int dis_asm_read_memory(bfd_vma memaddr, gdb_byte *myaddr, unsigned int len, struct disassemble_info *info) noexcept
bool use_ext_lang_for_styling() const
gdb_disassembler(struct gdbarch *gdbarch, struct ui_file *file)
bool use_libopcodes_for_styling() const
static void dis_asm_memory_error(int err, bfd_vma memaddr, struct disassemble_info *info) noexcept
int print_insn(CORE_ADDR memaddr, int *branch_delay_insns=NULL)
static bool use_ext_lang_colorization_p
gdb::optional< CORE_ADDR > m_err_memaddr
static void dis_asm_print_address(bfd_vma addr, struct disassemble_info *info) noexcept
gdb_non_printing_buffer_disassembler(struct gdbarch *gdbarch, gdb::array_view< const gdb_byte > buffer, CORE_ADDR insn_address)
static int static int null_fprintf_styled_func(void *stream, enum disassembler_style style, const char *format,...) noexcept ATTRIBUTE_PRINTF(3
static int null_fprintf_func(void *stream, const char *format,...) noexcept ATTRIBUTE_PRINTF(2
static int fprintf_func(void *dis_info, const char *format,...) noexcept ATTRIBUTE_PRINTF(2
struct ui_file * stream()
void set_in_comment(bool c)
static int static int fprintf_styled_func(void *dis_info, enum disassembler_style style, const char *format,...) noexcept ATTRIBUTE_PRINTF(3
static int static int bool in_comment_p() const
static ui_file * stream_from_gdb_disassemble_info(void *dis_info)
CORE_ADDR pc(const struct objfile *objfile) const
unrelocated_addr unrelocated_pc() const
struct linetable_entry item[1]
CORE_ADDR text_section_offset() const
struct compunit_symtab * compunit() const
const struct linetable * linetable() const
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
int target_read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
void gdb_vprintf(struct ui_file *stream, const char *format, va_list args)
void gdb_printf(struct ui_file *stream, const char *format,...)
void fputs_styled(const char *linebuffer, const ui_file_style &style, struct ui_file *stream)
void gdb_flush(struct ui_file *stream)
void gdb_puts(const char *linebuffer, struct ui_file *stream)