/* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 1986-2013 Free Software Foundation, Inc.
This file is part of GDB.
#include "disasm.h"
#include "inline-frame.h"
#include "linespec.h"
+#include "cli/cli-utils.h"
#include "gdb_assert.h"
#include <ctype.h>
}
}
- 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)))
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)))
{
/* Initialize it just to avoid a GCC false warning. */
struct value *val_deref = NULL, *entryval_deref;
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))
if (val != val_deref
&& value_available_contents_eq (val_deref, 0,
entryval_deref, 0,
- len_deref))
+ TYPE_LENGTH (type_deref)))
val_equal = 1;
}
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 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 = 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)
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, ":");
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));
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;
}
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);
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;
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)
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;
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;
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;
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)
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;
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"));
}
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)
}
}
+/* 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)
{
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;
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"));
}
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.");
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."));
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
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;
+ }
}
}
{
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*/);
}
return;
frame = parse_frame_specification ("0");
- sals = decode_line_spec (arg, DECODE_LINE_FUNFIRSTLINE);
+ 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);
projects / deliverable / binutils-gdb.git / blobdiff