/* Print and select stack frames for GDB, the GNU debugger.
- Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "breakpoint.h"
#include "demangle.h"
+#include "inferior.h"
static void
return_command PARAMS ((char *, int));
args_info PARAMS ((char *, int));
static void
-print_frame_arg_vars PARAMS ((FRAME, FILE *));
+print_frame_arg_vars PARAMS ((FRAME, GDB_FILE *));
static void
catch_info PARAMS ((char *, int));
locals_info PARAMS ((char *, int));
static void
-print_frame_label_vars PARAMS ((FRAME, int, FILE *));
+print_frame_label_vars PARAMS ((FRAME, int, GDB_FILE *));
static void
-print_frame_local_vars PARAMS ((FRAME, FILE *));
+print_frame_local_vars PARAMS ((FRAME, GDB_FILE *));
static int
-print_block_frame_labels PARAMS ((struct block *, int *, FILE *));
+print_block_frame_labels PARAMS ((struct block *, int *, GDB_FILE *));
static int
-print_block_frame_locals PARAMS ((struct block *, FRAME, FILE *));
+print_block_frame_locals PARAMS ((struct block *, FRAME, GDB_FILE *));
static void
backtrace_command PARAMS ((char *, int));
int selected_frame_level;
-/* Nonzero means print the full filename and linenumber
- when a frame is printed, and do so in a format programs can parse. */
+/* 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
+ parse. Two means print similar annotations, but in many more
+ cases and in a slightly different syntax. */
-int frame_file_full_name = 0;
+int annotation_level = 0;
\f
+struct print_stack_frame_args {
+ struct frame_info *fi;
+ int level;
+ int source;
+ int args;
+};
+
+static int print_stack_frame_stub PARAMS ((char *));
+
+/* Pass the args the way catch_errors wants them. */
+static int
+print_stack_frame_stub (args)
+ char *args;
+{
+ struct print_stack_frame_args *p = (struct print_stack_frame_args *)args;
+ print_frame_info (p->fi, p->level, p->source, p->args);
+ return 0;
+}
+
/* Print a stack frame briefly. FRAME should be the frame id
and LEVEL should be its level in the stack (or -1 for level not defined).
This prints the level, the function executing, the arguments,
int level;
int source;
{
+ struct print_stack_frame_args args;
+
+ args.fi = get_frame_info (frame);
+ args.level = level;
+ args.source = source;
+ args.args = 1;
+
+ catch_errors (print_stack_frame_stub, (char *)&args, "", RETURN_MASK_ERROR);
+}
+
+struct print_args_args {
+ struct symbol *func;
struct frame_info *fi;
+};
- fi = get_frame_info (frame);
+static int print_args_stub PARAMS ((char *));
- print_frame_info (fi, level, source, 1);
+/* Pass the args the way catch_errors wants them. */
+static int
+print_args_stub (args)
+ char *args;
+{
+ int numargs;
+ struct print_args_args *p = (struct print_args_args *)args;
+ FRAME_NUM_ARGS (numargs, (p->fi));
+ print_frame_args (p->func, p->fi, numargs, gdb_stdout);
+ return 0;
}
void
struct symtab_and_line sal;
struct symbol *func;
register char *funname = 0;
- int numargs;
-
-#if 0 /* Symbol reading is fast enough now */
- struct partial_symtab *pst;
+ enum language funlang = language_unknown;
+ char buf[MAX_REGISTER_RAW_SIZE];
+ CORE_ADDR sp;
- /* Don't give very much information if we haven't readin the
- symbol table yet. */
- pst = find_pc_psymtab (fi->pc);
- if (pst && !pst->readin)
+#if 0
+ /* On the 68k, this spends too much time in m68k_find_saved_regs. */
+
+ /* Get the value of SP_REGNUM relative to the frame. */
+ get_saved_register (buf, (int *)NULL, (CORE_ADDR *)NULL,
+ FRAME_INFO_ID (fi), SP_REGNUM, (enum lval_type *)NULL);
+ sp = extract_address (buf, REGISTER_RAW_SIZE (SP_REGNUM));
+
+ /* This is not a perfect test, because if a function alloca's some
+ memory, puts some code there, and then jumps into it, then the test
+ will succeed even though there is no call dummy. Probably best is
+ to check for a bp_call_dummy breakpoint. */
+ if (PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame))
+#else
+ if (frame_in_dummy (fi))
+#endif
{
- /* Abbreviated information. */
- char *fname;
-
- if (!find_pc_partial_function (fi->pc, &fname, 0))
- fname = "??";
-
- printf_filtered ("#%-2d ", level);
- if (addressprint)
- printf_filtered ("%s in ", local_hex_string(fi->pc));
-
- fputs_demangled (fname, stdout, 0);
- fputs_filtered (" (...)\n", stdout);
-
+ /* Do this regardless of SOURCE because we don't have any source
+ to list for this frame. */
+ if (level >= 0)
+ printf_filtered ("#%-2d ", level);
+ printf_filtered ("<function called from gdb>\n");
+ return;
+ }
+ if (fi->signal_handler_caller)
+ {
+ /* Do this regardless of SOURCE because we don't have any source
+ to list for this frame. */
+ if (level >= 0)
+ printf_filtered ("#%-2d ", level);
+ printf_filtered ("<signal handler called>\n");
return;
}
-#endif
-#ifdef CORE_NEEDS_RELOCATION
- CORE_NEEDS_RELOCATION(fi->pc);
-#endif
+ /* If fi is not the innermost frame, that normally means that fi->pc
+ points to *after* the call instruction, and we want to get the line
+ containing the call, never the next line. But if the next frame is
+ a signal_handler_caller or a dummy frame, then the next frame was
+ not entered as the result of a call, and we want to get the line
+ containing fi->pc. */
+ sal =
+ find_pc_line (fi->pc,
+ fi->next != NULL
+ && !fi->next->signal_handler_caller
+ && !frame_in_dummy (fi->next));
- sal = find_pc_line (fi->pc, fi->next_frame);
func = find_pc_function (fi->pc);
if (func)
{
is compiled with debugging symbols, and the "foo.o" symbol
that is supposed to tell us where the file with debugging symbols
ends has been truncated by ar because it is longer than 15
- characters).
+ characters). This also occurs if the user uses asm() to create
+ a function but not stabs for it (in a file compiled -g).
So look in the minimal symbol tables as well, and if it comes
up with a larger address for the function use that instead.
I don't think this can ever cause any problems; there shouldn't
- be any minimal symbols in the middle of a function.
- FIXME: (Not necessarily true. What about text labels) */
+ be any minimal symbols in the middle of a function; if this is
+ ever changed many parts of GDB will need to be changed (and we'll
+ create a find_pc_minimal_function or some such). */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL
- && (msymbol -> address
+ && (SYMBOL_VALUE_ADDRESS (msymbol)
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
{
+#if 0
+ /* There is no particular reason to think the line number
+ information is wrong. Someone might have just put in
+ a label with asm() but left the line numbers alone. */
/* In this case we have no way of knowing the source file
and line number, so don't print them. */
sal.symtab = 0;
+#endif
/* We also don't know anything about the function besides
its address and name. */
func = 0;
- funname = msymbol -> name;
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
}
else
- funname = SYMBOL_NAME (func);
+ {
+ funname = SYMBOL_NAME (func);
+ funlang = SYMBOL_LANGUAGE (func);
+ }
}
else
{
register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
- funname = msymbol -> name;
+ {
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
+ }
}
if (source >= 0 || !sal.symtab)
printf_filtered ("#%-2d ", level);
if (addressprint)
if (fi->pc != sal.pc || !sal.symtab)
- printf_filtered ("%s in ", local_hex_string(fi->pc));
- fputs_demangled (funname ? funname : "??", stdout, 0);
+ {
+ print_address_numeric (fi->pc, 1, gdb_stdout);
+ printf_filtered (" in ");
+ }
+ fprintf_symbol_filtered (gdb_stdout, funname ? funname : "??", funlang,
+ DMGL_ANSI);
wrap_here (" ");
- fputs_filtered (" (", stdout);
+ fputs_filtered (" (", gdb_stdout);
if (args)
{
- FRAME_NUM_ARGS (numargs, fi);
- print_frame_args (func, fi, numargs, stdout);
+ struct print_args_args args;
+ args.fi = fi;
+ args.func = func;
+ catch_errors (print_args_stub, (char *)&args, "", RETURN_MASK_ERROR);
}
printf_filtered (")");
if (sal.symtab && sal.symtab->filename)
{
int done = 0;
int mid_statement = source < 0 && fi->pc != sal.pc;
- if (frame_file_full_name)
- done = identify_source_line (sal.symtab, sal.line, mid_statement);
+ if (annotation_level)
+ done = identify_source_line (sal.symtab, sal.line, mid_statement,
+ fi->pc);
if (!done)
{
if (addressprint && mid_statement)
- printf_filtered ("%s\t", local_hex_string(fi->pc));
+ {
+ print_address_numeric (fi->pc, 1, gdb_stdout);
+ printf_filtered ("\t");
+ }
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
}
current_source_line = max (sal.line - lines_to_list/2, 1);
if (source != 0)
set_default_breakpoint (1, fi->pc, sal.symtab, sal.line);
- fflush (stdout);
+ gdb_flush (gdb_stdout);
}
-#ifdef FRAME_SPECIFICATION_DYADIC
-extern FRAME setup_arbitrary_frame ();
-#endif
-
/*
* Read a frame specification in whatever the appropriate format is.
* Call error() if the specification is in any way invalid (i.e.
char *frame_exp;
{
int numargs = 0;
- int arg1, arg2;
+#define MAXARGS 4
+ CORE_ADDR args[MAXARGS];
if (frame_exp)
{
struct cleanup *tmp_cleanup;
while (*frame_exp == ' ') frame_exp++;
- for (p = frame_exp; *p && *p != ' '; p++)
- ;
- if (*frame_exp)
+ while (*frame_exp)
{
- numargs = 1;
+ if (numargs > MAXARGS)
+ error ("Too many args in frame specification");
+ /* Parse an argument. */
+ for (p = frame_exp; *p && *p != ' '; p++)
+ ;
addr_string = savestring(frame_exp, p - frame_exp);
{
tmp_cleanup = make_cleanup (free, addr_string);
- arg1 = parse_and_eval_address (addr_string);
+ args[numargs++] = parse_and_eval_address (addr_string);
do_cleanups (tmp_cleanup);
}
+ /* Skip spaces, move to possible next arg. */
while (*p == ' ') p++;
-
- if (*p)
- {
- numargs = 2;
- arg2 = parse_and_eval_address (p);
- }
+ frame_exp = p;
}
}
/* NOTREACHED */
case 1:
{
- int level = arg1;
+ int level = args[0];
FRAME fid = find_relative_frame (get_current_frame (), &level);
FRAME tfid;
/* find_relative_frame was successful */
return fid;
+ /* If SETUP_ARBITRARY_FRAME is defined, then frame specifications
+ take at least 2 addresses. It is important to detect this case
+ here so that "frame 100" does not give a confusing error message
+ like "frame specification requires two addresses". This of course
+ does not solve the "frame 100" problem for machines on which
+ a frame specification can be made with one address. To solve
+ that, we need a new syntax for a specifying a frame by address.
+ I think the cleanest syntax is $frame(0x45) ($frame(0x23,0x45) for
+ two args, etc.), but people might think that is too much typing,
+ so I guess *0x23,0x45 would be a possible alternative (commas
+ really should be used instead of spaces to delimit; using spaces
+ normally works in an expression). */
+#ifdef SETUP_ARBITRARY_FRAME
+ error ("No frame %d", args[0]);
+#endif
+
/* If (s)he specifies the frame with an address, he deserves what
(s)he gets. Still, give the highest one that matches. */
for (fid = get_current_frame ();
- fid && FRAME_FP (fid) != arg1;
+ fid && FRAME_FP (fid) != args[0];
fid = get_prev_frame (fid))
;
if (fid)
while ((tfid = get_prev_frame (fid)) &&
- (FRAME_FP (tfid) == arg1))
+ (FRAME_FP (tfid) == args[0]))
fid = tfid;
-#ifdef FRAME_SPECIFICATION_DYADIC
- if (!fid)
- error ("Incorrect number of args in frame specification");
-
- return fid;
-#else
- return create_new_frame (arg1, 0);
-#endif
+ /* We couldn't identify the frame as an existing frame, but
+ perhaps we can create one with a single argument. */
}
- /* NOTREACHED */
- case 2:
- /* Must be addresses */
-#ifndef FRAME_SPECIFICATION_DYADIC
- error ("Incorrect number of args in frame specification");
+
+ default:
+#ifdef SETUP_ARBITRARY_FRAME
+ return SETUP_ARBITRARY_FRAME (numargs, args);
#else
- return setup_arbitrary_frame (arg1, arg2);
+ /* Usual case. Do it here rather than have everyone supply
+ a SETUP_ARBITRARY_FRAME that does this. */
+ if (numargs == 1)
+ return create_new_frame (args[0], 0);
+ error ("Too many args in frame specification");
#endif
/* NOTREACHED */
}
- fatal ("Internal: Error in parsing in parse_frame_specification");
/* NOTREACHED */
}
FRAME calling_frame;
int i, count;
char *funname = 0;
+ enum language funlang = language_unknown;
if (!target_has_stack)
- error ("No inferior or core file.");
+ error ("No stack.");
frame = parse_frame_specification (addr_exp);
if (!frame)
error ("Invalid frame specified.");
fi = get_frame_info (frame);
- sal = find_pc_line (fi->pc, fi->next_frame);
+ sal = find_pc_line (fi->pc,
+ fi->next != NULL
+ && !fi->next->signal_handler_caller
+ && !frame_in_dummy (fi->next));
func = get_frame_function (frame);
s = find_pc_symtab(fi->pc);
if (func)
- funname = SYMBOL_NAME (func);
+ {
+ funname = SYMBOL_NAME (func);
+ funlang = SYMBOL_LANGUAGE (func);
+ }
else
{
register struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL)
- funname = msymbol -> name;
+ {
+ funname = SYMBOL_NAME (msymbol);
+ funlang = SYMBOL_LANGUAGE (msymbol);
+ }
}
calling_frame = get_prev_frame (frame);
- if (!addr_exp && selected_frame_level >= 0) {
- printf_filtered ("Stack level %d, frame at %s:\n",
- selected_frame_level,
- local_hex_string(FRAME_FP(frame)));
- } else {
- printf_filtered ("Stack frame at %s:\n",
- local_hex_string(FRAME_FP(frame)));
- }
- printf_filtered (" %s = %s",
- reg_names[PC_REGNUM],
- local_hex_string(fi->pc));
+ if (!addr_exp && selected_frame_level >= 0)
+ {
+ printf_filtered ("Stack level %d, frame at ", selected_frame_level);
+ print_address_numeric (FRAME_FP(frame), 1, gdb_stdout);
+ printf_filtered (":\n");
+ }
+ else
+ {
+ printf_filtered ("Stack frame at ");
+ print_address_numeric (FRAME_FP(frame), 1, gdb_stdout);
+ printf_filtered (":\n");
+ }
+ printf_filtered (" %s = ",
+ reg_names[PC_REGNUM]);
+ print_address_numeric (fi->pc, 1, gdb_stdout);
wrap_here (" ");
if (funname)
{
printf_filtered (" in ");
- fputs_demangled (funname, stdout, DMGL_ANSI | DMGL_PARAMS);
+ fprintf_symbol_filtered (gdb_stdout, funname, funlang,
+ DMGL_ANSI | DMGL_PARAMS);
}
wrap_here (" ");
if (sal.symtab)
printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
puts_filtered ("; ");
wrap_here (" ");
- printf_filtered ("saved %s %s\n", reg_names[PC_REGNUM],
- local_hex_string(FRAME_SAVED_PC (frame)));
+ printf_filtered ("saved %s ", reg_names[PC_REGNUM]);
+ print_address_numeric (FRAME_SAVED_PC (frame), 1, gdb_stdout);
+ printf_filtered ("\n");
{
int frameless = 0;
}
if (calling_frame)
- printf_filtered (" called by frame at %s",
- local_hex_string(FRAME_FP (calling_frame)));
- if (fi->next_frame && calling_frame)
+ {
+ printf_filtered (" called by frame at ");
+ print_address_numeric (FRAME_FP (calling_frame), 1, gdb_stdout);
+ }
+ if (fi->next && calling_frame)
puts_filtered (",");
wrap_here (" ");
- if (fi->next_frame)
- printf_filtered (" caller of frame at %s", local_hex_string(fi->next_frame));
- if (fi->next_frame || calling_frame)
+ if (fi->next)
+ {
+ printf_filtered (" caller of frame at ");
+ print_address_numeric (fi->next->frame, 1, gdb_stdout);
+ }
+ if (fi->next || calling_frame)
puts_filtered ("\n");
if (s)
- printf_filtered(" source language %s.\n", language_str(s->language));
+ printf_filtered (" source language %s.\n", language_str (s->language));
+
+#ifdef PRINT_EXTRA_FRAME_INFO
+ PRINT_EXTRA_FRAME_INFO (fi);
+#endif
{
/* Address of the argument list for this frame, or 0. */
int numargs;
if (arg_list == 0)
- printf_filtered (" Arglist at unknown address.\n");
+ printf_filtered (" Arglist at unknown address.\n");
else
{
- printf_filtered (" Arglist at %s,", local_hex_string(arg_list));
+ printf_filtered (" Arglist at ");
+ print_address_numeric (arg_list, 1, gdb_stdout);
+ printf_filtered (",");
FRAME_NUM_ARGS (numargs, fi);
if (numargs < 0)
puts_filtered (" 1 arg: ");
else
printf_filtered (" %d args: ", numargs);
- print_frame_args (func, fi, numargs, stdout);
+ print_frame_args (func, fi, numargs, gdb_stdout);
puts_filtered ("\n");
}
}
CORE_ADDR arg_list = FRAME_LOCALS_ADDRESS (fi);
if (arg_list == 0)
- printf_filtered (" Locals at unknown address,");
+ printf_filtered (" Locals at unknown address,");
else
- printf_filtered (" Locals at %s,", local_hex_string(arg_list));
+ {
+ printf_filtered (" Locals at ");
+ print_address_numeric (arg_list, 1, gdb_stdout);
+ printf_filtered (",");
+ }
}
#if defined (FRAME_FIND_SAVED_REGS)
get_frame_saved_regs (fi, &fsr);
/* The sp is special; what's returned isn't the save address, but
actually the value of the previous frame's sp. */
- printf_filtered (" Previous frame's sp is %s\n",
- local_hex_string(fsr.regs[SP_REGNUM]));
+ printf_filtered (" Previous frame's sp is ");
+ print_address_numeric (fsr.regs[SP_REGNUM], 1, gdb_stdout);
+ printf_filtered ("\n");
count = 0;
for (i = 0; i < NUM_REGS; i++)
if (fsr.regs[i] && i != SP_REGNUM)
else
puts_filtered (",");
wrap_here (" ");
- printf_filtered (" %s at %s", reg_names[i],
- local_hex_string(fsr.regs[i]));
+ printf_filtered (" %s at ", reg_names[i]);
+ print_address_numeric (fsr.regs[i], 1, gdb_stdout);
count++;
}
if (count)
puts_filtered ("\n");
+#else /* Have FRAME_FIND_SAVED_REGS. */
+ puts_filtered ("\n");
#endif /* Have FRAME_FIND_SAVED_REGS. */
}
if (arg)
error ("\"Info backtrace-limit\" takes no arguments.");
- printf ("Backtrace limit: %d.\n", backtrace_limit);
+ printf_unfiltered ("Backtrace limit: %d.\n", backtrace_limit);
}
#endif
fi = get_frame_info (frame);
ps = find_pc_psymtab (fi->pc);
if (ps)
- (void) PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in */
+ PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in */
}
}
{
QUIT;
fi = get_frame_info (frame);
+
+ /* 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, trailing_level + i, 0, 1);
}
print_block_frame_locals (b, frame, stream)
struct block *b;
register FRAME frame;
- register FILE *stream;
+ register GDB_FILE *stream;
{
int nsyms;
register int i;
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (SYMBOL_CLASS (sym) == LOC_LOCAL
- || SYMBOL_CLASS (sym) == LOC_REGISTER
- || SYMBOL_CLASS (sym) == LOC_STATIC)
+ switch (SYMBOL_CLASS (sym))
{
+ case LOC_LOCAL:
+ case LOC_REGISTER:
+ case LOC_STATIC:
+ case LOC_BASEREG:
values_printed = 1;
- fprint_symbol (stream, SYMBOL_NAME (sym));
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
print_variable_value (sym, frame, stream);
fprintf_filtered (stream, "\n");
+ break;
+
+ default:
+ /* Ignore symbols which are not locals. */
+ break;
}
}
return values_printed;
print_block_frame_labels (b, have_default, stream)
struct block *b;
int *have_default;
- register FILE *stream;
+ register GDB_FILE *stream;
{
int nsyms;
register int i;
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (! strcmp (SYMBOL_NAME (sym), "default"))
+ if (STREQ (SYMBOL_NAME (sym), "default"))
{
if (*have_default)
continue;
struct symtab_and_line sal;
sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
values_printed = 1;
- fputs_demangled (SYMBOL_NAME (sym), stream, DMGL_ANSI | DMGL_PARAMS);
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
if (addressprint)
- fprintf_filtered (stream, " %s",
- local_hex_string(SYMBOL_VALUE_ADDRESS (sym)));
+ {
+ fprintf_filtered (stream, " ");
+ print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream);
+ }
fprintf_filtered (stream, " in file %s, line %d\n",
sal.symtab->filename, sal.line);
}
static void
print_frame_local_vars (frame, stream)
register FRAME frame;
- register FILE *stream;
+ register GDB_FILE *stream;
{
register struct block *block = get_frame_block (frame);
register int values_printed = 0;
print_frame_label_vars (frame, this_level_only, stream)
register FRAME frame;
int this_level_only;
- register FILE *stream;
+ register GDB_FILE *stream;
{
register struct blockvector *bl;
register struct block *block = get_frame_block (frame);
bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
blocks_printed = (char *) alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
- (void) memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
+ memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
while (block != 0)
{
{
if (!selected_frame)
error ("No frame selected.");
- print_frame_local_vars (selected_frame, stdout);
+ print_frame_local_vars (selected_frame, gdb_stdout);
}
static void
{
if (!selected_frame)
error ("No frame selected.");
- print_frame_label_vars (selected_frame, 0, stdout);
+ print_frame_label_vars (selected_frame, 0, gdb_stdout);
}
static void
print_frame_arg_vars (frame, stream)
register FRAME frame;
- register FILE *stream;
+ register GDB_FILE *stream;
{
struct symbol *func = get_frame_function (frame);
register struct block *b;
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (SYMBOL_CLASS (sym) == LOC_ARG
- || SYMBOL_CLASS (sym) == LOC_LOCAL_ARG
- || SYMBOL_CLASS (sym) == LOC_REF_ARG
- || SYMBOL_CLASS (sym) == LOC_REGPARM)
+ switch (SYMBOL_CLASS (sym))
{
+ case LOC_ARG:
+ case LOC_LOCAL_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
+ case LOC_BASEREG_ARG:
values_printed = 1;
- fprint_symbol (stream, SYMBOL_NAME (sym));
+ fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
- /* We have to look up the symbol because arguments often have
- two entries (one a parameter, one a register) and the one
- we want is the register, which lookup_symbol will find for
- us. */
+
+ /* We have to look up the symbol because arguments can have
+ two entries (one a parameter, one a local) and the one we
+ want is the local, which lookup_symbol will find for us.
+ This includes gcc1 (not gcc2) on the sparc when passing a
+ small structure and gcc2 when the argument type is float
+ and it is passed as a double and converted to float by
+ the prologue (in the latter case the type of the LOC_ARG
+ symbol is double and the type of the LOC_LOCAL symbol is
+ float). There are also LOC_ARG/LOC_REGISTER pairs which
+ are not combined in symbol-reading. */
+
sym2 = lookup_symbol (SYMBOL_NAME (sym),
b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
print_variable_value (sym2, frame, stream);
fprintf_filtered (stream, "\n");
+ break;
+
+ default:
+ /* Don't worry about things which aren't arguments. */
+ break;
}
}
{
if (!selected_frame)
error ("No frame selected.");
- print_frame_arg_vars (selected_frame, stdout);
+ print_frame_arg_vars (selected_frame, gdb_stdout);
}
\f
/* Select frame FRAME, and note that its stack level is LEVEL.
count = parse_and_eval_address (count_exp);
count1 = count;
- if (!target_has_stack)
+ if (target_has_stack == 0 || selected_frame == 0)
error ("No stack.");
frame = find_relative_frame (selected_frame, &count1);
count = - parse_and_eval_address (count_exp);
count1 = count;
- if (!target_has_stack)
+ if (target_has_stack == 0 || selected_frame == 0)
error ("No stack.");
frame = find_relative_frame (selected_frame, &count1);
if (count1 != 0 && count_exp == 0)
- error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
+ {
+
+ /* We only do this if count_exp is not specified. That way "down"
+ means to really go down (and let me know if that is
+ impossible), but "down 9999" can be used to mean go all the way
+ down without getting an error. */
+
+ error ("Bottom (i.e., innermost) frame selected; you cannot go down.");
+ }
+
select_frame (frame, selected_frame_level + count - count1);
}
FRAME_ADDR selected_frame_addr;
CORE_ADDR selected_frame_pc;
FRAME frame;
- char *funcname;
- struct cleanup *back_to;
+ value_ptr return_value = NULL;
if (selected_frame == NULL)
error ("No selected frame.");
selected_frame_addr = FRAME_FP (selected_frame);
selected_frame_pc = (get_frame_info (selected_frame))->pc;
+ /* Compute the return value (if any -- possibly getting errors here). */
+
+ if (retval_exp)
+ {
+ return_value = parse_and_eval (retval_exp);
+
+ /* Make sure we have fully evaluated it, since
+ it might live in the stack frame we're about to pop. */
+ if (VALUE_LAZY (return_value))
+ value_fetch_lazy (return_value);
+ }
+
/* If interactive, require confirmation. */
if (from_tty)
{
if (thisfun != 0)
{
- funcname = strdup_demangled (SYMBOL_NAME (thisfun));
- back_to = make_cleanup (free, funcname);
- if (!query ("Make %s return now? ", funcname))
+ if (!query ("Make %s return now? ", SYMBOL_SOURCE_NAME (thisfun)))
{
error ("Not confirmed.");
/* NOTREACHED */
}
- do_cleanups (back_to);
}
else
if (!query ("Make selected stack frame return now? "))
for return values. */
if (retval_exp)
- set_return_value (parse_and_eval (retval_exp));
+ set_return_value (return_value);
/* If interactive, print the frame that is now current. */
"Select and print stack frame called by this one.\n\
An argument says how many frames down to go.");
add_com_alias ("do", "down", class_stack, 1);
+ add_com_alias ("dow", "down", class_stack, 1);
add_com ("down-silently", class_support, down_silently_command,
"Same as the `down' command, but does not print anything.\n\
This is useful in command scripts.");