1 /* Get info from stack frames; convert between frames, blocks,
2 functions and pc values.
4 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
5 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
32 #include "value.h" /* for read_register */
33 #include "target.h" /* for target_has_stack */
34 #include "inferior.h" /* for read_pc */
37 #include "gdb_assert.h"
38 #include "dummy-frame.h"
40 /* Prototypes for exported functions. */
42 void _initialize_blockframe (void);
44 /* A default FRAME_CHAIN_VALID, in the form that is suitable for most
45 targets. If FRAME_CHAIN_VALID returns zero it means that the given
46 frame is the outermost one and has no caller. */
49 file_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
52 && !inside_entry_file (frame_pc_unwind (thisframe)));
55 /* Use the alternate method of avoiding running up off the end of the
56 frame chain or following frames back into the startup code. See
57 the comments in objfiles.h. */
60 func_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
63 && !inside_main_func ((thisframe)->pc)
64 && !inside_entry_func ((thisframe)->pc));
67 /* A very simple method of determining a valid frame */
70 nonnull_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
72 return ((chain) != 0);
75 /* Is ADDR inside the startup file? Note that if your machine
76 has a way to detect the bottom of the stack, there is no need
77 to call this function from FRAME_CHAIN_VALID; the reason for
78 doing so is that some machines have no way of detecting bottom
81 A PC of zero is always considered to be the bottom of the stack. */
84 inside_entry_file (CORE_ADDR addr)
88 if (symfile_objfile == 0)
90 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
92 /* Do not stop backtracing if the pc is in the call dummy
93 at the entry point. */
94 /* FIXME: Won't always work with zeros for the last two arguments */
95 if (PC_IN_CALL_DUMMY (addr, 0, 0))
98 return (addr >= symfile_objfile->ei.entry_file_lowpc &&
99 addr < symfile_objfile->ei.entry_file_highpc);
102 /* Test a specified PC value to see if it is in the range of addresses
103 that correspond to the main() function. See comments above for why
104 we might want to do this.
106 Typically called from FRAME_CHAIN_VALID.
108 A PC of zero is always considered to be the bottom of the stack. */
111 inside_main_func (CORE_ADDR pc)
115 if (symfile_objfile == 0)
118 /* If the addr range is not set up at symbol reading time, set it up now.
119 This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
120 it is unable to set it up and symbol reading time. */
122 if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
123 symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
125 struct symbol *mainsym;
127 mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
128 if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
130 symfile_objfile->ei.main_func_lowpc =
131 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
132 symfile_objfile->ei.main_func_highpc =
133 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
136 return (symfile_objfile->ei.main_func_lowpc <= pc &&
137 symfile_objfile->ei.main_func_highpc > pc);
140 /* Test a specified PC value to see if it is in the range of addresses
141 that correspond to the process entry point function. See comments
142 in objfiles.h for why we might want to do this.
144 Typically called from FRAME_CHAIN_VALID.
146 A PC of zero is always considered to be the bottom of the stack. */
149 inside_entry_func (CORE_ADDR pc)
153 if (symfile_objfile == 0)
155 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
157 /* Do not stop backtracing if the pc is in the call dummy
158 at the entry point. */
159 /* FIXME: Won't always work with zeros for the last two arguments */
160 if (PC_IN_CALL_DUMMY (pc, 0, 0))
163 return (symfile_objfile->ei.entry_func_lowpc <= pc &&
164 symfile_objfile->ei.entry_func_highpc > pc);
167 /* Return nonzero if the function for this frame lacks a prologue. Many
168 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
172 frameless_look_for_prologue (struct frame_info *frame)
174 CORE_ADDR func_start, after_prologue;
176 func_start = get_pc_function_start (frame->pc);
179 func_start += FUNCTION_START_OFFSET;
180 /* This is faster, since only care whether there *is* a
181 prologue, not how long it is. */
182 return PROLOGUE_FRAMELESS_P (func_start);
184 else if (frame->pc == 0)
185 /* A frame with a zero PC is usually created by dereferencing a
186 NULL function pointer, normally causing an immediate core dump
187 of the inferior. Mark function as frameless, as the inferior
188 has no chance of setting up a stack frame. */
191 /* If we can't find the start of the function, we don't really
192 know whether the function is frameless, but we should be able
193 to get a reasonable (i.e. best we can do under the
194 circumstances) backtrace by saying that it isn't. */
198 /* return the address of the PC for the given FRAME, ie the current PC value
199 if FRAME is the innermost frame, or the address adjusted to point to the
200 call instruction if not. */
203 frame_address_in_block (struct frame_info *frame)
205 CORE_ADDR pc = frame->pc;
207 /* If we are not in the innermost frame, and we are not interrupted
208 by a signal, frame->pc points to the instruction following the
209 call. As a consequence, we need to get the address of the previous
210 instruction. Unfortunately, this is not straightforward to do, so
211 we just use the address minus one, which is a good enough
213 /* FIXME: cagney/2002-11-10: Should this instead test for
214 NORMAL_FRAME? A dummy frame (in fact all the abnormal frames)
215 save the PC value in the block. */
217 && get_frame_type (frame->next) != SIGTRAMP_FRAME)
223 /* Return the innermost lexical block in execution
224 in a specified stack frame. The frame address is assumed valid.
226 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
227 address we used to choose the block. We use this to find a source
228 line, to decide which macro definitions are in scope.
230 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
231 PC, and may not really be a valid PC at all. For example, in the
232 caller of a function declared to never return, the code at the
233 return address will never be reached, so the call instruction may
234 be the very last instruction in the block. So the address we use
235 to choose the block is actually one byte before the return address
236 --- hopefully pointing us at the call instruction, or its delay
240 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
242 const CORE_ADDR pc = frame_address_in_block (frame);
247 return block_for_pc (pc);
251 get_current_block (CORE_ADDR *addr_in_block)
253 CORE_ADDR pc = read_pc ();
258 return block_for_pc (pc);
262 get_pc_function_start (CORE_ADDR pc)
264 register struct block *bl;
265 register struct symbol *symbol;
266 register struct minimal_symbol *msymbol;
269 if ((bl = block_for_pc (pc)) != NULL &&
270 (symbol = block_function (bl)) != NULL)
272 bl = SYMBOL_BLOCK_VALUE (symbol);
273 fstart = BLOCK_START (bl);
275 else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
277 fstart = SYMBOL_VALUE_ADDRESS (msymbol);
278 if (!find_pc_section (fstart))
288 /* Return the symbol for the function executing in frame FRAME. */
291 get_frame_function (struct frame_info *frame)
293 register struct block *bl = get_frame_block (frame, 0);
296 return block_function (bl);
300 /* Return the blockvector immediately containing the innermost lexical block
301 containing the specified pc value and section, or 0 if there is none.
302 PINDEX is a pointer to the index value of the block. If PINDEX
303 is NULL, we don't pass this information back to the caller. */
306 blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section,
307 int *pindex, struct symtab *symtab)
309 register struct block *b;
310 register int bot, top, half;
311 struct blockvector *bl;
313 if (symtab == 0) /* if no symtab specified by caller */
315 /* First search all symtabs for one whose file contains our pc */
316 if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
320 bl = BLOCKVECTOR (symtab);
321 b = BLOCKVECTOR_BLOCK (bl, 0);
323 /* Then search that symtab for the smallest block that wins. */
324 /* Use binary search to find the last block that starts before PC. */
327 top = BLOCKVECTOR_NBLOCKS (bl);
329 while (top - bot > 1)
331 half = (top - bot + 1) >> 1;
332 b = BLOCKVECTOR_BLOCK (bl, bot + half);
333 if (BLOCK_START (b) <= pc)
339 /* Now search backward for a block that ends after PC. */
343 b = BLOCKVECTOR_BLOCK (bl, bot);
344 if (BLOCK_END (b) > pc)
355 /* Return the blockvector immediately containing the innermost lexical block
356 containing the specified pc value, or 0 if there is none.
357 Backward compatibility, no section. */
360 blockvector_for_pc (register CORE_ADDR pc, int *pindex)
362 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
366 /* Return the innermost lexical block containing the specified pc value
367 in the specified section, or 0 if there is none. */
370 block_for_pc_sect (register CORE_ADDR pc, struct sec *section)
372 register struct blockvector *bl;
375 bl = blockvector_for_pc_sect (pc, section, &index, NULL);
377 return BLOCKVECTOR_BLOCK (bl, index);
381 /* Return the innermost lexical block containing the specified pc value,
382 or 0 if there is none. Backward compatibility, no section. */
385 block_for_pc (register CORE_ADDR pc)
387 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
390 /* Return the function containing pc value PC in section SECTION.
391 Returns 0 if function is not known. */
394 find_pc_sect_function (CORE_ADDR pc, struct sec *section)
396 register struct block *b = block_for_pc_sect (pc, section);
399 return block_function (b);
402 /* Return the function containing pc value PC.
403 Returns 0 if function is not known. Backward compatibility, no section */
406 find_pc_function (CORE_ADDR pc)
408 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
411 /* These variables are used to cache the most recent result
412 * of find_pc_partial_function. */
414 static CORE_ADDR cache_pc_function_low = 0;
415 static CORE_ADDR cache_pc_function_high = 0;
416 static char *cache_pc_function_name = 0;
417 static struct sec *cache_pc_function_section = NULL;
419 /* Clear cache, e.g. when symbol table is discarded. */
422 clear_pc_function_cache (void)
424 cache_pc_function_low = 0;
425 cache_pc_function_high = 0;
426 cache_pc_function_name = (char *) 0;
427 cache_pc_function_section = NULL;
430 /* Finds the "function" (text symbol) that is smaller than PC but
431 greatest of all of the potential text symbols in SECTION. Sets
432 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
433 If ENDADDR is non-null, then set *ENDADDR to be the end of the
434 function (exclusive), but passing ENDADDR as non-null means that
435 the function might cause symbols to be read. This function either
436 succeeds or fails (not halfway succeeds). If it succeeds, it sets
437 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
438 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
442 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
443 CORE_ADDR *address, CORE_ADDR *endaddr)
445 struct partial_symtab *pst;
447 struct minimal_symbol *msymbol;
448 struct partial_symbol *psb;
449 struct obj_section *osect;
453 mapped_pc = overlay_mapped_address (pc, section);
455 if (mapped_pc >= cache_pc_function_low
456 && mapped_pc < cache_pc_function_high
457 && section == cache_pc_function_section)
458 goto return_cached_value;
460 /* If sigtramp is in the u area, it counts as a function (especially
461 important for step_1). */
462 if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
464 cache_pc_function_low = SIGTRAMP_START (mapped_pc);
465 cache_pc_function_high = SIGTRAMP_END (mapped_pc);
466 cache_pc_function_name = "<sigtramp>";
467 cache_pc_function_section = section;
468 goto return_cached_value;
471 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
472 pst = find_pc_sect_psymtab (mapped_pc, section);
475 /* Need to read the symbols to get a good value for the end address. */
476 if (endaddr != NULL && !pst->readin)
478 /* Need to get the terminal in case symbol-reading produces
480 target_terminal_ours_for_output ();
481 PSYMTAB_TO_SYMTAB (pst);
486 /* Checking whether the msymbol has a larger value is for the
487 "pathological" case mentioned in print_frame_info. */
488 f = find_pc_sect_function (mapped_pc, section);
491 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
492 >= SYMBOL_VALUE_ADDRESS (msymbol))))
494 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
495 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
496 cache_pc_function_name = SYMBOL_NAME (f);
497 cache_pc_function_section = section;
498 goto return_cached_value;
503 /* Now that static symbols go in the minimal symbol table, perhaps
504 we could just ignore the partial symbols. But at least for now
505 we use the partial or minimal symbol, whichever is larger. */
506 psb = find_pc_sect_psymbol (pst, mapped_pc, section);
509 && (msymbol == NULL ||
510 (SYMBOL_VALUE_ADDRESS (psb)
511 >= SYMBOL_VALUE_ADDRESS (msymbol))))
513 /* This case isn't being cached currently. */
515 *address = SYMBOL_VALUE_ADDRESS (psb);
517 *name = SYMBOL_NAME (psb);
518 /* endaddr non-NULL can't happen here. */
524 /* Not in the normal symbol tables, see if the pc is in a known section.
525 If it's not, then give up. This ensures that anything beyond the end
526 of the text seg doesn't appear to be part of the last function in the
529 osect = find_pc_sect_section (mapped_pc, section);
534 /* Must be in the minimal symbol table. */
537 /* No available symbol. */
547 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
548 cache_pc_function_name = SYMBOL_NAME (msymbol);
549 cache_pc_function_section = section;
551 /* Use the lesser of the next minimal symbol in the same section, or
552 the end of the section, as the end of the function. */
554 /* Step over other symbols at this same address, and symbols in
555 other sections, to find the next symbol in this section with
556 a different address. */
558 for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
560 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
561 && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
565 if (SYMBOL_NAME (msymbol + i) != NULL
566 && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
567 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
569 /* We got the start address from the last msymbol in the objfile.
570 So the end address is the end of the section. */
571 cache_pc_function_high = osect->endaddr;
577 if (pc_in_unmapped_range (pc, section))
578 *address = overlay_unmapped_address (cache_pc_function_low, section);
580 *address = cache_pc_function_low;
584 *name = cache_pc_function_name;
588 if (pc_in_unmapped_range (pc, section))
590 /* Because the high address is actually beyond the end of
591 the function (and therefore possibly beyond the end of
592 the overlay), we must actually convert (high - 1) and
593 then add one to that. */
595 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
599 *endaddr = cache_pc_function_high;
605 /* Backward compatibility, no section argument. */
608 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
613 section = find_pc_overlay (pc);
614 return find_pc_sect_partial_function (pc, section, name, address, endaddr);
617 /* Return the innermost stack frame executing inside of BLOCK,
618 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
621 block_innermost_frame (struct block *block)
623 struct frame_info *frame;
624 register CORE_ADDR start;
625 register CORE_ADDR end;
626 CORE_ADDR calling_pc;
631 start = BLOCK_START (block);
632 end = BLOCK_END (block);
637 frame = get_prev_frame (frame);
640 calling_pc = frame_address_in_block (frame);
641 if (calling_pc >= start && calling_pc < end)
646 /* Return the full FRAME which corresponds to the given CORE_ADDR
647 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
650 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
652 struct frame_info *frame = NULL;
654 if (frame_addr == (CORE_ADDR) 0)
659 frame = get_prev_frame (frame);
662 if (FRAME_FP (frame) == frame_addr)
667 /* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK
668 below is for infrun.c, which may give the macro a pc without that
671 extern CORE_ADDR text_end;
674 pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
675 CORE_ADDR frame_address)
677 return ((pc) >= text_end - CALL_DUMMY_LENGTH
678 && (pc) <= text_end + DECR_PC_AFTER_BREAK);
682 pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
683 CORE_ADDR frame_address)
685 return ((pc) >= text_end
686 && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
689 /* Is the PC in a call dummy? SP and FRAME_ADDRESS are the bottom and
690 top of the stack frame which we are checking, where "bottom" and
691 "top" refer to some section of memory which contains the code for
692 the call dummy. Calls to this macro assume that the contents of
693 SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
694 are the things to pass.
696 This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
697 have that meaning, but the 29k doesn't use ON_STACK. This could be
698 fixed by generalizing this scheme, perhaps by passing in a frame
699 and adding a few fields, at least on machines which need them for
702 Something simpler, like checking for the stack segment, doesn't work,
703 since various programs (threads implementations, gcc nested function
704 stubs, etc) may either allocate stack frames in another segment, or
705 allocate other kinds of code on the stack. */
708 pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
710 return (INNER_THAN ((sp), (pc))
711 && (frame_address != 0)
712 && INNER_THAN ((pc), (frame_address)));
716 pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
717 CORE_ADDR frame_address)
719 return ((pc) >= CALL_DUMMY_ADDRESS ()
720 && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
724 /* Function: frame_chain_valid
725 Returns true for a user frame or a call_function_by_hand dummy frame,
726 and false for the CRT0 start-up frame. Purpose is to terminate backtrace */
729 generic_file_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
731 if (PC_IN_CALL_DUMMY (frame_pc_unwind (fi), fp, fp))
732 return 1; /* don't prune CALL_DUMMY frames */
733 else /* fall back to default algorithm (see frame.h) */
735 && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
736 && !inside_entry_file (frame_pc_unwind (fi)));
740 generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
742 if (USE_GENERIC_DUMMY_FRAMES
743 && PC_IN_CALL_DUMMY ((fi)->pc, 0, 0))
744 return 1; /* don't prune CALL_DUMMY frames */
745 else /* fall back to default algorithm (see frame.h) */
747 && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
748 && !inside_main_func ((fi)->pc)
749 && !inside_entry_func ((fi)->pc));