X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fblockframe.c;h=a55e85a9f8d0188b6267c5eb36f2ab4ac80a2fe1;hb=ee824ca663bb513ba3c2637e154b19f2ef373349;hp=7acbf6a41f22f895b00b955101a090714973a405;hpb=cef4c2e7a5f2d3426a8255f74b6c7f4e795fd9a4;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/blockframe.c b/gdb/blockframe.c index 7acbf6a41f..a55e85a9f8 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -1,6 +1,6 @@ /* Get info from stack frames; convert between frames, blocks, functions and pc values. - Copyright 1986, 1987, 1988, 1989, 1991 Free Software Foundation, Inc. + Copyright 1986, 1987, 1988, 1989, 1991, 1994 Free Software Foundation, Inc. This file is part of GDB. @@ -16,7 +16,7 @@ GNU General Public License for more details. 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. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" #include "symtab.h" @@ -28,6 +28,7 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "value.h" /* for read_register */ #include "target.h" /* for target_has_stack */ #include "inferior.h" /* for read_pc */ +#include "annotate.h" /* Is ADDR inside the startup file? Note that if your machine has a way to detect the bottom of the stack, there is no need @@ -67,10 +68,23 @@ int inside_main_func (pc) CORE_ADDR pc; { +struct symbol *mainsym; if (pc == 0) return 1; if (symfile_objfile == 0) return 0; + + if (symfile_objfile -> ei.main_func_lowpc == 0 && + symfile_objfile -> ei.main_func_highpc == 0) + { + mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL); + if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK) + { + symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); + symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); + } + + } return (symfile_objfile -> ei.main_func_lowpc <= pc && symfile_objfile -> ei.main_func_highpc > pc); } @@ -101,89 +115,90 @@ CORE_ADDR pc; symfile_objfile -> ei.entry_func_highpc > pc); } -/* Address of innermost stack frame (contents of FP register) */ +/* Info about the innermost stack frame (contents of FP register) */ + +static struct frame_info *current_frame; -static FRAME current_frame; +/* Cache for frame addresses already read by gdb. Valid only while + inferior is stopped. Control variables for the frame cache should + be local to this module. */ -/* - * Cache for frame addresses already read by gdb. Valid only while - * inferior is stopped. Control variables for the frame cache should - * be local to this module. - */ struct obstack frame_cache_obstack; /* Return the innermost (currently executing) stack frame. */ -FRAME +struct frame_info * get_current_frame () { - /* We assume its address is kept in a general register; - param.h says which register. */ - + if (current_frame == NULL) + { + if (target_has_stack) + current_frame = create_new_frame (read_fp (), read_pc ()); + else + error ("No stack."); + } return current_frame; } void set_current_frame (frame) - FRAME frame; + struct frame_info *frame; { current_frame = frame; } -FRAME +/* Create an arbitrary (i.e. address specified by user) or innermost frame. + Always returns a non-NULL value. */ + +struct frame_info * create_new_frame (addr, pc) - FRAME_ADDR addr; + CORE_ADDR addr; CORE_ADDR pc; { - struct frame_info *fci; /* Same type as FRAME */ + struct frame_info *fi; char *name; - fci = (struct frame_info *) + fi = (struct frame_info *) obstack_alloc (&frame_cache_obstack, sizeof (struct frame_info)); /* Arbitrary frame */ - fci->next = (struct frame_info *) 0; - fci->prev = (struct frame_info *) 0; - fci->frame = addr; - fci->pc = pc; + fi->next = NULL; + fi->prev = NULL; + fi->frame = addr; + fi->pc = pc; find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL); - fci->signal_handler_caller = IN_SIGTRAMP (fci->pc, name); + fi->signal_handler_caller = IN_SIGTRAMP (fi->pc, name); #ifdef INIT_EXTRA_FRAME_INFO - INIT_EXTRA_FRAME_INFO (0, fci); + INIT_EXTRA_FRAME_INFO (0, fi); #endif - return fci; + return fi; } -/* Return the frame that called FRAME. - If FRAME is the original frame (it has no caller), return 0. */ +/* Return the frame that called FI. + If FI is the original frame (it has no caller), return 0. */ -FRAME +struct frame_info * get_prev_frame (frame) - FRAME frame; + struct frame_info *frame; { - /* We're allowed to know that FRAME and "struct frame_info *" are - the same */ return get_prev_frame_info (frame); } -/* Return the frame that FRAME calls (0 if FRAME is the innermost +/* Return the frame that FRAME calls (NULL if FRAME is the innermost frame). */ -FRAME +struct frame_info * get_next_frame (frame) - FRAME frame; + struct frame_info *frame; { - /* We're allowed to know that FRAME and "struct frame_info *" are - the same */ return frame->next; } -/* - * Flush the entire frame cache. - */ +/* Flush the entire frame cache. */ + void flush_cached_frames () { @@ -191,38 +206,23 @@ flush_cached_frames () obstack_free (&frame_cache_obstack, 0); obstack_init (&frame_cache_obstack); - current_frame = (struct frame_info *) 0; /* Invalidate cache */ + current_frame = NULL; /* Invalidate cache */ + select_frame (NULL, -1); + annotate_frames_invalid (); } /* Flush the frame cache, and start a new one if necessary. */ + void reinit_frame_cache () { flush_cached_frames (); - if (target_has_stack) + + /* FIXME: The inferior_pid test is wrong if there is a corefile. */ + if (inferior_pid != 0) { - set_current_frame (create_new_frame (read_fp (), read_pc ())); select_frame (get_current_frame (), 0); } - else - { - set_current_frame (0); - select_frame ((FRAME) 0, -1); - } -} - -/* Return a structure containing various interesting information - about a specified stack frame. */ -/* How do I justify including this function? Well, the FRAME - identifier format has gone through several changes recently, and - it's not completely inconceivable that it could happen again. If - it does, have this routine around will help */ - -struct frame_info * -get_frame_info (frame) - FRAME frame; -{ - return frame; } /* If a machine allows frameless functions, it should define a macro @@ -236,11 +236,10 @@ get_frame_info (frame) int frameless_look_for_prologue (frame) - FRAME frame; + struct frame_info *frame; { CORE_ADDR func_start, after_prologue; - func_start = (get_pc_function_start (frame->pc) + - FUNCTION_START_OFFSET); + func_start = (get_pc_function_start (frame->pc) + FUNCTION_START_OFFSET); if (func_start) { after_prologue = func_start; @@ -279,9 +278,9 @@ frameless_look_for_prologue (frame) struct frame_info * get_prev_frame_info (next_frame) - FRAME next_frame; + struct frame_info *next_frame; { - FRAME_ADDR address = 0; + CORE_ADDR address = 0; struct frame_info *prev; int fromleaf = 0; char *name; @@ -292,10 +291,16 @@ get_prev_frame_info (next_frame) if (!next_frame) { +#if 0 + /* This screws value_of_variable, which just wants a nice clean + NULL return from block_innermost_frame if there are no frames. + I don't think I've ever seen this message happen otherwise. + And returning NULL here is a perfectly legitimate thing to do. */ if (!current_frame) { error ("You haven't set up a process's stack to examine."); } +#endif return current_frame; } @@ -317,7 +322,7 @@ get_prev_frame_info (next_frame) { FRAMELESS_FUNCTION_INVOCATION (next_frame, fromleaf); if (fromleaf) - address = next_frame->frame; + address = FRAME_FP (next_frame); } #endif @@ -372,8 +377,8 @@ get_prev_frame_info (next_frame) We shouldn't need INIT_FRAME_PC_FIRST to add more complication to an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92. - To answer the question, yes the sparc needs INIT_FRAME_PC after - INIT_EXTRA_FRAME_INFO. Suggested scheme: + Assuming that some machines need INIT_FRAME_PC after + INIT_EXTRA_FRAME_INFO, one possible scheme: SETUP_INNERMOST_FRAME() Default version is just create_new_frame (read_fp ()), @@ -383,13 +388,18 @@ get_prev_frame_info (next_frame) Only change here is that create_new_frame would no longer init extra frame info; SETUP_ARBITRARY_FRAME would have to do that. INIT_PREV_FRAME(fromleaf, prev) - Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. + Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should + also return a flag saying whether to keep the new frame, or + whether to discard it, because on some machines (e.g. mips) it + is really awkward to have FRAME_CHAIN_VALID called *before* + INIT_EXTRA_FRAME_INFO (there is no good way to get information + deduced in FRAME_CHAIN_VALID into the extra fields of the new frame). std_frame_pc(fromleaf, prev) This is the default setting for INIT_PREV_FRAME. It just does what the default INIT_FRAME_PC does. Some machines will call it from INIT_PREV_FRAME (either at the beginning, the end, or in the middle). Some machines won't use it. - kingdon@cygnus.com, 13Apr93. */ + kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */ #ifdef INIT_FRAME_PC_FIRST INIT_FRAME_PC_FIRST (fromleaf, prev); @@ -400,10 +410,25 @@ get_prev_frame_info (next_frame) #endif /* This entry is in the frame queue now, which is good since - FRAME_SAVED_PC may use that queue to figure out it's value + FRAME_SAVED_PC may use that queue to figure out its value (see tm-sparc.h). We want the pc saved in the inferior frame. */ INIT_FRAME_PC(fromleaf, prev); + /* If ->frame and ->pc are unchanged, we are in the process of getting + ourselves into an infinite backtrace. Some architectures check this + in FRAME_CHAIN or thereabouts, but it seems like there is no reason + this can't be an architecture-independent check. */ + if (next_frame != NULL) + { + if (prev->frame == next_frame->frame + && prev->pc == next_frame->pc) + { + next_frame->prev = NULL; + obstack_free (&frame_cache_obstack, prev); + return NULL; + } + } + find_pc_partial_function (prev->pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL); if (IN_SIGTRAMP (prev->pc, name)) @@ -414,22 +439,20 @@ get_prev_frame_info (next_frame) CORE_ADDR get_frame_pc (frame) - FRAME frame; + struct frame_info *frame; { - struct frame_info *fi; - fi = get_frame_info (frame); - return fi->pc; + return frame->pc; } #if defined (FRAME_FIND_SAVED_REGS) /* Find the addresses in which registers are saved in FRAME. */ void -get_frame_saved_regs (frame_info_addr, saved_regs_addr) - struct frame_info *frame_info_addr; +get_frame_saved_regs (frame, saved_regs_addr) + struct frame_info *frame; struct frame_saved_regs *saved_regs_addr; { - FRAME_FIND_SAVED_REGS (frame_info_addr, *saved_regs_addr); + FRAME_FIND_SAVED_REGS (frame, *saved_regs_addr); } #endif @@ -438,20 +461,18 @@ get_frame_saved_regs (frame_info_addr, saved_regs_addr) struct block * get_frame_block (frame) - FRAME frame; + struct frame_info *frame; { - struct frame_info *fi; CORE_ADDR pc; - fi = get_frame_info (frame); - - pc = fi->pc; - if (fi->next != 0) - /* We are not in the innermost frame. We need to subtract one to - get the correct block, in case the call instruction was the - last instruction of the block. If there are any machines on - which the saved pc does not point to after the call insn, we - probably want to make fi->pc point after the call insn anyway. */ + pc = frame->pc; + if (frame->next != 0 && frame->next->signal_handler_caller == 0) + /* We are not in the innermost frame and we were not interrupted + by a signal. We need to subtract one to get the correct block, + in case the call instruction was the last instruction of the block. + If there are any machines on which the saved pc does not point to + after the call insn, we probably want to make frame->pc point after + the call insn anyway. */ --pc; return block_for_pc (pc); } @@ -492,7 +513,7 @@ get_pc_function_start (pc) struct symbol * get_frame_function (frame) - FRAME frame; + struct frame_info *frame; { register struct block *bl = get_frame_block (frame); if (bl == 0) @@ -624,6 +645,7 @@ find_pc_partial_function (pc, name, address, endaddr) struct symbol *f; struct minimal_symbol *msymbol; struct partial_symbol *psb; + struct obj_section *sec; if (pc >= cache_pc_function_low && pc < cache_pc_function_high) goto return_cached_value; @@ -647,7 +669,12 @@ find_pc_partial_function (pc, name, address, endaddr) { /* Need to read the symbols to get a good value for the end address. */ if (endaddr != NULL && !pst->readin) - PSYMTAB_TO_SYMTAB (pst); + { + /* Need to get the terminal in case symbol-reading produces + output. */ + target_terminal_ours_for_output (); + PSYMTAB_TO_SYMTAB (pst); + } if (pst->readin) { @@ -688,6 +715,16 @@ find_pc_partial_function (pc, name, address, endaddr) } } + /* Not in the normal symbol tables, see if the pc is in a known section. + If it's not, then give up. This ensures that anything beyond the end + of the text seg doesn't appear to be part of the last function in the + text segment. */ + + sec = find_pc_section (pc); + + if (!sec) + msymbol = NULL; + /* Must be in the minimal symbol table. */ if (msymbol == NULL) { @@ -701,40 +738,37 @@ find_pc_partial_function (pc, name, address, endaddr) return 0; } - /* I believe the purpose of this check is to make sure that anything - beyond the end of the text segment does not appear as part of the - last function of the text segment. It assumes that there is something - other than a mst_text symbol after the text segment. It is broken in - various cases, so anything relying on this behavior (there might be - some places) should be using find_pc_section or some such instead. */ - if (msymbol -> type == mst_text) + /* See if we're in a transfer table for Sun shared libs. + + Note the hack for Sun shared library transfer tables creates + problems for single stepping through the return path from a shared + library call if the return path includes trampoline code. + + I don't really understand the reasoning behind the magic handling + for mst_trampoline symbols. */ + +#ifdef INHIBIT_SUNSOLIB_TRANSFER_TABLE_HACK + cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol); +#else + if (msymbol -> type == mst_text || msymbol -> type == mst_file_text) cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol); else /* It is a transfer table for Sun shared libraries. */ cache_pc_function_low = pc - FUNCTION_START_OFFSET; +#endif + cache_pc_function_name = SYMBOL_NAME (msymbol); - if (SYMBOL_NAME (msymbol + 1) != NULL) - /* This might be part of a different segment, which might be a bad - idea. Perhaps we should be using the smaller of this address or the - endaddr from find_pc_section. */ + /* Use the lesser of the next minimal symbol, or the end of the section, as + the end of the function. */ + + if (SYMBOL_NAME (msymbol + 1) != NULL + && SYMBOL_VALUE_ADDRESS (msymbol + 1) < sec->endaddr) cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + 1); else - { - /* We got the start address from the last msymbol in the objfile. - So the end address is the end of the section. */ - struct obj_section *sec; - - sec = find_pc_section (pc); - if (sec == NULL) - { - /* Don't know if this can happen but if it does, then just say - that the function is 1 byte long. */ - cache_pc_function_high = cache_pc_function_low + 1; - } - else - cache_pc_function_high = sec->endaddr; - } + /* We got the start address from the last msymbol in the objfile. + So the end address is the end of the section. */ + cache_pc_function_high = sec->endaddr; return_cached_value: if (address) @@ -749,12 +783,11 @@ find_pc_partial_function (pc, name, address, endaddr) /* Return the innermost stack frame executing inside of BLOCK, or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */ -FRAME +struct frame_info * block_innermost_frame (block) struct block *block; { - struct frame_info *fi; - register FRAME frame; + struct frame_info *frame; register CORE_ADDR start; register CORE_ADDR end; @@ -764,14 +797,35 @@ block_innermost_frame (block) start = BLOCK_START (block); end = BLOCK_END (block); - frame = 0; + frame = NULL; while (1) { frame = get_prev_frame (frame); - if (frame == 0) - return 0; - fi = get_frame_info (frame); - if (fi->pc >= start && fi->pc < end) + if (frame == NULL) + return NULL; + if (frame->pc >= start && frame->pc < end) + return frame; + } +} + +/* Return the full FRAME which corresponds to the given CORE_ADDR + or NULL if no FRAME on the chain corresponds to CORE_ADDR. */ + +struct frame_info * +find_frame_addr_in_frame_chain (frame_addr) + CORE_ADDR frame_addr; +{ + struct frame_info *frame = NULL; + + if (frame_addr == (CORE_ADDR)0) + return NULL; + + while (1) + { + frame = get_prev_frame (frame); + if (frame == NULL) + return NULL; + if (FRAME_FP (frame) == frame_addr) return frame; } } @@ -781,7 +835,7 @@ block_innermost_frame (block) CORE_ADDR sigtramp_saved_pc (frame) - FRAME frame; + struct frame_info *frame; { CORE_ADDR sigcontext_addr; char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT]; @@ -791,7 +845,8 @@ sigtramp_saved_pc (frame) /* Get sigcontext address, it is the third parameter on the stack. */ if (frame->next) sigcontext_addr = read_memory_integer (FRAME_ARGS_ADDRESS (frame->next) - + FRAME_ARGS_SKIP + sigcontext_offs, + + FRAME_ARGS_SKIP + + sigcontext_offs, ptrbytes); else sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)