/* 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
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008
Free Software Foundation, Inc.
This file is part of GDB.
#include "regcache.h"
#include "solib.h"
#include "valprint.h"
+#include "gdbthread.h"
+#include "cp-support.h"
#include "gdb_assert.h"
#include <ctype.h>
args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
args.print_args = 1;
- catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL);
+ catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
}
struct print_args_args
/* Keep track of the highest stack argument offset seen, and
skip over any kinds of symbols we don't care about. */
+ if (!SYMBOL_IS_ARGUMENT (sym))
+ continue;
+
switch (SYMBOL_CLASS (sym))
{
case LOC_ARG:
/* We care about types of symbols, but don't need to
keep track of stack offsets in them. */
- case LOC_REGPARM:
+ case LOC_REGISTER:
case LOC_REGPARM_ADDR:
- case LOC_LOCAL_ARG:
- case LOC_BASEREG_ARG:
- case LOC_COMPUTED_ARG:
- break;
-
- /* Other types of symbols we just skip over. */
+ case LOC_COMPUTED:
+ case LOC_OPTIMIZED_OUT:
default:
- continue;
+ break;
}
/* We have to look up the symbol because arguments can have
parameter names occur on the RS/6000, for traceback
tables. FIXME, should we even print them? */
- if (*DEPRECATED_SYMBOL_NAME (sym))
+ if (*SYMBOL_LINKAGE_NAME (sym))
{
struct symbol *nsym;
- nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
- b, VAR_DOMAIN, NULL, NULL);
+ nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
+ b, VAR_DOMAIN, NULL);
gdb_assert (nsym != NULL);
- if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
+ if (SYMBOL_CLASS (nsym) == LOC_REGISTER
+ && !SYMBOL_IS_ARGUMENT (nsym))
{
/* There is a LOC_ARG/LOC_REGISTER pair. This means
that it was passed on the stack and loaded into a
if (val)
{
+ const struct language_defn *language;
+
+ /* Use the appropriate language to display our symbol,
+ unless the user forced the language to a specific
+ language. */
+ if (language_mode == language_mode_auto)
+ language = language_def (SYMBOL_LANGUAGE (sym));
+ else
+ language = current_language;
+
common_val_print (val, stb->stream, 0, 0, 2,
- Val_no_prettyprint);
+ Val_no_prettyprint, language);
ui_out_field_stream (uiout, "value", stb);
}
else
/* We also don't know anything about the function besides
its address and name. */
func = 0;
- funname = DEPRECATED_SYMBOL_NAME (msymbol);
+ funname = SYMBOL_PRINT_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
}
else
{
- funname = DEPRECATED_SYMBOL_NAME (func);
+ funname = SYMBOL_PRINT_NAME (func);
funlang = SYMBOL_LANGUAGE (func);
if (funlang == language_cplus)
{
to display the demangled name that we already have
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 call the demangler again, with
- DMGL_ANSI only.
-
- Yes, printf_symbol_filtered() will again try to
- demangle the name on the fly, but the issue is that
- if cplus_demangle() fails here, it will fail there
- too. So we want to catch the failure (where DEMANGLED
- is NULL below) here, while we still have our hands on
- the function symbol.) */
- char *demangled = cplus_demangle (funname, DMGL_ANSI);
- if (demangled == NULL)
- /* If the demangler fails, try the demangled name from
- the symbol table. That'll have parameters, but
- that's preferable to displaying a mangled name. */
- funname = SYMBOL_PRINT_NAME (func);
- else
- xfree (demangled);
+ display parameters. So remove the parameters. */
+ char *func_only = cp_remove_params (funname);
+ if (func_only)
+ {
+ funname = func_only;
+ make_cleanup (xfree, func_only);
+ }
}
}
}
if (msymbol != NULL)
{
- funname = DEPRECATED_SYMBOL_NAME (msymbol);
+ funname = SYMBOL_PRINT_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
}
}
args.func = func;
args.stream = gdb_stdout;
args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
- catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL);
+ catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
/* 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 (old_chain);
}
\f
-/* Show the frame info. If this is the tui, it will be shown in the
- source display otherwise, nothing is done. */
-
-void
-show_stack_frame (struct frame_info *frame)
-{
-}
-\f
/* Read a frame specification in whatever the appropriate format is
from FRAME_EXP. Call error(), printing MESSAGE, if the
const char *pc_regname;
int selected_frame_p;
struct gdbarch *gdbarch;
+ struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
gdbarch = get_frame_arch (fi);
s = find_pc_symtab (get_frame_pc (fi));
if (func)
{
- /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to
- display the demangled name that we already have 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 call the
- demangler again, with DMGL_ANSI only.
-
- Yes, printf_symbol_filtered() will again try to demangle the
- name on the fly, but the issue is that if cplus_demangle()
- fails here, it will fail there too. So we want to catch the
- failure (where DEMANGLED is NULL below) here, while we still
- have our hands on the function symbol.) */
- funname = DEPRECATED_SYMBOL_NAME (func);
+ funname = SYMBOL_PRINT_NAME (func);
funlang = SYMBOL_LANGUAGE (func);
if (funlang == language_cplus)
{
- char *demangled = cplus_demangle (funname, DMGL_ANSI);
- /* If the demangler fails, try the demangled name from the
- symbol table. That'll have parameters, but that's
- preferable to displaying a mangled name. */
- if (demangled == NULL)
- funname = SYMBOL_PRINT_NAME (func);
- else
- xfree (demangled);
+ /* It seems appropriate to use SYMBOL_PRINT_NAME() here,
+ to display the demangled name that we already have
+ 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);
+ if (func_only)
+ {
+ funname = func_only;
+ make_cleanup (xfree, func_only);
+ }
}
}
else
msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
if (msymbol != NULL)
{
- funname = DEPRECATED_SYMBOL_NAME (msymbol);
+ funname = SYMBOL_PRINT_NAME (msymbol);
funlang = SYMBOL_LANGUAGE (msymbol);
}
}
{
printf_filtered (_("Stack frame at "));
}
- deprecated_print_address_numeric (get_frame_base (fi), 1, gdb_stdout);
+ fputs_filtered (paddress (get_frame_base (fi)), gdb_stdout);
printf_filtered (":\n");
printf_filtered (" %s = ", pc_regname);
- deprecated_print_address_numeric (get_frame_pc (fi), 1, gdb_stdout);
+ fputs_filtered (paddress (get_frame_pc (fi)), gdb_stdout);
wrap_here (" ");
if (funname)
puts_filtered ("; ");
wrap_here (" ");
printf_filtered ("saved %s ", pc_regname);
- deprecated_print_address_numeric (frame_pc_unwind (fi), 1, gdb_stdout);
+ fputs_filtered (paddress (frame_pc_unwind (fi)), gdb_stdout);
printf_filtered ("\n");
if (calling_frame_info == NULL)
if (calling_frame_info)
{
printf_filtered (" called by frame at ");
- deprecated_print_address_numeric (get_frame_base (calling_frame_info),
- 1, gdb_stdout);
+ fputs_filtered (paddress (get_frame_base (calling_frame_info)),
+ gdb_stdout);
}
if (get_next_frame (fi) && calling_frame_info)
puts_filtered (",");
if (get_next_frame (fi))
{
printf_filtered (" caller of frame at ");
- deprecated_print_address_numeric (get_frame_base (get_next_frame (fi)), 1,
- gdb_stdout);
+ fputs_filtered (paddress (get_frame_base (get_next_frame (fi))),
+ gdb_stdout);
}
if (get_next_frame (fi) || calling_frame_info)
puts_filtered ("\n");
else
{
printf_filtered (" Arglist at ");
- deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
+ fputs_filtered (paddress (arg_list), gdb_stdout);
printf_filtered (",");
if (!gdbarch_frame_num_args_p (gdbarch))
else
{
printf_filtered (" Locals at ");
- deprecated_print_address_numeric (arg_list, 1, gdb_stdout);
+ fputs_filtered (paddress (arg_list), gdb_stdout);
printf_filtered (",");
}
}
register_size (gdbarch,
gdbarch_sp_regnum (gdbarch)));
printf_filtered (" Previous frame's sp is ");
- deprecated_print_address_numeric (sp, 1, gdb_stdout);
+ fputs_filtered (paddress (sp), gdb_stdout);
printf_filtered ("\n");
need_nl = 0;
}
else if (!optimized && lval == lval_memory)
{
printf_filtered (" Previous frame's sp at ");
- deprecated_print_address_numeric (addr, 1, gdb_stdout);
+ fputs_filtered (paddress (addr), gdb_stdout);
printf_filtered ("\n");
need_nl = 0;
}
wrap_here (" ");
printf_filtered (" %s at ",
gdbarch_register_name (gdbarch, i));
- deprecated_print_address_numeric (addr, 1, gdb_stdout);
+ fputs_filtered (paddress (addr), gdb_stdout);
count++;
}
}
if (count || need_nl)
puts_filtered ("\n");
}
+
+ do_cleanups (back_to);
}
/* Print briefly all stack frames or just the innermost COUNT_EXP
case LOC_LOCAL:
case LOC_REGISTER:
case LOC_STATIC:
- case LOC_BASEREG:
case LOC_COMPUTED:
+ if (SYMBOL_IS_ARGUMENT (sym))
+ break;
values_printed = 1;
for (j = 0; j < num_tabs; j++)
fputs_filtered ("\t", stream);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0)
+ if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
{
if (*have_default)
continue;
if (addressprint)
{
fprintf_filtered (stream, " ");
- deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream);
+ fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream);
}
fprintf_filtered (stream, " in file %s, line %d\n",
sal.symtab->filename, sal.line);
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);
int values_printed = 0;
if (!values_printed && !this_level_only)
fprintf_filtered (stream, _("No catches.\n"));
+#endif
}
void
{
struct symtab_and_line *sal;
- /* Check for target support for exception handling */
- sal = target_enable_exception_callback (EX_EVENT_CATCH, 1);
- if (sal)
- {
- /* Currently not handling this. Ideally, here we should
- interact with the C++ runtime system to find the list of
- active handlers, etc. */
- fprintf_filtered (gdb_stdout, _("\
-Info catch not supported with this target/compiler combination.\n"));
- }
- else
- {
- /* Assume g++ compiled code; old GDB 4.16 behaviour. */
- print_frame_label_vars (get_selected_frame (_("No frame selected.")),
- 0, gdb_stdout);
- }
+ /* Assume g++ compiled code; old GDB 4.16 behaviour. */
+ print_frame_label_vars (get_selected_frame (_("No frame selected.")),
+ 0, gdb_stdout);
}
static void
b = SYMBOL_BLOCK_VALUE (func);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
- switch (SYMBOL_CLASS (sym))
+ /* Don't worry about things which aren't arguments. */
+ if (SYMBOL_IS_ARGUMENT (sym))
{
- case LOC_ARG:
- case LOC_LOCAL_ARG:
- case LOC_REF_ARG:
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
- case LOC_BASEREG_ARG:
- case LOC_COMPUTED_ARG:
values_printed = 1;
fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
fputs_filtered (" = ", stream);
float). There are also LOC_ARG/LOC_REGISTER pairs which
are not combined in symbol-reading. */
- sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),
- b, VAR_DOMAIN, NULL, NULL);
+ sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
+ b, VAR_DOMAIN, NULL);
print_variable_value (sym2, frame, stream);
fprintf_filtered (stream, "\n");
- break;
-
- default:
- /* Don't worry about things which aren't arguments. */
- break;
}
}
if (!target_has_stack)
return 0;
+ if (is_exited (inferior_ptid))
+ return 0;
+
+ if (is_executing (inferior_ptid))
+ return 0;
+
return get_frame_block (get_selected_frame (NULL), addr_in_block);
}
is discarded, side effects such as "return i++" still
occur. */
return_value = NULL;
- else if (using_struct_return (return_type))
+ else if (using_struct_return (SYMBOL_TYPE (thisfun), return_type))
{
query_prefix = "\
The location at which to store the function's return value is unknown.\n\
error (_("Not confirmed"));
}
- /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each
- frame in turn, should this code just go straight to the relevant
- frame and pop that? */
-
- /* First discard all frames inner-to the selected frame (making the
- selected frame current). */
- {
- struct frame_id selected_id = get_frame_id (get_selected_frame (NULL));
- while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ())))
- {
- struct frame_info *frame = get_current_frame ();
- if (frame_id_inner (get_frame_arch (frame), selected_id,
- get_frame_id (frame)))
- /* Caught in the safety net, oops! We've gone way past the
- selected frame. */
- error (_("Problem while popping stack frames (corrupt stack?)"));
- frame_pop (get_current_frame ());
- }
- }
-
- /* Second discard the selected frame (which is now also the current
- frame). */
- frame_pop (get_current_frame ());
+ /* Discard the selected frame and all frames inner-to it. */
+ frame_pop (get_selected_frame (NULL));
/* Store RETURN_VALUE in the just-returned register set. */
if (return_value != NULL)
{
struct type *return_type = value_type (return_value);
struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
- gdb_assert (gdbarch_return_value (gdbarch, return_type, NULL, NULL, NULL)
+ gdb_assert (gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun),
+ return_type, NULL, NULL, NULL)
== RETURN_VALUE_REGISTER_CONVENTION);
- gdbarch_return_value (gdbarch, return_type,
+ gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun), return_type,
get_current_regcache (), NULL /*read*/,
value_contents (return_value) /*write*/);
}
projects / deliverable / binutils-gdb.git / blobdiff