* configure.in: Check for unistd.h.
* configure: Regenerated. * command.c, cp-valprint.c, fork-child.c, i386-tdep.c, i386b-nat.c, inflow.c, main.c, maint.c, objfiles.c, solib.c, source.c, stack.c, symfile.c, top.c, utils.c: Include strings.h and/or unistd.h to bring prototypes into scope.
This commit is contained in:
J.T. Conklin
parent
f641906be5
commit
1a49497348
18 changed files with 564 additions and 319 deletions
316
gdb/stack.c
316
gdb/stack.c
|
|
@ -1,5 +1,6 @@
|
|||
/* Print and select stack frames for GDB, the GNU debugger.
|
||||
Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
|
||||
Copyright 1986, 1987, 1989, 1991, 1992, 1993, 1994
|
||||
Free Software Foundation, Inc.
|
||||
|
||||
This file is part of GDB.
|
||||
|
||||
|
|
@ -17,6 +18,7 @@ You should have received a copy of the GNU General Public License
|
|||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
|
||||
#include <string.h>
|
||||
#include "defs.h"
|
||||
#include "value.h"
|
||||
#include "symtab.h"
|
||||
|
|
@ -30,61 +32,47 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|||
#include "breakpoint.h"
|
||||
#include "demangle.h"
|
||||
#include "inferior.h"
|
||||
#include "annotate.h"
|
||||
|
||||
static void
|
||||
return_command PARAMS ((char *, int));
|
||||
static void return_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
down_command PARAMS ((char *, int));
|
||||
static void down_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
down_silently_command PARAMS ((char *, int));
|
||||
static void down_silently_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
up_command PARAMS ((char *, int));
|
||||
static void up_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
up_silently_command PARAMS ((char *, int));
|
||||
static void up_silently_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
frame_command PARAMS ((char *, int));
|
||||
static void frame_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
select_frame_command PARAMS ((char *, int));
|
||||
static void select_frame_command PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
args_info PARAMS ((char *, int));
|
||||
static void args_info PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
print_frame_arg_vars PARAMS ((FRAME, GDB_FILE *));
|
||||
static void print_frame_arg_vars PARAMS ((struct frame_info *, GDB_FILE *));
|
||||
|
||||
static void
|
||||
catch_info PARAMS ((char *, int));
|
||||
static void catch_info PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
locals_info PARAMS ((char *, int));
|
||||
static void locals_info PARAMS ((char *, int));
|
||||
|
||||
static void
|
||||
print_frame_label_vars PARAMS ((FRAME, int, GDB_FILE *));
|
||||
static void print_frame_label_vars PARAMS ((struct frame_info *, int,
|
||||
GDB_FILE *));
|
||||
|
||||
static void
|
||||
print_frame_local_vars PARAMS ((FRAME, GDB_FILE *));
|
||||
static void print_frame_local_vars PARAMS ((struct frame_info *, GDB_FILE *));
|
||||
|
||||
static int
|
||||
print_block_frame_labels PARAMS ((struct block *, int *, GDB_FILE *));
|
||||
static int print_block_frame_labels PARAMS ((struct block *, int *,
|
||||
GDB_FILE *));
|
||||
|
||||
static int
|
||||
print_block_frame_locals PARAMS ((struct block *, FRAME, GDB_FILE *));
|
||||
static int print_block_frame_locals PARAMS ((struct block *,
|
||||
struct frame_info *,
|
||||
GDB_FILE *));
|
||||
|
||||
static void
|
||||
backtrace_command PARAMS ((char *, int));
|
||||
static void backtrace_command PARAMS ((char *, int));
|
||||
|
||||
static FRAME
|
||||
parse_frame_specification PARAMS ((char *));
|
||||
|
||||
static void
|
||||
frame_info PARAMS ((char *, int));
|
||||
static struct frame_info *parse_frame_specification PARAMS ((char *));
|
||||
|
||||
static void frame_info PARAMS ((char *, int));
|
||||
|
||||
extern int addressprint; /* Print addresses, or stay symbolic only? */
|
||||
extern int info_verbose; /* Verbosity of symbol reading msgs */
|
||||
|
|
@ -93,7 +81,7 @@ extern int lines_to_list; /* # of lines "list" command shows by default */
|
|||
/* The "selected" stack frame is used by default for local and arg access.
|
||||
May be zero, for no selected frame. */
|
||||
|
||||
FRAME selected_frame;
|
||||
struct frame_info *selected_frame;
|
||||
|
||||
/* Level of the selected frame:
|
||||
0 for innermost, 1 for its caller, ...
|
||||
|
|
@ -125,11 +113,12 @@ 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
|
||||
/* Print a stack frame briefly. FRAME_INFI should be the frame info
|
||||
and LEVEL should be its level in the stack (or -1 for level not defined).
|
||||
This prints the level, the function executing, the arguments,
|
||||
and the file name and line number.
|
||||
|
|
@ -140,14 +129,14 @@ print_stack_frame_stub (args)
|
|||
If SOURCE is -1, print ONLY the source line. */
|
||||
|
||||
void
|
||||
print_stack_frame (frame, level, source)
|
||||
FRAME frame;
|
||||
print_stack_frame (fi, level, source)
|
||||
struct frame_info *fi;
|
||||
int level;
|
||||
int source;
|
||||
{
|
||||
struct print_stack_frame_args args;
|
||||
|
||||
args.fi = get_frame_info (frame);
|
||||
args.fi = fi;
|
||||
args.level = level;
|
||||
args.source = source;
|
||||
args.args = 1;
|
||||
|
|
@ -163,17 +152,22 @@ struct print_args_args {
|
|||
static int print_args_stub PARAMS ((char *));
|
||||
|
||||
/* 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;
|
||||
}
|
||||
|
||||
/* LEVEL is the level of the frame, or -1 if it is the innermost frame
|
||||
but we don't want to print the level. */
|
||||
|
||||
void
|
||||
print_frame_info (fi, level, source, args)
|
||||
struct frame_info *fi;
|
||||
|
|
@ -185,10 +179,11 @@ print_frame_info (fi, level, source, args)
|
|||
struct symbol *func;
|
||||
register char *funname = 0;
|
||||
enum language funlang = language_unknown;
|
||||
|
||||
#if 0
|
||||
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. */
|
||||
|
|
@ -205,20 +200,28 @@ print_frame_info (fi, level, source, args)
|
|||
if (frame_in_dummy (fi))
|
||||
#endif
|
||||
{
|
||||
annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
|
||||
|
||||
/* Do this regardless of SOURCE because we don't have any source
|
||||
to list for this frame. */
|
||||
if (level >= 0)
|
||||
printf_filtered ("#%-2d ", level);
|
||||
annotate_function_call ();
|
||||
printf_filtered ("<function called from gdb>\n");
|
||||
annotate_frame_end ();
|
||||
return;
|
||||
}
|
||||
if (fi->signal_handler_caller)
|
||||
{
|
||||
annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
|
||||
|
||||
/* Do this regardless of SOURCE because we don't have any source
|
||||
to list for this frame. */
|
||||
if (level >= 0)
|
||||
printf_filtered ("#%-2d ", level);
|
||||
annotate_signal_handler_caller ();
|
||||
printf_filtered ("<signal handler called>\n");
|
||||
annotate_frame_end ();
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -290,17 +293,23 @@ print_frame_info (fi, level, source, args)
|
|||
|
||||
if (source >= 0 || !sal.symtab)
|
||||
{
|
||||
annotate_frame_begin (level == -1 ? 0 : level, fi->pc);
|
||||
|
||||
if (level >= 0)
|
||||
printf_filtered ("#%-2d ", level);
|
||||
if (addressprint)
|
||||
if (fi->pc != sal.pc || !sal.symtab)
|
||||
{
|
||||
annotate_frame_address ();
|
||||
print_address_numeric (fi->pc, 1, gdb_stdout);
|
||||
annotate_frame_address_end ();
|
||||
printf_filtered (" in ");
|
||||
}
|
||||
annotate_frame_function_name ();
|
||||
fprintf_symbol_filtered (gdb_stdout, funname ? funname : "??", funlang,
|
||||
DMGL_ANSI);
|
||||
wrap_here (" ");
|
||||
annotate_frame_args ();
|
||||
fputs_filtered (" (", gdb_stdout);
|
||||
if (args)
|
||||
{
|
||||
|
|
@ -312,18 +321,28 @@ print_frame_info (fi, level, source, args)
|
|||
printf_filtered (")");
|
||||
if (sal.symtab && sal.symtab->filename)
|
||||
{
|
||||
annotate_frame_source_begin ();
|
||||
wrap_here (" ");
|
||||
printf_filtered (" at %s:%d", sal.symtab->filename, sal.line);
|
||||
printf_filtered (" at ");
|
||||
annotate_frame_source_file ();
|
||||
printf_filtered ("%s", sal.symtab->filename);
|
||||
annotate_frame_source_file_end ();
|
||||
printf_filtered (":");
|
||||
annotate_frame_source_line ();
|
||||
printf_filtered ("%d", sal.line);
|
||||
annotate_frame_source_end ();
|
||||
}
|
||||
|
||||
#ifdef PC_LOAD_SEGMENT
|
||||
/* If we couldn't print out function name but if can figure out what
|
||||
load segment this pc value is from, at least print out some info
|
||||
about its load segment. */
|
||||
if (!funname) {
|
||||
wrap_here (" ");
|
||||
printf_filtered (" from %s", PC_LOAD_SEGMENT (fi->pc));
|
||||
}
|
||||
if (!funname)
|
||||
{
|
||||
annotate_frame_where ();
|
||||
wrap_here (" ");
|
||||
printf_filtered (" from %s", PC_LOAD_SEGMENT (fi->pc));
|
||||
}
|
||||
#endif
|
||||
printf_filtered ("\n");
|
||||
}
|
||||
|
|
@ -342,22 +361,26 @@ print_frame_info (fi, level, source, args)
|
|||
print_address_numeric (fi->pc, 1, gdb_stdout);
|
||||
printf_filtered ("\t");
|
||||
}
|
||||
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
|
||||
if (print_frame_info_listing_hook)
|
||||
print_frame_info_listing_hook (sal.symtab, sal.line, sal.line + 1, 0);
|
||||
else
|
||||
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);
|
||||
|
||||
annotate_frame_end ();
|
||||
|
||||
gdb_flush (gdb_stdout);
|
||||
}
|
||||
|
||||
/*
|
||||
* Read a frame specification in whatever the appropriate format is.
|
||||
* Call error() if the specification is in any way invalid (i.e.
|
||||
* this function never returns NULL).
|
||||
*/
|
||||
static FRAME
|
||||
/* Read a frame specification in whatever the appropriate format is.
|
||||
Call error() if the specification is in any way invalid (i.e.
|
||||
this function never returns NULL). */
|
||||
|
||||
static struct frame_info *
|
||||
parse_frame_specification (frame_exp)
|
||||
char *frame_exp;
|
||||
{
|
||||
|
|
@ -403,8 +426,9 @@ parse_frame_specification (frame_exp)
|
|||
case 1:
|
||||
{
|
||||
int level = args[0];
|
||||
FRAME fid = find_relative_frame (get_current_frame (), &level);
|
||||
FRAME tfid;
|
||||
struct frame_info *fid =
|
||||
find_relative_frame (get_current_frame (), &level);
|
||||
struct frame_info *tfid;
|
||||
|
||||
if (level == 0)
|
||||
/* find_relative_frame was successful */
|
||||
|
|
@ -430,13 +454,13 @@ parse_frame_specification (frame_exp)
|
|||
(s)he gets. Still, give the highest one that matches. */
|
||||
|
||||
for (fid = get_current_frame ();
|
||||
fid && FRAME_FP (fid) != args[0];
|
||||
fid && fid->frame != args[0];
|
||||
fid = get_prev_frame (fid))
|
||||
;
|
||||
|
||||
if (fid)
|
||||
while ((tfid = get_prev_frame (fid)) &&
|
||||
(FRAME_FP (tfid) == args[0]))
|
||||
(tfid->frame == args[0]))
|
||||
fid = tfid;
|
||||
|
||||
/* We couldn't identify the frame as an existing frame, but
|
||||
|
|
@ -476,30 +500,28 @@ frame_info (addr_exp, from_tty)
|
|||
char *addr_exp;
|
||||
int from_tty;
|
||||
{
|
||||
FRAME frame;
|
||||
struct frame_info *fi;
|
||||
struct frame_saved_regs fsr;
|
||||
struct symtab_and_line sal;
|
||||
struct symbol *func;
|
||||
struct symtab *s;
|
||||
FRAME calling_frame;
|
||||
int i, count;
|
||||
struct frame_info *calling_frame_info;
|
||||
int i, count, numregs;
|
||||
char *funname = 0;
|
||||
enum language funlang = language_unknown;
|
||||
|
||||
if (!target_has_stack)
|
||||
error ("No stack.");
|
||||
|
||||
frame = parse_frame_specification (addr_exp);
|
||||
if (!frame)
|
||||
fi = parse_frame_specification (addr_exp);
|
||||
if (fi == NULL)
|
||||
error ("Invalid frame specified.");
|
||||
|
||||
fi = get_frame_info (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);
|
||||
func = get_frame_function (fi);
|
||||
s = find_pc_symtab(fi->pc);
|
||||
if (func)
|
||||
{
|
||||
|
|
@ -515,22 +537,21 @@ frame_info (addr_exp, from_tty)
|
|||
funlang = SYMBOL_LANGUAGE (msymbol);
|
||||
}
|
||||
}
|
||||
calling_frame = get_prev_frame (frame);
|
||||
calling_frame_info = get_prev_frame (fi);
|
||||
|
||||
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);
|
||||
print_address_numeric (fi->frame, 1, gdb_stdout);
|
||||
printf_filtered (":\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
printf_filtered ("Stack frame at ");
|
||||
print_address_numeric (FRAME_FP(frame), 1, gdb_stdout);
|
||||
print_address_numeric (fi->frame, 1, gdb_stdout);
|
||||
printf_filtered (":\n");
|
||||
}
|
||||
printf_filtered (" %s = ",
|
||||
reg_names[PC_REGNUM]);
|
||||
printf_filtered (" %s = ", reg_names[PC_REGNUM]);
|
||||
print_address_numeric (fi->pc, 1, gdb_stdout);
|
||||
|
||||
wrap_here (" ");
|
||||
|
|
@ -546,7 +567,7 @@ frame_info (addr_exp, from_tty)
|
|||
puts_filtered ("; ");
|
||||
wrap_here (" ");
|
||||
printf_filtered ("saved %s ", reg_names[PC_REGNUM]);
|
||||
print_address_numeric (FRAME_SAVED_PC (frame), 1, gdb_stdout);
|
||||
print_address_numeric (FRAME_SAVED_PC (fi), 1, gdb_stdout);
|
||||
printf_filtered ("\n");
|
||||
|
||||
{
|
||||
|
|
@ -558,12 +579,12 @@ frame_info (addr_exp, from_tty)
|
|||
printf_filtered (" (FRAMELESS),");
|
||||
}
|
||||
|
||||
if (calling_frame)
|
||||
if (calling_frame_info)
|
||||
{
|
||||
printf_filtered (" called by frame at ");
|
||||
print_address_numeric (FRAME_FP (calling_frame), 1, gdb_stdout);
|
||||
print_address_numeric (calling_frame_info->frame, 1, gdb_stdout);
|
||||
}
|
||||
if (fi->next && calling_frame)
|
||||
if (fi->next && calling_frame_info)
|
||||
puts_filtered (",");
|
||||
wrap_here (" ");
|
||||
if (fi->next)
|
||||
|
|
@ -571,7 +592,7 @@ frame_info (addr_exp, from_tty)
|
|||
printf_filtered (" caller of frame at ");
|
||||
print_address_numeric (fi->next->frame, 1, gdb_stdout);
|
||||
}
|
||||
if (fi->next || calling_frame)
|
||||
if (fi->next || calling_frame_info)
|
||||
puts_filtered ("\n");
|
||||
if (s)
|
||||
printf_filtered (" source language %s.\n", language_str (s->language));
|
||||
|
|
@ -629,7 +650,8 @@ frame_info (addr_exp, from_tty)
|
|||
print_address_numeric (fsr.regs[SP_REGNUM], 1, gdb_stdout);
|
||||
printf_filtered ("\n");
|
||||
count = 0;
|
||||
for (i = 0; i < NUM_REGS; i++)
|
||||
numregs = ARCH_NUM_REGS;
|
||||
for (i = 0; i < numregs; i++)
|
||||
if (fsr.regs[i] && i != SP_REGNUM)
|
||||
{
|
||||
if (count == 0)
|
||||
|
|
@ -644,6 +666,10 @@ frame_info (addr_exp, from_tty)
|
|||
if (count)
|
||||
puts_filtered ("\n");
|
||||
#else /* Have FRAME_FIND_SAVED_REGS. */
|
||||
/* We could get some information about saved registers by calling
|
||||
get_saved_register on each register. Which info goes with which frame
|
||||
is necessarily lost, however, and I suspect that the users don't care
|
||||
whether they get the info. */
|
||||
puts_filtered ("\n");
|
||||
#endif /* Have FRAME_FIND_SAVED_REGS. */
|
||||
}
|
||||
|
|
@ -688,9 +714,8 @@ backtrace_command (count_exp, from_tty)
|
|||
{
|
||||
struct frame_info *fi;
|
||||
register int count;
|
||||
register FRAME frame;
|
||||
register int i;
|
||||
register FRAME trailing;
|
||||
register struct frame_info *trailing;
|
||||
register int trailing_level;
|
||||
|
||||
if (!target_has_stack)
|
||||
|
|
@ -707,7 +732,7 @@ backtrace_command (count_exp, from_tty)
|
|||
count = parse_and_eval_address (count_exp);
|
||||
if (count < 0)
|
||||
{
|
||||
FRAME current;
|
||||
struct frame_info *current;
|
||||
|
||||
count = -count;
|
||||
|
||||
|
|
@ -744,24 +769,22 @@ backtrace_command (count_exp, from_tty)
|
|||
if people have strong opinions against reading symbols for
|
||||
backtrace this may have to be an option. */
|
||||
i = count;
|
||||
for (frame = trailing;
|
||||
frame != NULL && i--;
|
||||
frame = get_prev_frame (frame))
|
||||
for (fi = trailing;
|
||||
fi != NULL && i--;
|
||||
fi = get_prev_frame (fi))
|
||||
{
|
||||
QUIT;
|
||||
fi = get_frame_info (frame);
|
||||
ps = find_pc_psymtab (fi->pc);
|
||||
if (ps)
|
||||
PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in */
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0, frame = trailing;
|
||||
frame && count--;
|
||||
i++, frame = get_prev_frame (frame))
|
||||
for (i = 0, fi = trailing;
|
||||
fi && count--;
|
||||
i++, fi = get_prev_frame (fi))
|
||||
{
|
||||
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
|
||||
|
|
@ -771,7 +794,7 @@ backtrace_command (count_exp, from_tty)
|
|||
}
|
||||
|
||||
/* If we've stopped before the end, mention that. */
|
||||
if (frame && from_tty)
|
||||
if (fi && from_tty)
|
||||
printf_filtered ("(More stack frames follow...)\n");
|
||||
}
|
||||
|
||||
|
|
@ -779,9 +802,9 @@ backtrace_command (count_exp, from_tty)
|
|||
Return 1 if any variables were printed; 0 otherwise. */
|
||||
|
||||
static int
|
||||
print_block_frame_locals (b, frame, stream)
|
||||
print_block_frame_locals (b, fi, stream)
|
||||
struct block *b;
|
||||
register FRAME frame;
|
||||
register struct frame_info *fi;
|
||||
register GDB_FILE *stream;
|
||||
{
|
||||
int nsyms;
|
||||
|
|
@ -803,7 +826,7 @@ print_block_frame_locals (b, frame, stream)
|
|||
values_printed = 1;
|
||||
fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
|
||||
fputs_filtered (" = ", stream);
|
||||
print_variable_value (sym, frame, stream);
|
||||
print_variable_value (sym, fi, stream);
|
||||
fprintf_filtered (stream, "\n");
|
||||
break;
|
||||
|
||||
|
|
@ -866,11 +889,11 @@ print_block_frame_labels (b, have_default, stream)
|
|||
on the function running in FRAME. */
|
||||
|
||||
static void
|
||||
print_frame_local_vars (frame, stream)
|
||||
register FRAME frame;
|
||||
print_frame_local_vars (fi, stream)
|
||||
register struct frame_info *fi;
|
||||
register GDB_FILE *stream;
|
||||
{
|
||||
register struct block *block = get_frame_block (frame);
|
||||
register struct block *block = get_frame_block (fi);
|
||||
register int values_printed = 0;
|
||||
|
||||
if (block == 0)
|
||||
|
|
@ -881,7 +904,7 @@ print_frame_local_vars (frame, stream)
|
|||
|
||||
while (block != 0)
|
||||
{
|
||||
if (print_block_frame_locals (block, frame, stream))
|
||||
if (print_block_frame_locals (block, fi, stream))
|
||||
values_printed = 1;
|
||||
/* After handling the function's top-level block, stop.
|
||||
Don't continue to its superblock, the block of
|
||||
|
|
@ -900,17 +923,16 @@ print_frame_local_vars (frame, stream)
|
|||
/* Same, but print labels. */
|
||||
|
||||
static void
|
||||
print_frame_label_vars (frame, this_level_only, stream)
|
||||
register FRAME frame;
|
||||
print_frame_label_vars (fi, this_level_only, stream)
|
||||
register struct frame_info *fi;
|
||||
int this_level_only;
|
||||
register GDB_FILE *stream;
|
||||
{
|
||||
register struct blockvector *bl;
|
||||
register struct block *block = get_frame_block (frame);
|
||||
register struct block *block = get_frame_block (fi);
|
||||
register int values_printed = 0;
|
||||
int index, have_default = 0;
|
||||
char *blocks_printed;
|
||||
struct frame_info *fi = get_frame_info (frame);
|
||||
CORE_ADDR pc = fi->pc;
|
||||
|
||||
if (block == 0)
|
||||
|
|
@ -992,11 +1014,11 @@ catch_info (ignore, from_tty)
|
|||
}
|
||||
|
||||
static void
|
||||
print_frame_arg_vars (frame, stream)
|
||||
register FRAME frame;
|
||||
print_frame_arg_vars (fi, stream)
|
||||
register struct frame_info *fi;
|
||||
register GDB_FILE *stream;
|
||||
{
|
||||
struct symbol *func = get_frame_function (frame);
|
||||
struct symbol *func = get_frame_function (fi);
|
||||
register struct block *b;
|
||||
int nsyms;
|
||||
register int i;
|
||||
|
|
@ -1040,7 +1062,7 @@ print_frame_arg_vars (frame, stream)
|
|||
|
||||
sym2 = lookup_symbol (SYMBOL_NAME (sym),
|
||||
b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
|
||||
print_variable_value (sym2, frame, stream);
|
||||
print_variable_value (sym2, fi, stream);
|
||||
fprintf_filtered (stream, "\n");
|
||||
break;
|
||||
|
||||
|
|
@ -1066,24 +1088,24 @@ args_info (ignore, from_tty)
|
|||
print_frame_arg_vars (selected_frame, gdb_stdout);
|
||||
}
|
||||
|
||||
/* Select frame FRAME, and note that its stack level is LEVEL.
|
||||
/* Select frame FI, and note that its stack level is LEVEL.
|
||||
LEVEL may be -1 if an actual level number is not known. */
|
||||
|
||||
void
|
||||
select_frame (frame, level)
|
||||
FRAME frame;
|
||||
select_frame (fi, level)
|
||||
struct frame_info *fi;
|
||||
int level;
|
||||
{
|
||||
register struct symtab *s;
|
||||
|
||||
selected_frame = frame;
|
||||
selected_frame = fi;
|
||||
selected_frame_level = level;
|
||||
|
||||
/* Ensure that symbols for this frame are read in. Also, determine the
|
||||
source language of this frame, and switch to it if desired. */
|
||||
if (frame)
|
||||
if (fi)
|
||||
{
|
||||
s = find_pc_symtab (get_frame_info (frame)->pc);
|
||||
s = find_pc_symtab (fi->pc);
|
||||
if (s
|
||||
&& s->language != current_language->la_language
|
||||
&& s->language != language_unknown
|
||||
|
|
@ -1098,10 +1120,10 @@ select_frame (frame, level)
|
|||
|
||||
void
|
||||
record_selected_frame (frameaddrp, levelp)
|
||||
FRAME_ADDR *frameaddrp;
|
||||
CORE_ADDR *frameaddrp;
|
||||
int *levelp;
|
||||
{
|
||||
*frameaddrp = selected_frame ? FRAME_FP (selected_frame) : 0;
|
||||
*frameaddrp = selected_frame ? selected_frame->frame : 0;
|
||||
*levelp = selected_frame_level;
|
||||
}
|
||||
|
||||
|
|
@ -1128,13 +1150,13 @@ get_selected_block ()
|
|||
but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
|
||||
how much farther the original request asked to go. */
|
||||
|
||||
FRAME
|
||||
struct frame_info *
|
||||
find_relative_frame (frame, level_offset_ptr)
|
||||
register FRAME frame;
|
||||
register int* level_offset_ptr;
|
||||
register struct frame_info *frame;
|
||||
register int *level_offset_ptr;
|
||||
{
|
||||
register FRAME prev;
|
||||
register FRAME frame1;
|
||||
register struct frame_info *prev;
|
||||
register struct frame_info *frame1;
|
||||
|
||||
/* Going up is simple: just do get_prev_frame enough times
|
||||
or until initial frame is reached. */
|
||||
|
|
@ -1172,7 +1194,7 @@ select_frame_command (level_exp, from_tty)
|
|||
char *level_exp;
|
||||
int from_tty;
|
||||
{
|
||||
register FRAME frame, frame1;
|
||||
register struct frame_info *frame, *frame1;
|
||||
unsigned int level = 0;
|
||||
|
||||
if (!target_has_stack)
|
||||
|
|
@ -1218,7 +1240,7 @@ up_silently_command (count_exp, from_tty)
|
|||
char *count_exp;
|
||||
int from_tty;
|
||||
{
|
||||
register FRAME frame;
|
||||
register struct frame_info *fi;
|
||||
int count = 1, count1;
|
||||
if (count_exp)
|
||||
count = parse_and_eval_address (count_exp);
|
||||
|
|
@ -1227,10 +1249,10 @@ up_silently_command (count_exp, from_tty)
|
|||
if (target_has_stack == 0 || selected_frame == 0)
|
||||
error ("No stack.");
|
||||
|
||||
frame = find_relative_frame (selected_frame, &count1);
|
||||
fi = find_relative_frame (selected_frame, &count1);
|
||||
if (count1 != 0 && count_exp == 0)
|
||||
error ("Initial frame selected; you cannot go up.");
|
||||
select_frame (frame, selected_frame_level + count - count1);
|
||||
select_frame (fi, selected_frame_level + count - count1);
|
||||
}
|
||||
|
||||
static void
|
||||
|
|
@ -1251,7 +1273,7 @@ down_silently_command (count_exp, from_tty)
|
|||
char *count_exp;
|
||||
int from_tty;
|
||||
{
|
||||
register FRAME frame;
|
||||
register struct frame_info *frame;
|
||||
int count = -1, count1;
|
||||
if (count_exp)
|
||||
count = - parse_and_eval_address (count_exp);
|
||||
|
|
@ -1291,23 +1313,32 @@ return_command (retval_exp, from_tty)
|
|||
int from_tty;
|
||||
{
|
||||
struct symbol *thisfun;
|
||||
FRAME_ADDR selected_frame_addr;
|
||||
CORE_ADDR selected_frame_addr;
|
||||
CORE_ADDR selected_frame_pc;
|
||||
FRAME frame;
|
||||
struct frame_info *frame;
|
||||
value_ptr return_value = NULL;
|
||||
|
||||
if (selected_frame == NULL)
|
||||
error ("No selected frame.");
|
||||
thisfun = get_frame_function (selected_frame);
|
||||
selected_frame_addr = FRAME_FP (selected_frame);
|
||||
selected_frame_pc = (get_frame_info (selected_frame))->pc;
|
||||
selected_frame_pc = selected_frame->pc;
|
||||
|
||||
/* Compute the return value (if any -- possibly getting errors here). */
|
||||
|
||||
if (retval_exp)
|
||||
{
|
||||
struct type *return_type = NULL;
|
||||
|
||||
return_value = parse_and_eval (retval_exp);
|
||||
|
||||
/* Cast return value to the return type of the function. */
|
||||
if (thisfun != NULL)
|
||||
return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
|
||||
if (return_type == NULL)
|
||||
return_type = builtin_type_int;
|
||||
return_value = value_cast (return_type, 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))
|
||||
|
|
@ -1336,8 +1367,8 @@ return_command (retval_exp, from_tty)
|
|||
a POP_FRAME. The pc comparison makes this work even if the
|
||||
selected frame shares its fp with another frame. */
|
||||
|
||||
while ( selected_frame_addr != FRAME_FP (frame = get_current_frame())
|
||||
|| selected_frame_pc != (get_frame_info (frame))->pc )
|
||||
while (selected_frame_addr != (frame = get_current_frame())->frame
|
||||
|| selected_frame_pc != frame->pc)
|
||||
POP_FRAME;
|
||||
|
||||
/* Then pop that frame. */
|
||||
|
|
@ -1356,27 +1387,26 @@ return_command (retval_exp, from_tty)
|
|||
frame_command ("0", 1);
|
||||
}
|
||||
|
||||
/* Gets the language of the current frame. */
|
||||
/* Gets the language of the current frame. */
|
||||
|
||||
enum language
|
||||
get_frame_language()
|
||||
{
|
||||
register struct symtab *s;
|
||||
FRAME fr;
|
||||
enum language flang; /* The language of the current frame */
|
||||
register struct symtab *s;
|
||||
enum language flang; /* The language of the current frame */
|
||||
|
||||
fr = get_frame_info(selected_frame);
|
||||
if(fr)
|
||||
{
|
||||
s = find_pc_symtab(fr->pc);
|
||||
if(s)
|
||||
flang = s->language;
|
||||
if (selected_frame)
|
||||
{
|
||||
s = find_pc_symtab(selected_frame->pc);
|
||||
if (s)
|
||||
flang = s->language;
|
||||
else
|
||||
flang = language_unknown;
|
||||
}
|
||||
else
|
||||
flang = language_unknown;
|
||||
flang = language_unknown;
|
||||
}
|
||||
else
|
||||
flang = language_unknown;
|
||||
|
||||
return flang;
|
||||
return flang;
|
||||
}
|
||||
|
||||
void
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue