/* Print and select stack frames for GDB, the GNU debugger.
|
/* Print and select stack frames for GDB, the GNU debugger.
|
|
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
|
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008,
|
2009, 2010 Free Software Foundation, Inc.
|
2009, 2010 Free Software Foundation, Inc.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
This program is free software; you can redistribute it and/or modify
|
it under the terms of the GNU General Public License as published by
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "value.h"
|
#include "value.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "gdbtypes.h"
|
#include "gdbtypes.h"
|
#include "expression.h"
|
#include "expression.h"
|
#include "language.h"
|
#include "language.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "target.h"
|
#include "target.h"
|
#include "source.h"
|
#include "source.h"
|
#include "breakpoint.h"
|
#include "breakpoint.h"
|
#include "demangle.h"
|
#include "demangle.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "annotate.h"
|
#include "annotate.h"
|
#include "ui-out.h"
|
#include "ui-out.h"
|
#include "block.h"
|
#include "block.h"
|
#include "stack.h"
|
#include "stack.h"
|
#include "dictionary.h"
|
#include "dictionary.h"
|
#include "exceptions.h"
|
#include "exceptions.h"
|
#include "reggroups.h"
|
#include "reggroups.h"
|
#include "regcache.h"
|
#include "regcache.h"
|
#include "solib.h"
|
#include "solib.h"
|
#include "valprint.h"
|
#include "valprint.h"
|
#include "gdbthread.h"
|
#include "gdbthread.h"
|
#include "cp-support.h"
|
#include "cp-support.h"
|
#include "disasm.h"
|
#include "disasm.h"
|
#include "inline-frame.h"
|
#include "inline-frame.h"
|
|
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include <ctype.h>
|
#include <ctype.h>
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
|
|
void (*deprecated_selected_frame_level_changed_hook) (int);
|
void (*deprecated_selected_frame_level_changed_hook) (int);
|
|
|
/* The possible choices of "set print frame-arguments, and the value
|
/* The possible choices of "set print frame-arguments, and the value
|
of this setting. */
|
of this setting. */
|
|
|
static const char *print_frame_arguments_choices[] =
|
static const char *print_frame_arguments_choices[] =
|
{"all", "scalars", "none", NULL};
|
{"all", "scalars", "none", NULL};
|
static const char *print_frame_arguments = "scalars";
|
static const char *print_frame_arguments = "scalars";
|
|
|
/* Prototypes for local functions. */
|
/* Prototypes for local functions. */
|
|
|
static void print_frame_local_vars (struct frame_info *, int,
|
static void print_frame_local_vars (struct frame_info *, int,
|
struct ui_file *);
|
struct ui_file *);
|
|
|
static void print_frame (struct frame_info *frame, int print_level,
|
static void print_frame (struct frame_info *frame, int print_level,
|
enum print_what print_what, int print_args,
|
enum print_what print_what, int print_args,
|
struct symtab_and_line sal);
|
struct symtab_and_line sal);
|
|
|
/* Zero means do things normally; we are interacting directly with the
|
/* Zero means do things normally; we are interacting directly with the
|
user. One means print the full filename and linenumber when a
|
user. One means print the full filename and linenumber when a
|
frame is printed, and do so in a format emacs18/emacs19.22 can
|
frame is printed, and do so in a format emacs18/emacs19.22 can
|
parse. Two means print similar annotations, but in many more
|
parse. Two means print similar annotations, but in many more
|
cases and in a slightly different syntax. */
|
cases and in a slightly different syntax. */
|
|
|
int annotation_level = 0;
|
int annotation_level = 0;
|
|
|
|
|
struct print_stack_frame_args
|
struct print_stack_frame_args
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
int print_level;
|
int print_level;
|
enum print_what print_what;
|
enum print_what print_what;
|
int print_args;
|
int print_args;
|
};
|
};
|
|
|
/* Show or print the frame arguments; stub for catch_errors. */
|
/* Show or print the frame arguments; stub for catch_errors. */
|
|
|
static int
|
static int
|
print_stack_frame_stub (void *args)
|
print_stack_frame_stub (void *args)
|
{
|
{
|
struct print_stack_frame_args *p = args;
|
struct print_stack_frame_args *p = args;
|
int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
|
int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);
|
|
|
print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
|
print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);
|
set_current_sal_from_frame (p->frame, center);
|
set_current_sal_from_frame (p->frame, center);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Return 1 if we should display the address in addition to the location,
|
/* Return 1 if we should display the address in addition to the location,
|
because we are in the middle of a statement. */
|
because we are in the middle of a statement. */
|
|
|
static int
|
static int
|
frame_show_address (struct frame_info *frame,
|
frame_show_address (struct frame_info *frame,
|
struct symtab_and_line sal)
|
struct symtab_and_line sal)
|
{
|
{
|
/* If there is a line number, but no PC, then there is no location
|
/* If there is a line number, but no PC, then there is no location
|
information associated with this sal. The only way that should
|
information associated with this sal. The only way that should
|
happen is for the call sites of inlined functions (SAL comes from
|
happen is for the call sites of inlined functions (SAL comes from
|
find_frame_sal). Otherwise, we would have some PC range if the
|
find_frame_sal). Otherwise, we would have some PC range if the
|
SAL came from a line table. */
|
SAL came from a line table. */
|
if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
|
if (sal.line != 0 && sal.pc == 0 && sal.end == 0)
|
{
|
{
|
if (get_next_frame (frame) == NULL)
|
if (get_next_frame (frame) == NULL)
|
gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
|
gdb_assert (inline_skipped_frames (inferior_ptid) > 0);
|
else
|
else
|
gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
|
gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
return get_frame_pc (frame) != sal.pc;
|
return get_frame_pc (frame) != sal.pc;
|
}
|
}
|
|
|
/* Show or print a stack frame FRAME briefly. The output is format
|
/* Show or print a stack frame FRAME briefly. The output is format
|
according to PRINT_LEVEL and PRINT_WHAT printing the frame's
|
according to PRINT_LEVEL and PRINT_WHAT printing the frame's
|
relative level, function name, argument list, and file name and
|
relative level, function name, argument list, and file name and
|
line number. If the frame's PC is not at the beginning of the
|
line number. If the frame's PC is not at the beginning of the
|
source line, the actual PC is printed at the beginning. */
|
source line, the actual PC is printed at the beginning. */
|
|
|
void
|
void
|
print_stack_frame (struct frame_info *frame, int print_level,
|
print_stack_frame (struct frame_info *frame, int print_level,
|
enum print_what print_what)
|
enum print_what print_what)
|
{
|
{
|
struct print_stack_frame_args args;
|
struct print_stack_frame_args args;
|
|
|
args.frame = frame;
|
args.frame = frame;
|
args.print_level = print_level;
|
args.print_level = print_level;
|
args.print_what = print_what;
|
args.print_what = print_what;
|
/* For mi, alway print location and address. */
|
/* For mi, alway print location and address. */
|
args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
|
args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what;
|
args.print_args = 1;
|
args.print_args = 1;
|
|
|
catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
|
catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR);
|
}
|
}
|
|
|
struct print_args_args
|
struct print_args_args
|
{
|
{
|
struct symbol *func;
|
struct symbol *func;
|
struct frame_info *frame;
|
struct frame_info *frame;
|
struct ui_file *stream;
|
struct ui_file *stream;
|
};
|
};
|
|
|
static int print_args_stub (void *args);
|
static int print_args_stub (void *args);
|
|
|
/* Print nameless arguments of frame FRAME on STREAM, where START is
|
/* Print nameless arguments of frame FRAME on STREAM, where START is
|
the offset of the first nameless argument, and NUM is the number of
|
the offset of the first nameless argument, and NUM is the number of
|
nameless arguments to print. FIRST is nonzero if this is the first
|
nameless arguments to print. FIRST is nonzero if this is the first
|
argument (not just the first nameless argument). */
|
argument (not just the first nameless argument). */
|
|
|
static void
|
static void
|
print_frame_nameless_args (struct frame_info *frame, long start, int num,
|
print_frame_nameless_args (struct frame_info *frame, long start, int num,
|
int first, struct ui_file *stream)
|
int first, struct ui_file *stream)
|
{
|
{
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
int i;
|
int i;
|
CORE_ADDR argsaddr;
|
CORE_ADDR argsaddr;
|
long arg_value;
|
long arg_value;
|
|
|
for (i = 0; i < num; i++)
|
for (i = 0; i < num; i++)
|
{
|
{
|
QUIT;
|
QUIT;
|
argsaddr = get_frame_args_address (frame);
|
argsaddr = get_frame_args_address (frame);
|
if (!argsaddr)
|
if (!argsaddr)
|
return;
|
return;
|
arg_value = read_memory_integer (argsaddr + start,
|
arg_value = read_memory_integer (argsaddr + start,
|
sizeof (int), byte_order);
|
sizeof (int), byte_order);
|
if (!first)
|
if (!first)
|
fprintf_filtered (stream, ", ");
|
fprintf_filtered (stream, ", ");
|
fprintf_filtered (stream, "%ld", arg_value);
|
fprintf_filtered (stream, "%ld", arg_value);
|
first = 0;
|
first = 0;
|
start += sizeof (int);
|
start += sizeof (int);
|
}
|
}
|
}
|
}
|
|
|
/* Print the arguments of frame FRAME on STREAM, given the function
|
/* Print the arguments of frame FRAME on STREAM, given the function
|
FUNC running in that frame (as a symbol), where NUM is the number
|
FUNC running in that frame (as a symbol), where NUM is the number
|
of arguments according to the stack frame (or -1 if the number of
|
of arguments according to the stack frame (or -1 if the number of
|
arguments is unknown). */
|
arguments is unknown). */
|
|
|
/* Note that currently the "number of arguments according to the
|
/* Note that currently the "number of arguments according to the
|
stack frame" is only known on VAX where i refers to the "number of
|
stack frame" is only known on VAX where i refers to the "number of
|
ints of arguments according to the stack frame". */
|
ints of arguments according to the stack frame". */
|
|
|
static void
|
static void
|
print_frame_args (struct symbol *func, struct frame_info *frame,
|
print_frame_args (struct symbol *func, struct frame_info *frame,
|
int num, struct ui_file *stream)
|
int num, struct ui_file *stream)
|
{
|
{
|
int first = 1;
|
int first = 1;
|
/* Offset of next stack argument beyond the one we have seen that is
|
/* Offset of next stack argument beyond the one we have seen that is
|
at the highest offset, or -1 if we haven't come to a stack
|
at the highest offset, or -1 if we haven't come to a stack
|
argument yet. */
|
argument yet. */
|
long highest_offset = -1;
|
long highest_offset = -1;
|
/* Number of ints of arguments that we have printed so far. */
|
/* Number of ints of arguments that we have printed so far. */
|
int args_printed = 0;
|
int args_printed = 0;
|
struct cleanup *old_chain, *list_chain;
|
struct cleanup *old_chain, *list_chain;
|
struct ui_stream *stb;
|
struct ui_stream *stb;
|
/* True if we should print arguments, false otherwise. */
|
/* True if we should print arguments, false otherwise. */
|
int print_args = strcmp (print_frame_arguments, "none");
|
int print_args = strcmp (print_frame_arguments, "none");
|
/* True in "summary" mode, false otherwise. */
|
/* True in "summary" mode, false otherwise. */
|
int summary = !strcmp (print_frame_arguments, "scalars");
|
int summary = !strcmp (print_frame_arguments, "scalars");
|
|
|
stb = ui_out_stream_new (uiout);
|
stb = ui_out_stream_new (uiout);
|
old_chain = make_cleanup_ui_out_stream_delete (stb);
|
old_chain = make_cleanup_ui_out_stream_delete (stb);
|
|
|
if (func)
|
if (func)
|
{
|
{
|
struct block *b = SYMBOL_BLOCK_VALUE (func);
|
struct block *b = SYMBOL_BLOCK_VALUE (func);
|
struct dict_iterator iter;
|
struct dict_iterator iter;
|
struct symbol *sym;
|
struct symbol *sym;
|
struct value *val;
|
struct value *val;
|
|
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
{
|
{
|
QUIT;
|
QUIT;
|
|
|
/* Keep track of the highest stack argument offset seen, and
|
/* Keep track of the highest stack argument offset seen, and
|
skip over any kinds of symbols we don't care about. */
|
skip over any kinds of symbols we don't care about. */
|
|
|
if (!SYMBOL_IS_ARGUMENT (sym))
|
if (!SYMBOL_IS_ARGUMENT (sym))
|
continue;
|
continue;
|
|
|
switch (SYMBOL_CLASS (sym))
|
switch (SYMBOL_CLASS (sym))
|
{
|
{
|
case LOC_ARG:
|
case LOC_ARG:
|
case LOC_REF_ARG:
|
case LOC_REF_ARG:
|
{
|
{
|
long current_offset = SYMBOL_VALUE (sym);
|
long current_offset = SYMBOL_VALUE (sym);
|
int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
|
int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
|
|
|
/* Compute address of next argument by adding the size of
|
/* Compute address of next argument by adding the size of
|
this argument and rounding to an int boundary. */
|
this argument and rounding to an int boundary. */
|
current_offset =
|
current_offset =
|
((current_offset + arg_size + sizeof (int) - 1)
|
((current_offset + arg_size + sizeof (int) - 1)
|
& ~(sizeof (int) - 1));
|
& ~(sizeof (int) - 1));
|
|
|
/* If this is the highest offset seen yet, set
|
/* If this is the highest offset seen yet, set
|
highest_offset. */
|
highest_offset. */
|
if (highest_offset == -1
|
if (highest_offset == -1
|
|| (current_offset > highest_offset))
|
|| (current_offset > highest_offset))
|
highest_offset = current_offset;
|
highest_offset = current_offset;
|
|
|
/* Add the number of ints we're about to print to
|
/* Add the number of ints we're about to print to
|
args_printed. */
|
args_printed. */
|
args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
|
args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
|
}
|
}
|
|
|
/* We care about types of symbols, but don't need to
|
/* We care about types of symbols, but don't need to
|
keep track of stack offsets in them. */
|
keep track of stack offsets in them. */
|
case LOC_REGISTER:
|
case LOC_REGISTER:
|
case LOC_REGPARM_ADDR:
|
case LOC_REGPARM_ADDR:
|
case LOC_COMPUTED:
|
case LOC_COMPUTED:
|
case LOC_OPTIMIZED_OUT:
|
case LOC_OPTIMIZED_OUT:
|
default:
|
default:
|
break;
|
break;
|
}
|
}
|
|
|
/* We have to look up the symbol because arguments can have
|
/* We have to look up the symbol because arguments can have
|
two entries (one a parameter, one a local) and the one we
|
two entries (one a parameter, one a local) and the one we
|
want is the local, which lookup_symbol will find for us.
|
want is the local, which lookup_symbol will find for us.
|
This includes gcc1 (not gcc2) on SPARC when passing a
|
This includes gcc1 (not gcc2) on SPARC when passing a
|
small structure and gcc2 when the argument type is float
|
small structure and gcc2 when the argument type is float
|
and it is passed as a double and converted to float by
|
and it is passed as a double and converted to float by
|
the prologue (in the latter case the type of the LOC_ARG
|
the prologue (in the latter case the type of the LOC_ARG
|
symbol is double and the type of the LOC_LOCAL symbol is
|
symbol is double and the type of the LOC_LOCAL symbol is
|
float). */
|
float). */
|
/* But if the parameter name is null, don't try it. Null
|
/* But if the parameter name is null, don't try it. Null
|
parameter names occur on the RS/6000, for traceback
|
parameter names occur on the RS/6000, for traceback
|
tables. FIXME, should we even print them? */
|
tables. FIXME, should we even print them? */
|
|
|
if (*SYMBOL_LINKAGE_NAME (sym))
|
if (*SYMBOL_LINKAGE_NAME (sym))
|
{
|
{
|
struct symbol *nsym;
|
struct symbol *nsym;
|
nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
|
nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
|
b, VAR_DOMAIN, NULL);
|
b, VAR_DOMAIN, NULL);
|
gdb_assert (nsym != NULL);
|
gdb_assert (nsym != NULL);
|
if (SYMBOL_CLASS (nsym) == LOC_REGISTER
|
if (SYMBOL_CLASS (nsym) == LOC_REGISTER
|
&& !SYMBOL_IS_ARGUMENT (nsym))
|
&& !SYMBOL_IS_ARGUMENT (nsym))
|
{
|
{
|
/* There is a LOC_ARG/LOC_REGISTER pair. This means
|
/* There is a LOC_ARG/LOC_REGISTER pair. This means
|
that it was passed on the stack and loaded into a
|
that it was passed on the stack and loaded into a
|
register, or passed in a register and stored in a
|
register, or passed in a register and stored in a
|
stack slot. GDB 3.x used the LOC_ARG; GDB
|
stack slot. GDB 3.x used the LOC_ARG; GDB
|
4.0-4.11 used the LOC_REGISTER.
|
4.0-4.11 used the LOC_REGISTER.
|
|
|
Reasons for using the LOC_ARG:
|
Reasons for using the LOC_ARG:
|
|
|
(1) Because find_saved_registers may be slow for
|
(1) Because find_saved_registers may be slow for
|
remote debugging.
|
remote debugging.
|
|
|
(2) Because registers are often re-used and stack
|
(2) Because registers are often re-used and stack
|
slots rarely (never?) are. Therefore using
|
slots rarely (never?) are. Therefore using
|
the stack slot is much less likely to print
|
the stack slot is much less likely to print
|
garbage.
|
garbage.
|
|
|
Reasons why we might want to use the LOC_REGISTER:
|
Reasons why we might want to use the LOC_REGISTER:
|
|
|
(1) So that the backtrace prints the same value
|
(1) So that the backtrace prints the same value
|
as "print foo". I see no compelling reason
|
as "print foo". I see no compelling reason
|
why this needs to be the case; having the
|
why this needs to be the case; having the
|
backtrace print the value which was passed
|
backtrace print the value which was passed
|
in, and "print foo" print the value as
|
in, and "print foo" print the value as
|
modified within the called function, makes
|
modified within the called function, makes
|
perfect sense to me.
|
perfect sense to me.
|
|
|
Additional note: It might be nice if "info args"
|
Additional note: It might be nice if "info args"
|
displayed both values.
|
displayed both values.
|
|
|
One more note: There is a case with SPARC
|
One more note: There is a case with SPARC
|
structure passing where we need to use the
|
structure passing where we need to use the
|
LOC_REGISTER, but this is dealt with by creating
|
LOC_REGISTER, but this is dealt with by creating
|
a single LOC_REGPARM in symbol reading. */
|
a single LOC_REGPARM in symbol reading. */
|
|
|
/* Leave sym (the LOC_ARG) alone. */
|
/* Leave sym (the LOC_ARG) alone. */
|
;
|
;
|
}
|
}
|
else
|
else
|
sym = nsym;
|
sym = nsym;
|
}
|
}
|
|
|
/* Print the current arg. */
|
/* Print the current arg. */
|
if (!first)
|
if (!first)
|
ui_out_text (uiout, ", ");
|
ui_out_text (uiout, ", ");
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_wrap_hint (uiout, " ");
|
|
|
annotate_arg_begin ();
|
annotate_arg_begin ();
|
|
|
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
|
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
|
fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
|
fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),
|
SYMBOL_LANGUAGE (sym),
|
SYMBOL_LANGUAGE (sym),
|
DMGL_PARAMS | DMGL_ANSI);
|
DMGL_PARAMS | DMGL_ANSI);
|
ui_out_field_stream (uiout, "name", stb);
|
ui_out_field_stream (uiout, "name", stb);
|
annotate_arg_name_end ();
|
annotate_arg_name_end ();
|
ui_out_text (uiout, "=");
|
ui_out_text (uiout, "=");
|
|
|
if (print_args)
|
if (print_args)
|
{
|
{
|
/* Avoid value_print because it will deref ref parameters.
|
/* Avoid value_print because it will deref ref parameters.
|
We just want to print their addresses. Print ??? for
|
We just want to print their addresses. Print ??? for
|
args whose address we do not know. We pass 2 as
|
args whose address we do not know. We pass 2 as
|
"recurse" to val_print because our standard indentation
|
"recurse" to val_print because our standard indentation
|
here is 4 spaces, and val_print indents 2 for each
|
here is 4 spaces, and val_print indents 2 for each
|
recurse. */
|
recurse. */
|
val = read_var_value (sym, frame);
|
val = read_var_value (sym, frame);
|
|
|
annotate_arg_value (val == NULL ? NULL : value_type (val));
|
annotate_arg_value (val == NULL ? NULL : value_type (val));
|
|
|
if (val)
|
if (val)
|
{
|
{
|
const struct language_defn *language;
|
const struct language_defn *language;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
/* Use the appropriate language to display our symbol,
|
/* Use the appropriate language to display our symbol,
|
unless the user forced the language to a specific
|
unless the user forced the language to a specific
|
language. */
|
language. */
|
if (language_mode == language_mode_auto)
|
if (language_mode == language_mode_auto)
|
language = language_def (SYMBOL_LANGUAGE (sym));
|
language = language_def (SYMBOL_LANGUAGE (sym));
|
else
|
else
|
language = current_language;
|
language = current_language;
|
|
|
get_raw_print_options (&opts);
|
get_raw_print_options (&opts);
|
opts.deref_ref = 0;
|
opts.deref_ref = 0;
|
opts.summary = summary;
|
opts.summary = summary;
|
common_val_print (val, stb->stream, 2, &opts, language);
|
common_val_print (val, stb->stream, 2, &opts, language);
|
ui_out_field_stream (uiout, "value", stb);
|
ui_out_field_stream (uiout, "value", stb);
|
}
|
}
|
else
|
else
|
ui_out_text (uiout, "???");
|
ui_out_text (uiout, "???");
|
}
|
}
|
else
|
else
|
ui_out_text (uiout, "...");
|
ui_out_text (uiout, "...");
|
|
|
|
|
/* Invoke ui_out_tuple_end. */
|
/* Invoke ui_out_tuple_end. */
|
do_cleanups (list_chain);
|
do_cleanups (list_chain);
|
|
|
annotate_arg_end ();
|
annotate_arg_end ();
|
|
|
first = 0;
|
first = 0;
|
}
|
}
|
}
|
}
|
|
|
/* Don't print nameless args in situations where we don't know
|
/* Don't print nameless args in situations where we don't know
|
enough about the stack to find them. */
|
enough about the stack to find them. */
|
if (num != -1)
|
if (num != -1)
|
{
|
{
|
long start;
|
long start;
|
|
|
if (highest_offset == -1)
|
if (highest_offset == -1)
|
start = gdbarch_frame_args_skip (get_frame_arch (frame));
|
start = gdbarch_frame_args_skip (get_frame_arch (frame));
|
else
|
else
|
start = highest_offset;
|
start = highest_offset;
|
|
|
print_frame_nameless_args (frame, start, num - args_printed,
|
print_frame_nameless_args (frame, start, num - args_printed,
|
first, stream);
|
first, stream);
|
}
|
}
|
|
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
/* Stub for catch_errors. */
|
/* Stub for catch_errors. */
|
|
|
static int
|
static int
|
print_args_stub (void *args)
|
print_args_stub (void *args)
|
{
|
{
|
struct print_args_args *p = args;
|
struct print_args_args *p = args;
|
struct gdbarch *gdbarch = get_frame_arch (p->frame);
|
struct gdbarch *gdbarch = get_frame_arch (p->frame);
|
int numargs;
|
int numargs;
|
|
|
if (gdbarch_frame_num_args_p (gdbarch))
|
if (gdbarch_frame_num_args_p (gdbarch))
|
{
|
{
|
numargs = gdbarch_frame_num_args (gdbarch, p->frame);
|
numargs = gdbarch_frame_num_args (gdbarch, p->frame);
|
gdb_assert (numargs >= 0);
|
gdb_assert (numargs >= 0);
|
}
|
}
|
else
|
else
|
numargs = -1;
|
numargs = -1;
|
print_frame_args (p->func, p->frame, numargs, p->stream);
|
print_frame_args (p->func, p->frame, numargs, p->stream);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Set the current source and line to the location given by frame
|
/* Set the current source and line to the location given by frame
|
FRAME, if possible. When CENTER is true, adjust so the relevant
|
FRAME, if possible. When CENTER is true, adjust so the relevant
|
line is in the center of the next 'list'. */
|
line is in the center of the next 'list'. */
|
|
|
void
|
void
|
set_current_sal_from_frame (struct frame_info *frame, int center)
|
set_current_sal_from_frame (struct frame_info *frame, int center)
|
{
|
{
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
|
|
find_frame_sal (frame, &sal);
|
find_frame_sal (frame, &sal);
|
if (sal.symtab)
|
if (sal.symtab)
|
{
|
{
|
if (center)
|
if (center)
|
sal.line = max (sal.line - get_lines_to_list () / 2, 1);
|
sal.line = max (sal.line - get_lines_to_list () / 2, 1);
|
set_current_source_symtab_and_line (&sal);
|
set_current_source_symtab_and_line (&sal);
|
}
|
}
|
}
|
}
|
|
|
/* If ON, GDB will display disassembly of the next source line when
|
/* If ON, GDB will display disassembly of the next source line when
|
execution of the program being debugged stops.
|
execution of the program being debugged stops.
|
If AUTO (which is the default), or there's no line info to determine
|
If AUTO (which is the default), or there's no line info to determine
|
the source line of the next instruction, display disassembly of next
|
the source line of the next instruction, display disassembly of next
|
instruction instead. */
|
instruction instead. */
|
|
|
static enum auto_boolean disassemble_next_line;
|
static enum auto_boolean disassemble_next_line;
|
|
|
static void
|
static void
|
show_disassemble_next_line (struct ui_file *file, int from_tty,
|
show_disassemble_next_line (struct ui_file *file, int from_tty,
|
struct cmd_list_element *c,
|
struct cmd_list_element *c,
|
const char *value)
|
const char *value)
|
{
|
{
|
fprintf_filtered (file, _("\
|
fprintf_filtered (file, _("\
|
Debugger's willingness to use disassemble-next-line is %s.\n"),
|
Debugger's willingness to use disassemble-next-line is %s.\n"),
|
value);
|
value);
|
}
|
}
|
|
|
/* Show assembly codes; stub for catch_errors. */
|
/* Show assembly codes; stub for catch_errors. */
|
|
|
struct gdb_disassembly_stub_args
|
struct gdb_disassembly_stub_args
|
{
|
{
|
struct gdbarch *gdbarch;
|
struct gdbarch *gdbarch;
|
int how_many;
|
int how_many;
|
CORE_ADDR low;
|
CORE_ADDR low;
|
CORE_ADDR high;
|
CORE_ADDR high;
|
};
|
};
|
|
|
static void
|
static void
|
gdb_disassembly_stub (void *args)
|
gdb_disassembly_stub (void *args)
|
{
|
{
|
struct gdb_disassembly_stub_args *p = args;
|
struct gdb_disassembly_stub_args *p = args;
|
gdb_disassembly (p->gdbarch, uiout, 0,
|
gdb_disassembly (p->gdbarch, uiout, 0,
|
DISASSEMBLY_RAW_INSN, p->how_many,
|
DISASSEMBLY_RAW_INSN, p->how_many,
|
p->low, p->high);
|
p->low, p->high);
|
}
|
}
|
|
|
/* Use TRY_CATCH to catch the exception from the gdb_disassembly
|
/* Use TRY_CATCH to catch the exception from the gdb_disassembly
|
because it will be broken by filter sometime. */
|
because it will be broken by filter sometime. */
|
|
|
static void
|
static void
|
do_gdb_disassembly (struct gdbarch *gdbarch,
|
do_gdb_disassembly (struct gdbarch *gdbarch,
|
int how_many, CORE_ADDR low, CORE_ADDR high)
|
int how_many, CORE_ADDR low, CORE_ADDR high)
|
{
|
{
|
volatile struct gdb_exception exception;
|
volatile struct gdb_exception exception;
|
struct gdb_disassembly_stub_args args;
|
struct gdb_disassembly_stub_args args;
|
|
|
args.gdbarch = gdbarch;
|
args.gdbarch = gdbarch;
|
args.how_many = how_many;
|
args.how_many = how_many;
|
args.low = low;
|
args.low = low;
|
args.high = high;
|
args.high = high;
|
TRY_CATCH (exception, RETURN_MASK_ALL)
|
TRY_CATCH (exception, RETURN_MASK_ALL)
|
{
|
{
|
gdb_disassembly_stub (&args);
|
gdb_disassembly_stub (&args);
|
}
|
}
|
/* If an exception was thrown while doing the disassembly, print
|
/* If an exception was thrown while doing the disassembly, print
|
the error message, to give the user a clue of what happened. */
|
the error message, to give the user a clue of what happened. */
|
if (exception.reason == RETURN_ERROR)
|
if (exception.reason == RETURN_ERROR)
|
exception_print (gdb_stderr, exception);
|
exception_print (gdb_stderr, exception);
|
}
|
}
|
|
|
/* Print information about frame FRAME. The output is format according
|
/* Print information about frame FRAME. The output is format according
|
to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
|
to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of
|
PRINT_WHAT is:
|
PRINT_WHAT is:
|
|
|
SRC_LINE: Print only source line.
|
SRC_LINE: Print only source line.
|
LOCATION: Print only location.
|
LOCATION: Print only location.
|
LOC_AND_SRC: Print location and source line.
|
LOC_AND_SRC: Print location and source line.
|
|
|
Used in "where" output, and to emit breakpoint or step
|
Used in "where" output, and to emit breakpoint or step
|
messages. */
|
messages. */
|
|
|
void
|
void
|
print_frame_info (struct frame_info *frame, int print_level,
|
print_frame_info (struct frame_info *frame, int print_level,
|
enum print_what print_what, int print_args)
|
enum print_what print_what, int print_args)
|
{
|
{
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
int source_print;
|
int source_print;
|
int location_print;
|
int location_print;
|
|
|
if (get_frame_type (frame) == DUMMY_FRAME
|
if (get_frame_type (frame) == DUMMY_FRAME
|
|| get_frame_type (frame) == SIGTRAMP_FRAME
|
|| get_frame_type (frame) == SIGTRAMP_FRAME
|
|| get_frame_type (frame) == ARCH_FRAME)
|
|| get_frame_type (frame) == ARCH_FRAME)
|
{
|
{
|
struct cleanup *uiout_cleanup
|
struct cleanup *uiout_cleanup
|
= make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
|
= make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
|
|
|
annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
|
annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
|
gdbarch, get_frame_pc (frame));
|
gdbarch, get_frame_pc (frame));
|
|
|
/* Do this regardless of SOURCE because we don't have any source
|
/* Do this regardless of SOURCE because we don't have any source
|
to list for this frame. */
|
to list for this frame. */
|
if (print_level)
|
if (print_level)
|
{
|
{
|
ui_out_text (uiout, "#");
|
ui_out_text (uiout, "#");
|
ui_out_field_fmt_int (uiout, 2, ui_left, "level",
|
ui_out_field_fmt_int (uiout, 2, ui_left, "level",
|
frame_relative_level (frame));
|
frame_relative_level (frame));
|
}
|
}
|
if (ui_out_is_mi_like_p (uiout))
|
if (ui_out_is_mi_like_p (uiout))
|
{
|
{
|
annotate_frame_address ();
|
annotate_frame_address ();
|
ui_out_field_core_addr (uiout, "addr",
|
ui_out_field_core_addr (uiout, "addr",
|
gdbarch, get_frame_pc (frame));
|
gdbarch, get_frame_pc (frame));
|
annotate_frame_address_end ();
|
annotate_frame_address_end ();
|
}
|
}
|
|
|
if (get_frame_type (frame) == DUMMY_FRAME)
|
if (get_frame_type (frame) == DUMMY_FRAME)
|
{
|
{
|
annotate_function_call ();
|
annotate_function_call ();
|
ui_out_field_string (uiout, "func", "<function called from gdb>");
|
ui_out_field_string (uiout, "func", "<function called from gdb>");
|
}
|
}
|
else if (get_frame_type (frame) == SIGTRAMP_FRAME)
|
else if (get_frame_type (frame) == SIGTRAMP_FRAME)
|
{
|
{
|
annotate_signal_handler_caller ();
|
annotate_signal_handler_caller ();
|
ui_out_field_string (uiout, "func", "<signal handler called>");
|
ui_out_field_string (uiout, "func", "<signal handler called>");
|
}
|
}
|
else if (get_frame_type (frame) == ARCH_FRAME)
|
else if (get_frame_type (frame) == ARCH_FRAME)
|
{
|
{
|
ui_out_field_string (uiout, "func", "<cross-architecture call>");
|
ui_out_field_string (uiout, "func", "<cross-architecture call>");
|
}
|
}
|
ui_out_text (uiout, "\n");
|
ui_out_text (uiout, "\n");
|
annotate_frame_end ();
|
annotate_frame_end ();
|
|
|
do_cleanups (uiout_cleanup);
|
do_cleanups (uiout_cleanup);
|
return;
|
return;
|
}
|
}
|
|
|
/* If FRAME is not the innermost frame, that normally means that
|
/* If FRAME is not the innermost frame, that normally means that
|
FRAME->pc points to *after* the call instruction, and we want to
|
FRAME->pc points to *after* the call instruction, and we want to
|
get the line containing the call, never the next line. But if
|
get the line containing the call, never the next line. But if
|
the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
|
the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the
|
next frame was not entered as the result of a call, and we want
|
next frame was not entered as the result of a call, and we want
|
to get the line containing FRAME->pc. */
|
to get the line containing FRAME->pc. */
|
find_frame_sal (frame, &sal);
|
find_frame_sal (frame, &sal);
|
|
|
location_print = (print_what == LOCATION
|
location_print = (print_what == LOCATION
|
|| print_what == LOC_AND_ADDRESS
|
|| print_what == LOC_AND_ADDRESS
|
|| print_what == SRC_AND_LOC);
|
|| print_what == SRC_AND_LOC);
|
|
|
if (location_print || !sal.symtab)
|
if (location_print || !sal.symtab)
|
print_frame (frame, print_level, print_what, print_args, sal);
|
print_frame (frame, print_level, print_what, print_args, sal);
|
|
|
source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
|
source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);
|
|
|
/* If disassemble-next-line is set to auto or on and doesn't have
|
/* If disassemble-next-line is set to auto or on and doesn't have
|
the line debug messages for $pc, output the next instruction. */
|
the line debug messages for $pc, output the next instruction. */
|
if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
|
if ((disassemble_next_line == AUTO_BOOLEAN_AUTO
|
|| disassemble_next_line == AUTO_BOOLEAN_TRUE)
|
|| disassemble_next_line == AUTO_BOOLEAN_TRUE)
|
&& source_print && !sal.symtab)
|
&& source_print && !sal.symtab)
|
do_gdb_disassembly (get_frame_arch (frame), 1,
|
do_gdb_disassembly (get_frame_arch (frame), 1,
|
get_frame_pc (frame), get_frame_pc (frame) + 1);
|
get_frame_pc (frame), get_frame_pc (frame) + 1);
|
|
|
if (source_print && sal.symtab)
|
if (source_print && sal.symtab)
|
{
|
{
|
int done = 0;
|
int done = 0;
|
int mid_statement = ((print_what == SRC_LINE)
|
int mid_statement = ((print_what == SRC_LINE)
|
&& frame_show_address (frame, sal));
|
&& frame_show_address (frame, sal));
|
|
|
if (annotation_level)
|
if (annotation_level)
|
done = identify_source_line (sal.symtab, sal.line, mid_statement,
|
done = identify_source_line (sal.symtab, sal.line, mid_statement,
|
get_frame_pc (frame));
|
get_frame_pc (frame));
|
if (!done)
|
if (!done)
|
{
|
{
|
if (deprecated_print_frame_info_listing_hook)
|
if (deprecated_print_frame_info_listing_hook)
|
deprecated_print_frame_info_listing_hook (sal.symtab,
|
deprecated_print_frame_info_listing_hook (sal.symtab,
|
sal.line,
|
sal.line,
|
sal.line + 1, 0);
|
sal.line + 1, 0);
|
else
|
else
|
{
|
{
|
struct value_print_options opts;
|
struct value_print_options opts;
|
get_user_print_options (&opts);
|
get_user_print_options (&opts);
|
/* We used to do this earlier, but that is clearly
|
/* We used to do this earlier, but that is clearly
|
wrong. This function is used by many different
|
wrong. This function is used by many different
|
parts of gdb, including normal_stop in infrun.c,
|
parts of gdb, including normal_stop in infrun.c,
|
which uses this to print out the current PC
|
which uses this to print out the current PC
|
when we stepi/nexti into the middle of a source
|
when we stepi/nexti into the middle of a source
|
line. Only the command line really wants this
|
line. Only the command line really wants this
|
behavior. Other UIs probably would like the
|
behavior. Other UIs probably would like the
|
ability to decide for themselves if it is desired. */
|
ability to decide for themselves if it is desired. */
|
if (opts.addressprint && mid_statement)
|
if (opts.addressprint && mid_statement)
|
{
|
{
|
ui_out_field_core_addr (uiout, "addr",
|
ui_out_field_core_addr (uiout, "addr",
|
gdbarch, get_frame_pc (frame));
|
gdbarch, get_frame_pc (frame));
|
ui_out_text (uiout, "\t");
|
ui_out_text (uiout, "\t");
|
}
|
}
|
|
|
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
|
print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
|
}
|
}
|
}
|
}
|
|
|
/* If disassemble-next-line is set to on and there is line debug
|
/* If disassemble-next-line is set to on and there is line debug
|
messages, output assembly codes for next line. */
|
messages, output assembly codes for next line. */
|
if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
|
if (disassemble_next_line == AUTO_BOOLEAN_TRUE)
|
do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
|
do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end);
|
}
|
}
|
|
|
if (print_what != LOCATION)
|
if (print_what != LOCATION)
|
set_default_breakpoint (1, sal.pspace,
|
set_default_breakpoint (1, sal.pspace,
|
get_frame_pc (frame), sal.symtab, sal.line);
|
get_frame_pc (frame), sal.symtab, sal.line);
|
|
|
annotate_frame_end ();
|
annotate_frame_end ();
|
|
|
gdb_flush (gdb_stdout);
|
gdb_flush (gdb_stdout);
|
}
|
}
|
|
|
/* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
|
/* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding
|
to FRAME. */
|
to FRAME. */
|
void
|
void
|
find_frame_funname (struct frame_info *frame, char **funname,
|
find_frame_funname (struct frame_info *frame, char **funname,
|
enum language *funlang)
|
enum language *funlang)
|
{
|
{
|
struct symbol *func;
|
struct symbol *func;
|
|
|
*funname = NULL;
|
*funname = NULL;
|
*funlang = language_unknown;
|
*funlang = language_unknown;
|
|
|
func = get_frame_function (frame);
|
func = get_frame_function (frame);
|
if (func)
|
if (func)
|
{
|
{
|
/* In certain pathological cases, the symtabs give the wrong
|
/* In certain pathological cases, the symtabs give the wrong
|
function (when we are in the first function in a file which
|
function (when we are in the first function in a file which
|
is compiled without debugging symbols, the previous function
|
is compiled without debugging symbols, the previous function
|
is compiled with debugging symbols, and the "foo.o" symbol
|
is compiled with debugging symbols, and the "foo.o" symbol
|
that is supposed to tell us where the file with debugging
|
that is supposed to tell us where the file with debugging
|
symbols ends has been truncated by ar because it is longer
|
symbols ends has been truncated by ar because it is longer
|
than 15 characters). This also occurs if the user uses asm()
|
than 15 characters). This also occurs if the user uses asm()
|
to create a function but not stabs for it (in a file compiled
|
to create a function but not stabs for it (in a file compiled
|
with -g).
|
with -g).
|
|
|
So look in the minimal symbol tables as well, and if it comes
|
So look in the minimal symbol tables as well, and if it comes
|
up with a larger address for the function use that instead.
|
up with a larger address for the function use that instead.
|
I don't think this can ever cause any problems; there
|
I don't think this can ever cause any problems; there
|
shouldn't be any minimal symbols in the middle of a function;
|
shouldn't be any minimal symbols in the middle of a function;
|
if this is ever changed many parts of GDB will need to be
|
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
|
changed (and we'll create a find_pc_minimal_function or some
|
such). */
|
such). */
|
|
|
struct minimal_symbol *msymbol = NULL;
|
struct minimal_symbol *msymbol = NULL;
|
|
|
/* Don't attempt to do this for inlined functions, which do not
|
/* Don't attempt to do this for inlined functions, which do not
|
have a corresponding minimal symbol. */
|
have a corresponding minimal symbol. */
|
if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
|
if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func)))
|
msymbol
|
msymbol
|
= lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
|
= lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
|
|
|
if (msymbol != NULL
|
if (msymbol != NULL
|
&& (SYMBOL_VALUE_ADDRESS (msymbol)
|
&& (SYMBOL_VALUE_ADDRESS (msymbol)
|
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
|
> BLOCK_START (SYMBOL_BLOCK_VALUE (func))))
|
{
|
{
|
/* We also don't know anything about the function besides
|
/* We also don't know anything about the function besides
|
its address and name. */
|
its address and name. */
|
func = 0;
|
func = 0;
|
*funname = SYMBOL_PRINT_NAME (msymbol);
|
*funname = SYMBOL_PRINT_NAME (msymbol);
|
*funlang = SYMBOL_LANGUAGE (msymbol);
|
*funlang = SYMBOL_LANGUAGE (msymbol);
|
}
|
}
|
else
|
else
|
{
|
{
|
*funname = SYMBOL_PRINT_NAME (func);
|
*funname = SYMBOL_PRINT_NAME (func);
|
*funlang = SYMBOL_LANGUAGE (func);
|
*funlang = SYMBOL_LANGUAGE (func);
|
if (*funlang == language_cplus)
|
if (*funlang == language_cplus)
|
{
|
{
|
/* It seems appropriate to use SYMBOL_PRINT_NAME() here,
|
/* It seems appropriate to use SYMBOL_PRINT_NAME() here,
|
to display the demangled name that we already have
|
to display the demangled name that we already have
|
stored in the symbol table, but we stored a version
|
stored in the symbol table, but we stored a version
|
with DMGL_PARAMS turned on, and here we don't want to
|
with DMGL_PARAMS turned on, and here we don't want to
|
display parameters. So remove the parameters. */
|
display parameters. So remove the parameters. */
|
char *func_only = cp_remove_params (*funname);
|
char *func_only = cp_remove_params (*funname);
|
if (func_only)
|
if (func_only)
|
{
|
{
|
*funname = func_only;
|
*funname = func_only;
|
make_cleanup (xfree, func_only);
|
make_cleanup (xfree, func_only);
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
struct minimal_symbol *msymbol =
|
struct minimal_symbol *msymbol =
|
lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
|
lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));
|
|
|
if (msymbol != NULL)
|
if (msymbol != NULL)
|
{
|
{
|
*funname = SYMBOL_PRINT_NAME (msymbol);
|
*funname = SYMBOL_PRINT_NAME (msymbol);
|
*funlang = SYMBOL_LANGUAGE (msymbol);
|
*funlang = SYMBOL_LANGUAGE (msymbol);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
static void
|
static void
|
print_frame (struct frame_info *frame, int print_level,
|
print_frame (struct frame_info *frame, int print_level,
|
enum print_what print_what, int print_args,
|
enum print_what print_what, int print_args,
|
struct symtab_and_line sal)
|
struct symtab_and_line sal)
|
{
|
{
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
char *funname = NULL;
|
char *funname = NULL;
|
enum language funlang = language_unknown;
|
enum language funlang = language_unknown;
|
struct ui_stream *stb;
|
struct ui_stream *stb;
|
struct cleanup *old_chain, *list_chain;
|
struct cleanup *old_chain, *list_chain;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
|
|
stb = ui_out_stream_new (uiout);
|
stb = ui_out_stream_new (uiout);
|
old_chain = make_cleanup_ui_out_stream_delete (stb);
|
old_chain = make_cleanup_ui_out_stream_delete (stb);
|
|
|
find_frame_funname (frame, &funname, &funlang);
|
find_frame_funname (frame, &funname, &funlang);
|
|
|
annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
|
annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,
|
gdbarch, get_frame_pc (frame));
|
gdbarch, get_frame_pc (frame));
|
|
|
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
|
list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");
|
|
|
if (print_level)
|
if (print_level)
|
{
|
{
|
ui_out_text (uiout, "#");
|
ui_out_text (uiout, "#");
|
ui_out_field_fmt_int (uiout, 2, ui_left, "level",
|
ui_out_field_fmt_int (uiout, 2, ui_left, "level",
|
frame_relative_level (frame));
|
frame_relative_level (frame));
|
}
|
}
|
get_user_print_options (&opts);
|
get_user_print_options (&opts);
|
if (opts.addressprint)
|
if (opts.addressprint)
|
if (frame_show_address (frame, sal) || !sal.symtab
|
if (frame_show_address (frame, sal) || !sal.symtab
|
|| print_what == LOC_AND_ADDRESS)
|
|| print_what == LOC_AND_ADDRESS)
|
{
|
{
|
annotate_frame_address ();
|
annotate_frame_address ();
|
ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame));
|
ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame));
|
annotate_frame_address_end ();
|
annotate_frame_address_end ();
|
ui_out_text (uiout, " in ");
|
ui_out_text (uiout, " in ");
|
}
|
}
|
annotate_frame_function_name ();
|
annotate_frame_function_name ();
|
fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
|
fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
|
funlang, DMGL_ANSI);
|
funlang, DMGL_ANSI);
|
ui_out_field_stream (uiout, "func", stb);
|
ui_out_field_stream (uiout, "func", stb);
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_wrap_hint (uiout, " ");
|
annotate_frame_args ();
|
annotate_frame_args ();
|
|
|
ui_out_text (uiout, " (");
|
ui_out_text (uiout, " (");
|
if (print_args)
|
if (print_args)
|
{
|
{
|
struct print_args_args args;
|
struct print_args_args args;
|
struct cleanup *args_list_chain;
|
struct cleanup *args_list_chain;
|
args.frame = frame;
|
args.frame = frame;
|
args.func = find_pc_function (get_frame_address_in_block (frame));
|
args.func = find_pc_function (get_frame_address_in_block (frame));
|
args.stream = gdb_stdout;
|
args.stream = gdb_stdout;
|
args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
|
args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args");
|
catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
|
catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR);
|
/* FIXME: ARGS must be a list. If one argument is a string it
|
/* FIXME: ARGS must be a list. If one argument is a string it
|
will have " that will not be properly escaped. */
|
will have " that will not be properly escaped. */
|
/* Invoke ui_out_tuple_end. */
|
/* Invoke ui_out_tuple_end. */
|
do_cleanups (args_list_chain);
|
do_cleanups (args_list_chain);
|
QUIT;
|
QUIT;
|
}
|
}
|
ui_out_text (uiout, ")");
|
ui_out_text (uiout, ")");
|
if (sal.symtab && sal.symtab->filename)
|
if (sal.symtab && sal.symtab->filename)
|
{
|
{
|
annotate_frame_source_begin ();
|
annotate_frame_source_begin ();
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_text (uiout, " at ");
|
ui_out_text (uiout, " at ");
|
annotate_frame_source_file ();
|
annotate_frame_source_file ();
|
ui_out_field_string (uiout, "file", sal.symtab->filename);
|
ui_out_field_string (uiout, "file", sal.symtab->filename);
|
if (ui_out_is_mi_like_p (uiout))
|
if (ui_out_is_mi_like_p (uiout))
|
{
|
{
|
const char *fullname = symtab_to_fullname (sal.symtab);
|
const char *fullname = symtab_to_fullname (sal.symtab);
|
if (fullname != NULL)
|
if (fullname != NULL)
|
ui_out_field_string (uiout, "fullname", fullname);
|
ui_out_field_string (uiout, "fullname", fullname);
|
}
|
}
|
annotate_frame_source_file_end ();
|
annotate_frame_source_file_end ();
|
ui_out_text (uiout, ":");
|
ui_out_text (uiout, ":");
|
annotate_frame_source_line ();
|
annotate_frame_source_line ();
|
ui_out_field_int (uiout, "line", sal.line);
|
ui_out_field_int (uiout, "line", sal.line);
|
annotate_frame_source_end ();
|
annotate_frame_source_end ();
|
}
|
}
|
|
|
if (!funname || (!sal.symtab || !sal.symtab->filename))
|
if (!funname || (!sal.symtab || !sal.symtab->filename))
|
{
|
{
|
#ifdef PC_SOLIB
|
#ifdef PC_SOLIB
|
char *lib = PC_SOLIB (get_frame_pc (frame));
|
char *lib = PC_SOLIB (get_frame_pc (frame));
|
#else
|
#else
|
char *lib = solib_name_from_address (get_frame_program_space (frame),
|
char *lib = solib_name_from_address (get_frame_program_space (frame),
|
get_frame_pc (frame));
|
get_frame_pc (frame));
|
#endif
|
#endif
|
if (lib)
|
if (lib)
|
{
|
{
|
annotate_frame_where ();
|
annotate_frame_where ();
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_wrap_hint (uiout, " ");
|
ui_out_text (uiout, " from ");
|
ui_out_text (uiout, " from ");
|
ui_out_field_string (uiout, "from", lib);
|
ui_out_field_string (uiout, "from", lib);
|
}
|
}
|
}
|
}
|
|
|
/* do_cleanups will call ui_out_tuple_end() for us. */
|
/* do_cleanups will call ui_out_tuple_end() for us. */
|
do_cleanups (list_chain);
|
do_cleanups (list_chain);
|
ui_out_text (uiout, "\n");
|
ui_out_text (uiout, "\n");
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
|
|
/* Read a frame specification in whatever the appropriate format is
|
/* Read a frame specification in whatever the appropriate format is
|
from FRAME_EXP. Call error(), printing MESSAGE, if the
|
from FRAME_EXP. Call error(), printing MESSAGE, if the
|
specification is in any way invalid (so this function never returns
|
specification is in any way invalid (so this function never returns
|
NULL). When SEPECTED_P is non-NULL set its target to indicate that
|
NULL). When SEPECTED_P is non-NULL set its target to indicate that
|
the default selected frame was used. */
|
the default selected frame was used. */
|
|
|
static struct frame_info *
|
static struct frame_info *
|
parse_frame_specification_1 (const char *frame_exp, const char *message,
|
parse_frame_specification_1 (const char *frame_exp, const char *message,
|
int *selected_frame_p)
|
int *selected_frame_p)
|
{
|
{
|
int numargs;
|
int numargs;
|
struct value *args[4];
|
struct value *args[4];
|
CORE_ADDR addrs[ARRAY_SIZE (args)];
|
CORE_ADDR addrs[ARRAY_SIZE (args)];
|
|
|
if (frame_exp == NULL)
|
if (frame_exp == NULL)
|
numargs = 0;
|
numargs = 0;
|
else
|
else
|
{
|
{
|
char *addr_string;
|
char *addr_string;
|
struct cleanup *tmp_cleanup;
|
struct cleanup *tmp_cleanup;
|
|
|
numargs = 0;
|
numargs = 0;
|
while (1)
|
while (1)
|
{
|
{
|
char *addr_string;
|
char *addr_string;
|
struct cleanup *cleanup;
|
struct cleanup *cleanup;
|
const char *p;
|
const char *p;
|
|
|
/* Skip leading white space, bail of EOL. */
|
/* Skip leading white space, bail of EOL. */
|
while (isspace (*frame_exp))
|
while (isspace (*frame_exp))
|
frame_exp++;
|
frame_exp++;
|
if (!*frame_exp)
|
if (!*frame_exp)
|
break;
|
break;
|
|
|
/* Parse the argument, extract it, save it. */
|
/* Parse the argument, extract it, save it. */
|
for (p = frame_exp;
|
for (p = frame_exp;
|
*p && !isspace (*p);
|
*p && !isspace (*p);
|
p++);
|
p++);
|
addr_string = savestring (frame_exp, p - frame_exp);
|
addr_string = savestring (frame_exp, p - frame_exp);
|
frame_exp = p;
|
frame_exp = p;
|
cleanup = make_cleanup (xfree, addr_string);
|
cleanup = make_cleanup (xfree, addr_string);
|
|
|
/* NOTE: Parse and evaluate expression, but do not use
|
/* NOTE: Parse and evaluate expression, but do not use
|
functions such as parse_and_eval_long or
|
functions such as parse_and_eval_long or
|
parse_and_eval_address to also extract the value.
|
parse_and_eval_address to also extract the value.
|
Instead value_as_long and value_as_address are used.
|
Instead value_as_long and value_as_address are used.
|
This avoids problems with expressions that contain
|
This avoids problems with expressions that contain
|
side-effects. */
|
side-effects. */
|
if (numargs >= ARRAY_SIZE (args))
|
if (numargs >= ARRAY_SIZE (args))
|
error (_("Too many args in frame specification"));
|
error (_("Too many args in frame specification"));
|
args[numargs++] = parse_and_eval (addr_string);
|
args[numargs++] = parse_and_eval (addr_string);
|
|
|
do_cleanups (cleanup);
|
do_cleanups (cleanup);
|
}
|
}
|
}
|
}
|
|
|
/* If no args, default to the selected frame. */
|
/* If no args, default to the selected frame. */
|
if (numargs == 0)
|
if (numargs == 0)
|
{
|
{
|
if (selected_frame_p != NULL)
|
if (selected_frame_p != NULL)
|
(*selected_frame_p) = 1;
|
(*selected_frame_p) = 1;
|
return get_selected_frame (message);
|
return get_selected_frame (message);
|
}
|
}
|
|
|
/* None of the remaining use the selected frame. */
|
/* None of the remaining use the selected frame. */
|
if (selected_frame_p != NULL)
|
if (selected_frame_p != NULL)
|
(*selected_frame_p) = 0;
|
(*selected_frame_p) = 0;
|
|
|
/* Assume the single arg[0] is an integer, and try using that to
|
/* Assume the single arg[0] is an integer, and try using that to
|
select a frame relative to current. */
|
select a frame relative to current. */
|
if (numargs == 1)
|
if (numargs == 1)
|
{
|
{
|
struct frame_info *fid;
|
struct frame_info *fid;
|
int level = value_as_long (args[0]);
|
int level = value_as_long (args[0]);
|
fid = find_relative_frame (get_current_frame (), &level);
|
fid = find_relative_frame (get_current_frame (), &level);
|
if (level == 0)
|
if (level == 0)
|
/* find_relative_frame was successful */
|
/* find_relative_frame was successful */
|
return fid;
|
return fid;
|
}
|
}
|
|
|
/* Convert each value into a corresponding address. */
|
/* Convert each value into a corresponding address. */
|
{
|
{
|
int i;
|
int i;
|
for (i = 0; i < numargs; i++)
|
for (i = 0; i < numargs; i++)
|
addrs[i] = value_as_address (args[i]);
|
addrs[i] = value_as_address (args[i]);
|
}
|
}
|
|
|
/* Assume that the single arg[0] is an address, use that to identify
|
/* Assume that the single arg[0] is an address, use that to identify
|
a frame with a matching ID. Should this also accept stack/pc or
|
a frame with a matching ID. Should this also accept stack/pc or
|
stack/pc/special. */
|
stack/pc/special. */
|
if (numargs == 1)
|
if (numargs == 1)
|
{
|
{
|
struct frame_id id = frame_id_build_wild (addrs[0]);
|
struct frame_id id = frame_id_build_wild (addrs[0]);
|
struct frame_info *fid;
|
struct frame_info *fid;
|
|
|
/* If (s)he specifies the frame with an address, he deserves
|
/* If (s)he specifies the frame with an address, he deserves
|
what (s)he gets. Still, give the highest one that matches.
|
what (s)he gets. Still, give the highest one that matches.
|
(NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
|
(NOTE: cagney/2004-10-29: Why highest, or outer-most, I don't
|
know). */
|
know). */
|
for (fid = get_current_frame ();
|
for (fid = get_current_frame ();
|
fid != NULL;
|
fid != NULL;
|
fid = get_prev_frame (fid))
|
fid = get_prev_frame (fid))
|
{
|
{
|
if (frame_id_eq (id, get_frame_id (fid)))
|
if (frame_id_eq (id, get_frame_id (fid)))
|
{
|
{
|
struct frame_info *prev_frame;
|
struct frame_info *prev_frame;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
prev_frame = get_prev_frame (fid);
|
prev_frame = get_prev_frame (fid);
|
if (!prev_frame
|
if (!prev_frame
|
|| !frame_id_eq (id, get_frame_id (prev_frame)))
|
|| !frame_id_eq (id, get_frame_id (prev_frame)))
|
break;
|
break;
|
fid = prev_frame;
|
fid = prev_frame;
|
}
|
}
|
return fid;
|
return fid;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* We couldn't identify the frame as an existing frame, but
|
/* We couldn't identify the frame as an existing frame, but
|
perhaps we can create one with a single argument. */
|
perhaps we can create one with a single argument. */
|
if (numargs == 1)
|
if (numargs == 1)
|
return create_new_frame (addrs[0], 0);
|
return create_new_frame (addrs[0], 0);
|
else if (numargs == 2)
|
else if (numargs == 2)
|
return create_new_frame (addrs[0], addrs[1]);
|
return create_new_frame (addrs[0], addrs[1]);
|
else
|
else
|
error (_("Too many args in frame specification"));
|
error (_("Too many args in frame specification"));
|
}
|
}
|
|
|
static struct frame_info *
|
static struct frame_info *
|
parse_frame_specification (char *frame_exp)
|
parse_frame_specification (char *frame_exp)
|
{
|
{
|
return parse_frame_specification_1 (frame_exp, NULL, NULL);
|
return parse_frame_specification_1 (frame_exp, NULL, NULL);
|
}
|
}
|
|
|
/* Print verbosely the selected frame or the frame at address
|
/* Print verbosely the selected frame or the frame at address
|
ADDR_EXP. Absolutely all information in the frame is printed. */
|
ADDR_EXP. Absolutely all information in the frame is printed. */
|
|
|
static void
|
static void
|
frame_info (char *addr_exp, int from_tty)
|
frame_info (char *addr_exp, int from_tty)
|
{
|
{
|
struct frame_info *fi;
|
struct frame_info *fi;
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
struct symbol *func;
|
struct symbol *func;
|
struct symtab *s;
|
struct symtab *s;
|
struct frame_info *calling_frame_info;
|
struct frame_info *calling_frame_info;
|
int i, count, numregs;
|
int i, count, numregs;
|
char *funname = 0;
|
char *funname = 0;
|
enum language funlang = language_unknown;
|
enum language funlang = language_unknown;
|
const char *pc_regname;
|
const char *pc_regname;
|
int selected_frame_p;
|
int selected_frame_p;
|
struct gdbarch *gdbarch;
|
struct gdbarch *gdbarch;
|
struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
|
struct cleanup *back_to = make_cleanup (null_cleanup, NULL);
|
|
|
fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
|
fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p);
|
gdbarch = get_frame_arch (fi);
|
gdbarch = get_frame_arch (fi);
|
|
|
/* Name of the value returned by get_frame_pc(). Per comments, "pc"
|
/* Name of the value returned by get_frame_pc(). Per comments, "pc"
|
is not a good name. */
|
is not a good name. */
|
if (gdbarch_pc_regnum (gdbarch) >= 0)
|
if (gdbarch_pc_regnum (gdbarch) >= 0)
|
/* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
|
/* OK, this is weird. The gdbarch_pc_regnum hardware register's value can
|
easily not match that of the internal value returned by
|
easily not match that of the internal value returned by
|
get_frame_pc(). */
|
get_frame_pc(). */
|
pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
|
pc_regname = gdbarch_register_name (gdbarch, gdbarch_pc_regnum (gdbarch));
|
else
|
else
|
/* But then, this is weird to. Even without gdbarch_pc_regnum, an
|
/* But then, this is weird to. Even without gdbarch_pc_regnum, an
|
architectures will often have a hardware register called "pc",
|
architectures will often have a hardware register called "pc",
|
and that register's value, again, can easily not match
|
and that register's value, again, can easily not match
|
get_frame_pc(). */
|
get_frame_pc(). */
|
pc_regname = "pc";
|
pc_regname = "pc";
|
|
|
find_frame_sal (fi, &sal);
|
find_frame_sal (fi, &sal);
|
func = get_frame_function (fi);
|
func = get_frame_function (fi);
|
/* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
|
/* FIXME: cagney/2002-11-28: Why bother? Won't sal.symtab contain
|
the same value? */
|
the same value? */
|
s = find_pc_symtab (get_frame_pc (fi));
|
s = find_pc_symtab (get_frame_pc (fi));
|
if (func)
|
if (func)
|
{
|
{
|
funname = SYMBOL_PRINT_NAME (func);
|
funname = SYMBOL_PRINT_NAME (func);
|
funlang = SYMBOL_LANGUAGE (func);
|
funlang = SYMBOL_LANGUAGE (func);
|
if (funlang == language_cplus)
|
if (funlang == language_cplus)
|
{
|
{
|
/* It seems appropriate to use SYMBOL_PRINT_NAME() here,
|
/* It seems appropriate to use SYMBOL_PRINT_NAME() here,
|
to display the demangled name that we already have
|
to display the demangled name that we already have
|
stored in the symbol table, but we stored a version
|
stored in the symbol table, but we stored a version
|
with DMGL_PARAMS turned on, and here we don't want to
|
with DMGL_PARAMS turned on, and here we don't want to
|
display parameters. So remove the parameters. */
|
display parameters. So remove the parameters. */
|
char *func_only = cp_remove_params (funname);
|
char *func_only = cp_remove_params (funname);
|
if (func_only)
|
if (func_only)
|
{
|
{
|
funname = func_only;
|
funname = func_only;
|
make_cleanup (xfree, func_only);
|
make_cleanup (xfree, func_only);
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
{
|
{
|
struct minimal_symbol *msymbol;
|
struct minimal_symbol *msymbol;
|
|
|
msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
|
msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi));
|
if (msymbol != NULL)
|
if (msymbol != NULL)
|
{
|
{
|
funname = SYMBOL_PRINT_NAME (msymbol);
|
funname = SYMBOL_PRINT_NAME (msymbol);
|
funlang = SYMBOL_LANGUAGE (msymbol);
|
funlang = SYMBOL_LANGUAGE (msymbol);
|
}
|
}
|
}
|
}
|
calling_frame_info = get_prev_frame (fi);
|
calling_frame_info = get_prev_frame (fi);
|
|
|
if (selected_frame_p && frame_relative_level (fi) >= 0)
|
if (selected_frame_p && frame_relative_level (fi) >= 0)
|
{
|
{
|
printf_filtered (_("Stack level %d, frame at "),
|
printf_filtered (_("Stack level %d, frame at "),
|
frame_relative_level (fi));
|
frame_relative_level (fi));
|
}
|
}
|
else
|
else
|
{
|
{
|
printf_filtered (_("Stack frame at "));
|
printf_filtered (_("Stack frame at "));
|
}
|
}
|
fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout);
|
printf_filtered (":\n");
|
printf_filtered (":\n");
|
printf_filtered (" %s = ", pc_regname);
|
printf_filtered (" %s = ", pc_regname);
|
fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout);
|
|
|
wrap_here (" ");
|
wrap_here (" ");
|
if (funname)
|
if (funname)
|
{
|
{
|
printf_filtered (" in ");
|
printf_filtered (" in ");
|
fprintf_symbol_filtered (gdb_stdout, funname, funlang,
|
fprintf_symbol_filtered (gdb_stdout, funname, funlang,
|
DMGL_ANSI | DMGL_PARAMS);
|
DMGL_ANSI | DMGL_PARAMS);
|
}
|
}
|
wrap_here (" ");
|
wrap_here (" ");
|
if (sal.symtab)
|
if (sal.symtab)
|
printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
|
printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
|
puts_filtered ("; ");
|
puts_filtered ("; ");
|
wrap_here (" ");
|
wrap_here (" ");
|
printf_filtered ("saved %s ", pc_regname);
|
printf_filtered ("saved %s ", pc_regname);
|
fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
|
|
if (calling_frame_info == NULL)
|
if (calling_frame_info == NULL)
|
{
|
{
|
enum unwind_stop_reason reason;
|
enum unwind_stop_reason reason;
|
|
|
reason = get_frame_unwind_stop_reason (fi);
|
reason = get_frame_unwind_stop_reason (fi);
|
if (reason != UNWIND_NO_REASON)
|
if (reason != UNWIND_NO_REASON)
|
printf_filtered (_(" Outermost frame: %s\n"),
|
printf_filtered (_(" Outermost frame: %s\n"),
|
frame_stop_reason_string (reason));
|
frame_stop_reason_string (reason));
|
}
|
}
|
else if (get_frame_type (fi) == INLINE_FRAME)
|
else if (get_frame_type (fi) == INLINE_FRAME)
|
printf_filtered (" inlined into frame %d",
|
printf_filtered (" inlined into frame %d",
|
frame_relative_level (get_prev_frame (fi)));
|
frame_relative_level (get_prev_frame (fi)));
|
else
|
else
|
{
|
{
|
printf_filtered (" called by frame at ");
|
printf_filtered (" called by frame at ");
|
fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
|
fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)),
|
gdb_stdout);
|
gdb_stdout);
|
}
|
}
|
if (get_next_frame (fi) && calling_frame_info)
|
if (get_next_frame (fi) && calling_frame_info)
|
puts_filtered (",");
|
puts_filtered (",");
|
wrap_here (" ");
|
wrap_here (" ");
|
if (get_next_frame (fi))
|
if (get_next_frame (fi))
|
{
|
{
|
printf_filtered (" caller of frame at ");
|
printf_filtered (" caller of frame at ");
|
fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
|
fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))),
|
gdb_stdout);
|
gdb_stdout);
|
}
|
}
|
if (get_next_frame (fi) || calling_frame_info)
|
if (get_next_frame (fi) || calling_frame_info)
|
puts_filtered ("\n");
|
puts_filtered ("\n");
|
|
|
if (s)
|
if (s)
|
printf_filtered (" source language %s.\n",
|
printf_filtered (" source language %s.\n",
|
language_str (s->language));
|
language_str (s->language));
|
|
|
{
|
{
|
/* Address of the argument list for this frame, or 0. */
|
/* Address of the argument list for this frame, or 0. */
|
CORE_ADDR arg_list = get_frame_args_address (fi);
|
CORE_ADDR arg_list = get_frame_args_address (fi);
|
/* Number of args for this frame, or -1 if unknown. */
|
/* Number of args for this frame, or -1 if unknown. */
|
int numargs;
|
int numargs;
|
|
|
if (arg_list == 0)
|
if (arg_list == 0)
|
printf_filtered (" Arglist at unknown address.\n");
|
printf_filtered (" Arglist at unknown address.\n");
|
else
|
else
|
{
|
{
|
printf_filtered (" Arglist at ");
|
printf_filtered (" Arglist at ");
|
fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
|
printf_filtered (",");
|
printf_filtered (",");
|
|
|
if (!gdbarch_frame_num_args_p (gdbarch))
|
if (!gdbarch_frame_num_args_p (gdbarch))
|
{
|
{
|
numargs = -1;
|
numargs = -1;
|
puts_filtered (" args: ");
|
puts_filtered (" args: ");
|
}
|
}
|
else
|
else
|
{
|
{
|
numargs = gdbarch_frame_num_args (gdbarch, fi);
|
numargs = gdbarch_frame_num_args (gdbarch, fi);
|
gdb_assert (numargs >= 0);
|
gdb_assert (numargs >= 0);
|
if (numargs == 0)
|
if (numargs == 0)
|
puts_filtered (" no args.");
|
puts_filtered (" no args.");
|
else if (numargs == 1)
|
else if (numargs == 1)
|
puts_filtered (" 1 arg: ");
|
puts_filtered (" 1 arg: ");
|
else
|
else
|
printf_filtered (" %d args: ", numargs);
|
printf_filtered (" %d args: ", numargs);
|
}
|
}
|
print_frame_args (func, fi, numargs, gdb_stdout);
|
print_frame_args (func, fi, numargs, gdb_stdout);
|
puts_filtered ("\n");
|
puts_filtered ("\n");
|
}
|
}
|
}
|
}
|
{
|
{
|
/* Address of the local variables for this frame, or 0. */
|
/* Address of the local variables for this frame, or 0. */
|
CORE_ADDR arg_list = get_frame_locals_address (fi);
|
CORE_ADDR arg_list = get_frame_locals_address (fi);
|
|
|
if (arg_list == 0)
|
if (arg_list == 0)
|
printf_filtered (" Locals at unknown address,");
|
printf_filtered (" Locals at unknown address,");
|
else
|
else
|
{
|
{
|
printf_filtered (" Locals at ");
|
printf_filtered (" Locals at ");
|
fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout);
|
printf_filtered (",");
|
printf_filtered (",");
|
}
|
}
|
}
|
}
|
|
|
/* Print as much information as possible on the location of all the
|
/* Print as much information as possible on the location of all the
|
registers. */
|
registers. */
|
{
|
{
|
enum lval_type lval;
|
enum lval_type lval;
|
int optimized;
|
int optimized;
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
int realnum;
|
int realnum;
|
int count;
|
int count;
|
int i;
|
int i;
|
int need_nl = 1;
|
int need_nl = 1;
|
|
|
/* The sp is special; what's displayed isn't the save address, but
|
/* The sp is special; what's displayed isn't the save address, but
|
the value of the previous frame's sp. This is a legacy thing,
|
the value of the previous frame's sp. This is a legacy thing,
|
at one stage the frame cached the previous frame's SP instead
|
at one stage the frame cached the previous frame's SP instead
|
of its address, hence it was easiest to just display the cached
|
of its address, hence it was easiest to just display the cached
|
value. */
|
value. */
|
if (gdbarch_sp_regnum (gdbarch) >= 0)
|
if (gdbarch_sp_regnum (gdbarch) >= 0)
|
{
|
{
|
/* Find out the location of the saved stack pointer with out
|
/* Find out the location of the saved stack pointer with out
|
actually evaluating it. */
|
actually evaluating it. */
|
frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
|
frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
|
&optimized, &lval, &addr,
|
&optimized, &lval, &addr,
|
&realnum, NULL);
|
&realnum, NULL);
|
if (!optimized && lval == not_lval)
|
if (!optimized && lval == not_lval)
|
{
|
{
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
|
int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
|
int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch));
|
gdb_byte value[MAX_REGISTER_SIZE];
|
gdb_byte value[MAX_REGISTER_SIZE];
|
CORE_ADDR sp;
|
CORE_ADDR sp;
|
frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
|
frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch),
|
&optimized, &lval, &addr,
|
&optimized, &lval, &addr,
|
&realnum, value);
|
&realnum, value);
|
/* NOTE: cagney/2003-05-22: This is assuming that the
|
/* NOTE: cagney/2003-05-22: This is assuming that the
|
stack pointer was packed as an unsigned integer. That
|
stack pointer was packed as an unsigned integer. That
|
may or may not be valid. */
|
may or may not be valid. */
|
sp = extract_unsigned_integer (value, sp_size, byte_order);
|
sp = extract_unsigned_integer (value, sp_size, byte_order);
|
printf_filtered (" Previous frame's sp is ");
|
printf_filtered (" Previous frame's sp is ");
|
fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, sp), gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
need_nl = 0;
|
need_nl = 0;
|
}
|
}
|
else if (!optimized && lval == lval_memory)
|
else if (!optimized && lval == lval_memory)
|
{
|
{
|
printf_filtered (" Previous frame's sp at ");
|
printf_filtered (" Previous frame's sp at ");
|
fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
|
printf_filtered ("\n");
|
printf_filtered ("\n");
|
need_nl = 0;
|
need_nl = 0;
|
}
|
}
|
else if (!optimized && lval == lval_register)
|
else if (!optimized && lval == lval_register)
|
{
|
{
|
printf_filtered (" Previous frame's sp in %s\n",
|
printf_filtered (" Previous frame's sp in %s\n",
|
gdbarch_register_name (gdbarch, realnum));
|
gdbarch_register_name (gdbarch, realnum));
|
need_nl = 0;
|
need_nl = 0;
|
}
|
}
|
/* else keep quiet. */
|
/* else keep quiet. */
|
}
|
}
|
|
|
count = 0;
|
count = 0;
|
numregs = gdbarch_num_regs (gdbarch)
|
numregs = gdbarch_num_regs (gdbarch)
|
+ gdbarch_num_pseudo_regs (gdbarch);
|
+ gdbarch_num_pseudo_regs (gdbarch);
|
for (i = 0; i < numregs; i++)
|
for (i = 0; i < numregs; i++)
|
if (i != gdbarch_sp_regnum (gdbarch)
|
if (i != gdbarch_sp_regnum (gdbarch)
|
&& gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
|
&& gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
|
{
|
{
|
/* Find out the location of the saved register without
|
/* Find out the location of the saved register without
|
fetching the corresponding value. */
|
fetching the corresponding value. */
|
frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
|
frame_register_unwind (fi, i, &optimized, &lval, &addr, &realnum,
|
NULL);
|
NULL);
|
/* For moment, only display registers that were saved on the
|
/* For moment, only display registers that were saved on the
|
stack. */
|
stack. */
|
if (!optimized && lval == lval_memory)
|
if (!optimized && lval == lval_memory)
|
{
|
{
|
if (count == 0)
|
if (count == 0)
|
puts_filtered (" Saved registers:\n ");
|
puts_filtered (" Saved registers:\n ");
|
else
|
else
|
puts_filtered (",");
|
puts_filtered (",");
|
wrap_here (" ");
|
wrap_here (" ");
|
printf_filtered (" %s at ",
|
printf_filtered (" %s at ",
|
gdbarch_register_name (gdbarch, i));
|
gdbarch_register_name (gdbarch, i));
|
fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
|
fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
|
count++;
|
count++;
|
}
|
}
|
}
|
}
|
if (count || need_nl)
|
if (count || need_nl)
|
puts_filtered ("\n");
|
puts_filtered ("\n");
|
}
|
}
|
|
|
do_cleanups (back_to);
|
do_cleanups (back_to);
|
}
|
}
|
|
|
/* Print briefly all stack frames or just the innermost COUNT_EXP
|
/* Print briefly all stack frames or just the innermost COUNT_EXP
|
frames. */
|
frames. */
|
|
|
static void
|
static void
|
backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
|
backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
|
{
|
{
|
struct frame_info *fi;
|
struct frame_info *fi;
|
int count;
|
int count;
|
int i;
|
int i;
|
struct frame_info *trailing;
|
struct frame_info *trailing;
|
int trailing_level;
|
int trailing_level;
|
|
|
if (!target_has_stack)
|
if (!target_has_stack)
|
error (_("No stack."));
|
error (_("No stack."));
|
|
|
/* The following code must do two things. First, it must set the
|
/* The following code must do two things. First, it must set the
|
variable TRAILING to the frame from which we should start
|
variable TRAILING to the frame from which we should start
|
printing. Second, it must set the variable count to the number
|
printing. Second, it must set the variable count to the number
|
of frames which we should print, or -1 if all of them. */
|
of frames which we should print, or -1 if all of them. */
|
trailing = get_current_frame ();
|
trailing = get_current_frame ();
|
|
|
trailing_level = 0;
|
trailing_level = 0;
|
if (count_exp)
|
if (count_exp)
|
{
|
{
|
count = parse_and_eval_long (count_exp);
|
count = parse_and_eval_long (count_exp);
|
if (count < 0)
|
if (count < 0)
|
{
|
{
|
struct frame_info *current;
|
struct frame_info *current;
|
|
|
count = -count;
|
count = -count;
|
|
|
current = trailing;
|
current = trailing;
|
while (current && count--)
|
while (current && count--)
|
{
|
{
|
QUIT;
|
QUIT;
|
current = get_prev_frame (current);
|
current = get_prev_frame (current);
|
}
|
}
|
|
|
/* Will stop when CURRENT reaches the top of the stack.
|
/* Will stop when CURRENT reaches the top of the stack.
|
TRAILING will be COUNT below it. */
|
TRAILING will be COUNT below it. */
|
while (current)
|
while (current)
|
{
|
{
|
QUIT;
|
QUIT;
|
trailing = get_prev_frame (trailing);
|
trailing = get_prev_frame (trailing);
|
current = get_prev_frame (current);
|
current = get_prev_frame (current);
|
trailing_level++;
|
trailing_level++;
|
}
|
}
|
|
|
count = -1;
|
count = -1;
|
}
|
}
|
}
|
}
|
else
|
else
|
count = -1;
|
count = -1;
|
|
|
if (info_verbose)
|
if (info_verbose)
|
{
|
{
|
struct partial_symtab *ps;
|
struct partial_symtab *ps;
|
|
|
/* Read in symbols for all of the frames. Need to do this in a
|
/* Read in symbols for all of the frames. Need to do this in a
|
separate pass so that "Reading in symbols for xxx" messages
|
separate pass so that "Reading in symbols for xxx" messages
|
don't screw up the appearance of the backtrace. Also if
|
don't screw up the appearance of the backtrace. Also if
|
people have strong opinions against reading symbols for
|
people have strong opinions against reading symbols for
|
backtrace this may have to be an option. */
|
backtrace this may have to be an option. */
|
i = count;
|
i = count;
|
for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
|
for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi))
|
{
|
{
|
QUIT;
|
QUIT;
|
ps = find_pc_psymtab (get_frame_address_in_block (fi));
|
ps = find_pc_psymtab (get_frame_address_in_block (fi));
|
if (ps)
|
if (ps)
|
PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
|
PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */
|
}
|
}
|
}
|
}
|
|
|
for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
|
for (i = 0, fi = trailing; fi && count--; i++, fi = get_prev_frame (fi))
|
{
|
{
|
QUIT;
|
QUIT;
|
|
|
/* Don't use print_stack_frame; if an error() occurs it probably
|
/* Don't use print_stack_frame; if an error() occurs it probably
|
means further attempts to backtrace would fail (on the other
|
means further attempts to backtrace would fail (on the other
|
hand, perhaps the code does or could be fixed to make sure
|
hand, perhaps the code does or could be fixed to make sure
|
the frame->prev field gets set to NULL in that case). */
|
the frame->prev field gets set to NULL in that case). */
|
print_frame_info (fi, 1, LOCATION, 1);
|
print_frame_info (fi, 1, LOCATION, 1);
|
if (show_locals)
|
if (show_locals)
|
print_frame_local_vars (fi, 1, gdb_stdout);
|
print_frame_local_vars (fi, 1, gdb_stdout);
|
|
|
/* Save the last frame to check for error conditions. */
|
/* Save the last frame to check for error conditions. */
|
trailing = fi;
|
trailing = fi;
|
}
|
}
|
|
|
/* If we've stopped before the end, mention that. */
|
/* If we've stopped before the end, mention that. */
|
if (fi && from_tty)
|
if (fi && from_tty)
|
printf_filtered (_("(More stack frames follow...)\n"));
|
printf_filtered (_("(More stack frames follow...)\n"));
|
|
|
/* If we've run out of frames, and the reason appears to be an error
|
/* If we've run out of frames, and the reason appears to be an error
|
condition, print it. */
|
condition, print it. */
|
if (fi == NULL && trailing != NULL)
|
if (fi == NULL && trailing != NULL)
|
{
|
{
|
enum unwind_stop_reason reason;
|
enum unwind_stop_reason reason;
|
|
|
reason = get_frame_unwind_stop_reason (trailing);
|
reason = get_frame_unwind_stop_reason (trailing);
|
if (reason > UNWIND_FIRST_ERROR)
|
if (reason > UNWIND_FIRST_ERROR)
|
printf_filtered (_("Backtrace stopped: %s\n"),
|
printf_filtered (_("Backtrace stopped: %s\n"),
|
frame_stop_reason_string (reason));
|
frame_stop_reason_string (reason));
|
}
|
}
|
}
|
}
|
|
|
struct backtrace_command_args
|
struct backtrace_command_args
|
{
|
{
|
char *count_exp;
|
char *count_exp;
|
int show_locals;
|
int show_locals;
|
int from_tty;
|
int from_tty;
|
};
|
};
|
|
|
/* Stub for catch_errors. */
|
/* Stub for catch_errors. */
|
|
|
static int
|
static int
|
backtrace_command_stub (void *data)
|
backtrace_command_stub (void *data)
|
{
|
{
|
struct backtrace_command_args *args = data;
|
struct backtrace_command_args *args = data;
|
backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
|
backtrace_command_1 (args->count_exp, args->show_locals, args->from_tty);
|
return 0;
|
return 0;
|
}
|
}
|
|
|
static void
|
static void
|
backtrace_command (char *arg, int from_tty)
|
backtrace_command (char *arg, int from_tty)
|
{
|
{
|
struct cleanup *old_chain = NULL;
|
struct cleanup *old_chain = NULL;
|
int fulltrace_arg = -1, arglen = 0, argc = 0;
|
int fulltrace_arg = -1, arglen = 0, argc = 0;
|
struct backtrace_command_args btargs;
|
struct backtrace_command_args btargs;
|
|
|
if (arg)
|
if (arg)
|
{
|
{
|
char **argv;
|
char **argv;
|
int i;
|
int i;
|
|
|
argv = gdb_buildargv (arg);
|
argv = gdb_buildargv (arg);
|
old_chain = make_cleanup_freeargv (argv);
|
old_chain = make_cleanup_freeargv (argv);
|
argc = 0;
|
argc = 0;
|
for (i = 0; argv[i]; i++)
|
for (i = 0; argv[i]; i++)
|
{
|
{
|
unsigned int j;
|
unsigned int j;
|
|
|
for (j = 0; j < strlen (argv[i]); j++)
|
for (j = 0; j < strlen (argv[i]); j++)
|
argv[i][j] = tolower (argv[i][j]);
|
argv[i][j] = tolower (argv[i][j]);
|
|
|
if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
|
if (fulltrace_arg < 0 && subset_compare (argv[i], "full"))
|
fulltrace_arg = argc;
|
fulltrace_arg = argc;
|
else
|
else
|
{
|
{
|
arglen += strlen (argv[i]);
|
arglen += strlen (argv[i]);
|
argc++;
|
argc++;
|
}
|
}
|
}
|
}
|
arglen += argc;
|
arglen += argc;
|
if (fulltrace_arg >= 0)
|
if (fulltrace_arg >= 0)
|
{
|
{
|
if (arglen > 0)
|
if (arglen > 0)
|
{
|
{
|
arg = xmalloc (arglen + 1);
|
arg = xmalloc (arglen + 1);
|
memset (arg, 0, arglen + 1);
|
memset (arg, 0, arglen + 1);
|
for (i = 0; i < (argc + 1); i++)
|
for (i = 0; i < (argc + 1); i++)
|
{
|
{
|
if (i != fulltrace_arg)
|
if (i != fulltrace_arg)
|
{
|
{
|
strcat (arg, argv[i]);
|
strcat (arg, argv[i]);
|
strcat (arg, " ");
|
strcat (arg, " ");
|
}
|
}
|
}
|
}
|
}
|
}
|
else
|
else
|
arg = NULL;
|
arg = NULL;
|
}
|
}
|
}
|
}
|
|
|
btargs.count_exp = arg;
|
btargs.count_exp = arg;
|
btargs.show_locals = (fulltrace_arg >= 0);
|
btargs.show_locals = (fulltrace_arg >= 0);
|
btargs.from_tty = from_tty;
|
btargs.from_tty = from_tty;
|
catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
|
catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
|
|
|
if (fulltrace_arg >= 0 && arglen > 0)
|
if (fulltrace_arg >= 0 && arglen > 0)
|
xfree (arg);
|
xfree (arg);
|
|
|
if (old_chain)
|
if (old_chain)
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
}
|
}
|
|
|
static void
|
static void
|
backtrace_full_command (char *arg, int from_tty)
|
backtrace_full_command (char *arg, int from_tty)
|
{
|
{
|
struct backtrace_command_args btargs;
|
struct backtrace_command_args btargs;
|
btargs.count_exp = arg;
|
btargs.count_exp = arg;
|
btargs.show_locals = 1;
|
btargs.show_locals = 1;
|
btargs.from_tty = from_tty;
|
btargs.from_tty = from_tty;
|
catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
|
catch_errors (backtrace_command_stub, &btargs, "", RETURN_MASK_ERROR);
|
}
|
}
|
|
|
|
|
/* Print the local variables of a block B active in FRAME on STREAM.
|
/* Print the local variables of a block B active in FRAME on STREAM.
|
Return 1 if any variables were printed; 0 otherwise. */
|
Return 1 if any variables were printed; 0 otherwise. */
|
|
|
static int
|
static int
|
print_block_frame_locals (struct block *b, struct frame_info *frame,
|
print_block_frame_locals (struct block *b, struct frame_info *frame,
|
int num_tabs, struct ui_file *stream)
|
int num_tabs, struct ui_file *stream)
|
{
|
{
|
struct dict_iterator iter;
|
struct dict_iterator iter;
|
struct symbol *sym;
|
struct symbol *sym;
|
int values_printed = 0;
|
int values_printed = 0;
|
int j;
|
int j;
|
|
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
{
|
{
|
switch (SYMBOL_CLASS (sym))
|
switch (SYMBOL_CLASS (sym))
|
{
|
{
|
case LOC_LOCAL:
|
case LOC_LOCAL:
|
case LOC_REGISTER:
|
case LOC_REGISTER:
|
case LOC_STATIC:
|
case LOC_STATIC:
|
case LOC_COMPUTED:
|
case LOC_COMPUTED:
|
if (SYMBOL_IS_ARGUMENT (sym))
|
if (SYMBOL_IS_ARGUMENT (sym))
|
break;
|
break;
|
values_printed = 1;
|
values_printed = 1;
|
print_variable_and_value (NULL, sym, frame, stream, 4 * num_tabs);
|
print_variable_and_value (NULL, sym, frame, stream, 4 * num_tabs);
|
break;
|
break;
|
|
|
default:
|
default:
|
/* Ignore symbols which are not locals. */
|
/* Ignore symbols which are not locals. */
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
return values_printed;
|
return values_printed;
|
}
|
}
|
|
|
|
|
/* Same, but print labels. */
|
/* Same, but print labels. */
|
|
|
#if 0
|
#if 0
|
/* Commented out, as the code using this function has also been
|
/* Commented out, as the code using this function has also been
|
commented out. FIXME:brobecker/2009-01-13: Find out why the code
|
commented out. FIXME:brobecker/2009-01-13: Find out why the code
|
was commented out in the first place. The discussion introducing
|
was commented out in the first place. The discussion introducing
|
this change (2007-12-04: Support lexical blocks and function bodies
|
this change (2007-12-04: Support lexical blocks and function bodies
|
that occupy non-contiguous address ranges) did not explain why
|
that occupy non-contiguous address ranges) did not explain why
|
this change was made. */
|
this change was made. */
|
static int
|
static int
|
print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
|
print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
|
int *have_default, struct ui_file *stream)
|
int *have_default, struct ui_file *stream)
|
{
|
{
|
struct dict_iterator iter;
|
struct dict_iterator iter;
|
struct symbol *sym;
|
struct symbol *sym;
|
int values_printed = 0;
|
int values_printed = 0;
|
|
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
{
|
{
|
if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
|
if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0)
|
{
|
{
|
if (*have_default)
|
if (*have_default)
|
continue;
|
continue;
|
*have_default = 1;
|
*have_default = 1;
|
}
|
}
|
if (SYMBOL_CLASS (sym) == LOC_LABEL)
|
if (SYMBOL_CLASS (sym) == LOC_LABEL)
|
{
|
{
|
struct symtab_and_line sal;
|
struct symtab_and_line sal;
|
struct value_print_options opts;
|
struct value_print_options opts;
|
sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
|
sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0);
|
values_printed = 1;
|
values_printed = 1;
|
fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
|
fputs_filtered (SYMBOL_PRINT_NAME (sym), stream);
|
get_user_print_options (&opts);
|
get_user_print_options (&opts);
|
if (opts.addressprint)
|
if (opts.addressprint)
|
{
|
{
|
fprintf_filtered (stream, " ");
|
fprintf_filtered (stream, " ");
|
fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
|
fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)),
|
stream);
|
stream);
|
}
|
}
|
fprintf_filtered (stream, " in file %s, line %d\n",
|
fprintf_filtered (stream, " in file %s, line %d\n",
|
sal.symtab->filename, sal.line);
|
sal.symtab->filename, sal.line);
|
}
|
}
|
}
|
}
|
|
|
return values_printed;
|
return values_printed;
|
}
|
}
|
#endif
|
#endif
|
|
|
/* Print on STREAM all the local variables in frame FRAME, including
|
/* Print on STREAM all the local variables in frame FRAME, including
|
all the blocks active in that frame at its current PC.
|
all the blocks active in that frame at its current PC.
|
|
|
Returns 1 if the job was done, or 0 if nothing was printed because
|
Returns 1 if the job was done, or 0 if nothing was printed because
|
we have no info on the function running in FRAME. */
|
we have no info on the function running in FRAME. */
|
|
|
static void
|
static void
|
print_frame_local_vars (struct frame_info *frame, int num_tabs,
|
print_frame_local_vars (struct frame_info *frame, int num_tabs,
|
struct ui_file *stream)
|
struct ui_file *stream)
|
{
|
{
|
struct block *block = get_frame_block (frame, 0);
|
struct block *block = get_frame_block (frame, 0);
|
int values_printed = 0;
|
int values_printed = 0;
|
|
|
if (block == 0)
|
if (block == 0)
|
{
|
{
|
fprintf_filtered (stream, "No symbol table info available.\n");
|
fprintf_filtered (stream, "No symbol table info available.\n");
|
return;
|
return;
|
}
|
}
|
|
|
while (block)
|
while (block)
|
{
|
{
|
if (print_block_frame_locals (block, frame, num_tabs, stream))
|
if (print_block_frame_locals (block, frame, num_tabs, stream))
|
values_printed = 1;
|
values_printed = 1;
|
/* After handling the function's top-level block, stop. Don't
|
/* After handling the function's top-level block, stop. Don't
|
continue to its superblock, the block of per-file symbols.
|
continue to its superblock, the block of per-file symbols.
|
Also do not continue to the containing function of an inlined
|
Also do not continue to the containing function of an inlined
|
function. */
|
function. */
|
if (BLOCK_FUNCTION (block))
|
if (BLOCK_FUNCTION (block))
|
break;
|
break;
|
block = BLOCK_SUPERBLOCK (block);
|
block = BLOCK_SUPERBLOCK (block);
|
}
|
}
|
|
|
if (!values_printed)
|
if (!values_printed)
|
fprintf_filtered (stream, _("No locals.\n"));
|
fprintf_filtered (stream, _("No locals.\n"));
|
}
|
}
|
|
|
/* Same, but print labels. */
|
/* Same, but print labels. */
|
|
|
static void
|
static void
|
print_frame_label_vars (struct frame_info *frame, int this_level_only,
|
print_frame_label_vars (struct frame_info *frame, int this_level_only,
|
struct ui_file *stream)
|
struct ui_file *stream)
|
{
|
{
|
#if 1
|
#if 1
|
fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
|
fprintf_filtered (stream, "print_frame_label_vars disabled.\n");
|
#else
|
#else
|
struct blockvector *bl;
|
struct blockvector *bl;
|
struct block *block = get_frame_block (frame, 0);
|
struct block *block = get_frame_block (frame, 0);
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
struct gdbarch *gdbarch = get_frame_arch (frame);
|
int values_printed = 0;
|
int values_printed = 0;
|
int index, have_default = 0;
|
int index, have_default = 0;
|
char *blocks_printed;
|
char *blocks_printed;
|
CORE_ADDR pc = get_frame_pc (frame);
|
CORE_ADDR pc = get_frame_pc (frame);
|
|
|
if (block == 0)
|
if (block == 0)
|
{
|
{
|
fprintf_filtered (stream, "No symbol table info available.\n");
|
fprintf_filtered (stream, "No symbol table info available.\n");
|
return;
|
return;
|
}
|
}
|
|
|
bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
|
bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
|
blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
|
blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
|
memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
|
memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
|
|
|
while (block != 0)
|
while (block != 0)
|
{
|
{
|
CORE_ADDR end = BLOCK_END (block) - 4;
|
CORE_ADDR end = BLOCK_END (block) - 4;
|
int last_index;
|
int last_index;
|
|
|
if (bl != blockvector_for_pc (end, &index))
|
if (bl != blockvector_for_pc (end, &index))
|
error (_("blockvector blotch"));
|
error (_("blockvector blotch"));
|
if (BLOCKVECTOR_BLOCK (bl, index) != block)
|
if (BLOCKVECTOR_BLOCK (bl, index) != block)
|
error (_("blockvector botch"));
|
error (_("blockvector botch"));
|
last_index = BLOCKVECTOR_NBLOCKS (bl);
|
last_index = BLOCKVECTOR_NBLOCKS (bl);
|
index += 1;
|
index += 1;
|
|
|
/* Don't print out blocks that have gone by. */
|
/* Don't print out blocks that have gone by. */
|
while (index < last_index
|
while (index < last_index
|
&& BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
|
&& BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
|
index++;
|
index++;
|
|
|
while (index < last_index
|
while (index < last_index
|
&& BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
|
&& BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
|
{
|
{
|
if (blocks_printed[index] == 0)
|
if (blocks_printed[index] == 0)
|
{
|
{
|
if (print_block_frame_labels (gdbarch,
|
if (print_block_frame_labels (gdbarch,
|
BLOCKVECTOR_BLOCK (bl, index),
|
BLOCKVECTOR_BLOCK (bl, index),
|
&have_default, stream))
|
&have_default, stream))
|
values_printed = 1;
|
values_printed = 1;
|
blocks_printed[index] = 1;
|
blocks_printed[index] = 1;
|
}
|
}
|
index++;
|
index++;
|
}
|
}
|
if (have_default)
|
if (have_default)
|
return;
|
return;
|
if (values_printed && this_level_only)
|
if (values_printed && this_level_only)
|
return;
|
return;
|
|
|
/* After handling the function's top-level block, stop. Don't
|
/* After handling the function's top-level block, stop. Don't
|
continue to its superblock, the block of per-file symbols.
|
continue to its superblock, the block of per-file symbols.
|
Also do not continue to the containing function of an inlined
|
Also do not continue to the containing function of an inlined
|
function. */
|
function. */
|
if (BLOCK_FUNCTION (block))
|
if (BLOCK_FUNCTION (block))
|
break;
|
break;
|
block = BLOCK_SUPERBLOCK (block);
|
block = BLOCK_SUPERBLOCK (block);
|
}
|
}
|
|
|
if (!values_printed && !this_level_only)
|
if (!values_printed && !this_level_only)
|
fprintf_filtered (stream, _("No catches.\n"));
|
fprintf_filtered (stream, _("No catches.\n"));
|
#endif
|
#endif
|
}
|
}
|
|
|
void
|
void
|
locals_info (char *args, int from_tty)
|
locals_info (char *args, int from_tty)
|
{
|
{
|
print_frame_local_vars (get_selected_frame (_("No frame selected.")),
|
print_frame_local_vars (get_selected_frame (_("No frame selected.")),
|
0, gdb_stdout);
|
0, gdb_stdout);
|
}
|
}
|
|
|
static void
|
static void
|
catch_info (char *ignore, int from_tty)
|
catch_info (char *ignore, int from_tty)
|
{
|
{
|
struct symtab_and_line *sal;
|
struct symtab_and_line *sal;
|
|
|
/* Assume g++ compiled code; old GDB 4.16 behaviour. */
|
/* Assume g++ compiled code; old GDB 4.16 behaviour. */
|
print_frame_label_vars (get_selected_frame (_("No frame selected.")),
|
print_frame_label_vars (get_selected_frame (_("No frame selected.")),
|
0, gdb_stdout);
|
0, gdb_stdout);
|
}
|
}
|
|
|
static void
|
static void
|
print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
|
print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
|
{
|
{
|
struct symbol *func = get_frame_function (frame);
|
struct symbol *func = get_frame_function (frame);
|
struct block *b;
|
struct block *b;
|
struct dict_iterator iter;
|
struct dict_iterator iter;
|
struct symbol *sym, *sym2;
|
struct symbol *sym, *sym2;
|
int values_printed = 0;
|
int values_printed = 0;
|
|
|
if (func == 0)
|
if (func == 0)
|
{
|
{
|
fprintf_filtered (stream, _("No symbol table info available.\n"));
|
fprintf_filtered (stream, _("No symbol table info available.\n"));
|
return;
|
return;
|
}
|
}
|
|
|
b = SYMBOL_BLOCK_VALUE (func);
|
b = SYMBOL_BLOCK_VALUE (func);
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
ALL_BLOCK_SYMBOLS (b, iter, sym)
|
{
|
{
|
/* Don't worry about things which aren't arguments. */
|
/* Don't worry about things which aren't arguments. */
|
if (SYMBOL_IS_ARGUMENT (sym))
|
if (SYMBOL_IS_ARGUMENT (sym))
|
{
|
{
|
values_printed = 1;
|
values_printed = 1;
|
|
|
/* We have to look up the symbol because arguments can have
|
/* We have to look up the symbol because arguments can have
|
two entries (one a parameter, one a local) and the one we
|
two entries (one a parameter, one a local) and the one we
|
want is the local, which lookup_symbol will find for us.
|
want is the local, which lookup_symbol will find for us.
|
This includes gcc1 (not gcc2) on the sparc when passing a
|
This includes gcc1 (not gcc2) on the sparc when passing a
|
small structure and gcc2 when the argument type is float
|
small structure and gcc2 when the argument type is float
|
and it is passed as a double and converted to float by
|
and it is passed as a double and converted to float by
|
the prologue (in the latter case the type of the LOC_ARG
|
the prologue (in the latter case the type of the LOC_ARG
|
symbol is double and the type of the LOC_LOCAL symbol is
|
symbol is double and the type of the LOC_LOCAL symbol is
|
float). There are also LOC_ARG/LOC_REGISTER pairs which
|
float). There are also LOC_ARG/LOC_REGISTER pairs which
|
are not combined in symbol-reading. */
|
are not combined in symbol-reading. */
|
|
|
sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
|
sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),
|
b, VAR_DOMAIN, NULL);
|
b, VAR_DOMAIN, NULL);
|
print_variable_and_value (SYMBOL_PRINT_NAME (sym), sym2,
|
print_variable_and_value (SYMBOL_PRINT_NAME (sym), sym2,
|
frame, stream, 0);
|
frame, stream, 0);
|
}
|
}
|
}
|
}
|
|
|
if (!values_printed)
|
if (!values_printed)
|
fprintf_filtered (stream, _("No arguments.\n"));
|
fprintf_filtered (stream, _("No arguments.\n"));
|
}
|
}
|
|
|
void
|
void
|
args_info (char *ignore, int from_tty)
|
args_info (char *ignore, int from_tty)
|
{
|
{
|
print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
|
print_frame_arg_vars (get_selected_frame (_("No frame selected.")),
|
gdb_stdout);
|
gdb_stdout);
|
}
|
}
|
|
|
|
|
static void
|
static void
|
args_plus_locals_info (char *ignore, int from_tty)
|
args_plus_locals_info (char *ignore, int from_tty)
|
{
|
{
|
args_info (ignore, from_tty);
|
args_info (ignore, from_tty);
|
locals_info (ignore, from_tty);
|
locals_info (ignore, from_tty);
|
}
|
}
|
|
|
|
|
/* Select frame FRAME. Also print the stack frame and show the source
|
/* Select frame FRAME. Also print the stack frame and show the source
|
if this is the tui version. */
|
if this is the tui version. */
|
static void
|
static void
|
select_and_print_frame (struct frame_info *frame)
|
select_and_print_frame (struct frame_info *frame)
|
{
|
{
|
select_frame (frame);
|
select_frame (frame);
|
if (frame)
|
if (frame)
|
print_stack_frame (frame, 1, SRC_AND_LOC);
|
print_stack_frame (frame, 1, SRC_AND_LOC);
|
}
|
}
|
|
|
/* Return the symbol-block in which the selected frame is executing.
|
/* Return the symbol-block in which the selected frame is executing.
|
Can return zero under various legitimate circumstances.
|
Can return zero under various legitimate circumstances.
|
|
|
If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
|
If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the relevant
|
code address within the block returned. We use this to decide
|
code address within the block returned. We use this to decide
|
which macros are in scope. */
|
which macros are in scope. */
|
|
|
struct block *
|
struct block *
|
get_selected_block (CORE_ADDR *addr_in_block)
|
get_selected_block (CORE_ADDR *addr_in_block)
|
{
|
{
|
if (!has_stack_frames ())
|
if (!has_stack_frames ())
|
return 0;
|
return 0;
|
|
|
return get_frame_block (get_selected_frame (NULL), addr_in_block);
|
return get_frame_block (get_selected_frame (NULL), addr_in_block);
|
}
|
}
|
|
|
/* Find a frame a certain number of levels away from FRAME.
|
/* Find a frame a certain number of levels away from FRAME.
|
LEVEL_OFFSET_PTR points to an int containing the number of levels.
|
LEVEL_OFFSET_PTR points to an int containing the number of levels.
|
Positive means go to earlier frames (up); negative, the reverse.
|
Positive means go to earlier frames (up); negative, the reverse.
|
The int that contains the number of levels is counted toward
|
The int that contains the number of levels is counted toward
|
zero as the frames for those levels are found.
|
zero as the frames for those levels are found.
|
If the top or bottom frame is reached, that frame is returned,
|
If the top or bottom frame is reached, that frame is returned,
|
but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
|
but the final value of *LEVEL_OFFSET_PTR is nonzero and indicates
|
how much farther the original request asked to go. */
|
how much farther the original request asked to go. */
|
|
|
struct frame_info *
|
struct frame_info *
|
find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
|
find_relative_frame (struct frame_info *frame, int *level_offset_ptr)
|
{
|
{
|
/* Going up is simple: just call get_prev_frame enough times or
|
/* Going up is simple: just call get_prev_frame enough times or
|
until the initial frame is reached. */
|
until the initial frame is reached. */
|
while (*level_offset_ptr > 0)
|
while (*level_offset_ptr > 0)
|
{
|
{
|
struct frame_info *prev = get_prev_frame (frame);
|
struct frame_info *prev = get_prev_frame (frame);
|
if (!prev)
|
if (!prev)
|
break;
|
break;
|
(*level_offset_ptr)--;
|
(*level_offset_ptr)--;
|
frame = prev;
|
frame = prev;
|
}
|
}
|
|
|
/* Going down is just as simple. */
|
/* Going down is just as simple. */
|
while (*level_offset_ptr < 0)
|
while (*level_offset_ptr < 0)
|
{
|
{
|
struct frame_info *next = get_next_frame (frame);
|
struct frame_info *next = get_next_frame (frame);
|
if (!next)
|
if (!next)
|
break;
|
break;
|
(*level_offset_ptr)++;
|
(*level_offset_ptr)++;
|
frame = next;
|
frame = next;
|
}
|
}
|
|
|
return frame;
|
return frame;
|
}
|
}
|
|
|
/* The "select_frame" command. With no argument this is a NOP.
|
/* The "select_frame" command. With no argument this is a NOP.
|
Select the frame at level LEVEL_EXP if it is a valid level.
|
Select the frame at level LEVEL_EXP if it is a valid level.
|
Otherwise, treat LEVEL_EXP as an address expression and select it.
|
Otherwise, treat LEVEL_EXP as an address expression and select it.
|
|
|
See parse_frame_specification for more info on proper frame
|
See parse_frame_specification for more info on proper frame
|
expressions. */
|
expressions. */
|
|
|
void
|
void
|
select_frame_command (char *level_exp, int from_tty)
|
select_frame_command (char *level_exp, int from_tty)
|
{
|
{
|
select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
|
select_frame (parse_frame_specification_1 (level_exp, "No stack.", NULL));
|
}
|
}
|
|
|
/* The "frame" command. With no argument, print the selected frame
|
/* The "frame" command. With no argument, print the selected frame
|
briefly. With an argument, behave like select_frame and then print
|
briefly. With an argument, behave like select_frame and then print
|
the selected frame. */
|
the selected frame. */
|
|
|
static void
|
static void
|
frame_command (char *level_exp, int from_tty)
|
frame_command (char *level_exp, int from_tty)
|
{
|
{
|
select_frame_command (level_exp, from_tty);
|
select_frame_command (level_exp, from_tty);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
}
|
}
|
|
|
/* The XDB Compatibility command to print the current frame. */
|
/* The XDB Compatibility command to print the current frame. */
|
|
|
static void
|
static void
|
current_frame_command (char *level_exp, int from_tty)
|
current_frame_command (char *level_exp, int from_tty)
|
{
|
{
|
print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
|
print_stack_frame (get_selected_frame (_("No stack.")), 1, SRC_AND_LOC);
|
}
|
}
|
|
|
/* Select the frame up one or COUNT_EXP stack levels from the
|
/* Select the frame up one or COUNT_EXP stack levels from the
|
previously selected frame, and print it briefly. */
|
previously selected frame, and print it briefly. */
|
|
|
static void
|
static void
|
up_silently_base (char *count_exp)
|
up_silently_base (char *count_exp)
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
int count = 1;
|
int count = 1;
|
|
|
if (count_exp)
|
if (count_exp)
|
count = parse_and_eval_long (count_exp);
|
count = parse_and_eval_long (count_exp);
|
|
|
frame = find_relative_frame (get_selected_frame ("No stack."), &count);
|
frame = find_relative_frame (get_selected_frame ("No stack."), &count);
|
if (count != 0 && count_exp == NULL)
|
if (count != 0 && count_exp == NULL)
|
error (_("Initial frame selected; you cannot go up."));
|
error (_("Initial frame selected; you cannot go up."));
|
select_frame (frame);
|
select_frame (frame);
|
}
|
}
|
|
|
static void
|
static void
|
up_silently_command (char *count_exp, int from_tty)
|
up_silently_command (char *count_exp, int from_tty)
|
{
|
{
|
up_silently_base (count_exp);
|
up_silently_base (count_exp);
|
}
|
}
|
|
|
static void
|
static void
|
up_command (char *count_exp, int from_tty)
|
up_command (char *count_exp, int from_tty)
|
{
|
{
|
up_silently_base (count_exp);
|
up_silently_base (count_exp);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
}
|
}
|
|
|
/* Select the frame down one or COUNT_EXP stack levels from the previously
|
/* Select the frame down one or COUNT_EXP stack levels from the previously
|
selected frame, and print it briefly. */
|
selected frame, and print it briefly. */
|
|
|
static void
|
static void
|
down_silently_base (char *count_exp)
|
down_silently_base (char *count_exp)
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
int count = -1;
|
int count = -1;
|
if (count_exp)
|
if (count_exp)
|
count = -parse_and_eval_long (count_exp);
|
count = -parse_and_eval_long (count_exp);
|
|
|
frame = find_relative_frame (get_selected_frame ("No stack."), &count);
|
frame = find_relative_frame (get_selected_frame ("No stack."), &count);
|
if (count != 0 && count_exp == NULL)
|
if (count != 0 && count_exp == NULL)
|
{
|
{
|
/* We only do this if COUNT_EXP is not specified. That way
|
/* 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
|
"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
|
impossible), but "down 9999" can be used to mean go all the
|
way down without getting an error. */
|
way down without getting an error. */
|
|
|
error (_("Bottom (innermost) frame selected; you cannot go down."));
|
error (_("Bottom (innermost) frame selected; you cannot go down."));
|
}
|
}
|
|
|
select_frame (frame);
|
select_frame (frame);
|
}
|
}
|
|
|
static void
|
static void
|
down_silently_command (char *count_exp, int from_tty)
|
down_silently_command (char *count_exp, int from_tty)
|
{
|
{
|
down_silently_base (count_exp);
|
down_silently_base (count_exp);
|
}
|
}
|
|
|
static void
|
static void
|
down_command (char *count_exp, int from_tty)
|
down_command (char *count_exp, int from_tty)
|
{
|
{
|
down_silently_base (count_exp);
|
down_silently_base (count_exp);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
|
}
|
}
|
|
|
|
|
void
|
void
|
return_command (char *retval_exp, int from_tty)
|
return_command (char *retval_exp, int from_tty)
|
{
|
{
|
struct frame_info *thisframe;
|
struct frame_info *thisframe;
|
struct gdbarch *gdbarch;
|
struct gdbarch *gdbarch;
|
struct symbol *thisfun;
|
struct symbol *thisfun;
|
struct value *return_value = NULL;
|
struct value *return_value = NULL;
|
const char *query_prefix = "";
|
const char *query_prefix = "";
|
|
|
thisframe = get_selected_frame ("No selected frame.");
|
thisframe = get_selected_frame ("No selected frame.");
|
thisfun = get_frame_function (thisframe);
|
thisfun = get_frame_function (thisframe);
|
gdbarch = get_frame_arch (thisframe);
|
gdbarch = get_frame_arch (thisframe);
|
|
|
if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
|
if (get_frame_type (get_current_frame ()) == INLINE_FRAME)
|
error (_("Can not force return from an inlined function."));
|
error (_("Can not force return from an inlined function."));
|
|
|
/* Compute the return value. If the computation triggers an error,
|
/* Compute the return value. If the computation triggers an error,
|
let it bail. If the return type can't be handled, set
|
let it bail. If the return type can't be handled, set
|
RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
|
RETURN_VALUE to NULL, and QUERY_PREFIX to an informational
|
message. */
|
message. */
|
if (retval_exp)
|
if (retval_exp)
|
{
|
{
|
struct expression *retval_expr = parse_expression (retval_exp);
|
struct expression *retval_expr = parse_expression (retval_exp);
|
struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
|
struct cleanup *old_chain = make_cleanup (xfree, retval_expr);
|
struct type *return_type = NULL;
|
struct type *return_type = NULL;
|
|
|
/* Compute the return value. Should the computation fail, this
|
/* Compute the return value. Should the computation fail, this
|
call throws an error. */
|
call throws an error. */
|
return_value = evaluate_expression (retval_expr);
|
return_value = evaluate_expression (retval_expr);
|
|
|
/* Cast return value to the return type of the function. Should
|
/* Cast return value to the return type of the function. Should
|
the cast fail, this call throws an error. */
|
the cast fail, this call throws an error. */
|
if (thisfun != NULL)
|
if (thisfun != NULL)
|
return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
|
return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
|
if (return_type == NULL)
|
if (return_type == NULL)
|
{
|
{
|
if (retval_expr->elts[0].opcode != UNOP_CAST)
|
if (retval_expr->elts[0].opcode != UNOP_CAST)
|
error (_("Return value type not available for selected "
|
error (_("Return value type not available for selected "
|
"stack frame.\n"
|
"stack frame.\n"
|
"Please use an explicit cast of the value to return."));
|
"Please use an explicit cast of the value to return."));
|
return_type = value_type (return_value);
|
return_type = value_type (return_value);
|
}
|
}
|
do_cleanups (old_chain);
|
do_cleanups (old_chain);
|
CHECK_TYPEDEF (return_type);
|
CHECK_TYPEDEF (return_type);
|
return_value = value_cast (return_type, return_value);
|
return_value = value_cast (return_type, return_value);
|
|
|
/* Make sure the value is fully evaluated. It may live in the
|
/* Make sure the value is fully evaluated. It may live in the
|
stack frame we're about to pop. */
|
stack frame we're about to pop. */
|
if (value_lazy (return_value))
|
if (value_lazy (return_value))
|
value_fetch_lazy (return_value);
|
value_fetch_lazy (return_value);
|
|
|
if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
|
if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
|
/* If the return-type is "void", don't try to find the
|
/* If the return-type is "void", don't try to find the
|
return-value's location. However, do still evaluate the
|
return-value's location. However, do still evaluate the
|
return expression so that, even when the expression result
|
return expression so that, even when the expression result
|
is discarded, side effects such as "return i++" still
|
is discarded, side effects such as "return i++" still
|
occur. */
|
occur. */
|
return_value = NULL;
|
return_value = NULL;
|
else if (thisfun != NULL
|
else if (thisfun != NULL
|
&& using_struct_return (gdbarch,
|
&& using_struct_return (gdbarch,
|
SYMBOL_TYPE (thisfun), return_type))
|
SYMBOL_TYPE (thisfun), return_type))
|
{
|
{
|
query_prefix = "\
|
query_prefix = "\
|
The location at which to store the function's return value is unknown.\n\
|
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";
|
If you continue, the return value that you specified will be ignored.\n";
|
return_value = NULL;
|
return_value = NULL;
|
}
|
}
|
}
|
}
|
|
|
/* Does an interactive user really want to do this? Include
|
/* Does an interactive user really want to do this? Include
|
information, such as how well GDB can handle the return value, in
|
information, such as how well GDB can handle the return value, in
|
the query message. */
|
the query message. */
|
if (from_tty)
|
if (from_tty)
|
{
|
{
|
int confirmed;
|
int confirmed;
|
if (thisfun == NULL)
|
if (thisfun == NULL)
|
confirmed = query (_("%sMake selected stack frame return now? "),
|
confirmed = query (_("%sMake selected stack frame return now? "),
|
query_prefix);
|
query_prefix);
|
else
|
else
|
confirmed = query (_("%sMake %s return now? "), query_prefix,
|
confirmed = query (_("%sMake %s return now? "), query_prefix,
|
SYMBOL_PRINT_NAME (thisfun));
|
SYMBOL_PRINT_NAME (thisfun));
|
if (!confirmed)
|
if (!confirmed)
|
error (_("Not confirmed"));
|
error (_("Not confirmed"));
|
}
|
}
|
|
|
/* Discard the selected frame and all frames inner-to it. */
|
/* Discard the selected frame and all frames inner-to it. */
|
frame_pop (get_selected_frame (NULL));
|
frame_pop (get_selected_frame (NULL));
|
|
|
/* Store RETURN_VALUE in the just-returned register set. */
|
/* Store RETURN_VALUE in the just-returned register set. */
|
if (return_value != NULL)
|
if (return_value != NULL)
|
{
|
{
|
struct type *return_type = value_type (return_value);
|
struct type *return_type = value_type (return_value);
|
struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
|
struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
|
struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
|
struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun);
|
|
|
gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
|
gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL,
|
NULL, NULL)
|
NULL, NULL)
|
== RETURN_VALUE_REGISTER_CONVENTION);
|
== RETURN_VALUE_REGISTER_CONVENTION);
|
gdbarch_return_value (gdbarch, func_type, return_type,
|
gdbarch_return_value (gdbarch, func_type, return_type,
|
get_current_regcache (), NULL /*read*/,
|
get_current_regcache (), NULL /*read*/,
|
value_contents (return_value) /*write*/);
|
value_contents (return_value) /*write*/);
|
}
|
}
|
|
|
/* If we are at the end of a call dummy now, pop the dummy frame
|
/* If we are at the end of a call dummy now, pop the dummy frame
|
too. */
|
too. */
|
if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
|
if (get_frame_type (get_current_frame ()) == DUMMY_FRAME)
|
frame_pop (get_current_frame ());
|
frame_pop (get_current_frame ());
|
|
|
/* If interactive, print the frame that is now current. */
|
/* If interactive, print the frame that is now current. */
|
if (from_tty)
|
if (from_tty)
|
frame_command ("0", 1);
|
frame_command ("0", 1);
|
else
|
else
|
select_frame_command ("0", 0);
|
select_frame_command ("0", 0);
|
}
|
}
|
|
|
/* Sets the scope to input function name, provided that the function
|
/* Sets the scope to input function name, provided that the function
|
is within the current stack frame */
|
is within the current stack frame */
|
|
|
struct function_bounds
|
struct function_bounds
|
{
|
{
|
CORE_ADDR low, high;
|
CORE_ADDR low, high;
|
};
|
};
|
|
|
static void
|
static void
|
func_command (char *arg, int from_tty)
|
func_command (char *arg, int from_tty)
|
{
|
{
|
struct frame_info *frame;
|
struct frame_info *frame;
|
int found = 0;
|
int found = 0;
|
struct symtabs_and_lines sals;
|
struct symtabs_and_lines sals;
|
int i;
|
int i;
|
int level = 1;
|
int level = 1;
|
struct function_bounds *func_bounds = NULL;
|
struct function_bounds *func_bounds = NULL;
|
|
|
if (arg != NULL)
|
if (arg != NULL)
|
return;
|
return;
|
|
|
frame = parse_frame_specification ("0");
|
frame = parse_frame_specification ("0");
|
sals = decode_line_spec (arg, 1);
|
sals = decode_line_spec (arg, 1);
|
func_bounds = (struct function_bounds *) xmalloc (
|
func_bounds = (struct function_bounds *) xmalloc (
|
sizeof (struct function_bounds) * sals.nelts);
|
sizeof (struct function_bounds) * sals.nelts);
|
for (i = 0; (i < sals.nelts && !found); i++)
|
for (i = 0; (i < sals.nelts && !found); i++)
|
{
|
{
|
if (sals.sals[i].pc == 0
|
if (sals.sals[i].pc == 0
|
|| find_pc_partial_function (sals.sals[i].pc, NULL,
|
|| find_pc_partial_function (sals.sals[i].pc, NULL,
|
&func_bounds[i].low,
|
&func_bounds[i].low,
|
&func_bounds[i].high) == 0)
|
&func_bounds[i].high) == 0)
|
{
|
{
|
func_bounds[i].low = func_bounds[i].high = 0;
|
func_bounds[i].low = func_bounds[i].high = 0;
|
}
|
}
|
}
|
}
|
|
|
do
|
do
|
{
|
{
|
for (i = 0; (i < sals.nelts && !found); i++)
|
for (i = 0; (i < sals.nelts && !found); i++)
|
found = (get_frame_pc (frame) >= func_bounds[i].low
|
found = (get_frame_pc (frame) >= func_bounds[i].low
|
&& get_frame_pc (frame) < func_bounds[i].high);
|
&& get_frame_pc (frame) < func_bounds[i].high);
|
if (!found)
|
if (!found)
|
{
|
{
|
level = 1;
|
level = 1;
|
frame = find_relative_frame (frame, &level);
|
frame = find_relative_frame (frame, &level);
|
}
|
}
|
}
|
}
|
while (!found && level == 0);
|
while (!found && level == 0);
|
|
|
if (func_bounds)
|
if (func_bounds)
|
xfree (func_bounds);
|
xfree (func_bounds);
|
|
|
if (!found)
|
if (!found)
|
printf_filtered (_("'%s' not within current stack frame.\n"), arg);
|
printf_filtered (_("'%s' not within current stack frame.\n"), arg);
|
else if (frame != get_selected_frame (NULL))
|
else if (frame != get_selected_frame (NULL))
|
select_and_print_frame (frame);
|
select_and_print_frame (frame);
|
}
|
}
|
|
|
/* Gets the language of the current frame. */
|
/* Gets the language of the current frame. */
|
|
|
enum language
|
enum language
|
get_frame_language (void)
|
get_frame_language (void)
|
{
|
{
|
struct frame_info *frame = deprecated_safe_get_selected_frame ();
|
struct frame_info *frame = deprecated_safe_get_selected_frame ();
|
|
|
if (frame)
|
if (frame)
|
{
|
{
|
/* We determine the current frame language by looking up its
|
/* We determine the current frame language by looking up its
|
associated symtab. To retrieve this symtab, we use the frame
|
associated symtab. To retrieve this symtab, we use the frame
|
PC. However we cannot use the frame PC as is, because it
|
PC. However we cannot use the frame PC as is, because it
|
usually points to the instruction following the "call", which
|
usually points to the instruction following the "call", which
|
is sometimes the first instruction of another function. So
|
is sometimes the first instruction of another function. So
|
we rely on get_frame_address_in_block(), it provides us with
|
we rely on get_frame_address_in_block(), it provides us with
|
a PC that is guaranteed to be inside the frame's code
|
a PC that is guaranteed to be inside the frame's code
|
block. */
|
block. */
|
CORE_ADDR pc = get_frame_address_in_block (frame);
|
CORE_ADDR pc = get_frame_address_in_block (frame);
|
struct symtab *s = find_pc_symtab (pc);
|
struct symtab *s = find_pc_symtab (pc);
|
|
|
if (s)
|
if (s)
|
return s->language;
|
return s->language;
|
}
|
}
|
|
|
return language_unknown;
|
return language_unknown;
|
}
|
}
|
|
|
|
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
/* Provide a prototype to silence -Wmissing-prototypes. */
|
void _initialize_stack (void);
|
void _initialize_stack (void);
|
|
|
void
|
void
|
_initialize_stack (void)
|
_initialize_stack (void)
|
{
|
{
|
#if 0
|
#if 0
|
backtrace_limit = 30;
|
backtrace_limit = 30;
|
#endif
|
#endif
|
|
|
add_com ("return", class_stack, return_command, _("\
|
add_com ("return", class_stack, return_command, _("\
|
Make selected stack frame return to its caller.\n\
|
Make selected stack frame return to its caller.\n\
|
Control remains in the debugger, but when you continue\n\
|
Control remains in the debugger, but when you continue\n\
|
execution will resume in the frame above the one now selected.\n\
|
execution will resume in the frame above the one now selected.\n\
|
If an argument is given, it is an expression for the value to return."));
|
If an argument is given, it is an expression for the value to return."));
|
|
|
add_com ("up", class_stack, up_command, _("\
|
add_com ("up", class_stack, up_command, _("\
|
Select and print stack frame that called this one.\n\
|
Select and print stack frame that called this one.\n\
|
An argument says how many frames up to go."));
|
An argument says how many frames up to go."));
|
add_com ("up-silently", class_support, up_silently_command, _("\
|
add_com ("up-silently", class_support, up_silently_command, _("\
|
Same as the `up' command, but does not print anything.\n\
|
Same as the `up' command, but does not print anything.\n\
|
This is useful in command scripts."));
|
This is useful in command scripts."));
|
|
|
add_com ("down", class_stack, down_command, _("\
|
add_com ("down", class_stack, down_command, _("\
|
Select and print stack frame called by this one.\n\
|
Select and print stack frame called by this one.\n\
|
An argument says how many frames down to go."));
|
An argument says how many frames down to go."));
|
add_com_alias ("do", "down", class_stack, 1);
|
add_com_alias ("do", "down", class_stack, 1);
|
add_com_alias ("dow", "down", class_stack, 1);
|
add_com_alias ("dow", "down", class_stack, 1);
|
add_com ("down-silently", class_support, down_silently_command, _("\
|
add_com ("down-silently", class_support, down_silently_command, _("\
|
Same as the `down' command, but does not print anything.\n\
|
Same as the `down' command, but does not print anything.\n\
|
This is useful in command scripts."));
|
This is useful in command scripts."));
|
|
|
add_com ("frame", class_stack, frame_command, _("\
|
add_com ("frame", class_stack, frame_command, _("\
|
Select and print a stack frame.\n\
|
Select and print a stack frame.\n\
|
With no argument, print the selected stack frame. (See also \"info frame\").\n\
|
With no argument, print the selected stack frame. (See also \"info frame\").\n\
|
An argument specifies the frame to select.\n\
|
An argument specifies the frame to select.\n\
|
It can be a stack frame number or the address of the frame.\n\
|
It can be a stack frame number or the address of the frame.\n\
|
With argument, nothing is printed if input is coming from\n\
|
With argument, nothing is printed if input is coming from\n\
|
a command file or a user-defined command."));
|
a command file or a user-defined command."));
|
|
|
add_com_alias ("f", "frame", class_stack, 1);
|
add_com_alias ("f", "frame", class_stack, 1);
|
|
|
if (xdb_commands)
|
if (xdb_commands)
|
{
|
{
|
add_com ("L", class_stack, current_frame_command,
|
add_com ("L", class_stack, current_frame_command,
|
_("Print the current stack frame.\n"));
|
_("Print the current stack frame.\n"));
|
add_com_alias ("V", "frame", class_stack, 1);
|
add_com_alias ("V", "frame", class_stack, 1);
|
}
|
}
|
add_com ("select-frame", class_stack, select_frame_command, _("\
|
add_com ("select-frame", class_stack, select_frame_command, _("\
|
Select a stack frame without printing anything.\n\
|
Select a stack frame without printing anything.\n\
|
An argument specifies the frame to select.\n\
|
An argument specifies the frame to select.\n\
|
It can be a stack frame number or the address of the frame.\n"));
|
It can be a stack frame number or the address of the frame.\n"));
|
|
|
add_com ("backtrace", class_stack, backtrace_command, _("\
|
add_com ("backtrace", class_stack, backtrace_command, _("\
|
Print backtrace of all stack frames, or innermost COUNT frames.\n\
|
Print backtrace of all stack frames, or innermost COUNT frames.\n\
|
With a negative argument, print outermost -COUNT frames.\n\
|
With a negative argument, print outermost -COUNT frames.\n\
|
Use of the 'full' qualifier also prints the values of the local variables.\n"));
|
Use of the 'full' qualifier also prints the values of the local variables.\n"));
|
add_com_alias ("bt", "backtrace", class_stack, 0);
|
add_com_alias ("bt", "backtrace", class_stack, 0);
|
if (xdb_commands)
|
if (xdb_commands)
|
{
|
{
|
add_com_alias ("t", "backtrace", class_stack, 0);
|
add_com_alias ("t", "backtrace", class_stack, 0);
|
add_com ("T", class_stack, backtrace_full_command, _("\
|
add_com ("T", class_stack, backtrace_full_command, _("\
|
Print backtrace of all stack frames, or innermost COUNT frames \n\
|
Print backtrace of all stack frames, or innermost COUNT frames \n\
|
and the values of the local variables.\n\
|
and the values of the local variables.\n\
|
With a negative argument, print outermost -COUNT frames.\n\
|
With a negative argument, print outermost -COUNT frames.\n\
|
Usage: T <count>\n"));
|
Usage: T <count>\n"));
|
}
|
}
|
|
|
add_com_alias ("where", "backtrace", class_alias, 0);
|
add_com_alias ("where", "backtrace", class_alias, 0);
|
add_info ("stack", backtrace_command,
|
add_info ("stack", backtrace_command,
|
_("Backtrace of the stack, or innermost COUNT frames."));
|
_("Backtrace of the stack, or innermost COUNT frames."));
|
add_info_alias ("s", "stack", 1);
|
add_info_alias ("s", "stack", 1);
|
add_info ("frame", frame_info,
|
add_info ("frame", frame_info,
|
_("All about selected stack frame, or frame at ADDR."));
|
_("All about selected stack frame, or frame at ADDR."));
|
add_info_alias ("f", "frame", 1);
|
add_info_alias ("f", "frame", 1);
|
add_info ("locals", locals_info,
|
add_info ("locals", locals_info,
|
_("Local variables of current stack frame."));
|
_("Local variables of current stack frame."));
|
add_info ("args", args_info,
|
add_info ("args", args_info,
|
_("Argument variables of current stack frame."));
|
_("Argument variables of current stack frame."));
|
if (xdb_commands)
|
if (xdb_commands)
|
add_com ("l", class_info, args_plus_locals_info,
|
add_com ("l", class_info, args_plus_locals_info,
|
_("Argument and local variables of current stack frame."));
|
_("Argument and local variables of current stack frame."));
|
|
|
if (dbx_commands)
|
if (dbx_commands)
|
add_com ("func", class_stack, func_command, _("\
|
add_com ("func", class_stack, func_command, _("\
|
Select the stack frame that contains <func>.\n\
|
Select the stack frame that contains <func>.\n\
|
Usage: func <name>\n"));
|
Usage: func <name>\n"));
|
|
|
add_info ("catch", catch_info,
|
add_info ("catch", catch_info,
|
_("Exceptions that can be caught in the current stack frame."));
|
_("Exceptions that can be caught in the current stack frame."));
|
|
|
add_setshow_enum_cmd ("frame-arguments", class_stack,
|
add_setshow_enum_cmd ("frame-arguments", class_stack,
|
print_frame_arguments_choices, &print_frame_arguments,
|
print_frame_arguments_choices, &print_frame_arguments,
|
_("Set printing of non-scalar frame arguments"),
|
_("Set printing of non-scalar frame arguments"),
|
_("Show printing of non-scalar frame arguments"),
|
_("Show printing of non-scalar frame arguments"),
|
NULL, NULL, NULL, &setprintlist, &showprintlist);
|
NULL, NULL, NULL, &setprintlist, &showprintlist);
|
|
|
add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
|
add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack,
|
&disassemble_next_line, _("\
|
&disassemble_next_line, _("\
|
Set whether to disassemble next source line or insn when execution stops."), _("\
|
Set whether to disassemble next source line or insn when execution stops."), _("\
|
Show whether to disassemble next source line or insn when execution stops."), _("\
|
Show whether to disassemble next source line or insn when execution stops."), _("\
|
If ON, GDB will display disassembly of the next source line, in addition\n\
|
If ON, GDB will display disassembly of the next source line, in addition\n\
|
to displaying the source line itself. If the next source line cannot\n\
|
to displaying the source line itself. If the next source line cannot\n\
|
be displayed (e.g., source is unavailable or there's no line info), GDB\n\
|
be displayed (e.g., source is unavailable or there's no line info), GDB\n\
|
will display disassembly of next instruction instead of showing the\n\
|
will display disassembly of next instruction instead of showing the\n\
|
source line.\n\
|
source line.\n\
|
If AUTO, display disassembly of next instruction only if the source line\n\
|
If AUTO, display disassembly of next instruction only if the source line\n\
|
cannot be displayed.\n\
|
cannot be displayed.\n\
|
If OFF (which is the default), never display the disassembly of the next\n\
|
If OFF (which is the default), never display the disassembly of the next\n\
|
source line."),
|
source line."),
|
NULL,
|
NULL,
|
show_disassemble_next_line,
|
show_disassemble_next_line,
|
&setlist, &showlist);
|
&setlist, &showlist);
|
disassemble_next_line = AUTO_BOOLEAN_FALSE;
|
disassemble_next_line = AUTO_BOOLEAN_FALSE;
|
|
|
#if 0
|
#if 0
|
add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
|
add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\
|
"Specify maximum number of frames for \"backtrace\" to print by default."),
|
"Specify maximum number of frames for \"backtrace\" to print by default."),
|
&setlist);
|
&setlist);
|
add_info ("backtrace-limit", backtrace_limit_info, _("\
|
add_info ("backtrace-limit", backtrace_limit_info, _("\
|
The maximum number of frames for \"backtrace\" to print by default."));
|
The maximum number of frames for \"backtrace\" to print by default."));
|
#endif
|
#endif
|
}
|
}
|
|
|
