X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fstack.c;h=1d4397187e690377f8b5a0d3bf6741203da0b301;hb=431e5de3f224e94fb0d061edb3a56d8e3c3f4403;hp=276dd2b25296c119f86a84e4a2ba6bd7c333a67d;hpb=e18b27534c2181c92dc9b685adc05bcf6b685817;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index 276dd2b252..1d4397187e 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -1,8 +1,6 @@ /* Print and select stack frames for GDB, the GNU debugger. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, - 2009, 2010, 2011 Free Software Foundation, Inc. + Copyright (C) 1986-2017 Free Software Foundation, Inc. This file is part of GDB. @@ -38,7 +36,6 @@ #include "block.h" #include "stack.h" #include "dictionary.h" -#include "exceptions.h" #include "reggroups.h" #include "regcache.h" #include "solib.h" @@ -47,23 +44,25 @@ #include "cp-support.h" #include "disasm.h" #include "inline-frame.h" +#include "linespec.h" +#include "cli/cli-utils.h" +#include "objfiles.h" -#include "gdb_assert.h" -#include -#include "gdb_string.h" - -#include "psymtab.h" +#include "safe-ctype.h" #include "symfile.h" - -void (*deprecated_selected_frame_level_changed_hook) (int); +#include "extension.h" +#include "observer.h" /* The possible choices of "set print frame-arguments", and the value of this setting. */ -static const char *print_frame_arguments_choices[] = +static const char *const print_frame_arguments_choices[] = {"all", "scalars", "none", NULL}; static const char *print_frame_arguments = "scalars"; +/* If non-zero, don't invoke pretty-printers for frame arguments. */ +static int print_raw_frame_arguments; + /* The possible choices of "set print entry-values", and the value of this setting. */ @@ -74,7 +73,7 @@ const char print_entry_values_if_needed[] = "if-needed"; const char print_entry_values_both[] = "both"; const char print_entry_values_compact[] = "compact"; const char print_entry_values_default[] = "default"; -static const char *print_entry_values_choices[] = +static const char *const print_entry_values_choices[] = { print_entry_values_no, print_entry_values_only, @@ -96,6 +95,12 @@ static void print_frame (struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal); +static void set_last_displayed_sal (int valid, + struct program_space *pspace, + CORE_ADDR addr, + struct symtab *symtab, + int line); + /* Zero means do things normally; we are interacting directly with the user. One means print the full filename and linenumber when a frame is printed, and do so in a format emacs18/emacs19.22 can @@ -103,6 +108,14 @@ static void print_frame (struct frame_info *frame, int print_level, cases and in a slightly different syntax. */ int annotation_level = 0; + +/* These variables hold the last symtab and line we displayed to the user. + * This is where we insert a breakpoint or a skiplist entry by default. */ +static int last_displayed_sal_valid = 0; +static struct program_space *last_displayed_pspace = 0; +static CORE_ADDR last_displayed_addr = 0; +static struct symtab *last_displayed_symtab = 0; +static int last_displayed_line = 0; /* Return 1 if we should display the address in addition to the location, @@ -129,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 @@ -137,21 +162,25 @@ frame_show_address (struct frame_info *frame, void print_stack_frame (struct frame_info *frame, int print_level, - enum print_what print_what) + enum print_what print_what, + int set_current_sal) { - volatile struct gdb_exception e; /* 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_CATCH (e, RETURN_MASK_ERROR) + TRY + { + print_frame_info (frame, print_level, print_what, 1 /* print_args */, + set_current_sal); + if (set_current_sal) + set_current_sal_from_frame (frame); + } + CATCH (e, RETURN_MASK_ERROR) { - int center = (print_what == SRC_LINE || print_what == SRC_AND_LOC); - - print_frame_info (frame, print_level, print_what, 1 /* print_args */); - set_current_sal_from_frame (frame, center); } + END_CATCH } /* Print nameless arguments of frame FRAME on STREAM, where START is @@ -195,52 +224,50 @@ static void print_frame_arg (const struct frame_arg *arg) { struct ui_out *uiout = current_uiout; - volatile struct gdb_exception except; struct cleanup *old_chain; - struct ui_stream *stb; + struct ui_file *stb; + const char *error_message = NULL; - stb = ui_out_stream_new (uiout); - old_chain = make_cleanup_ui_out_stream_delete (stb); + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (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->stream, 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_compact) { /* It is OK to provide invalid MI-like stream as with PRINT_ENTRY_VALUE_COMPACT we never use MI. */ - fputs_filtered ("=", stb->stream); + fputs_filtered ("=", stb); - fprintf_symbol_filtered (stb->stream, 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->stream); - ui_out_field_stream (uiout, "name", stb); + fputs_filtered ("@entry", 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) - except.message = arg->error; + error_message = arg->error; else { - /* TRY_CATCH has two statements, wrap it in a block. */ - - TRY_CATCH (except, RETURN_MASK_ERROR) + TRY { const struct language_defn *language; struct value_print_options opts; @@ -260,28 +287,57 @@ print_frame_arg (const struct frame_arg *arg) else language = current_language; - get_raw_print_options (&opts); - opts.deref_ref = 0; + get_no_prettyformat_print_options (&opts); + opts.deref_ref = 1; + opts.raw = print_raw_frame_arguments; /* True in "summary" mode, false otherwise. */ opts.summary = !strcmp (print_frame_arguments, "scalars"); - common_val_print (arg->val, stb->stream, 2, &opts, language); + common_val_print (arg->val, stb, 2, &opts, language); + } + CATCH (except, RETURN_MASK_ERROR) + { + error_message = except.message; } + END_CATCH } - if (except.message) - fprintf_filtered (stb->stream, _(""), - except.message); + if (error_message != NULL) + fprintf_filtered (stb, _(""), + error_message); } - ui_out_field_stream (uiout, "value", stb); + uiout->field_stream ("value", stb); - /* Aleo invoke ui_out_tuple_end. */ + /* Also invoke ui_out_tuple_end. */ do_cleanups (old_chain); annotate_arg_end (); } +/* Read in inferior function local SYM at FRAME into ARGP. Caller is + responsible for xfree of ARGP->ERROR. This function never throws an + exception. */ + +void +read_frame_local (struct symbol *sym, struct frame_info *frame, + struct frame_arg *argp) +{ + argp->sym = sym; + argp->val = NULL; + argp->error = NULL; + + TRY + { + argp->val = read_var_value (sym, NULL, frame); + } + CATCH (except, RETURN_MASK_ERROR) + { + argp->error = xstrdup (except.message); + } + END_CATCH +} + /* Read in inferior function parameter SYM at FRAME into ARGP. Caller is responsible for xfree of ARGP->ERROR. This function never throws an exception. */ @@ -293,65 +349,113 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, struct value *val = NULL, *entryval = NULL; char *val_error = NULL, *entryval_error = NULL; int val_equal = 0; - volatile struct gdb_exception except; if (print_entry_values != print_entry_values_only && print_entry_values != print_entry_values_preferred) { - TRY_CATCH (except, RETURN_MASK_ERROR) + TRY { - val = read_var_value (sym, frame); + val = read_var_value (sym, NULL, frame); } - if (!val) + 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 } - if (SYMBOL_CLASS (sym) == LOC_COMPUTED + if (SYMBOL_COMPUTED_OPS (sym) != NULL + && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL && print_entry_values != print_entry_values_no && (print_entry_values != print_entry_values_if_needed || !val || value_optimized_out (val))) { - TRY_CATCH (except, RETURN_MASK_ERROR) + TRY { const struct symbol_computed_ops *ops; ops = SYMBOL_COMPUTED_OPS (sym); entryval = ops->read_variable_at_entry (sym, frame); } - if (!entryval) + CATCH (except, RETURN_MASK_ERROR) { - entryval_error = alloca (strlen (except.message) + 1); - strcpy (entryval_error, except.message); + if (except.error != NO_ENTRY_VALUE_ERROR) + { + entryval_error = (char *) alloca (strlen (except.message) + 1); + strcpy (entryval_error, except.message); + } } + END_CATCH - if (except.error == NO_ENTRY_VALUE_ERROR - || (entryval && value_optimized_out (entryval))) - { - entryval = NULL; - entryval_error = NULL; - } + if (entryval != NULL && value_optimized_out (entryval)) + entryval = NULL; if (print_entry_values == print_entry_values_compact || print_entry_values == print_entry_values_default) { /* 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 ()) { - unsigned len = TYPE_LENGTH (value_type (val)); + struct type *type = value_type (val); - if (!value_optimized_out (val) && value_lazy (val)) + if (value_lazy (val)) value_fetch_lazy (val); - if (!value_optimized_out (val) && value_lazy (entryval)) + if (value_lazy (entryval)) value_fetch_lazy (entryval); - if (!value_optimized_out (val) - && value_available_contents_eq (val, 0, entryval, 0, len)) + + if (value_contents_eq (val, 0, entryval, 0, TYPE_LENGTH (type))) { - entryval = NULL; - val_equal = 1; + /* 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 + value. If it is a reference still try to verify if + dereferenced DW_AT_GNU_call_site_data_value does not + differ. */ + + TRY + { + struct type *type_deref; + + val_deref = coerce_ref (val); + if (value_lazy (val_deref)) + value_fetch_lazy (val_deref); + type_deref = value_type (val_deref); + + entryval_deref = coerce_ref (entryval); + if (value_lazy (entryval_deref)) + value_fetch_lazy (entryval_deref); + + /* If the reference addresses match but dereferenced + content does not match print them. */ + if (val != val_deref + && value_contents_eq (val_deref, 0, + entryval_deref, 0, + TYPE_LENGTH (type_deref))) + val_equal = 1; + } + CATCH (except, RETURN_MASK_ERROR) + { + /* If the dereferenced content could not be + fetched do not display anything. */ + if (except.error == NO_ENTRY_VALUE_ERROR) + val_equal = 1; + else if (except.message != NULL) + { + entryval_error = (char *) alloca (strlen (except.message) + 1); + strcpy (entryval_error, except.message); + } + } + END_CATCH + + /* Value was not a reference; and its content matches. */ + if (val == val_deref) + val_equal = 1; + + if (val_equal) + entryval = NULL; } } @@ -374,21 +478,27 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, { if (print_entry_values == print_entry_values_preferred) { - TRY_CATCH (except, RETURN_MASK_ERROR) + gdb_assert (val == NULL); + + TRY { - val = read_var_value (sym, frame); + val = read_var_value (sym, NULL, frame); } - if (!val) + 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 } if (print_entry_values == print_entry_values_only || print_entry_values == print_entry_values_both || (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 (SYMBOL_TYPE (sym)); + entryval_error = NULL; + } } if ((print_entry_values == print_entry_values_compact || print_entry_values == print_entry_values_if_needed @@ -408,7 +518,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; @@ -443,20 +553,18 @@ 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, *list_chain; - struct ui_stream *stb; + struct cleanup *old_chain; + struct ui_file *stb; /* True if we should print arguments, false otherwise. */ int print_args = strcmp (print_frame_arguments, "none"); - /* True in "summary" mode, false otherwise. */ - int summary = !strcmp (print_frame_arguments, "scalars"); - stb = ui_out_stream_new (uiout); - old_chain = make_cleanup_ui_out_stream_delete (stb); + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (stb); if (func) { - struct block *b = SYMBOL_BLOCK_VALUE (func); - struct dict_iterator iter; + const struct block *b = SYMBOL_BLOCK_VALUE (func); + struct block_iterator iter; struct symbol *sym; ALL_BLOCK_SYMBOLS (b, iter, sym) @@ -524,7 +632,7 @@ print_frame_args (struct symbol *func, struct frame_info *frame, struct symbol *nsym; nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), - b, VAR_DOMAIN, NULL); + b, VAR_DOMAIN, NULL).symbol; gdb_assert (nsym != NULL); if (SYMBOL_CLASS (nsym) == LOC_REGISTER && !SYMBOL_IS_ARGUMENT (nsym)) @@ -572,8 +680,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) { @@ -594,8 +702,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); @@ -631,17 +739,13 @@ print_frame_args (struct symbol *func, struct frame_info *frame, line is in the center of the next 'list'. */ void -set_current_sal_from_frame (struct frame_info *frame, int center) +set_current_sal_from_frame (struct frame_info *frame) { struct symtab_and_line sal; find_frame_sal (frame, &sal); - if (sal.symtab) - { - if (center) - sal.line = max (sal.line - get_lines_to_list () / 2, 1); - set_current_source_symtab_and_line (&sal); - } + if (sal.symtab != NULL) + set_current_source_symtab_and_line (&sal); } /* If ON, GDB will display disassembly of the next source line when @@ -670,20 +774,20 @@ static void do_gdb_disassembly (struct gdbarch *gdbarch, int how_many, CORE_ADDR low, CORE_ADDR high) { - volatile struct gdb_exception exception; - TRY_CATCH (exception, RETURN_MASK_ERROR) + TRY { gdb_disassembly (gdbarch, current_uiout, 0, DISASSEMBLY_RAW_INSN, how_many, low, high); } - if (exception.reason < 0) + CATCH (exception, RETURN_MASK_ERROR) { /* If an exception was thrown while doing the disassembly, print the error message, to give the user a clue of what happened. */ exception_print (gdb_stderr, exception); } + END_CATCH } /* Print information about frame FRAME. The output is format according @@ -699,7 +803,8 @@ do_gdb_disassembly (struct gdbarch *gdbarch, void print_frame_info (struct frame_info *frame, int print_level, - enum print_what print_what, int print_args) + enum print_what print_what, int print_args, + int set_current_sal) { struct gdbarch *gdbarch = get_frame_arch (frame); struct symtab_and_line sal; @@ -721,14 +826,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 (); } @@ -736,20 +841,27 @@ 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 + instruction. */ + if (disassemble_next_line == AUTO_BOOLEAN_AUTO + || disassemble_next_line == AUTO_BOOLEAN_TRUE) + do_gdb_disassembly (get_frame_arch (frame), 1, + get_frame_pc (frame), get_frame_pc (frame) + 1); + do_cleanups (uiout_cleanup); return; } @@ -809,9 +921,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); @@ -824,14 +936,14 @@ print_frame_info (struct frame_info *frame, int print_level, do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end); } - if (print_what != LOCATION) + if (set_current_sal) { CORE_ADDR pc; if (get_frame_pc_if_available (frame, &pc)) - set_default_breakpoint (1, sal.pspace, pc, sal.symtab, sal.line); + set_last_displayed_sal (1, sal.pspace, pc, sal.symtab, sal.line); else - set_default_breakpoint (0, 0, 0, 0, 0); + set_last_displayed_sal (0, 0, 0, 0, 0); } annotate_frame_end (); @@ -839,8 +951,114 @@ print_frame_info (struct frame_info *frame, int print_level, gdb_flush (gdb_stdout); } +/* Remember the last symtab and line we displayed, which we use e.g. + * as the place to put a breakpoint when the `break' command is + * invoked with no arguments. */ + +static void +set_last_displayed_sal (int valid, struct program_space *pspace, + CORE_ADDR addr, struct symtab *symtab, + int line) +{ + last_displayed_sal_valid = valid; + last_displayed_pspace = pspace; + last_displayed_addr = addr; + last_displayed_symtab = symtab; + last_displayed_line = line; + if (valid && pspace == NULL) + { + clear_last_displayed_sal (); + internal_error (__FILE__, __LINE__, + _("Trying to set NULL pspace.")); + } +} + +/* Forget the last sal we displayed. */ + +void +clear_last_displayed_sal (void) +{ + last_displayed_sal_valid = 0; + last_displayed_pspace = 0; + last_displayed_addr = 0; + last_displayed_symtab = 0; + last_displayed_line = 0; +} + +/* Is our record of the last sal we displayed valid? If not, + * the get_last_displayed_* functions will return NULL or 0, as + * appropriate. */ + +int +last_displayed_sal_is_valid (void) +{ + return last_displayed_sal_valid; +} + +/* Get the pspace of the last sal we displayed, if it's valid. */ + +struct program_space * +get_last_displayed_pspace (void) +{ + if (last_displayed_sal_valid) + return last_displayed_pspace; + return 0; +} + +/* Get the address of the last sal we displayed, if it's valid. */ + +CORE_ADDR +get_last_displayed_addr (void) +{ + if (last_displayed_sal_valid) + return last_displayed_addr; + return 0; +} + +/* Get the symtab of the last sal we displayed, if it's valid. */ + +struct symtab* +get_last_displayed_symtab (void) +{ + if (last_displayed_sal_valid) + return last_displayed_symtab; + return 0; +} + +/* Get the line of the last sal we displayed, if it's valid. */ + +int +get_last_displayed_line (void) +{ + if (last_displayed_sal_valid) + return last_displayed_line; + return 0; +} + +/* Get the last sal we displayed, if it's valid. */ + +void +get_last_displayed_sal (struct symtab_and_line *sal) +{ + if (last_displayed_sal_valid) + { + sal->pspace = last_displayed_pspace; + sal->pc = last_displayed_addr; + sal->symtab = last_displayed_symtab; + sal->line = last_displayed_line; + } + else + { + sal->pspace = 0; + sal->pc = 0; + sal->symtab = 0; + sal->line = 0; + } +} + + /* Attempt to obtain the FUNNAME, FUNLANG and optionally FUNCP of the function - corresponding to FRAME. */ + corresponding to FRAME. FUNNAME needs to be freed by the caller. */ void find_frame_funname (struct frame_info *frame, char **funname, @@ -874,27 +1092,30 @@ find_frame_funname (struct frame_info *frame, char **funname, changed (and we'll create a find_pc_minimal_function or some such). */ - struct minimal_symbol *msymbol = NULL; + struct bound_minimal_symbol msymbol; /* Don't attempt to do this for inlined functions, which do not have a corresponding minimal symbol. */ if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func))) msymbol = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); + else + memset (&msymbol, 0, sizeof (msymbol)); - if (msymbol != NULL - && (SYMBOL_VALUE_ADDRESS (msymbol) + if (msymbol.minsym != NULL + && (BMSYMBOL_VALUE_ADDRESS (msymbol) > BLOCK_START (SYMBOL_BLOCK_VALUE (func)))) { /* We also don't know anything about the function besides its address and name. */ func = 0; - *funname = SYMBOL_PRINT_NAME (msymbol); - *funlang = SYMBOL_LANGUAGE (msymbol); + *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)); + *funlang = MSYMBOL_LANGUAGE (msymbol.minsym); } else { - *funname = SYMBOL_PRINT_NAME (func); + const char *print_name = SYMBOL_PRINT_NAME (func); + *funlang = SYMBOL_LANGUAGE (func); if (funcp) *funcp = func; @@ -905,29 +1126,32 @@ 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) - { - *funname = func_only; - make_cleanup (xfree, 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 { - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; CORE_ADDR pc; if (!get_frame_address_in_block_if_available (frame, &pc)) return; msymbol = lookup_minimal_symbol_by_pc (pc); - if (msymbol != NULL) + if (msymbol.minsym != NULL) { - *funname = SYMBOL_PRINT_NAME (msymbol); - *funlang = SYMBOL_LANGUAGE (msymbol); + *funname = xstrdup (MSYMBOL_PRINT_NAME (msymbol.minsym)); + *funlang = MSYMBOL_LANGUAGE (msymbol.minsym); } } } @@ -941,7 +1165,7 @@ 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_stream *stb; + struct ui_file *stb; struct cleanup *old_chain, *list_chain; struct value_print_options opts; struct symbol *func; @@ -950,10 +1174,11 @@ print_frame (struct frame_info *frame, int print_level, pc_p = get_frame_pc_if_available (frame, &pc); - stb = ui_out_stream_new (uiout); - old_chain = make_cleanup_ui_out_stream_delete (stb); + stb = mem_fileopen (); + old_chain = make_cleanup_ui_file_delete (stb); find_frame_funname (frame, &funname, &funlang, &func); + make_cleanup (xfree, funname); annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, gdbarch, pc); @@ -962,8 +1187,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); @@ -974,26 +1199,25 @@ 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->stream, funname ? funname : "??", + 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; - volatile struct gdb_exception e; if (gdbarch_frame_num_args_p (gdbarch)) { @@ -1004,71 +1228,73 @@ print_frame (struct frame_info *frame, int print_level, numargs = -1; args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); - TRY_CATCH (e, RETURN_MASK_ERROR) + 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); QUIT; } - ui_out_text (uiout, ")"); - if (sal.symtab && sal.symtab->filename) + 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", sal.symtab->filename); - 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); - if (fullname != NULL) - 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 (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename))) + if (pc_p && (funname == NULL || sal.symtab == NULL)) { -#ifdef PC_SOLIB - char *lib = PC_SOLIB (get_frame_pc (frame)); -#else char *lib = solib_name_from_address (get_frame_program_space (frame), get_frame_pc (frame)); -#endif + 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]; @@ -1086,14 +1312,13 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, const char *p; /* Skip leading white space, bail of EOL. */ - while (isspace (*frame_exp)) - frame_exp++; + frame_exp = skip_spaces_const (frame_exp); if (!*frame_exp) break; /* 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; @@ -1118,7 +1343,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. */ @@ -1189,12 +1414,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. */ @@ -1207,7 +1426,7 @@ frame_info (char *addr_exp, int from_tty) struct symtab *s; struct frame_info *calling_frame_info; int numregs; - char *funname = 0; + const char *funname = 0; enum language funlang = language_unknown; const char *pc_regname; int selected_frame_p; @@ -1215,9 +1434,11 @@ frame_info (char *addr_exp, int from_tty) struct cleanup *back_to = make_cleanup (null_cleanup, NULL); CORE_ADDR frame_pc; int frame_pc_p; - CORE_ADDR caller_pc; + /* Initialize it to avoid "may be used uninitialized" warning. */ + 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" @@ -1260,13 +1481,13 @@ frame_info (char *addr_exp, int from_tty) } else if (frame_pc_p) { - struct minimal_symbol *msymbol; + struct bound_minimal_symbol msymbol; msymbol = lookup_minimal_symbol_by_pc (frame_pc); - if (msymbol != NULL) + if (msymbol.minsym != NULL) { - funname = SYMBOL_PRINT_NAME (msymbol); - funlang = SYMBOL_LANGUAGE (msymbol); + funname = MSYMBOL_PRINT_NAME (msymbol.minsym); + funlang = MSYMBOL_LANGUAGE (msymbol.minsym); } } calling_frame_info = get_prev_frame (fi); @@ -1297,14 +1518,41 @@ frame_info (char *addr_exp, int from_tty) } wrap_here (" "); if (sal.symtab) - printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line); + printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab), + sal.line); puts_filtered ("; "); wrap_here (" "); - printf_filtered ("saved %s ", pc_regname); - if (frame_unwind_caller_pc_if_available (fi, &caller_pc)) - fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); + printf_filtered ("saved %s = ", pc_regname); + + if (!frame_id_p (frame_unwind_caller_id (fi))) + val_print_not_saved (gdb_stdout); else - fputs_filtered ("", gdb_stdout); + { + TRY + { + 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 + } + + if (caller_pc_p) + fputs_filtered (paddress (gdbarch, caller_pc), gdb_stdout); printf_filtered ("\n"); if (calling_frame_info == NULL) @@ -1314,7 +1562,7 @@ frame_info (char *addr_exp, int from_tty) reason = get_frame_unwind_stop_reason (fi); if (reason != UNWIND_NO_REASON) printf_filtered (_(" Outermost frame: %s\n"), - frame_stop_reason_string (reason)); + frame_stop_reason_string (fi)); } else if (get_frame_type (fi) == TAILCALL_FRAME) puts_filtered (" tail call frame"); @@ -1487,13 +1735,15 @@ frame_info (char *addr_exp, int from_tty) frames. */ static void -backtrace_command_1 (char *count_exp, int show_locals, int from_tty) +backtrace_command_1 (char *count_exp, int show_locals, int no_filters, + int from_tty) { struct frame_info *fi; int count; int i; struct frame_info *trailing; - int trailing_level; + int trailing_level, py_start = 0, py_end = 0; + enum ext_lang_bt_status result = EXT_LANG_BT_ERROR; if (!target_has_stack) error (_("No stack.")); @@ -1512,6 +1762,7 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) { struct frame_info *current; + py_start = count; count = -count; current = trailing; @@ -1533,9 +1784,17 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) count = -1; } + else + { + py_start = 0; + py_end = count; + } } else - count = -1; + { + py_end = -1; + count = -1; + } if (info_verbose) { @@ -1551,40 +1810,79 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) QUIT; pc = get_frame_address_in_block (fi); - find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc)); + expand_symtab_containing_pc (pc, find_pc_mapped_section (pc)); } } - for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi)) + if (! no_filters) { - QUIT; + int flags = PRINT_LEVEL | PRINT_FRAME_INFO | PRINT_ARGS; + enum ext_lang_frame_args arg_type; - /* Don't use print_stack_frame; if an error() occurs it probably - means further attempts to backtrace would fail (on the other - hand, perhaps the code does or could be fixed to make sure - the frame->prev field gets set to NULL in that case). */ - print_frame_info (fi, 1, LOCATION, 1); if (show_locals) - print_frame_local_vars (fi, 1, gdb_stdout); + flags |= PRINT_LOCALS; - /* Save the last frame to check for error conditions. */ - trailing = fi; - } + if (!strcmp (print_frame_arguments, "scalars")) + arg_type = CLI_SCALAR_VALUES; + else if (!strcmp (print_frame_arguments, "all")) + arg_type = CLI_ALL_VALUES; + else + arg_type = NO_VALUES; - /* If we've stopped before the end, mention that. */ - if (fi && from_tty) - printf_filtered (_("(More stack frames follow...)\n")); + result = apply_ext_lang_frame_filter (get_current_frame (), flags, + arg_type, current_uiout, + py_start, py_end); + } - /* If we've run out of frames, and the reason appears to be an error - condition, print it. */ - if (fi == NULL && trailing != NULL) + /* Run the inbuilt backtrace if there are no filters registered, or + "no-filters" has been specified from the command. */ + if (no_filters || result == EXT_LANG_BT_NO_FILTERS) { - enum unwind_stop_reason reason; + for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi)) + { + QUIT; + + /* Don't use print_stack_frame; if an error() occurs it probably + means further attempts to backtrace would fail (on the other + hand, perhaps the code does or could be fixed to make sure + the frame->prev field gets set to NULL in that case). */ + + print_frame_info (fi, 1, LOCATION, 1, 0); + if (show_locals) + { + struct frame_id frame_id = get_frame_id (fi); + + print_frame_local_vars (fi, 1, gdb_stdout); - reason = get_frame_unwind_stop_reason (trailing); - if (reason > UNWIND_FIRST_ERROR) - printf_filtered (_("Backtrace stopped: %s\n"), - frame_stop_reason_string (reason)); + /* print_frame_local_vars invalidates FI. */ + fi = frame_find_by_id (frame_id); + if (fi == NULL) + { + trailing = NULL; + warning (_("Unable to restore previously selected frame.")); + break; + } + } + + /* Save the last frame to check for error conditions. */ + trailing = fi; + } + + /* If we've stopped before the end, mention that. */ + if (fi && from_tty) + printf_filtered (_("(More stack frames follow...)\n")); + + /* If we've run out of frames, and the reason appears to be an error + condition, print it. */ + if (fi == NULL && trailing != NULL) + { + enum unwind_stop_reason reason; + + reason = get_frame_unwind_stop_reason (trailing); + if (reason >= UNWIND_FIRST_ERROR) + printf_filtered (_("Backtrace stopped: %s\n"), + frame_stop_reason_string (trailing)); + } } } @@ -1592,7 +1890,8 @@ static void backtrace_command (char *arg, int from_tty) { struct cleanup *old_chain = make_cleanup (null_cleanup, NULL); - int fulltrace_arg = -1, arglen = 0, argc = 0; + int fulltrace_arg = -1, arglen = 0, argc = 0, no_filters = -1; + int user_arg = 0; if (arg) { @@ -1607,27 +1906,33 @@ 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 (fulltrace_arg < 0 && subset_compare (argv[i], "full")) - fulltrace_arg = argc; + if (no_filters < 0 && subset_compare (argv[i], "no-filters")) + no_filters = argc; else { - arglen += strlen (argv[i]); - argc++; + if (fulltrace_arg < 0 && subset_compare (argv[i], "full")) + fulltrace_arg = argc; + else + { + user_arg++; + arglen += strlen (argv[i]); + } } + argc++; } - arglen += argc; - if (fulltrace_arg >= 0) + arglen += user_arg; + if (fulltrace_arg >= 0 || no_filters >= 0) { if (arglen > 0) { - arg = xmalloc (arglen + 1); + arg = (char *) xmalloc (arglen + 1); make_cleanup (xfree, arg); arg[0] = 0; - for (i = 0; i < (argc + 1); i++) + for (i = 0; i < argc; i++) { - if (i != fulltrace_arg) + if (i != fulltrace_arg && i != no_filters) { strcat (arg, argv[i]); strcat (arg, " "); @@ -1639,27 +1944,21 @@ backtrace_command (char *arg, int from_tty) } } - backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, from_tty); + backtrace_command_1 (arg, fulltrace_arg >= 0 /* show_locals */, + no_filters >= 0 /* no frame-filters */, from_tty); do_cleanups (old_chain); } -static void -backtrace_full_command (char *arg, int from_tty) -{ - backtrace_command_1 (arg, 1 /* show_locals */, from_tty); -} - - /* Iterate over the local variables of a block B, calling CB with CB_DATA. */ static void -iterate_over_block_locals (struct block *b, +iterate_over_block_locals (const struct block *b, iterate_over_block_arg_local_vars_cb cb, void *cb_data) { - struct dict_iterator iter; + struct block_iterator iter; struct symbol *sym; ALL_BLOCK_SYMBOLS (b, iter, sym) @@ -1672,6 +1971,8 @@ iterate_over_block_locals (struct block *b, case LOC_COMPUTED: if (SYMBOL_IS_ARGUMENT (sym)) break; + if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN) + break; (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data); break; @@ -1696,7 +1997,7 @@ static int print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, int *have_default, struct ui_file *stream) { - struct dict_iterator iter; + struct block_iterator iter; struct symbol *sym; int values_printed = 0; @@ -1736,7 +2037,7 @@ print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, superblocks, stopping when the top-level block is reached. */ void -iterate_over_block_local_vars (struct block *block, +iterate_over_block_local_vars (const struct block *block, iterate_over_block_arg_local_vars_cb cb, void *cb_data) { @@ -1757,7 +2058,7 @@ iterate_over_block_local_vars (struct block *block, struct print_variable_and_value_data { - struct frame_info *frame; + struct frame_id frame_id; int num_tabs; struct ui_file *stream; int values_printed; @@ -1770,20 +2071,38 @@ 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); + 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 invalidates FRAME. */ + frame = NULL; - print_variable_and_value (print_name, sym, - p->frame, p->stream, p->num_tabs); p->values_printed = 1; } +/* Print all variables from the innermost up to the function block of FRAME. + Print them with values to STREAM indented by NUM_TABS. + + This function will invalidate FRAME. */ + static void print_frame_local_vars (struct frame_info *frame, int num_tabs, struct ui_file *stream) { struct print_variable_and_value_data cb_data; - struct block *block; + const struct block *block; CORE_ADDR pc; + struct gdb_exception except = exception_none; if (!get_frame_pc_if_available (frame, &pc)) { @@ -1799,93 +2118,38 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs, return; } - cb_data.frame = frame; + cb_data.frame_id = get_frame_id (frame); cb_data.num_tabs = 4 * num_tabs; cb_data.stream = stream; cb_data.values_printed = 0; - iterate_over_block_local_vars (block, - do_print_variable_and_value, - &cb_data); - - if (!cb_data.values_printed) - fprintf_filtered (stream, _("No locals.\n")); -} - -/* Same, but print labels. */ - -static void -print_frame_label_vars (struct frame_info *frame, int this_level_only, - struct ui_file *stream) -{ -#if 1 - fprintf_filtered (stream, "print_frame_label_vars disabled.\n"); -#else - struct blockvector *bl; - struct block *block = get_frame_block (frame, 0); - struct gdbarch *gdbarch = get_frame_arch (frame); - int values_printed = 0; - int index, have_default = 0; - char *blocks_printed; - CORE_ADDR pc = get_frame_pc (frame); + /* 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); - if (block == 0) + TRY { - fprintf_filtered (stream, "No symbol table info available.\n"); - return; + iterate_over_block_local_vars (block, + do_print_variable_and_value, + &cb_data); } - - bl = blockvector_for_pc (BLOCK_END (block) - 4, &index); - blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); - memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char)); - - while (block != 0) + CATCH (ex, RETURN_MASK_ALL) { - CORE_ADDR end = BLOCK_END (block) - 4; - int last_index; - - if (bl != blockvector_for_pc (end, &index)) - error (_("blockvector blotch")); - if (BLOCKVECTOR_BLOCK (bl, index) != block) - error (_("blockvector botch")); - last_index = BLOCKVECTOR_NBLOCKS (bl); - index += 1; - - /* Don't print out blocks that have gone by. */ - while (index < last_index - && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc) - index++; + except = ex; + } + END_CATCH - while (index < last_index - && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end) - { - if (blocks_printed[index] == 0) - { - if (print_block_frame_labels (gdbarch, - BLOCKVECTOR_BLOCK (bl, index), - &have_default, stream)) - values_printed = 1; - blocks_printed[index] = 1; - } - index++; - } - if (have_default) - return; - if (values_printed && this_level_only) - return; + /* 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); - /* After handling the function's top-level block, stop. Don't - continue to its superblock, the block of per-file symbols. - Also do not continue to the containing function of an inlined - function. */ - if (BLOCK_FUNCTION (block)) - break; - block = BLOCK_SUPERBLOCK (block); - } + /* do_print_variable_and_value invalidates FRAME. */ + frame = NULL; - if (!values_printed && !this_level_only) - fprintf_filtered (stream, _("No catches.\n")); -#endif + if (!cb_data.values_printed) + fprintf_filtered (stream, _("No locals.\n")); } void @@ -1895,24 +2159,16 @@ locals_info (char *args, int from_tty) 0, gdb_stdout); } -static void -catch_info (char *ignore, int from_tty) -{ - /* Assume g++ compiled code; old GDB 4.16 behaviour. */ - print_frame_label_vars (get_selected_frame (_("No frame selected.")), - 0, gdb_stdout); -} - /* Iterate over all the argument variables in block B. Returns 1 if any argument was walked; 0 otherwise. */ void -iterate_over_block_arg_vars (struct block *b, +iterate_over_block_arg_vars (const struct block *b, iterate_over_block_arg_local_vars_cb cb, void *cb_data) { - struct dict_iterator iter; + struct block_iterator iter; struct symbol *sym, *sym2; ALL_BLOCK_SYMBOLS (b, iter, sym) @@ -1932,12 +2188,17 @@ iterate_over_block_arg_vars (struct block *b, are not combined in symbol-reading. */ sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), - b, VAR_DOMAIN, NULL); + b, VAR_DOMAIN, NULL).symbol; (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data); } } } +/* Print all argument variables of the function of FRAME. + Print them with values to STREAM. + + This function will invalidate FRAME. */ + static void print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) { @@ -1958,7 +2219,7 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) return; } - cb_data.frame = frame; + cb_data.frame_id = get_frame_id (frame); cb_data.num_tabs = 0; cb_data.stream = gdb_stdout; cb_data.values_printed = 0; @@ -1966,6 +2227,9 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), do_print_variable_and_value, &cb_data); + /* do_print_variable_and_value invalidates FRAME. */ + frame = NULL; + if (!cb_data.values_printed) fprintf_filtered (stream, _("No arguments.\n")); } @@ -1977,15 +2241,6 @@ args_info (char *ignore, int from_tty) gdb_stdout); } - -static void -args_plus_locals_info (char *ignore, int from_tty) -{ - args_info (ignore, from_tty); - locals_info (ignore, from_tty); -} - - /* Select frame FRAME. Also print the stack frame and show the source if this is the tui version. */ static void @@ -1993,7 +2248,7 @@ select_and_print_frame (struct frame_info *frame) { select_frame (frame); if (frame) - print_stack_frame (frame, 1, SRC_AND_LOC); + print_stack_frame (frame, 1, SRC_AND_LOC, 1); } /* Return the symbol-block in which the selected frame is executing. @@ -2003,7 +2258,7 @@ select_and_print_frame (struct frame_info *frame) code address within the block returned. We use this to decide which macros are in scope. */ -struct block * +const struct block * get_selected_block (CORE_ADDR *addr_in_block) { if (!has_stack_frames ()) @@ -2060,7 +2315,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 @@ -2070,23 +2329,20 @@ 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); -} + struct frame_info *prev_frame = get_selected_frame_if_set (); -/* The XDB Compatibility command to print the current frame. */ - -static void -current_frame_command (char *level_exp, int from_tty) -{ - print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC); + 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 previously selected frame, and print it briefly. */ static void -up_silently_base (char *count_exp) +up_silently_base (const char *count_exp) { struct frame_info *frame; int count = 1; @@ -2110,14 +2366,14 @@ 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); + observer_notify_user_selected_context_changed (USER_SELECTED_FRAME); } /* Select the frame down one or COUNT_EXP stack levels from the previously selected frame, and print it briefly. */ static void -down_silently_base (char *count_exp) +down_silently_base (const char *count_exp) { struct frame_info *frame; int count = -1; @@ -2149,17 +2405,19 @@ 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); + observer_notify_user_selected_context_changed (USER_SELECTED_FRAME); } - void return_command (char *retval_exp, int from_tty) { + /* Initialize it just to avoid a GCC false warning. */ + enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION; struct frame_info *thisframe; struct gdbarch *gdbarch; struct symbol *thisfun; struct value *return_value = NULL; + struct value *function = NULL; const char *query_prefix = ""; thisframe = get_selected_frame ("No selected frame."); @@ -2175,13 +2433,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. */ @@ -2189,14 +2446,14 @@ return_command (char *retval_exp, int from_tty) return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); if (return_type == NULL) { - if (retval_expr->elts[0].opcode != UNOP_CAST) + if (retval_expr->elts[0].opcode != UNOP_CAST + && retval_expr->elts[0].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_type = value_type (return_value); } - do_cleanups (old_chain); - CHECK_TYPEDEF (return_type); + return_type = check_typedef (return_type); return_value = value_cast (return_type, return_value); /* Make sure the value is fully evaluated. It may live in the @@ -2204,6 +2461,10 @@ return_command (char *retval_exp, int from_tty) if (value_lazy (return_value)) value_fetch_lazy (return_value); + if (thisfun != NULL) + function = read_var_value (thisfun, NULL, thisframe); + + rv_conv = RETURN_VALUE_REGISTER_CONVENTION; if (TYPE_CODE (return_type) == TYPE_CODE_VOID) /* If the return-type is "void", don't try to find the return-value's location. However, do still evaluate the @@ -2211,15 +2472,18 @@ return_command (char *retval_exp, int from_tty) is discarded, side effects such as "return i++" still occur. */ return_value = NULL; - else if (thisfun != NULL - && using_struct_return (gdbarch, - SYMBOL_TYPE (thisfun), return_type)) + else if (thisfun != NULL) { - query_prefix = "The location at which to store the " - "function's return value is unknown.\n" - "If you continue, the return value " - "that you specified will be ignored.\n"; - return_value = NULL; + rv_conv = struct_return_convention (gdbarch, function, return_type); + if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION + || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS) + { + query_prefix = "The location at which to store the " + "function's return value is unknown.\n" + "If you continue, the return value " + "that you specified will be ignored.\n"; + return_value = NULL; + } } } @@ -2234,8 +2498,12 @@ return_command (char *retval_exp, int from_tty) confirmed = query (_("%sMake selected stack frame return now? "), query_prefix); else - confirmed = query (_("%sMake %s return now? "), query_prefix, - SYMBOL_PRINT_NAME (thisfun)); + { + if (TYPE_NO_RETURN (thisfun->type)) + warning (_("Function does not return normally to caller.")); + confirmed = query (_("%sMake %s return now? "), query_prefix, + SYMBOL_PRINT_NAME (thisfun)); + } if (!confirmed) error (_("Not confirmed")); } @@ -2248,12 +2516,10 @@ return_command (char *retval_exp, int from_tty) { struct type *return_type = value_type (return_value); struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ()); - struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun); - gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL, - NULL, NULL) - == RETURN_VALUE_REGISTER_CONVENTION); - gdbarch_return_value (gdbarch, func_type, return_type, + gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION + && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS); + gdbarch_return_value (gdbarch, function, return_type, get_current_regcache (), NULL /*read*/, value_contents (return_value) /*write*/); } @@ -2263,11 +2529,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 @@ -2287,20 +2552,24 @@ func_command (char *arg, int from_tty) int i; int level = 1; struct function_bounds *func_bounds = NULL; + struct cleanup *cleanups; - if (arg != NULL) + if (arg == NULL) return; - frame = parse_frame_specification ("0"); - sals = decode_line_spec (arg, 1); - func_bounds = (struct function_bounds *) xmalloc ( - sizeof (struct function_bounds) * sals.nelts); + 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); + make_cleanup (xfree, func_bounds); for (i = 0; (i < sals.nelts && !found); i++) { - if (sals.sals[i].pc == 0 - || find_pc_partial_function (sals.sals[i].pc, NULL, - &func_bounds[i].low, - &func_bounds[i].high) == 0) + if (sals.sals[i].pspace != current_program_space) + func_bounds[i].low = func_bounds[i].high = 0; + else if (sals.sals[i].pc == 0 + || find_pc_partial_function (sals.sals[i].pc, NULL, + &func_bounds[i].low, + &func_bounds[i].high) == 0) { func_bounds[i].low = func_bounds[i].high = 0; } @@ -2319,56 +2588,13 @@ func_command (char *arg, int from_tty) } while (!found && level == 0); - if (func_bounds) - xfree (func_bounds); + do_cleanups (cleanups); if (!found) printf_filtered (_("'%s' not within current stack frame.\n"), arg); else if (frame != get_selected_frame (NULL)) select_and_print_frame (frame); } - -/* Gets the language of the current frame. */ - -enum language -get_frame_language (void) -{ - struct frame_info *frame = deprecated_safe_get_selected_frame (); - - if (frame) - { - volatile struct gdb_exception ex; - CORE_ADDR pc = 0; - struct symtab *s; - - /* We determine the current frame language by looking up its - associated symtab. To retrieve this symtab, we use the frame - PC. However we cannot use the frame PC as is, because it - usually points to the instruction following the "call", which - is sometimes the first instruction of another function. So - we rely on get_frame_address_in_block(), it provides us with - a PC that is guaranteed to be inside the frame's code - block. */ - - TRY_CATCH (ex, RETURN_MASK_ERROR) - { - pc = get_frame_address_in_block (frame); - } - if (ex.reason < 0) - { - if (ex.error != NOT_AVAILABLE_ERROR) - throw_exception (ex); - } - else - { - s = find_pc_symtab (pc); - if (s != NULL) - return s->language; - } - } - - return language_unknown; -} /* Provide a prototype to silence -Wmissing-prototypes. */ @@ -2409,31 +2635,19 @@ a command file or a user-defined command.")); add_com_alias ("f", "frame", class_stack, 1); - if (xdb_commands) - { - add_com ("L", class_stack, current_frame_command, - _("Print the current stack frame.\n")); - add_com_alias ("V", "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\ With a negative argument, print outermost -COUNT frames.\nUse of the \ -'full' qualifier also prints the values of the local variables.\n")); +'full' qualifier also prints the values of the local variables.\n\ +Use of the 'no-filters' qualifier prohibits frame filters from executing\n\ +on this backtrace.\n")); add_com_alias ("bt", "backtrace", class_stack, 0); - if (xdb_commands) - { - add_com_alias ("t", "backtrace", class_stack, 0); - add_com ("T", class_stack, backtrace_full_command, _("\ -Print backtrace of all stack frames, or innermost COUNT frames\n\ -and the values of the local variables.\n\ -With a negative argument, print outermost -COUNT frames.\n\ -Usage: T \n")); - } add_com_alias ("where", "backtrace", class_alias, 0); add_info ("stack", backtrace_command, @@ -2446,24 +2660,27 @@ Usage: T \n")); _("Local variables of current stack frame.")); add_info ("args", args_info, _("Argument variables of current stack frame.")); - if (xdb_commands) - add_com ("l", class_info, args_plus_locals_info, - _("Argument and local variables of current stack frame.")); if (dbx_commands) add_com ("func", class_stack, func_command, _("\ Select the stack frame that contains .\n\ Usage: func \n")); - add_info ("catch", catch_info, - _("Exceptions that can be caught in the current stack frame.")); - add_setshow_enum_cmd ("frame-arguments", class_stack, print_frame_arguments_choices, &print_frame_arguments, _("Set printing of non-scalar frame arguments"), _("Show printing of non-scalar frame arguments"), NULL, NULL, NULL, &setprintlist, &showprintlist); + add_setshow_boolean_cmd ("frame-arguments", no_class, + &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); + add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, &disassemble_next_line, _("\ Set whether to disassemble next source line or insn when execution stops."),