/* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "safe-ctype.h"
#include "symfile.h"
#include "extension.h"
+#include "observer.h"
/* The possible choices of "set print frame-arguments", and the value
of this setting. */
return get_frame_pc (frame) != sal.pc;
}
+/* See frame.h. */
+
+void
+print_stack_frame_to_uiout (struct ui_out *uiout, struct frame_info *frame,
+ int print_level, enum print_what print_what,
+ int set_current_sal)
+{
+ scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
+
+ print_stack_frame (frame, print_level, print_what, set_current_sal);
+}
+
/* Show or print a stack frame FRAME briefly. The output is formatted
according to PRINT_LEVEL and PRINT_WHAT printing the frame's
relative level, function name, argument list, and file name and
{
/* For mi, alway print location and address. */
- if (ui_out_is_mi_like_p (current_uiout))
+ if (current_uiout->is_mi_like_p ())
print_what = LOC_AND_ADDRESS;
TRY
gdb_assert (!arg->val || !arg->error);
gdb_assert (arg->entry_kind == print_entry_values_no
|| arg->entry_kind == print_entry_values_only
- || (!ui_out_is_mi_like_p (uiout)
+ || (!uiout->is_mi_like_p ()
&& arg->entry_kind == print_entry_values_compact));
annotate_arg_begin ();
if (arg->entry_kind == print_entry_values_only
|| arg->entry_kind == print_entry_values_compact)
fputs_filtered ("@entry", stb);
- ui_out_field_stream (uiout, "name", stb);
+ uiout->field_stream ("name", stb);
annotate_arg_name_end ();
- ui_out_text (uiout, "=");
+ uiout->text ("=");
if (!arg->val && !arg->error)
- ui_out_text (uiout, "...");
+ uiout->text ("...");
else
{
if (arg->error)
error_message);
}
- ui_out_field_stream (uiout, "value", stb);
+ uiout->field_stream ("value", stb);
/* Also invoke ui_out_tuple_end. */
do_cleanups (old_chain);
read_frame_local (struct symbol *sym, struct frame_info *frame,
struct frame_arg *argp)
{
- struct value *val = NULL;
-
argp->sym = sym;
argp->val = NULL;
argp->error = NULL;
{
/* For MI do not try to use print_entry_values_compact for ARGP. */
- if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
+ if (val && entryval && !current_uiout->is_mi_like_p ())
{
struct type *type = value_type (val);
|| print_entry_values == print_entry_values_default) && val_equal)
{
argp->entry_kind = print_entry_values_compact;
- gdb_assert (!ui_out_is_mi_like_p (current_uiout));
+ gdb_assert (!current_uiout->is_mi_like_p ());
}
else
argp->entry_kind = print_entry_values_no;
/* Print the current arg. */
if (!first)
- ui_out_text (uiout, ", ");
- ui_out_wrap_hint (uiout, " ");
+ uiout->text (", ");
+ uiout->wrap_hint (" ");
if (!print_args)
{
{
if (arg.entry_kind != print_entry_values_only)
{
- ui_out_text (uiout, ", ");
- ui_out_wrap_hint (uiout, " ");
+ uiout->text (", ");
+ uiout->wrap_hint (" ");
}
print_frame_arg (&entryarg);
to list for this frame. */
if (print_level)
{
- ui_out_text (uiout, "#");
- ui_out_field_fmt_int (uiout, 2, ui_left, "level",
+ uiout->text ("#");
+ uiout->field_fmt_int (2, ui_left, "level",
frame_relative_level (frame));
}
- if (ui_out_is_mi_like_p (uiout))
+ if (uiout->is_mi_like_p ())
{
annotate_frame_address ();
- ui_out_field_core_addr (uiout, "addr",
+ uiout->field_core_addr ("addr",
gdbarch, get_frame_pc (frame));
annotate_frame_address_end ();
}
if (get_frame_type (frame) == DUMMY_FRAME)
{
annotate_function_call ();
- ui_out_field_string (uiout, "func", "<function called from gdb>");
+ uiout->field_string ("func", "<function called from gdb>");
}
else if (get_frame_type (frame) == SIGTRAMP_FRAME)
{
annotate_signal_handler_caller ();
- ui_out_field_string (uiout, "func", "<signal handler called>");
+ uiout->field_string ("func", "<signal handler called>");
}
else if (get_frame_type (frame) == ARCH_FRAME)
{
- ui_out_field_string (uiout, "func", "<cross-architecture call>");
+ uiout->field_string ("func", "<cross-architecture call>");
}
- ui_out_text (uiout, "\n");
+ uiout->text ("\n");
annotate_frame_end ();
/* If disassemble-next-line is set to auto or on output the next
ability to decide for themselves if it is desired. */
if (opts.addressprint && mid_statement)
{
- ui_out_field_core_addr (uiout, "addr",
+ uiout->field_core_addr ("addr",
gdbarch, get_frame_pc (frame));
- ui_out_text (uiout, "\t");
+ uiout->text ("\t");
}
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
}
else
{
- *funname = xstrdup (SYMBOL_PRINT_NAME (func));
+ const char *print_name = SYMBOL_PRINT_NAME (func);
+
*funlang = SYMBOL_LANGUAGE (func);
if (funcp)
*funcp = func;
stored in the symbol table, but we stored a version
with DMGL_PARAMS turned on, and here we don't want to
display parameters. So remove the parameters. */
- char *func_only = cp_remove_params (*funname);
+ char *func_only = cp_remove_params (print_name);
if (func_only)
- {
- xfree (*funname);
- *funname = func_only;
- }
+ *funname = func_only;
}
+
+ /* If we didn't hit the C++ case above, set *funname here.
+ This approach is taken to avoid having to install a
+ cleanup in case cp_remove_params can throw. */
+ if (*funname == NULL)
+ *funname = xstrdup (print_name);
}
}
else
if (print_level)
{
- ui_out_text (uiout, "#");
- ui_out_field_fmt_int (uiout, 2, ui_left, "level",
+ uiout->text ("#");
+ uiout->field_fmt_int (2, ui_left, "level",
frame_relative_level (frame));
}
get_user_print_options (&opts);
{
annotate_frame_address ();
if (pc_p)
- ui_out_field_core_addr (uiout, "addr", gdbarch, pc);
+ uiout->field_core_addr ("addr", gdbarch, pc);
else
- ui_out_field_string (uiout, "addr", "<unavailable>");
+ uiout->field_string ("addr", "<unavailable>");
annotate_frame_address_end ();
- ui_out_text (uiout, " in ");
+ uiout->text (" in ");
}
annotate_frame_function_name ();
fprintf_symbol_filtered (stb, funname ? funname : "??",
funlang, DMGL_ANSI);
- ui_out_field_stream (uiout, "func", stb);
- ui_out_wrap_hint (uiout, " ");
+ uiout->field_stream ("func", stb);
+ uiout->wrap_hint (" ");
annotate_frame_args ();
- ui_out_text (uiout, " (");
+ uiout->text (" (");
if (print_args)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
do_cleanups (args_list_chain);
QUIT;
}
- ui_out_text (uiout, ")");
+ uiout->text (")");
if (sal.symtab)
{
const char *filename_display;
filename_display = symtab_to_filename_for_display (sal.symtab);
annotate_frame_source_begin ();
- ui_out_wrap_hint (uiout, " ");
- ui_out_text (uiout, " at ");
+ uiout->wrap_hint (" ");
+ uiout->text (" at ");
annotate_frame_source_file ();
- ui_out_field_string (uiout, "file", filename_display);
- if (ui_out_is_mi_like_p (uiout))
+ uiout->field_string ("file", filename_display);
+ if (uiout->is_mi_like_p ())
{
const char *fullname = symtab_to_fullname (sal.symtab);
- ui_out_field_string (uiout, "fullname", fullname);
+ uiout->field_string ("fullname", fullname);
}
annotate_frame_source_file_end ();
- ui_out_text (uiout, ":");
+ uiout->text (":");
annotate_frame_source_line ();
- ui_out_field_int (uiout, "line", sal.line);
+ uiout->field_int ("line", sal.line);
annotate_frame_source_end ();
}
if (lib)
{
annotate_frame_where ();
- ui_out_wrap_hint (uiout, " ");
- ui_out_text (uiout, " from ");
- ui_out_field_string (uiout, "from", lib);
+ uiout->wrap_hint (" ");
+ uiout->text (" from ");
+ uiout->field_string ("from", lib);
}
}
/* do_cleanups will call ui_out_tuple_end() for us. */
do_cleanups (list_chain);
- ui_out_text (uiout, "\n");
+ uiout->text ("\n");
do_cleanups (old_chain);
}
\f
-/* Read a frame specification in whatever the appropriate format is
- from FRAME_EXP. Call error(), printing MESSAGE, if the
- specification is in any way invalid (so this function never returns
- NULL). When SEPECTED_P is non-NULL set its target to indicate that
- the default selected frame was used. */
+/* Read a frame specification in whatever the appropriate format is from
+ FRAME_EXP. Call error() if the specification is in any way invalid (so
+ this function never returns NULL). When SELECTED_FRAME_P is non-NULL
+ set its target to indicate that the default selected frame was used. */
static struct frame_info *
-parse_frame_specification_1 (const char *frame_exp, const char *message,
- int *selected_frame_p)
+parse_frame_specification (const char *frame_exp, int *selected_frame_p)
{
int numargs;
struct value *args[4];
{
if (selected_frame_p != NULL)
(*selected_frame_p) = 1;
- return get_selected_frame (message);
+ return get_selected_frame (_("No stack."));
}
/* None of the remaining use the selected frame. */
error (_("Too many args in frame specification"));
}
-static struct frame_info *
-parse_frame_specification (char *frame_exp)
-{
- return parse_frame_specification_1 (frame_exp, NULL, NULL);
-}
-
/* Print verbosely the selected frame or the frame at address
ADDR_EXP. Absolutely all information in the frame is printed. */
CORE_ADDR caller_pc = 0;
int caller_pc_p = 0;
- fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
+ fi = parse_frame_specification (addr_exp, &selected_frame_p);
gdbarch = get_frame_arch (fi);
/* Name of the value returned by get_frame_pc(). Per comments, "pc"
wrap_here (" ");
printf_filtered ("saved %s = ", pc_regname);
- TRY
- {
- caller_pc = frame_unwind_caller_pc (fi);
- caller_pc_p = 1;
- }
- CATCH (ex, RETURN_MASK_ERROR)
+ if (!frame_id_p (frame_unwind_caller_id (fi)))
+ val_print_not_saved (gdb_stdout);
+ else
{
- switch (ex.error)
+ TRY
{
- case NOT_AVAILABLE_ERROR:
- val_print_unavailable (gdb_stdout);
- break;
- case OPTIMIZED_OUT_ERROR:
- val_print_not_saved (gdb_stdout);
- break;
- default:
- fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
- break;
+ caller_pc = frame_unwind_caller_pc (fi);
+ caller_pc_p = 1;
}
+ CATCH (ex, RETURN_MASK_ERROR)
+ {
+ switch (ex.error)
+ {
+ case NOT_AVAILABLE_ERROR:
+ val_print_unavailable (gdb_stdout);
+ break;
+ case OPTIMIZED_OUT_ERROR:
+ val_print_not_saved (gdb_stdout);
+ break;
+ default:
+ fprintf_filtered (gdb_stdout, _("<error: %s>"), ex.message);
+ break;
+ }
+ }
+ END_CATCH
}
- END_CATCH
if (caller_pc_p)
fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout);
struct print_variable_and_value_data cb_data;
const struct block *block;
CORE_ADDR pc;
+ struct gdb_exception except = exception_none;
if (!get_frame_pc_if_available (frame, &pc))
{
cb_data.stream = stream;
cb_data.values_printed = 0;
- iterate_over_block_local_vars (block,
- do_print_variable_and_value,
- &cb_data);
+ /* 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. */
+ select_frame (frame);
+
+ TRY
+ {
+ iterate_over_block_local_vars (block,
+ do_print_variable_and_value,
+ &cb_data);
+ }
+ CATCH (ex, RETURN_MASK_ALL)
+ {
+ except = ex;
+ }
+ END_CATCH
+
+ /* Restore the selected frame, and then rethrow if there was a problem. */
+ select_frame (frame_find_by_id (cb_data.frame_id));
+ if (except.reason < 0)
+ throw_exception (except);
/* do_print_variable_and_value invalidates FRAME. */
frame = NULL;
void
select_frame_command (char *level_exp, int from_tty)
{
- select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
+ struct frame_info *prev_frame = get_selected_frame_if_set ();
+
+ select_frame (parse_frame_specification (level_exp, NULL));
+ if (get_selected_frame_if_set () != prev_frame)
+ observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
}
/* The "frame" command. With no argument, print the selected frame
static void
frame_command (char *level_exp, int from_tty)
{
- select_frame_command (level_exp, from_tty);
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
+ struct frame_info *prev_frame = get_selected_frame_if_set ();
+
+ select_frame (parse_frame_specification (level_exp, NULL));
+ if (get_selected_frame_if_set () != prev_frame)
+ observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
+ else
+ print_selected_thread_frame (current_uiout, USER_SELECTED_FRAME);
}
/* Select the frame up one or COUNT_EXP stack levels from the
up_command (char *count_exp, int from_tty)
{
up_silently_base (count_exp);
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
+ observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
}
/* Select the frame down one or COUNT_EXP stack levels from the previously
down_command (char *count_exp, int from_tty)
{
down_silently_base (count_exp);
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
+ observer_notify_user_selected_context_changed (USER_SELECTED_FRAME);
}
-\f
void
return_command (char *retval_exp, int from_tty)
message. */
if (retval_exp)
{
- struct expression *retval_expr = parse_expression (retval_exp);
- struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
+ expression_up retval_expr = parse_expression (retval_exp);
struct type *return_type = NULL;
/* Compute the return value. Should the computation fail, this
call throws an error. */
- return_value = evaluate_expression (retval_expr);
+ 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. */
"Please use an explicit cast of the value to return."));
return_type = value_type (return_value);
}
- do_cleanups (old_chain);
return_type = check_typedef (return_type);
return_value = value_cast (return_type, return_value);
if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
frame_pop (get_current_frame ());
+ select_frame (get_current_frame ());
/* If interactive, print the frame that is now current. */
if (from_tty)
- frame_command ("0", 1);
- else
- select_frame_command ("0", 0);
+ print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1);
}
/* Sets the scope to input function name, provided that the function
if (arg == NULL)
return;
- frame = parse_frame_specification ("0");
+ frame = get_current_frame ();
sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
cleanups = make_cleanup (xfree, sals.sals);
func_bounds = XNEWVEC (struct function_bounds, sals.nelts);
add_com_alias ("f", "frame", class_stack, 1);
- add_com ("select-frame", class_stack, select_frame_command, _("\
+ add_com_suppress_notification ("select-frame", class_stack, select_frame_command, _("\
Select a stack frame without printing anything.\n\
An argument specifies the frame to select.\n\
-It can be a stack frame number or the address of the frame.\n"));
+It can be a stack frame number or the address of the frame.\n"),
+ &cli_suppress_notification.user_selected_context);
add_com ("backtrace", class_stack, backtrace_command, _("\
Print backtrace of all stack frames, or innermost COUNT frames.\n\
projects / deliverable / binutils-gdb.git / blobdiff