print_frame_info (fi, level, source, 1);
}
+struct print_args_args {
+ struct symbol *func;
+ struct frame_info *fi;
+};
+
+static int print_args_stub PARAMS ((char *));
+
+/* Pass the args the way catch_errors wants them. */
+static int
+print_args_stub (args)
+ char *args;
+{
+ int numargs;
+ struct print_args_args *p = (struct print_args_args *)args;
+ FRAME_NUM_ARGS (numargs, (p->fi));
+ print_frame_args (p->func, p->fi, numargs, stdout);
+ return 0;
+}
+
void
print_frame_info (fi, level, source, args)
struct frame_info *fi;
struct symbol *func;
register char *funname = 0;
enum language funlang = language_unknown;
- int numargs;
-
- if (PC_IN_CALL_DUMMY (fi->pc, read_register (SP_REGNUM), fi->frame))
+ char buf[MAX_REGISTER_RAW_SIZE];
+ CORE_ADDR sp;
+
+ /* Get the value of SP_REGNUM relative to the frame. */
+ get_saved_register (buf, (int *)NULL, (CORE_ADDR *)NULL,
+ FRAME_INFO_ID (fi), SP_REGNUM, (enum lval_type *)NULL);
+ sp = extract_address (buf, REGISTER_RAW_SIZE (SP_REGNUM));
+
+ /* This is not a perfect test, because if a function alloca's some
+ memory, puts some code there, and then jumps into it, then the test
+ will succeed even though there is no call dummy. A better
+ solution would be to keep track of where the call dummies are.
+ Probably the best way to do that is by setting a breakpoint.c
+ breakpoint at the end of the call dummy (wanted anyway, to clean
+ up wait_for_inferior). Then we know that the sizeof (CALL_DUMMY)
+ (or some such) bytes before that breakpoint are a call dummy.
+ Only problem I see with this approach is figuring out to get rid
+ of the breakpoint whenever the call dummy vanishes (e.g.
+ return_command, or longjmp out of the called function), which we
+ probably can solve (it's very similar to figuring out when a
+ watchpoint on a local variable goes out of scope if it is being
+ watched via something like a 386 debug register). */
+ if (PC_IN_CALL_DUMMY (fi->pc, sp, fi->frame))
{
/* Do this regardless of SOURCE because we don't have any source
to list for this frame. */
printf_filtered ("<function called from gdb>\n");
return;
}
+ if (fi->signal_handler_caller)
+ {
+ /* Do this regardless of SOURCE because we don't have any source
+ to list for this frame. */
+ if (level >= 0)
+ printf_filtered ("#%-2d ", level);
+ printf_filtered ("<signal handler called>\n");
+ return;
+ }
+
+ /* If fi is not the innermost frame, that normally means that fi->pc
+ points to *after* the call instruction, and we want to get the line
+ containing the call, never the next line. But if the next frame is
+ a signal_handler_caller frame, then the next frame was not entered
+ as the result of a call, and we want to get the line containing
+ fi->pc. */
+ sal =
+ find_pc_line (fi->pc,
+ fi->next != NULL && fi->next->signal_handler_caller == 0);
- sal = find_pc_line (fi->pc, fi->next_frame);
func = find_pc_function (fi->pc);
if (func)
{
is compiled with debugging symbols, and the "foo.o" symbol
that is supposed to tell us where the file with debugging symbols
ends has been truncated by ar because it is longer than 15
- characters).
+ characters). This also occurs if the user uses asm() to create
+ a function but not stabs for it (in a file compiled -g).
So look in the minimal symbol tables as well, and if it comes
up with a larger address for the function use that instead.
I don't think this can ever cause any problems; there shouldn't
- be any minimal symbols in the middle of a function.
- FIXME: (Not necessarily true. What about text labels) */
+ be any minimal symbols in the middle of a function; if this is
+ ever changed many parts of GDB will need to be changed (and we'll
+ create a find_pc_minimal_function or some such). */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (fi->pc);
if (msymbol != NULL
fputs_filtered (" (", stdout);
if (args)
{
- FRAME_NUM_ARGS (numargs, fi);
- print_frame_args (func, fi, numargs, stdout);
+ struct print_args_args args;
+ args.fi = fi;
+ args.func = func;
+ catch_errors (print_args_stub, (char *)&args, "", RETURN_MASK_ERROR);
}
printf_filtered (")");
if (sal.symtab && sal.symtab->filename)
int done = 0;
int mid_statement = source < 0 && fi->pc != sal.pc;
if (frame_file_full_name)
- done = identify_source_line (sal.symtab, sal.line, mid_statement);
+ done = identify_source_line (sal.symtab, sal.line, mid_statement,
+ fi->pc);
if (!done)
{
if (addressprint && mid_statement)
char *frame_exp;
{
int numargs = 0;
- int arg1, arg2, arg3;
#define MAXARGS 4
int args[MAXARGS];
enum language funlang = language_unknown;
if (!target_has_stack)
- error ("No inferior or core file.");
+ error ("No stack.");
frame = parse_frame_specification (addr_exp);
if (!frame)
error ("Invalid frame specified.");
fi = get_frame_info (frame);
- sal = find_pc_line (fi->pc, fi->next_frame);
+ sal = find_pc_line (fi->pc,
+ fi->next != NULL && fi->next->signal_handler_caller == 0);
func = get_frame_function (frame);
s = find_pc_symtab(fi->pc);
if (func)
if (calling_frame)
printf_filtered (" called by frame at %s",
local_hex_string(FRAME_FP (calling_frame)));
- if (fi->next_frame && calling_frame)
+ if (fi->next && calling_frame)
puts_filtered (",");
wrap_here (" ");
- if (fi->next_frame)
- printf_filtered (" caller of frame at %s", local_hex_string(fi->next_frame));
- if (fi->next_frame || calling_frame)
+ if (fi->next)
+ printf_filtered (" caller of frame at %s",
+ local_hex_string (fi->next->frame));
+ if (fi->next || calling_frame)
puts_filtered ("\n");
if (s)
printf_filtered(" source language %s.\n", language_str(s->language));
for (i = 0; i < nsyms; i++)
{
sym = BLOCK_SYM (b, i);
- if (SYMBOL_CLASS (sym) == LOC_ARG
- || SYMBOL_CLASS (sym) == LOC_LOCAL_ARG
- || SYMBOL_CLASS (sym) == LOC_REF_ARG
- || SYMBOL_CLASS (sym) == LOC_REGPARM)
+ switch (SYMBOL_CLASS (sym))
{
+ case LOC_ARG:
+ case LOC_LOCAL_ARG:
+ case LOC_REF_ARG:
+ case LOC_REGPARM:
+ case LOC_REGPARM_ADDR:
+ case LOC_BASEREG_ARG:
values_printed = 1;
fputs_filtered (SYMBOL_SOURCE_NAME (sym), stream);
fputs_filtered (" = ", stream);
- /* We have to look up the symbol because arguments often have
- two entries (one a parameter, one a register) and the one
- we want is the register, which lookup_symbol will find for
- us. */
+
+ /* We have to look up the symbol because arguments can have
+ two entries (one a parameter, one a local) and the one we
+ want is the local, which lookup_symbol will find for us.
+ This includes gcc1 (not gcc2) on the sparc when passing a
+ small structure and gcc2 when the argument type is float
+ and it is passed as a double and converted to float by
+ the prologue (in the latter case the type of the LOC_ARG
+ symbol is double and the type of the LOC_LOCAL symbol is
+ float). There are also LOC_ARG/LOC_REGISTER pairs which
+ are not combined in symbol-reading. */
+
sym2 = lookup_symbol (SYMBOL_NAME (sym),
b, VAR_NAMESPACE, (int *)NULL, (struct symtab **)NULL);
print_variable_value (sym2, frame, stream);
fprintf_filtered (stream, "\n");
+ break;
+
+ default:
+ /* Don't worry about things which aren't arguments. */
+ break;
}
}
FRAME_ADDR selected_frame_addr;
CORE_ADDR selected_frame_pc;
FRAME frame;
- value return_value;
+ value return_value = NULL;
if (selected_frame == NULL)
error ("No selected frame.");
projects / deliverable / binutils-gdb.git / blobdiff