X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fstack.c;h=9ac3123f7610e6a89689618e98dd45496d6ff885;hb=f85f34ede85d0c306e689736c6694caa2f0a0f78;hp=b01dc1c9fa603a2c148681e16337d2451305c2b4;hpb=a471c5941e127823b95893176c7c9301c4b4cb32;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index b01dc1c9fa..9ac3123f76 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-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -47,6 +45,8 @@ #include "cp-support.h" #include "disasm.h" #include "inline-frame.h" +#include "linespec.h" +#include "cli/cli-utils.h" #include "gdb_assert.h" #include @@ -60,7 +60,7 @@ void (*deprecated_selected_frame_level_changed_hook) (int); /* 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"; @@ -74,7 +74,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 +96,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 +109,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, @@ -197,10 +211,10 @@ 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; - 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 @@ -211,21 +225,21 @@ print_frame_arg (const struct frame_arg *arg) 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); + fputs_filtered ("@entry", stb); ui_out_field_stream (uiout, "name", stb); annotate_arg_name_end (); ui_out_text (uiout, "="); @@ -266,17 +280,17 @@ 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->stream, 2, &opts, language); + common_val_print (arg->val, stb, 2, &opts, language); } } if (except.message) - fprintf_filtered (stb->stream, _(""), + fprintf_filtered (stb, _(""), except.message); } ui_out_field_stream (uiout, "value", stb); - /* Aleo invoke ui_out_tuple_end. */ + /* Also invoke ui_out_tuple_end. */ do_cleanups (old_chain); annotate_arg_end (); @@ -309,7 +323,8 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, } } - 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))) @@ -341,16 +356,18 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, if (val && entryval && !ui_out_is_mi_like_p (current_uiout)) { - unsigned len = TYPE_LENGTH (value_type (val)); + struct type *type = value_type (val); if (!value_optimized_out (val) && value_lazy (val)) value_fetch_lazy (val); if (!value_optimized_out (val) && value_lazy (entryval)) value_fetch_lazy (entryval); if (!value_optimized_out (val) - && value_available_contents_eq (val, 0, entryval, 0, len)) + && value_available_contents_eq (val, 0, entryval, 0, + TYPE_LENGTH (type))) { - struct value *val_deref, *entryval_deref; + /* 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 @@ -359,12 +376,12 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, TRY_CATCH (except, RETURN_MASK_ERROR) { - unsigned len_deref; + struct type *type_deref; val_deref = coerce_ref (val); if (value_lazy (val_deref)) value_fetch_lazy (val_deref); - len_deref = TYPE_LENGTH (value_type (val_deref)); + type_deref = value_type (val_deref); entryval_deref = coerce_ref (entryval); if (value_lazy (entryval_deref)) @@ -375,7 +392,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame, if (val != val_deref && value_available_contents_eq (val_deref, 0, entryval_deref, 0, - len_deref)) + TYPE_LENGTH (type_deref))) val_equal = 1; } @@ -485,20 +502,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; + struct block_iterator iter; struct symbol *sym; ALL_BLOCK_SYMBOLS (b, iter, sym) @@ -871,9 +886,9 @@ print_frame_info (struct frame_info *frame, int print_level, 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 (); @@ -881,11 +896,117 @@ 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. */ void -find_frame_funname (struct frame_info *frame, char **funname, +find_frame_funname (struct frame_info *frame, const char **funname, enum language *funlang, struct symbol **funcp) { struct symbol *func; @@ -981,9 +1102,9 @@ print_frame (struct frame_info *frame, int print_level, { struct gdbarch *gdbarch = get_frame_arch (frame); struct ui_out *uiout = current_uiout; - char *funname = NULL; + const 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; @@ -992,8 +1113,8 @@ 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); @@ -1023,7 +1144,7 @@ print_frame (struct frame_info *frame, int print_level, ui_out_text (uiout, " 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, " "); @@ -1057,19 +1178,21 @@ print_frame (struct frame_info *frame, int print_level, QUIT; } ui_out_text (uiout, ")"); - if (sal.symtab && sal.symtab->filename) + 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 "); annotate_frame_source_file (); - ui_out_field_string (uiout, "file", sal.symtab->filename); + ui_out_field_string (uiout, "file", filename_display); if (ui_out_is_mi_like_p (uiout)) { const char *fullname = symtab_to_fullname (sal.symtab); - if (fullname != NULL) - ui_out_field_string (uiout, "fullname", fullname); + ui_out_field_string (uiout, "fullname", fullname); } annotate_frame_source_file_end (); ui_out_text (uiout, ":"); @@ -1078,7 +1201,7 @@ print_frame (struct frame_info *frame, int print_level, 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)); @@ -1128,8 +1251,7 @@ 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; @@ -1249,7 +1371,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; @@ -1339,7 +1461,8 @@ 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); @@ -1607,7 +1730,20 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) 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); + { + struct frame_id frame_id = get_frame_id (fi); + + print_frame_local_vars (fi, 1, gdb_stdout); + + /* 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; @@ -1624,7 +1760,7 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) enum unwind_stop_reason reason; reason = get_frame_unwind_stop_reason (trailing); - if (reason > UNWIND_FIRST_ERROR) + if (reason >= UNWIND_FIRST_ERROR) printf_filtered (_("Backtrace stopped: %s\n"), frame_stop_reason_string (reason)); } @@ -1701,7 +1837,7 @@ iterate_over_block_locals (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) @@ -1714,6 +1850,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; @@ -1738,7 +1876,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; @@ -1799,7 +1937,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; @@ -1813,12 +1951,28 @@ do_print_variable_and_value (const char *print_name, void *cb_data) { struct print_variable_and_value_data *p = 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) @@ -1841,7 +1995,7 @@ 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; @@ -1850,86 +2004,13 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs, 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 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); - - if (block == 0) - { - fprintf_filtered (stream, "No symbol table info available.\n"); - return; - } - - 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) - { - 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++; - - 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; - - /* 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); - } - - if (!values_printed && !this_level_only) - fprintf_filtered (stream, _("No catches.\n")); -#endif -} - void locals_info (char *args, int from_tty) { @@ -1937,14 +2018,6 @@ 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. */ @@ -1954,7 +2027,7 @@ iterate_over_block_arg_vars (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) @@ -1980,6 +2053,11 @@ iterate_over_block_arg_vars (struct block *b, } } +/* 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) { @@ -2000,7 +2078,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; @@ -2008,6 +2086,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")); } @@ -2198,10 +2279,13 @@ down_command (char *count_exp, int from_tty) 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."); @@ -2231,7 +2315,8 @@ 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.")); @@ -2246,6 +2331,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, 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 @@ -2253,15 +2342,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; + } } } @@ -2290,12 +2382,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*/); } @@ -2329,20 +2419,25 @@ func_command (char *arg, int from_tty) int i; int level = 1; struct function_bounds *func_bounds = NULL; + struct cleanup *cleanups; if (arg != NULL) return; frame = parse_frame_specification ("0"); - sals = decode_line_spec (arg, 1); + sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE); + cleanups = make_cleanup (xfree, sals.sals); func_bounds = (struct function_bounds *) xmalloc ( sizeof (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; } @@ -2361,8 +2456,7 @@ 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); @@ -2497,9 +2591,6 @@ Usage: T \n")); 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"),