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 frame_file_full_name = 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 frame_info *fi;
+ struct print_stack_frame_args args;
- fi = get_frame_info (frame);
+ args.fi = get_frame_info (frame);
+ args.level = level;
+ args.source = source;
+ args.args = 1;
- print_frame_info (fi, level, source, 1);
+ catch_errors (print_stack_frame_stub, (char *)&args, "", RETURN_MASK_ERROR);
}
struct print_args_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, stdout);
+ print_frame_args (p->func, p->fi, numargs, gdb_stdout);
return 0;
}
struct symbol *func;
register char *funname = 0;
enum language funlang = language_unknown;
- int numargs;
char buf[MAX_REGISTER_RAW_SIZE];
CORE_ADDR sp;
+#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);
/* 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. A better
- solution would be to keep track of where the call dummies are.
- Probably the best way to do that is by setting a breakpoint.c
- breakpoint at the end of the call dummy (wanted anyway, to clean
- up wait_for_inferior). Then we know that the sizeof (CALL_DUMMY)
- (or some such) bytes before that breakpoint are a call dummy.
- Only problem I see with this approach is figuring out to get rid
- of the breakpoint whenever the call dummy vanishes (e.g.
- return_command, or longjmp out of the called function), which we
- probably can solve (it's very similar to figuring out when a
- watchpoint on a local variable goes out of scope if it is being
- watched via something like a 386 debug register). */
+ 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
{
/* Do this regardless of SOURCE because we don't have any source
to list for this frame. */
return;
}
- sal = find_pc_line (fi->pc,
- fi->next != NULL && fi->next->signal_handler_caller == 0);
+ /* 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));
+
func = find_pc_function (fi->pc);
if (func)
{
printf_filtered ("#%-2d ", level);
if (addressprint)
if (fi->pc != sal.pc || !sal.symtab)
- printf_filtered ("%s in ", local_hex_string(fi->pc));
- fprintf_symbol_filtered (stdout, funname ? funname : "??", funlang,
- DMGL_NO_OPTS);
+ {
+ print_address_numeric (fi->pc, 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)
{
struct print_args_args args;
if (!done)
{
if (addressprint && mid_statement)
- printf_filtered ("%s\t", local_hex_string(fi->pc));
+ {
+ print_address_numeric (fi->pc, 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);
}
/*
char *frame_exp;
{
int numargs = 0;
- int arg1, arg2, arg3;
#define MAXARGS 4
- int args[MAXARGS];
+ CORE_ADDR args[MAXARGS];
if (frame_exp)
{
fi = get_frame_info (frame);
sal = find_pc_line (fi->pc,
- fi->next != NULL && fi->next->signal_handler_caller == 0);
+ 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)
}
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), gdb_stdout);
+ printf_filtered (":\n");
+ }
+ else
+ {
+ printf_filtered ("Stack frame at ");
+ print_address_numeric (FRAME_FP(frame), gdb_stdout);
+ printf_filtered (":\n");
+ }
+ printf_filtered (" %s = ",
+ reg_names[PC_REGNUM]);
+ print_address_numeric (fi->pc, gdb_stdout);
wrap_here (" ");
if (funname)
{
printf_filtered (" in ");
- fprintf_symbol_filtered (stdout, funname, funlang,
+ fprintf_symbol_filtered (gdb_stdout, funname, funlang,
DMGL_ANSI | DMGL_PARAMS);
}
wrap_here (" ");
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), 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)));
+ {
+ printf_filtered (" called by frame at ");
+ print_address_numeric (FRAME_FP (calling_frame), gdb_stdout);
+ }
if (fi->next && calling_frame)
puts_filtered (",");
wrap_here (" ");
if (fi->next)
- printf_filtered (" caller of frame at %s",
- local_hex_string (fi->next->frame));
+ {
+ printf_filtered (" caller of frame at ");
+ print_address_numeric (fi->next->frame, 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);
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, 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, 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], 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], 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
{
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;
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;
values_printed = 1;
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), 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);
{
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
- || SYMBOL_CLASS (sym) == LOC_REGPARM_ADDR)
+ 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;
fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
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.
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;
- value return_value;
+ value 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).
- Call VALUE_CONTENTS to make sure we have fully evaluated it, since
- it might live in the stack frame we're about to pop. */
+ /* Compute the return value (if any -- possibly getting errors here). */
if (retval_exp)
{
return_value = parse_and_eval (retval_exp);
- VALUE_CONTENTS (return_value);
+
+ /* 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. */