X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=gdb%2Fstack.c;h=7f8a51caa5602417172bc27f39bc40063bb5e2fd;hb=2090129c36c7e582943b7d300968d19b46160d84;hp=7d37dd179fad4ba3f57616d49099c69da2f0ec86;hpb=8d7493201cf01c9836403695f67f7e157341bfd5;p=binutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index 7d37dd179fa..7f8a51caa56 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-2015 Free Software Foundation, Inc. + Copyright (C) 1986-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -48,9 +48,10 @@ #include "cli/cli-utils.h" #include "objfiles.h" -#include +#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. */ @@ -141,7 +142,19 @@ frame_show_address (struct frame_info *frame, return get_frame_pc (frame) != sal.pc; } -/* Show or print a stack frame FRAME briefly. The output is format +/* 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 line number. If the frame's PC is not at the beginning of the @@ -154,7 +167,7 @@ print_stack_frame (struct frame_info *frame, int print_level, { /* 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 @@ -211,43 +224,39 @@ static void print_frame_arg (const struct frame_arg *arg) { struct ui_out *uiout = current_uiout; - struct cleanup *old_chain; - struct ui_file *stb; const char *error_message = NULL; - stb = mem_fileopen (); - old_chain = make_cleanup_ui_file_delete (stb); + string_file stb; 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 (); - - make_cleanup_ui_out_tuple_begin_end (uiout, NULL); - fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym), + annotate_arg_emitter arg_emitter; + ui_out_emit_tuple tuple_emitter (uiout, NULL); + fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym), SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI); 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. */ - fputs_filtered ("=", stb); + stb.puts ("="); - fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym), + fprintf_symbol_filtered (&stb, SYMBOL_PRINT_NAME (arg->sym), SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI); } 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); + stb.puts ("@entry"); + 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) @@ -281,7 +290,7 @@ print_frame_arg (const struct frame_arg *arg) /* True in "summary" mode, false otherwise. */ opts.summary = !strcmp (print_frame_arguments, "scalars"); - common_val_print (arg->val, stb, 2, &opts, language); + common_val_print (arg->val, &stb, 2, &opts, language); } CATCH (except, RETURN_MASK_ERROR) { @@ -290,16 +299,10 @@ print_frame_arg (const struct frame_arg *arg) END_CATCH } if (error_message != NULL) - fprintf_filtered (stb, _(""), - error_message); + stb.printf (_(""), error_message); } - ui_out_field_stream (uiout, "value", stb); - - /* Also invoke ui_out_tuple_end. */ - do_cleanups (old_chain); - - annotate_arg_end (); + uiout->field_stream ("value", stb); } /* Read in inferior function local SYM at FRAME into ARGP. Caller is @@ -310,8 +313,6 @@ void 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; @@ -348,7 +349,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, } CATCH (except, RETURN_MASK_ERROR) { - val_error = alloca (strlen (except.message) + 1); + val_error = (char *) alloca (strlen (except.message) + 1); strcpy (val_error, except.message); } END_CATCH @@ -385,7 +386,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, { /* 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); @@ -399,10 +400,9 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, /* Initialize it just to avoid a GCC false warning. */ struct value *val_deref = NULL, *entryval_deref; - /* DW_AT_GNU_call_site_value does match with the current + /* DW_AT_call_value does match with the current value. If it is a reference still try to verify if - dereferenced DW_AT_GNU_call_site_data_value does not - differ. */ + dereferenced DW_AT_call_data_value does not differ. */ TRY { @@ -475,7 +475,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, } CATCH (except, RETURN_MASK_ERROR) { - val_error = alloca (strlen (except.message) + 1); + val_error = (char *) alloca (strlen (except.message) + 1); strcpy (val_error, except.message); } END_CATCH @@ -507,7 +507,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, || 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; @@ -542,14 +542,9 @@ print_frame_args (struct symbol *func, struct frame_info *frame, long highest_offset = -1; /* Number of ints of arguments that we have printed so far. */ int args_printed = 0; - struct cleanup *old_chain; - struct ui_file *stb; /* True if we should print arguments, false otherwise. */ int print_args = strcmp (print_frame_arguments, "none"); - stb = mem_fileopen (); - old_chain = make_cleanup_ui_file_delete (stb); - if (func) { const struct block *b = SYMBOL_BLOCK_VALUE (func); @@ -669,8 +664,8 @@ print_frame_args (struct symbol *func, struct frame_info *frame, /* Print the current arg. */ if (!first) - ui_out_text (uiout, ", "); - ui_out_wrap_hint (uiout, " "); + uiout->text (", "); + uiout->wrap_hint (" "); if (!print_args) { @@ -691,8 +686,8 @@ print_frame_args (struct symbol *func, struct frame_info *frame, { 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); @@ -719,8 +714,6 @@ print_frame_args (struct symbol *func, struct frame_info *frame, print_frame_nameless_args (frame, start, num - args_printed, first, stream); } - - do_cleanups (old_chain); } /* Set the current source and line to the location given by frame @@ -766,7 +759,7 @@ do_gdb_disassembly (struct gdbarch *gdbarch, TRY { - gdb_disassembly (gdbarch, current_uiout, 0, + gdb_disassembly (gdbarch, current_uiout, DISASSEMBLY_RAW_INSN, how_many, low, high); } @@ -805,8 +798,7 @@ print_frame_info (struct frame_info *frame, int print_level, || get_frame_type (frame) == SIGTRAMP_FRAME || get_frame_type (frame) == ARCH_FRAME) { - struct cleanup *uiout_cleanup - = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); + ui_out_emit_tuple tuple_emitter (uiout, "frame"); annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, gdbarch, get_frame_pc (frame)); @@ -815,14 +807,14 @@ print_frame_info (struct frame_info *frame, int print_level, 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 (); } @@ -830,18 +822,18 @@ print_frame_info (struct frame_info *frame, int print_level, if (get_frame_type (frame) == DUMMY_FRAME) { annotate_function_call (); - ui_out_field_string (uiout, "func", ""); + uiout->field_string ("func", ""); } else if (get_frame_type (frame) == SIGTRAMP_FRAME) { annotate_signal_handler_caller (); - ui_out_field_string (uiout, "func", ""); + uiout->field_string ("func", ""); } else if (get_frame_type (frame) == ARCH_FRAME) { - ui_out_field_string (uiout, "func", ""); + uiout->field_string ("func", ""); } - ui_out_text (uiout, "\n"); + uiout->text ("\n"); annotate_frame_end (); /* If disassemble-next-line is set to auto or on output the next @@ -851,7 +843,6 @@ print_frame_info (struct frame_info *frame, int print_level, do_gdb_disassembly (get_frame_arch (frame), 1, get_frame_pc (frame), get_frame_pc (frame) + 1); - do_cleanups (uiout_cleanup); return; } @@ -910,9 +901,9 @@ print_frame_info (struct frame_info *frame, int print_level, 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); @@ -1103,7 +1094,8 @@ find_frame_funname (struct frame_info *frame, char **funname, } else { - *funname = xstrdup (SYMBOL_PRINT_NAME (func)); + const char *print_name = SYMBOL_PRINT_NAME (func); + *funlang = SYMBOL_LANGUAGE (func); if (funcp) *funcp = func; @@ -1114,14 +1106,17 @@ find_frame_funname (struct frame_info *frame, char **funname, 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 @@ -1150,7 +1145,6 @@ print_frame (struct frame_info *frame, int print_level, struct ui_out *uiout = current_uiout; char *funname = NULL; enum language funlang = language_unknown; - struct ui_file *stb; struct cleanup *old_chain, *list_chain; struct value_print_options opts; struct symbol *func; @@ -1159,11 +1153,9 @@ print_frame (struct frame_info *frame, int print_level, pc_p = get_frame_pc_if_available (frame, &pc); - stb = mem_fileopen (); - old_chain = make_cleanup_ui_file_delete (stb); find_frame_funname (frame, &funname, &funlang, &func); - make_cleanup (xfree, funname); + old_chain = make_cleanup (xfree, funname); annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, gdbarch, pc); @@ -1172,8 +1164,8 @@ print_frame (struct frame_info *frame, int print_level, 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); @@ -1184,25 +1176,26 @@ print_frame (struct frame_info *frame, int print_level, { 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", ""); + uiout->field_string ("addr", ""); annotate_frame_address_end (); - ui_out_text (uiout, " in "); + uiout->text (" in "); } annotate_frame_function_name (); - fprintf_symbol_filtered (stb, funname ? funname : "??", + + string_file stb; + 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); int numargs; - struct cleanup *args_list_chain; if (gdbarch_frame_num_args_p (gdbarch)) { @@ -1212,43 +1205,43 @@ print_frame (struct frame_info *frame, int print_level, else numargs = -1; - args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); - TRY - { - print_frame_args (func, frame, numargs, gdb_stdout); - } - CATCH (e, RETURN_MASK_ERROR) - { - } - END_CATCH + { + ui_out_emit_list list_emitter (uiout, "args"); + TRY + { + print_frame_args (func, frame, numargs, gdb_stdout); + } + CATCH (e, RETURN_MASK_ERROR) + { + } + END_CATCH - /* FIXME: ARGS must be a list. If one argument is a string it - will have " that will not be properly escaped. */ - /* Invoke ui_out_tuple_end. */ - do_cleanups (args_list_chain); + /* FIXME: ARGS must be a list. If one argument is a string it + will have " that will not be properly escaped. */ + } 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 (); } @@ -1260,28 +1253,26 @@ print_frame (struct frame_info *frame, int print_level, 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); } -/* 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]; @@ -1305,7 +1296,7 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, /* Parse the argument, extract it, save it. */ for (p = frame_exp; - *p && !isspace (*p); + *p && !ISSPACE (*p); p++); addr_string = savestring (frame_exp, p - frame_exp); frame_exp = p; @@ -1330,7 +1321,7 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, { 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. */ @@ -1401,12 +1392,6 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, 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. */ @@ -1431,7 +1416,7 @@ frame_info (char *addr_exp, int from_tty) 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" @@ -1517,27 +1502,32 @@ frame_info (char *addr_exp, int from_tty) 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, _(""), 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, _(""), ex.message); + break; + } + } + END_CATCH } - END_CATCH if (caller_pc_p) fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); @@ -1630,57 +1620,52 @@ frame_info (char *addr_exp, int from_tty) /* Print as much information as possible on the location of all the registers. */ { - enum lval_type lval; - int optimized; - int unavailable; - CORE_ADDR addr; - int realnum; int count; int i; int need_nl = 1; + int sp_regnum = gdbarch_sp_regnum (gdbarch); /* The sp is special; what's displayed isn't the save address, but the value of the previous frame's sp. This is a legacy thing, at one stage the frame cached the previous frame's SP instead of its address, hence it was easiest to just display the cached value. */ - if (gdbarch_sp_regnum (gdbarch) >= 0) + if (sp_regnum >= 0) { - /* Find out the location of the saved stack pointer with out - actually evaluating it. */ - frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), - &optimized, &unavailable, &lval, &addr, - &realnum, NULL); - if (!optimized && !unavailable && lval == not_lval) - { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); - int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch)); - gdb_byte value[MAX_REGISTER_SIZE]; - CORE_ADDR sp; - - frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), - &optimized, &unavailable, &lval, &addr, - &realnum, value); - /* NOTE: cagney/2003-05-22: This is assuming that the - stack pointer was packed as an unsigned integer. That - may or may not be valid. */ - sp = extract_unsigned_integer (value, sp_size, byte_order); - printf_filtered (" Previous frame's sp is "); - fputs_filtered (paddress (gdbarch, sp), gdb_stdout); - printf_filtered ("\n"); - need_nl = 0; - } - else if (!optimized && !unavailable && lval == lval_memory) - { - printf_filtered (" Previous frame's sp at "); - fputs_filtered (paddress (gdbarch, addr), gdb_stdout); - printf_filtered ("\n"); - need_nl = 0; - } - else if (!optimized && !unavailable && lval == lval_register) + struct value *value = frame_unwind_register_value (fi, sp_regnum); + gdb_assert (value != NULL); + + if (!value_optimized_out (value) && value_entirely_available (value)) { - printf_filtered (" Previous frame's sp in %s\n", - gdbarch_register_name (gdbarch, realnum)); + if (VALUE_LVAL (value) == not_lval) + { + CORE_ADDR sp; + 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); + + printf_filtered (" Previous frame's sp is "); + fputs_filtered (paddress (gdbarch, sp), gdb_stdout); + printf_filtered ("\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"); + } + else if (VALUE_LVAL (value) == lval_register) + { + printf_filtered (" Previous frame's sp in %s\n", + gdbarch_register_name (gdbarch, + VALUE_REGNUM (value))); + } + + release_value (value); + value_free (value); need_nl = 0; } /* else keep quiet. */ @@ -1690,9 +1675,15 @@ frame_info (char *addr_exp, int from_tty) numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch); for (i = 0; i < numregs; i++) - if (i != gdbarch_sp_regnum (gdbarch) + if (i != sp_regnum && gdbarch_register_reggroup_p (gdbarch, i, all_reggroup)) { + enum lval_type lval; + int optimized; + int unavailable; + CORE_ADDR addr; + int realnum; + /* Find out the location of the saved register without fetching the corresponding value. */ frame_register_unwind (fi, i, &optimized, &unavailable, @@ -1894,7 +1885,7 @@ backtrace_command (char *arg, int from_tty) unsigned int j; for (j = 0; j < strlen (argv[i]); j++) - argv[i][j] = tolower (argv[i][j]); + argv[i][j] = TOLOWER (argv[i][j]); if (no_filters < 0 && subset_compare (argv[i], "no-filters")) no_filters = argc; @@ -1915,7 +1906,7 @@ backtrace_command (char *arg, int from_tty) { if (arglen > 0) { - arg = xmalloc (arglen + 1); + arg = (char *) xmalloc (arglen + 1); make_cleanup (xfree, arg); arg[0] = 0; for (i = 0; i < argc; i++) @@ -2059,7 +2050,8 @@ do_print_variable_and_value (const char *print_name, struct symbol *sym, void *cb_data) { - struct print_variable_and_value_data *p = cb_data; + struct print_variable_and_value_data *p + = (struct print_variable_and_value_data *) cb_data; struct frame_info *frame; frame = frame_find_by_id (p->frame_id); @@ -2089,6 +2081,7 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs, 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)) { @@ -2109,9 +2102,27 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs, 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; @@ -2283,7 +2294,11 @@ find_relative_frame (struct frame_info *frame, int *level_offset_ptr) 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 @@ -2293,8 +2308,13 @@ select_frame_command (char *level_exp, int from_tty) 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 @@ -2325,7 +2345,7 @@ static void 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 @@ -2364,9 +2384,8 @@ static void 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); } - void return_command (char *retval_exp, int from_tty) @@ -2393,13 +2412,12 @@ 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. */ @@ -2414,7 +2432,6 @@ return_command (char *retval_exp, int from_tty) "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); @@ -2491,11 +2508,10 @@ return_command (char *retval_exp, int from_tty) 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 @@ -2517,10 +2533,10 @@ func_command (char *arg, int from_tty) struct function_bounds *func_bounds = NULL; struct cleanup *cleanups; - if (arg != NULL) + 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); @@ -2592,16 +2608,15 @@ This is useful in command scripts.")); Select and print a stack frame.\nWith no argument, \ print the selected stack frame. (See also \"info frame\").\n\ An argument specifies the frame to select.\n\ -It can be a stack frame number or the address of the frame.\n\ -With argument, nothing is printed if input is coming from\n\ -a command file or a user-defined command.")); +It can be a stack frame number or the address of the frame.\n")); 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\