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