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, 2003 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"
43 /* Prototypes for exported functions. */
45 void _initialize_blockframe (void);
47 /* Is ADDR inside the startup file? Note that if your machine has a
48 way to detect the bottom of the stack, there is no need to call
49 this function from DEPRECATED_FRAME_CHAIN_VALID; the reason for
50 doing so is that some machines have no way of detecting bottom of
53 A PC of zero is always considered to be the bottom of the stack. */
56 deprecated_inside_entry_file (CORE_ADDR addr)
60 if (symfile_objfile == 0)
62 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT
63 || CALL_DUMMY_LOCATION == AT_SYMBOL)
65 /* Do not stop backtracing if the pc is in the call dummy
66 at the entry point. */
67 /* FIXME: Won't always work with zeros for the last two arguments */
68 if (DEPRECATED_PC_IN_CALL_DUMMY (addr, 0, 0))
71 return (addr >= symfile_objfile->ei.deprecated_entry_file_lowpc &&
72 addr < symfile_objfile->ei.deprecated_entry_file_highpc);
75 /* Test whether PC is in the range of addresses that corresponds to
78 A PC of zero is always considered to be the bottom of the stack. */
81 inside_main_func (CORE_ADDR pc)
83 struct minimal_symbol *msymbol;
88 if (symfile_objfile == 0)
91 msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
93 /* If the address range hasn't been set up at symbol reading time,
97 && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC
98 && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
100 /* brobecker/2003-10-10: We used to rely on lookup_symbol() to
101 search the symbol associated to the "main" function.
102 Unfortunately, lookup_symbol() uses the current-language
103 la_lookup_symbol_nonlocal function to do the global symbol
104 search. Depending on the language, this can introduce
105 certain side-effects, because certain languages, for instance
106 Ada, may find more than one match. Therefore we prefer to
107 search the "main" function symbol using its address rather
109 struct symbol *mainsym =
110 find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol));
112 if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
114 symfile_objfile->ei.main_func_lowpc =
115 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
116 symfile_objfile->ei.main_func_highpc =
117 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
121 /* Not in the normal symbol tables, see if "main" is in the partial
122 symbol table. If it's not, then give up. */
123 if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
125 CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol);
126 asection *msect = SYMBOL_BFD_SECTION (msymbol);
127 struct obj_section *osect = find_pc_sect_section (maddr, msect);
133 /* Step over other symbols at this same address, and symbols
134 in other sections, to find the next symbol in this
135 section with a different address. */
136 for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
138 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr
139 && SYMBOL_BFD_SECTION (msymbol + i) == msect)
143 symfile_objfile->ei.main_func_lowpc = maddr;
145 /* Use the lesser of the next minimal symbol in the same
146 section, or the end of the section, as the end of the
148 if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
149 && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
150 symfile_objfile->ei.main_func_highpc =
151 SYMBOL_VALUE_ADDRESS (msymbol + i);
153 /* We got the start address from the last msymbol in the
154 objfile. So the end address is the end of the
156 symfile_objfile->ei.main_func_highpc = osect->endaddr;
160 return (symfile_objfile->ei.main_func_lowpc <= pc
161 && symfile_objfile->ei.main_func_highpc > pc);
164 /* Test a specified PC value to see if it is in the range of addresses
165 that correspond to the process entry point function. See comments
166 in objfiles.h for why we might want to do this.
168 Typically called from DEPRECATED_FRAME_CHAIN_VALID.
170 A PC of zero is always considered to be the bottom of the stack. */
173 inside_entry_func (CORE_ADDR pc)
177 if (symfile_objfile == 0)
179 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
181 /* Do not stop backtracing if the pc is in the call dummy
182 at the entry point. */
183 /* FIXME: Won't always work with zeros for the last two arguments */
184 if (DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0))
187 return (symfile_objfile->ei.entry_func_lowpc <= pc &&
188 symfile_objfile->ei.entry_func_highpc > pc);
191 /* Return nonzero if the function for this frame lacks a prologue. Many
192 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
196 frameless_look_for_prologue (struct frame_info *frame)
198 CORE_ADDR func_start;
200 func_start = get_frame_func (frame);
203 func_start += FUNCTION_START_OFFSET;
204 /* This is faster, since only care whether there *is* a
205 prologue, not how long it is. */
206 return PROLOGUE_FRAMELESS_P (func_start);
208 else if (get_frame_pc (frame) == 0)
209 /* A frame with a zero PC is usually created by dereferencing a
210 NULL function pointer, normally causing an immediate core dump
211 of the inferior. Mark function as frameless, as the inferior
212 has no chance of setting up a stack frame. */
215 /* If we can't find the start of the function, we don't really
216 know whether the function is frameless, but we should be able
217 to get a reasonable (i.e. best we can do under the
218 circumstances) backtrace by saying that it isn't. */
222 /* Return the innermost lexical block in execution
223 in a specified stack frame. The frame address is assumed valid.
225 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
226 address we used to choose the block. We use this to find a source
227 line, to decide which macro definitions are in scope.
229 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
230 PC, and may not really be a valid PC at all. For example, in the
231 caller of a function declared to never return, the code at the
232 return address will never be reached, so the call instruction may
233 be the very last instruction in the block. So the address we use
234 to choose the block is actually one byte before the return address
235 --- hopefully pointing us at the call instruction, or its delay
239 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
241 const CORE_ADDR pc = get_frame_address_in_block (frame);
246 return block_for_pc (pc);
250 get_pc_function_start (CORE_ADDR pc)
253 struct minimal_symbol *msymbol;
255 bl = block_for_pc (pc);
258 struct symbol *symbol = block_function (bl);
262 bl = SYMBOL_BLOCK_VALUE (symbol);
263 return BLOCK_START (bl);
267 msymbol = lookup_minimal_symbol_by_pc (pc);
270 CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
272 if (find_pc_section (fstart))
279 /* Return the symbol for the function executing in frame FRAME. */
282 get_frame_function (struct frame_info *frame)
284 struct block *bl = get_frame_block (frame, 0);
287 return block_function (bl);
291 /* Return the function containing pc value PC in section SECTION.
292 Returns 0 if function is not known. */
295 find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section)
297 struct block *b = block_for_pc_sect (pc, section);
300 return block_function (b);
303 /* Return the function containing pc value PC.
304 Returns 0 if function is not known. Backward compatibility, no section */
307 find_pc_function (CORE_ADDR pc)
309 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
312 /* These variables are used to cache the most recent result
313 * of find_pc_partial_function. */
315 static CORE_ADDR cache_pc_function_low = 0;
316 static CORE_ADDR cache_pc_function_high = 0;
317 static char *cache_pc_function_name = 0;
318 static struct bfd_section *cache_pc_function_section = NULL;
320 /* Clear cache, e.g. when symbol table is discarded. */
323 clear_pc_function_cache (void)
325 cache_pc_function_low = 0;
326 cache_pc_function_high = 0;
327 cache_pc_function_name = (char *) 0;
328 cache_pc_function_section = NULL;
331 /* Finds the "function" (text symbol) that is smaller than PC but
332 greatest of all of the potential text symbols in SECTION. Sets
333 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
334 If ENDADDR is non-null, then set *ENDADDR to be the end of the
335 function (exclusive), but passing ENDADDR as non-null means that
336 the function might cause symbols to be read. This function either
337 succeeds or fails (not halfway succeeds). If it succeeds, it sets
338 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
339 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
343 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
344 CORE_ADDR *address, CORE_ADDR *endaddr)
346 struct partial_symtab *pst;
348 struct minimal_symbol *msymbol;
349 struct partial_symbol *psb;
350 struct obj_section *osect;
354 mapped_pc = overlay_mapped_address (pc, section);
356 if (mapped_pc >= cache_pc_function_low
357 && mapped_pc < cache_pc_function_high
358 && section == cache_pc_function_section)
359 goto return_cached_value;
361 /* If sigtramp is in the u area, it counts as a function (especially
362 important for step_1). */
363 if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
365 cache_pc_function_low = SIGTRAMP_START (mapped_pc);
366 cache_pc_function_high = SIGTRAMP_END (mapped_pc);
367 cache_pc_function_name = "<sigtramp>";
368 cache_pc_function_section = section;
369 goto return_cached_value;
372 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
373 pst = find_pc_sect_psymtab (mapped_pc, section);
376 /* Need to read the symbols to get a good value for the end address. */
377 if (endaddr != NULL && !pst->readin)
379 /* Need to get the terminal in case symbol-reading produces
381 target_terminal_ours_for_output ();
382 PSYMTAB_TO_SYMTAB (pst);
387 /* Checking whether the msymbol has a larger value is for the
388 "pathological" case mentioned in print_frame_info. */
389 f = find_pc_sect_function (mapped_pc, section);
392 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
393 >= SYMBOL_VALUE_ADDRESS (msymbol))))
395 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
396 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
397 cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f);
398 cache_pc_function_section = section;
399 goto return_cached_value;
404 /* Now that static symbols go in the minimal symbol table, perhaps
405 we could just ignore the partial symbols. But at least for now
406 we use the partial or minimal symbol, whichever is larger. */
407 psb = find_pc_sect_psymbol (pst, mapped_pc, section);
410 && (msymbol == NULL ||
411 (SYMBOL_VALUE_ADDRESS (psb)
412 >= SYMBOL_VALUE_ADDRESS (msymbol))))
414 /* This case isn't being cached currently. */
416 *address = SYMBOL_VALUE_ADDRESS (psb);
418 *name = DEPRECATED_SYMBOL_NAME (psb);
419 /* endaddr non-NULL can't happen here. */
425 /* Not in the normal symbol tables, see if the pc is in a known section.
426 If it's not, then give up. This ensures that anything beyond the end
427 of the text seg doesn't appear to be part of the last function in the
430 osect = find_pc_sect_section (mapped_pc, section);
435 /* Must be in the minimal symbol table. */
438 /* No available symbol. */
448 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
449 cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
450 cache_pc_function_section = section;
452 /* Use the lesser of the next minimal symbol in the same section, or
453 the end of the section, as the end of the function. */
455 /* Step over other symbols at this same address, and symbols in
456 other sections, to find the next symbol in this section with
457 a different address. */
459 for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
461 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
462 && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
466 if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL
467 && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
468 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
470 /* We got the start address from the last msymbol in the objfile.
471 So the end address is the end of the section. */
472 cache_pc_function_high = osect->endaddr;
478 if (pc_in_unmapped_range (pc, section))
479 *address = overlay_unmapped_address (cache_pc_function_low, section);
481 *address = cache_pc_function_low;
485 *name = cache_pc_function_name;
489 if (pc_in_unmapped_range (pc, section))
491 /* Because the high address is actually beyond the end of
492 the function (and therefore possibly beyond the end of
493 the overlay), we must actually convert (high - 1) and
494 then add one to that. */
496 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
500 *endaddr = cache_pc_function_high;
506 /* Backward compatibility, no section argument. */
509 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
514 section = find_pc_overlay (pc);
515 return find_pc_sect_partial_function (pc, section, name, address, endaddr);
518 /* Return the innermost stack frame executing inside of BLOCK,
519 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
522 block_innermost_frame (struct block *block)
524 struct frame_info *frame;
527 CORE_ADDR calling_pc;
532 start = BLOCK_START (block);
533 end = BLOCK_END (block);
538 frame = get_prev_frame (frame);
541 calling_pc = get_frame_address_in_block (frame);
542 if (calling_pc >= start && calling_pc < end)
547 /* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK
548 below is for infrun.c, which may give the macro a pc without that
551 /* Is the PC in a call dummy? SP and FRAME_ADDRESS are the bottom and
552 top of the stack frame which we are checking, where "bottom" and
553 "top" refer to some section of memory which contains the code for
554 the call dummy. Calls to this macro assume that the contents of
555 SP_REGNUM and DEPRECATED_FP_REGNUM (or the saved values thereof),
556 respectively, are the things to pass.
558 This won't work on the 29k, where SP_REGNUM and
559 DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
560 use ON_STACK. This could be fixed by generalizing this scheme,
561 perhaps by passing in a frame and adding a few fields, at least on
562 machines which need them for DEPRECATED_PC_IN_CALL_DUMMY.
564 Something simpler, like checking for the stack segment, doesn't work,
565 since various programs (threads implementations, gcc nested function
566 stubs, etc) may either allocate stack frames in another segment, or
567 allocate other kinds of code on the stack. */
570 deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
571 CORE_ADDR frame_address)
573 return (INNER_THAN ((sp), (pc))
574 && (frame_address != 0)
575 && INNER_THAN ((pc), (frame_address)));
579 deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
580 CORE_ADDR frame_address)
582 CORE_ADDR addr = entry_point_address ();
583 if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
584 addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
585 return ((pc) >= addr && (pc) <= (addr + DECR_PC_AFTER_BREAK));
588 /* Returns true for a user frame or a call_function_by_hand dummy
589 frame, and false for the CRT0 start-up frame. Purpose is to
590 terminate backtrace. */
593 legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
595 /* Don't prune CALL_DUMMY frames. */
596 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
597 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
600 /* If the new frame pointer is zero, then it isn't valid. */
604 /* If the new frame would be inside (younger than) the previous frame,
605 then it isn't valid. */
606 if (INNER_THAN (fp, get_frame_base (fi)))
609 /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
611 if (DEPRECATED_FRAME_CHAIN_VALID_P ())
612 return DEPRECATED_FRAME_CHAIN_VALID (fp, fi);
614 /* If we're already inside the entry function for the main objfile, then it
616 if (inside_entry_func (get_frame_pc (fi)))
619 /* If we're inside the entry file, it isn't valid. */
620 /* NOTE/drow 2002-12-25: should there be a way to disable this check? It
621 assumes a single small entry file, and the way some debug readers (e.g.
622 dbxread) figure out which object is the entry file is somewhat hokey. */
623 if (deprecated_inside_entry_file (frame_pc_unwind (fi)))