X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fstack.c;h=71d85985d18c0706f221c04b4e146f286996329d;hb=c76d61da4a65eaadca861bf6c77d579a5cc3f422;hp=f67a151aeee96f45bdebeae6f9e96c1def4d58c9;hpb=7813437494ac39f3aef392d06ed5416e84fe386b;p=binutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index f67a151aeee..71d85985d18 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -1,6 +1,6 @@ /* Print and select stack frames for GDB, the GNU debugger. - Copyright (C) 1986-2020 Free Software Foundation, Inc. + Copyright (C) 1986-2022 Free Software Foundation, Inc. This file is part of GDB. @@ -55,6 +55,7 @@ #include "gdbsupport/def-vector.h" #include "cli/cli-option.h" #include "cli/cli-style.h" +#include "gdbsupport/buildargv.h" /* The possible choices of "set print frame-arguments", and the value of this setting. */ @@ -398,8 +399,8 @@ print_frame_nameless_args (struct frame_info *frame, long start, int num, arg_value = read_memory_integer (argsaddr + start, sizeof (int), byte_order); if (!first) - fprintf_filtered (stream, ", "); - fprintf_filtered (stream, "%ld", arg_value); + gdb_printf (stream, ", "); + gdb_printf (stream, "%ld", arg_value); first = 0; start += sizeof (int); } @@ -427,17 +428,14 @@ print_frame_arg (const frame_print_options &fp_opts, annotate_arg_emitter arg_emitter; ui_out_emit_tuple tuple_emitter (uiout, NULL); - fprintf_symbol_filtered (&stb, arg->sym->print_name (), - arg->sym->language (), DMGL_PARAMS | DMGL_ANSI); + gdb_puts (arg->sym->print_name (), &stb); if (arg->entry_kind == print_entry_values_compact) { /* It is OK to provide invalid MI-like stream as with PRINT_ENTRY_VALUE_COMPACT we never use MI. */ stb.puts ("="); - fprintf_symbol_filtered (&stb, arg->sym->print_name (), - arg->sym->language (), - DMGL_PARAMS | DMGL_ANSI); + gdb_puts (arg->sym->print_name (), &stb); } if (arg->entry_kind == print_entry_values_only || arg->entry_kind == print_entry_values_compact) @@ -528,7 +526,7 @@ read_frame_local (struct symbol *sym, struct frame_info *frame, void read_frame_arg (const frame_print_options &fp_opts, symbol *sym, frame_info *frame, - struct frame_arg *argp, struct frame_arg *entryargp) + struct frame_arg *argp, struct frame_arg *entryargp) { struct value *val = NULL, *entryval = NULL; char *val_error = NULL, *entryval_error = NULL; @@ -676,7 +674,7 @@ read_frame_arg (const frame_print_options &fp_opts, || (fp_opts.print_entry_values == print_entry_values_preferred && (!val || value_optimized_out (val)))) { - entryval = allocate_optimized_out_value (SYMBOL_TYPE (sym)); + entryval = allocate_optimized_out_value (sym->type ()); entryval_error = NULL; } } @@ -744,14 +742,20 @@ print_frame_args (const frame_print_options &fp_opts, = (print_names && fp_opts.print_frame_arguments != print_frame_arguments_none); + /* Temporarily change the selected frame to the given FRAME. + This allows routines that rely on the selected frame instead + of being given a frame as parameter to use the correct frame. */ + scoped_restore_selected_frame restore_selected_frame; + select_frame (frame); + if (func) { - const struct block *b = SYMBOL_BLOCK_VALUE (func); + const struct block *b = func->value_block (); struct block_iterator iter; struct symbol *sym; ALL_BLOCK_SYMBOLS (b, iter, sym) - { + { struct frame_arg arg, entryarg; QUIT; @@ -759,7 +763,7 @@ print_frame_args (const frame_print_options &fp_opts, /* Keep track of the highest stack argument offset seen, and skip over any kinds of symbols we don't care about. */ - if (!SYMBOL_IS_ARGUMENT (sym)) + if (!sym->is_argument ()) continue; if (!print_names) @@ -769,13 +773,13 @@ print_frame_args (const frame_print_options &fp_opts, break; } - switch (SYMBOL_CLASS (sym)) + switch (sym->aclass ()) { case LOC_ARG: case LOC_REF_ARG: { - long current_offset = SYMBOL_VALUE (sym); - int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym)); + long current_offset = sym->value_longest (); + int arg_size = TYPE_LENGTH (sym->type ()); /* Compute address of next argument by adding the size of this argument and rounding to an int boundary. */ @@ -824,8 +828,8 @@ print_frame_args (const frame_print_options &fp_opts, nsym = lookup_symbol_search_name (sym->search_name (), b, VAR_DOMAIN).symbol; gdb_assert (nsym != NULL); - if (SYMBOL_CLASS (nsym) == LOC_REGISTER - && !SYMBOL_IS_ARGUMENT (nsym)) + if (nsym->aclass () == LOC_REGISTER + && !nsym->is_argument ()) { /* There is a LOC_ARG/LOC_REGISTER pair. This means that it was passed on the stack and loaded into a @@ -836,22 +840,22 @@ print_frame_args (const frame_print_options &fp_opts, Reasons for using the LOC_ARG: (1) Because find_saved_registers may be slow for - remote debugging. + remote debugging. (2) Because registers are often re-used and stack - slots rarely (never?) are. Therefore using - the stack slot is much less likely to print - garbage. + slots rarely (never?) are. Therefore using + the stack slot is much less likely to print + garbage. Reasons why we might want to use the LOC_REGISTER: (1) So that the backtrace prints the same value - as "print foo". I see no compelling reason - why this needs to be the case; having the - backtrace print the value which was passed - in, and "print foo" print the value as - modified within the called function, makes - perfect sense to me. + as "print foo". I see no compelling reason + why this needs to be the case; having the + backtrace print the value which was passed + in, and "print foo" print the value as + modified within the called function, makes + perfect sense to me. Additional note: It might be nice if "info args" displayed both values. @@ -871,7 +875,7 @@ print_frame_args (const frame_print_options &fp_opts, /* Print the current arg. */ if (!first) uiout->text (", "); - uiout->wrap_hint (" "); + uiout->wrap_hint (4); if (!print_args) { @@ -891,7 +895,7 @@ print_frame_args (const frame_print_options &fp_opts, if (arg.entry_kind != print_entry_values_only) { uiout->text (", "); - uiout->wrap_hint (" "); + uiout->wrap_hint (4); } print_frame_arg (fp_opts, &entryarg); @@ -945,10 +949,10 @@ show_disassemble_next_line (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { - fprintf_filtered (file, - _("Debugger's willingness to use " - "disassemble-next-line is %s.\n"), - value); + gdb_printf (file, + _("Debugger's willingness to use " + "disassemble-next-line is %s.\n"), + value); } /* Use TRY_CATCH to catch the exception from the gdb_disassembly @@ -999,11 +1003,11 @@ print_pc (struct ui_out *uiout, struct gdbarch *gdbarch, frame_info *frame, std::string flags = gdbarch_get_pc_address_flags (gdbarch, frame, pc); if (!flags.empty ()) - { - uiout->text (" ["); - uiout->field_string ("addr_flags", flags); - uiout->text ("]"); - } + { + uiout->text (" ["); + uiout->field_string ("addr_flags", flags); + uiout->text ("]"); + } } /* See stack.h. */ @@ -1013,7 +1017,7 @@ get_user_print_what_frame_info (gdb::optional *what) { *what = print_frame_info_to_print_what - (user_frame_print_options.print_frame_info); + (user_frame_print_options.print_frame_info); } /* Print information about frame FRAME. The output is format according @@ -1053,35 +1057,35 @@ print_frame_info (const frame_print_options &fp_opts, gdbarch, get_frame_pc (frame)); /* Do this regardless of SOURCE because we don't have any source - to list for this frame. */ + to list for this frame. */ if (print_level) - { - uiout->text ("#"); - uiout->field_fmt_signed (2, ui_left, "level", + { + uiout->text ("#"); + uiout->field_fmt_signed (2, ui_left, "level", frame_relative_level (frame)); - } + } if (uiout->is_mi_like_p ()) - { - annotate_frame_address (); + { + annotate_frame_address (); print_pc (uiout, gdbarch, frame, get_frame_pc (frame)); - annotate_frame_address_end (); - } + annotate_frame_address_end (); + } if (get_frame_type (frame) == DUMMY_FRAME) - { - annotate_function_call (); - uiout->field_string ("func", "", + { + annotate_function_call (); + uiout->field_string ("func", "", metadata_style.style ()); } else if (get_frame_type (frame) == SIGTRAMP_FRAME) - { + { annotate_signal_handler_caller (); - uiout->field_string ("func", "", + uiout->field_string ("func", "", metadata_style.style ()); - } + } else if (get_frame_type (frame) == ARCH_FRAME) - { - uiout->field_string ("func", "", + { + uiout->field_string ("func", "", metadata_style.style ()); } uiout->text ("\n"); @@ -1126,10 +1130,25 @@ print_frame_info (const frame_print_options &fp_opts, { int mid_statement = ((print_what == SRC_LINE) && frame_show_address (frame, sal)); - annotate_source_line (sal.symtab, sal.line, mid_statement, - get_frame_pc (frame)); - - if (deprecated_print_frame_info_listing_hook) + if (annotation_level > 0 + && annotate_source_line (sal.symtab, sal.line, mid_statement, + get_frame_pc (frame))) + { + /* The call to ANNOTATE_SOURCE_LINE already printed the + annotation for this source line, so we avoid the two cases + below and do not print the actual source line. The + documentation for annotations makes it clear that the source + line annotation is printed __instead__ of printing the source + line, not as well as. + + However, if we fail to print the source line, which usually + means either the source file is missing, or the requested + line is out of range of the file, then we don't print the + source annotation, and will pass through the "normal" print + source line code below, the expectation is that this code + will print an appropriate error. */ + } + else if (deprecated_print_frame_info_listing_hook) deprecated_print_frame_info_listing_hook (sal.symtab, sal.line, sal.line + 1, 0); else @@ -1347,10 +1366,9 @@ print_frame (const frame_print_options &fp_opts, annotate_frame_function_name (); string_file stb; - fprintf_symbol_filtered (&stb, funname ? funname.get () : "??", - funlang, DMGL_ANSI); + gdb_puts (funname ? funname.get () : "??", &stb); uiout->field_stream ("func", stb, function_name_style.style ()); - uiout->wrap_hint (" "); + uiout->wrap_hint (3); annotate_frame_args (); uiout->text (" ("); @@ -1388,7 +1406,7 @@ print_frame (const frame_print_options &fp_opts, filename_display = symtab_to_filename_for_display (sal.symtab); annotate_frame_source_begin (); - uiout->wrap_hint (" "); + uiout->wrap_hint (3); uiout->text (" at "); annotate_frame_source_file (); uiout->field_string ("file", filename_display, @@ -1415,7 +1433,7 @@ print_frame (const frame_print_options &fp_opts, if (lib) { annotate_frame_where (); - uiout->wrap_hint (" "); + uiout->wrap_hint (2); uiout->text (" from "); uiout->field_string ("from", lib, file_name_style.style ()); } @@ -1524,38 +1542,37 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) if (selected_frame_p && frame_relative_level (fi) >= 0) { - printf_filtered (_("Stack level %d, frame at "), - frame_relative_level (fi)); + gdb_printf (_("Stack level %d, frame at "), + frame_relative_level (fi)); } else { - printf_filtered (_("Stack frame at ")); + gdb_printf (_("Stack frame at ")); } - fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout); - printf_filtered (":\n"); - printf_filtered (" %s = ", pc_regname); + gdb_puts (paddress (gdbarch, get_frame_base (fi))); + gdb_printf (":\n"); + gdb_printf (" %s = ", pc_regname); if (frame_pc_p) - fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); + gdb_puts (paddress (gdbarch, get_frame_pc (fi))); else fputs_styled ("", metadata_style.style (), gdb_stdout); - wrap_here (" "); + gdb_stdout->wrap_here (3); if (funname) { - printf_filtered (" in "); - fprintf_symbol_filtered (gdb_stdout, funname, funlang, - DMGL_ANSI | DMGL_PARAMS); + gdb_printf (" in "); + gdb_puts (funname); } - wrap_here (" "); + gdb_stdout->wrap_here (3); if (sal.symtab) - printf_filtered + gdb_printf (" (%ps:%d)", styled_string (file_name_style.style (), symtab_to_filename_for_display (sal.symtab)), sal.line); - puts_filtered ("; "); - wrap_here (" "); - printf_filtered ("saved %s = ", pc_regname); + gdb_puts ("; "); + gdb_stdout->wrap_here (4); + gdb_printf ("saved %s = ", pc_regname); if (!frame_id_p (frame_unwind_caller_id (fi))) val_print_not_saved (gdb_stdout); @@ -1586,8 +1603,8 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) } if (caller_pc_p) - fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); - printf_filtered ("\n"); + gdb_puts (paddress (gdbarch, caller_pc)); + gdb_printf ("\n"); if (calling_frame_info == NULL) { @@ -1595,35 +1612,33 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) reason = get_frame_unwind_stop_reason (fi); if (reason != UNWIND_NO_REASON) - printf_filtered (_(" Outermost frame: %s\n"), - frame_stop_reason_string (fi)); + gdb_printf (_(" Outermost frame: %s\n"), + frame_stop_reason_string (fi)); } else if (get_frame_type (fi) == TAILCALL_FRAME) - puts_filtered (" tail call frame"); + gdb_puts (" tail call frame"); else if (get_frame_type (fi) == INLINE_FRAME) - printf_filtered (" inlined into frame %d", - frame_relative_level (get_prev_frame (fi))); + gdb_printf (" inlined into frame %d", + frame_relative_level (get_prev_frame (fi))); else { - printf_filtered (" called by frame at "); - fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)), - gdb_stdout); + gdb_printf (" called by frame at "); + gdb_puts (paddress (gdbarch, get_frame_base (calling_frame_info))); } if (get_next_frame (fi) && calling_frame_info) - puts_filtered (","); - wrap_here (" "); + gdb_puts (","); + gdb_stdout->wrap_here (3); if (get_next_frame (fi)) { - printf_filtered (" caller of frame at "); - fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))), - gdb_stdout); + gdb_printf (" caller of frame at "); + gdb_puts (paddress (gdbarch, get_frame_base (get_next_frame (fi)))); } if (get_next_frame (fi) || calling_frame_info) - puts_filtered ("\n"); + gdb_puts ("\n"); if (s) - printf_filtered (" source language %s.\n", - language_str (s->language)); + gdb_printf (" source language %s.\n", + language_str (s->language ())); { /* Address of the argument list for this frame, or 0. */ @@ -1632,32 +1647,32 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) int numargs; if (arg_list == 0) - printf_filtered (" Arglist at unknown address.\n"); + gdb_printf (" Arglist at unknown address.\n"); else { - printf_filtered (" Arglist at "); - fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); - printf_filtered (","); + gdb_printf (" Arglist at "); + gdb_puts (paddress (gdbarch, arg_list)); + gdb_printf (","); if (!gdbarch_frame_num_args_p (gdbarch)) { numargs = -1; - puts_filtered (" args: "); + gdb_puts (" args: "); } else { numargs = gdbarch_frame_num_args (gdbarch, fi); gdb_assert (numargs >= 0); if (numargs == 0) - puts_filtered (" no args."); + gdb_puts (" no args."); else if (numargs == 1) - puts_filtered (" 1 arg: "); + gdb_puts (" 1 arg: "); else - printf_filtered (" %d args: ", numargs); + gdb_printf (" %d args: ", numargs); } print_frame_args (user_frame_print_options, func, fi, numargs, gdb_stdout); - puts_filtered ("\n"); + gdb_puts ("\n"); } } { @@ -1665,12 +1680,12 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) CORE_ADDR arg_list = get_frame_locals_address (fi); if (arg_list == 0) - printf_filtered (" Locals at unknown address,"); + gdb_printf (" Locals at unknown address,"); else { - printf_filtered (" Locals at "); - fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); - printf_filtered (","); + gdb_printf (" Locals at "); + gdb_puts (paddress (gdbarch, arg_list)); + gdb_printf (","); } } @@ -1700,25 +1715,24 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int sp_size = register_size (gdbarch, sp_regnum); - sp = extract_unsigned_integer (value_contents_all (value), - sp_size, byte_order); + sp = extract_unsigned_integer + (value_contents_all (value).data (), sp_size, byte_order); - printf_filtered (" Previous frame's sp is "); - fputs_filtered (paddress (gdbarch, sp), gdb_stdout); - printf_filtered ("\n"); + gdb_printf (" Previous frame's sp is "); + gdb_puts (paddress (gdbarch, sp)); + gdb_printf ("\n"); } else if (VALUE_LVAL (value) == lval_memory) { - printf_filtered (" Previous frame's sp at "); - fputs_filtered (paddress (gdbarch, value_address (value)), - gdb_stdout); - printf_filtered ("\n"); + gdb_printf (" Previous frame's sp at "); + gdb_puts (paddress (gdbarch, value_address (value))); + gdb_printf ("\n"); } else if (VALUE_LVAL (value) == lval_register) { - printf_filtered (" Previous frame's sp in %s\n", - gdbarch_register_name (gdbarch, - VALUE_REGNUM (value))); + gdb_printf (" Previous frame's sp in %s\n", + gdbarch_register_name (gdbarch, + VALUE_REGNUM (value))); } release_value (value); @@ -1740,7 +1754,7 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) int realnum; /* Find out the location of the saved register without - fetching the corresponding value. */ + fetching the corresponding value. */ frame_register_unwind (fi, i, &optimized, &unavailable, &lval, &addr, &realnum, NULL); /* For moment, only display registers that were saved on the @@ -1748,18 +1762,18 @@ info_frame_command_core (struct frame_info *fi, bool selected_frame_p) if (!optimized && !unavailable && lval == lval_memory) { if (count == 0) - puts_filtered (" Saved registers:\n "); + gdb_puts (" Saved registers:\n "); else - puts_filtered (","); - wrap_here (" "); - printf_filtered (" %s at ", - gdbarch_register_name (gdbarch, i)); - fputs_filtered (paddress (gdbarch, addr), gdb_stdout); + gdb_puts (","); + gdb_stdout->wrap_here (1); + gdb_printf (" %s at ", + gdbarch_register_name (gdbarch, i)); + gdb_puts (paddress (gdbarch, addr)); count++; } } if (count || need_nl) - puts_filtered ("\n"); + gdb_puts ("\n"); } } @@ -1821,20 +1835,12 @@ trailing_outermost_frame (int count) static void select_frame_command_core (struct frame_info *fi, bool ignored) { - struct frame_info *prev_frame = get_selected_frame_if_set (); + frame_info *prev_frame = get_selected_frame (); select_frame (fi); - if (get_selected_frame_if_set () != prev_frame) + if (get_selected_frame () != prev_frame) gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); } -/* See stack.h. */ - -void -select_frame_for_mi (struct frame_info *fi) -{ - select_frame_command_core (fi, false /* Ignored. */); -} - /* The core of all the "frame" sub-commands. Select frame FI, and if this means we change frame send out a change notification (otherwise, just reprint the current frame summary). */ @@ -1842,10 +1848,9 @@ select_frame_for_mi (struct frame_info *fi) static void frame_command_core (struct frame_info *fi, bool ignored) { - struct frame_info *prev_frame = get_selected_frame_if_set (); - + frame_info *prev_frame = get_selected_frame (); select_frame (fi); - if (get_selected_frame_if_set () != prev_frame) + if (get_selected_frame () != prev_frame) gdb::observers::user_selected_context_changed.notify (USER_SELECTED_FRAME); else print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME); @@ -1907,7 +1912,7 @@ public: struct frame_info *fid; if (args == NULL) - error (_("Missing address argument to view a frame")); + error (_("Missing address argument to view a frame")); gdb_argv argv (args); @@ -1980,7 +1985,7 @@ backtrace_command_1 (const frame_print_options &fp_opts, int py_start = 0, py_end = 0; enum ext_lang_bt_status result = EXT_LANG_BT_ERROR; - if (!target_has_stack) + if (!target_has_stack ()) error (_("No stack.")); if (count_exp) @@ -2084,7 +2089,7 @@ backtrace_command_1 (const frame_print_options &fp_opts, /* If we've stopped before the end, mention that. */ if (fi && from_tty) - printf_filtered (_("(More stack frames follow...)\n")); + gdb_printf (_("(More stack frames follow...)\n")); /* If we've run out of frames, and the reason appears to be an error condition, print it. */ @@ -2094,8 +2099,8 @@ backtrace_command_1 (const frame_print_options &fp_opts, reason = get_frame_unwind_stop_reason (trailing); if (reason >= UNWIND_FIRST_ERROR) - printf_filtered (_("Backtrace stopped: %s\n"), - frame_stop_reason_string (trailing)); + gdb_printf (_("Backtrace stopped: %s\n"), + frame_stop_reason_string (trailing)); } } } @@ -2222,20 +2227,18 @@ backtrace_command_completer (struct cmd_list_element *ignore, expression_completer (ignore, tracker, text, word); } -/* Iterate over the local variables of a block B, calling CB with - CB_DATA. */ +/* Iterate over the local variables of a block B, calling CB. */ static void iterate_over_block_locals (const struct block *b, - iterate_over_block_arg_local_vars_cb cb, - void *cb_data) + iterate_over_block_arg_local_vars_cb cb) { struct block_iterator iter; struct symbol *sym; ALL_BLOCK_SYMBOLS (b, iter, sym) { - switch (SYMBOL_CLASS (sym)) + switch (sym->aclass ()) { case LOC_CONST: case LOC_LOCAL: @@ -2243,11 +2246,11 @@ iterate_over_block_locals (const struct block *b, case LOC_STATIC: case LOC_COMPUTED: case LOC_OPTIMIZED_OUT: - if (SYMBOL_IS_ARGUMENT (sym)) + if (sym->is_argument ()) break; - if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN) + if (sym->domain () == COMMON_BLOCK_DOMAIN) break; - (*cb) (sym->print_name (), sym, cb_data); + cb (sym->print_name (), sym); break; default: @@ -2262,18 +2265,17 @@ iterate_over_block_locals (const struct block *b, void iterate_over_block_local_vars (const struct block *block, - iterate_over_block_arg_local_vars_cb cb, - void *cb_data) + iterate_over_block_arg_local_vars_cb cb) { while (block) { - iterate_over_block_locals (block, cb, cb_data); + iterate_over_block_locals (block, cb); /* After handling the function's top-level block, stop. Don't continue to its superblock, the block of per-file symbols. */ - if (BLOCK_FUNCTION (block)) + if (block->function ()) break; - block = BLOCK_SUPERBLOCK (block); + block = block->superblock (); } } @@ -2288,39 +2290,40 @@ struct print_variable_and_value_data int num_tabs; struct ui_file *stream; int values_printed; + + void operator() (const char *print_name, struct symbol *sym); }; /* The callback for the locals and args iterators. */ -static void -do_print_variable_and_value (const char *print_name, - struct symbol *sym, - void *cb_data) +void +print_variable_and_value_data::operator() (const char *print_name, + struct symbol *sym) { - struct print_variable_and_value_data *p - = (struct print_variable_and_value_data *) cb_data; struct frame_info *frame; - if (p->preg.has_value () - && p->preg->exec (sym->natural_name (), 0, NULL, 0) != 0) + if (preg.has_value () + && preg->exec (sym->natural_name (), 0, NULL, 0) != 0) return; - if (p->treg.has_value () - && !treg_matches_sym_type_name (*p->treg, sym)) + if (treg.has_value () + && !treg_matches_sym_type_name (*treg, sym)) + return; + if (language_def (sym->language ())->symbol_printing_suppressed (sym)) return; - frame = frame_find_by_id (p->frame_id); + frame = frame_find_by_id (frame_id); if (frame == NULL) { warning (_("Unable to restore previously selected frame.")); return; } - print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs); + print_variable_and_value (print_name, sym, frame, stream, num_tabs); /* print_variable_and_value invalidates FRAME. */ frame = NULL; - p->values_printed = 1; + values_printed = 1; } /* Prepares the regular expression REG from REGEXP. @@ -2363,8 +2366,8 @@ print_frame_local_vars (struct frame_info *frame, if (!get_frame_pc_if_available (frame, &pc)) { if (!quiet) - fprintf_filtered (stream, - _("PC unavailable, cannot determine locals.\n")); + gdb_printf (stream, + _("PC unavailable, cannot determine locals.\n")); return; } @@ -2372,7 +2375,7 @@ print_frame_local_vars (struct frame_info *frame, if (block == 0) { if (!quiet) - fprintf_filtered (stream, "No symbol table info available.\n"); + gdb_printf (stream, "No symbol table info available.\n"); return; } @@ -2389,16 +2392,14 @@ print_frame_local_vars (struct frame_info *frame, scoped_restore_selected_frame restore_selected_frame; select_frame (frame); - iterate_over_block_local_vars (block, - do_print_variable_and_value, - &cb_data); + iterate_over_block_local_vars (block, cb_data); if (!cb_data.values_printed && !quiet) { if (regexp == NULL && t_regexp == NULL) - fprintf_filtered (stream, _("No locals.\n")); + gdb_printf (stream, _("No locals.\n")); else - fprintf_filtered (stream, _("No matching locals.\n")); + gdb_printf (stream, _("No matching locals.\n")); } } @@ -2409,12 +2410,7 @@ print_frame_local_vars (struct frame_info *frame, struct info_print_options { bool quiet = false; - char *type_regexp = nullptr; - - ~info_print_options () - { - xfree (type_regexp); - } + std::string type_regexp; }; /* The options used by the 'info locals' and 'info args' commands. */ @@ -2473,17 +2469,18 @@ info_locals_command (const char *args, int from_tty) if (args != nullptr && *args == '\0') args = nullptr; - print_frame_local_vars (get_selected_frame (_("No frame selected.")), - opts.quiet, args, opts.type_regexp, - 0, gdb_stdout); + print_frame_local_vars + (get_selected_frame (_("No frame selected.")), + opts.quiet, args, + opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), + 0, gdb_stdout); } /* Iterate over all the argument variables in block B. */ void iterate_over_block_arg_vars (const struct block *b, - iterate_over_block_arg_local_vars_cb cb, - void *cb_data) + iterate_over_block_arg_local_vars_cb cb) { struct block_iterator iter; struct symbol *sym, *sym2; @@ -2491,7 +2488,7 @@ iterate_over_block_arg_vars (const struct block *b, ALL_BLOCK_SYMBOLS (b, iter, sym) { /* Don't worry about things which aren't arguments. */ - if (SYMBOL_IS_ARGUMENT (sym)) + if (sym->is_argument ()) { /* We have to look up the symbol because arguments can have two entries (one a parameter, one a local) and the one we @@ -2506,7 +2503,7 @@ iterate_over_block_arg_vars (const struct block *b, sym2 = lookup_symbol_search_name (sym->search_name (), b, VAR_DOMAIN).symbol; - (*cb) (sym->print_name (), sym2, cb_data); + cb (sym->print_name (), sym2); } } } @@ -2537,8 +2534,8 @@ print_frame_arg_vars (struct frame_info *frame, if (!get_frame_pc_if_available (frame, &pc)) { if (!quiet) - fprintf_filtered (stream, - _("PC unavailable, cannot determine args.\n")); + gdb_printf (stream, + _("PC unavailable, cannot determine args.\n")); return; } @@ -2546,7 +2543,7 @@ print_frame_arg_vars (struct frame_info *frame, if (func == NULL) { if (!quiet) - fprintf_filtered (stream, _("No symbol table info available.\n")); + gdb_printf (stream, _("No symbol table info available.\n")); return; } @@ -2557,8 +2554,7 @@ print_frame_arg_vars (struct frame_info *frame, cb_data.stream = stream; cb_data.values_printed = 0; - iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), - do_print_variable_and_value, &cb_data); + iterate_over_block_arg_vars (func->value_block (), cb_data); /* do_print_variable_and_value invalidates FRAME. */ frame = NULL; @@ -2566,9 +2562,9 @@ print_frame_arg_vars (struct frame_info *frame, if (!cb_data.values_printed && !quiet) { if (regexp == NULL && t_regexp == NULL) - fprintf_filtered (stream, _("No arguments.\n")); + gdb_printf (stream, _("No arguments.\n")); else - fprintf_filtered (stream, _("No matching arguments.\n")); + gdb_printf (stream, _("No matching arguments.\n")); } } @@ -2584,8 +2580,11 @@ info_args_command (const char *args, int from_tty) if (args != nullptr && *args == '\0') args = nullptr; - print_frame_arg_vars (get_selected_frame (_("No frame selected.")), - opts.quiet, args, opts.type_regexp, gdb_stdout); + print_frame_arg_vars + (get_selected_frame (_("No frame selected.")), + opts.quiet, args, + opts.type_regexp.empty () ? nullptr : opts.type_regexp.c_str (), + gdb_stdout); } /* Return the symbol-block in which the selected frame is executing. @@ -2689,9 +2688,9 @@ down_silently_base (const char *count_exp) if (count != 0 && count_exp == NULL) { /* We only do this if COUNT_EXP is not specified. That way - "down" means to really go down (and let me know if that is - impossible), but "down 9999" can be used to mean go all the - way down without getting an error. */ + "down" means to really go down (and let me know if that is + impossible), but "down 9999" can be used to mean go all the + way down without getting an error. */ error (_("Bottom (innermost) frame selected; you cannot go down.")); } @@ -2722,7 +2721,7 @@ return_command (const char *retval_exp, int from_tty) struct symbol *thisfun; struct value *return_value = NULL; struct value *function = NULL; - const char *query_prefix = ""; + std::string query_prefix; thisframe = get_selected_frame ("No selected frame."); thisfun = get_frame_function (thisframe); @@ -2741,17 +2740,17 @@ return_command (const char *retval_exp, int from_tty) struct type *return_type = NULL; /* Compute the return value. Should the computation fail, this - call throws an error. */ + call throws an error. */ return_value = evaluate_expression (retval_expr.get ()); /* Cast return value to the return type of the function. Should - the cast fail, this call throws an error. */ + the cast fail, this call throws an error. */ if (thisfun != NULL) - return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); + return_type = TYPE_TARGET_TYPE (thisfun->type ()); if (return_type == NULL) - { - if (retval_expr->elts[0].opcode != UNOP_CAST - && retval_expr->elts[0].opcode != UNOP_CAST_TYPE) + { + if (retval_expr->first_opcode () != UNOP_CAST + && retval_expr->first_opcode () != UNOP_CAST_TYPE) error (_("Return value type not available for selected " "stack frame.\n" "Please use an explicit cast of the value to return.")); @@ -2761,7 +2760,7 @@ return_command (const char *retval_exp, int from_tty) return_value = value_cast (return_type, return_value); /* Make sure the value is fully evaluated. It may live in the - stack frame we're about to pop. */ + stack frame we're about to pop. */ if (value_lazy (return_value)) value_fetch_lazy (return_value); @@ -2771,13 +2770,24 @@ return_command (const char *retval_exp, int from_tty) rv_conv = RETURN_VALUE_REGISTER_CONVENTION; if (return_type->code () == TYPE_CODE_VOID) /* If the return-type is "void", don't try to find the - return-value's location. However, do still evaluate the - return expression so that, even when the expression result - is discarded, side effects such as "return i++" still - occur. */ + return-value's location. However, do still evaluate the + return expression so that, even when the expression result + is discarded, side effects such as "return i++" still + occur. */ return_value = NULL; else if (thisfun != NULL) { + if (is_nocall_function (check_typedef (value_type (function)))) + { + query_prefix = + string_printf ("Function '%s' does not follow the target " + "calling convention.\n" + "If you continue, setting the return value " + "will probably lead to unpredictable " + "behaviors.\n", + thisfun->print_name ()); + } + rv_conv = struct_return_convention (gdbarch, function, return_type); if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS) @@ -2800,12 +2810,13 @@ return_command (const char *retval_exp, int from_tty) if (thisfun == NULL) confirmed = query (_("%sMake selected stack frame return now? "), - query_prefix); + query_prefix.c_str ()); else { - if (TYPE_NO_RETURN (thisfun->type)) + if (TYPE_NO_RETURN (thisfun->type ())) warning (_("Function does not return normally to caller.")); - confirmed = query (_("%sMake %s return now? "), query_prefix, + confirmed = query (_("%sMake %s return now? "), + query_prefix.c_str (), thisfun->print_name ()); } if (!confirmed) @@ -2825,7 +2836,7 @@ return_command (const char *retval_exp, int from_tty) && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS); gdbarch_return_value (cache_arch, function, return_type, get_current_regcache (), NULL /*read*/, - value_contents (return_value) /*write*/); + value_contents (return_value).data () /*write*/); } /* If we are at the end of a call dummy now, pop the dummy frame @@ -2892,24 +2903,6 @@ find_frame_for_function (const char *function_name) return frame; } -/* Implements the dbx 'func' command. */ - -static void -func_command (const char *arg, int from_tty) -{ - if (arg == NULL) - return; - - struct frame_info *frame = find_frame_for_function (arg); - if (frame == NULL) - error (_("'%s' not within current stack frame."), arg); - if (frame != get_selected_frame (NULL)) - { - select_frame (frame); - print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); - } -} - /* The qcs command line flags for the "frame apply" commands. Keep this in sync with the "thread apply" commands. */ @@ -2954,15 +2947,15 @@ make_frame_apply_options_def_group (qcs_flags *flags, frame apply -3 info frame Apply 'info frame' to outermost 3 frames. frame apply all x/i $pc Apply 'x/i $pc' cmd to all frames. frame apply all -s p local_var_no_idea_in_which_frame - If a frame has a local variable called - local_var_no_idea_in_which_frame, print frame - and value of local_var_no_idea_in_which_frame. + If a frame has a local variable called + local_var_no_idea_in_which_frame, print frame + and value of local_var_no_idea_in_which_frame. frame apply all -s -q p local_var_no_idea_in_which_frame - Same as before, but only print the variable value. + Same as before, but only print the variable value. frame apply level 2-5 0 4-7 -s p i = i + 1 - Adds 1 to the variable i in the specified frames. - Note that i will be incremented twice in - frames 4 and 5. */ + Adds 1 to the variable i in the specified frames. + Note that i will be incremented twice in + frames 4 and 5. */ /* Apply a GDB command to COUNT stack frames, starting at TRAILING. CMD starts with 0 or more qcs flags followed by the GDB command to apply. @@ -3011,8 +3004,8 @@ frame_apply_command_count (const char *which_command, set to the selected frame. */ scoped_restore_current_thread restore_fi_current_frame; - cmd_result = execute_command_to_string - (cmd, from_tty, gdb_stdout->term_out ()); + execute_command_to_string + (cmd_result, cmd, from_tty, gdb_stdout->term_out ()); } fi = get_selected_frame (_("frame apply " "unable to get selected frame.")); @@ -3020,7 +3013,7 @@ frame_apply_command_count (const char *which_command, { if (!flags.quiet) print_stack_frame (fi, 1, LOCATION, 0); - printf_filtered ("%s", cmd_result.c_str ()); + gdb_printf ("%s", cmd_result.c_str ()); } } catch (const gdb_exception_error &ex) @@ -3032,7 +3025,7 @@ frame_apply_command_count (const char *which_command, if (!flags.quiet) print_stack_frame (fi, 1, LOCATION, 0); if (flags.cont) - printf_filtered ("%s\n", ex.what ()); + gdb_printf ("%s\n", ex.what ()); else throw; } @@ -3143,7 +3136,7 @@ frame_apply_cmd_completer (struct cmd_list_element *ignore, static void frame_apply_level_command (const char *cmd, int from_tty) { - if (!target_has_stack) + if (!target_has_stack ()) error (_("No stack.")); bool level_found = false; @@ -3191,7 +3184,7 @@ frame_apply_level_command (const char *cmd, int from_tty) static void frame_apply_all_command (const char *cmd, int from_tty) { - if (!target_has_stack) + if (!target_has_stack ()) error (_("No stack.")); frame_apply_command_count ("frame apply all", cmd, from_tty, @@ -3206,7 +3199,7 @@ frame_apply_command (const char* cmd, int from_tty) int count; struct frame_info *trailing; - if (!target_has_stack) + if (!target_has_stack ()) error (_("No stack.")); if (cmd == NULL) @@ -3309,22 +3302,24 @@ An argument says how many frames up to go.")); Same as the `up' command, but does not print anything.\n\ This is useful in command scripts.")); - add_com ("down", class_stack, down_command, _("\ + cmd_list_element *down_cmd + = add_com ("down", class_stack, down_command, _("\ Select and print stack frame called by this one.\n\ An argument says how many frames down to go.")); - add_com_alias ("do", "down", class_stack, 1); - add_com_alias ("dow", "down", class_stack, 1); + add_com_alias ("do", down_cmd, class_stack, 1); + add_com_alias ("dow", down_cmd, class_stack, 1); add_com ("down-silently", class_support, down_silently_command, _("\ Same as the `down' command, but does not print anything.\n\ This is useful in command scripts.")); - add_prefix_cmd ("frame", class_stack, - &frame_cmd.base_command, _("\ + cmd_list_element *frame_cmd_el + = add_prefix_cmd ("frame", class_stack, + &frame_cmd.base_command, _("\ Select and print a stack frame.\n\ With no argument, print the selected stack frame. (See also \"info frame\").\n\ A single numerical argument specifies the frame to select."), - &frame_cmd_list, "frame ", 1, &cmdlist); - add_com_alias ("f", "frame", class_stack, 1); + &frame_cmd_list, 1, &cmdlist); + add_com_alias ("f", frame_cmd_el, class_stack, 1); #define FRAME_APPLY_OPTION_HELP "\ Prints the frame location information followed by COMMAND output.\n\ @@ -3347,7 +3342,7 @@ With a negative COUNT argument, applies the command on outermost -COUNT frames.\ cmd = add_prefix_cmd ("apply", class_stack, frame_apply_command, frame_apply_cmd_help.c_str (), - &frame_apply_cmd_list, "frame apply ", 1, + &frame_apply_cmd_list, 1, &frame_cmd_list); set_cmd_completer_handle_brkchars (cmd, frame_apply_cmd_completer); @@ -3420,7 +3415,7 @@ Usage: frame level LEVEL"), &select_frame_cmd.base_command, _("\ Select a stack frame without printing anything.\n\ A single numerical argument specifies the frame to select."), - &select_frame_cmd_list, "select-frame ", 1, &cmdlist, + &select_frame_cmd_list, 1, &cmdlist, &cli_suppress_notification.user_selected_context); add_cmd_suppress_notification ("address", class_stack, @@ -3478,25 +3473,27 @@ For backward compatibility, the following qualifiers are supported:\n\ With a negative COUNT, print outermost -COUNT frames."), backtrace_opts); - cmd_list_element *c = add_com ("backtrace", class_stack, - backtrace_command, - backtrace_help.c_str ()); - set_cmd_completer_handle_brkchars (c, backtrace_command_completer); + cmd_list_element *backtrace_cmd + = add_com ("backtrace", class_stack, backtrace_command, + backtrace_help.c_str ()); + set_cmd_completer_handle_brkchars (backtrace_cmd, backtrace_command_completer); - add_com_alias ("bt", "backtrace", class_stack, 0); + add_com_alias ("bt", backtrace_cmd, class_stack, 0); - add_com_alias ("where", "backtrace", class_alias, 0); - add_info ("stack", backtrace_command, - _("Backtrace of the stack, or innermost COUNT frames.")); - add_info_alias ("s", "stack", 1); + add_com_alias ("where", backtrace_cmd, class_stack, 0); + cmd_list_element *info_stack_cmd + = add_info ("stack", backtrace_command, + _("Backtrace of the stack, or innermost COUNT frames.")); + add_info_alias ("s", info_stack_cmd, 1); - add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command, - _("All about the selected stack frame.\n\ + cmd_list_element *info_frame_cmd_el + = add_prefix_cmd ("frame", class_info, &info_frame_cmd.base_command, + _("All about the selected stack frame.\n\ With no arguments, displays information about the currently selected stack\n\ frame. Alternatively a frame specification may be provided (See \"frame\")\n\ the information is then printed about the specified frame."), - &info_frame_cmd_list, "info frame ", 1, &infolist); - add_info_alias ("f", "frame", 1); + &info_frame_cmd_list, 1, &infolist); + add_info_alias ("f", info_frame_cmd_el, 1); add_cmd ("address", class_stack, &info_frame_cmd.address, _("\ @@ -3545,27 +3542,23 @@ Prints the argument variables of the current stack frame.\n"), false)); set_cmd_completer_handle_brkchars (cmd, info_print_command_completer); - if (dbx_commands) - add_com ("func", class_stack, func_command, _("\ -Select the stack frame that contains NAME.\n\ -Usage: func NAME")); - /* Install "set print raw frame-arguments", a deprecated spelling of "set print raw-frame-arguments". */ - cmd = add_setshow_boolean_cmd - ("frame-arguments", no_class, - &user_frame_print_options.print_raw_frame_arguments, - _("\ + set_show_commands set_show_frame_args + = add_setshow_boolean_cmd + ("frame-arguments", no_class, + &user_frame_print_options.print_raw_frame_arguments, + _("\ Set whether to print frame arguments in raw form."), _("\ Show whether to print frame arguments in raw form."), _("\ If set, frame arguments are printed in raw form, bypassing any\n\ pretty-printers for that value."), - NULL, NULL, - &setprintrawlist, &showprintrawlist); - deprecate_cmd (cmd, "set print raw-frame-arguments"); + NULL, NULL, + &setprintrawlist, &showprintrawlist); + deprecate_cmd (set_show_frame_args.set, "set print raw-frame-arguments"); add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, - &disassemble_next_line, _("\ + &disassemble_next_line, _("\ Set whether to disassemble next source line or insn when execution stops."), _("\ Show whether to disassemble next source line or insn when execution stops."), @@ -3579,9 +3572,9 @@ If AUTO, display disassembly of next instruction only if the source line\n\ cannot be displayed.\n\ If OFF (which is the default), never display the disassembly of the next\n\ source line."), - NULL, - show_disassemble_next_line, - &setlist, &showlist); + NULL, + show_disassemble_next_line, + &setlist, &showlist); disassemble_next_line = AUTO_BOOLEAN_FALSE; gdb::option::add_setshow_cmds_for_options