/* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
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;
struct symbol *sym;
ALL_BLOCK_SYMBOLS (b, iter, sym)
- {
+ {
struct frame_arg arg, entryarg;
QUIT;
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.
fprintf_filtered (file,
_("Debugger's willingness to use "
"disassemble-next-line is %s.\n"),
- value);
+ value);
}
/* Use TRY_CATCH to catch the exception from the gdb_disassembly
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. */
{
*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
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", "<function called from gdb>",
+ {
+ annotate_function_call ();
+ uiout->field_string ("func", "<function called from gdb>",
metadata_style.style ());
}
else if (get_frame_type (frame) == SIGTRAMP_FRAME)
- {
+ {
annotate_signal_handler_caller ();
- uiout->field_string ("func", "<signal handler called>",
+ uiout->field_string ("func", "<signal handler called>",
metadata_style.style ());
- }
+ }
else if (get_frame_type (frame) == ARCH_FRAME)
- {
- uiout->field_string ("func", "<cross-architecture call>",
+ {
+ uiout->field_string ("func", "<cross-architecture call>",
metadata_style.style ());
}
uiout->text ("\n");
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
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);
}
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);
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);
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)
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."));
}
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));
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."));
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);
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)
{
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.
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;
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,
int count;
struct frame_info *trailing;
- if (!target_has_stack)
+ if (!target_has_stack ())
error (_("No stack."));
if (cmd == NULL)
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\
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);
&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,
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_stack, 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,
_("\
/* 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."),
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
projects / deliverable / binutils-gdb.git / blobdiff