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 */
38 /* Prototypes for exported functions. */
40 void _initialize_blockframe (void);
42 /* A default FRAME_CHAIN_VALID, in the form that is suitable for most
43 targets. If FRAME_CHAIN_VALID returns zero it means that the given
44 frame is the outermost one and has no caller. */
47 file_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
50 && !inside_entry_file (FRAME_SAVED_PC (thisframe)));
53 /* Use the alternate method of avoiding running up off the end of the
54 frame chain or following frames back into the startup code. See
55 the comments in objfiles.h. */
58 func_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
61 && !inside_main_func ((thisframe)->pc)
62 && !inside_entry_func ((thisframe)->pc));
65 /* A very simple method of determining a valid frame */
68 nonnull_frame_chain_valid (CORE_ADDR chain, struct frame_info *thisframe)
70 return ((chain) != 0);
73 /* Is ADDR inside the startup file? Note that if your machine
74 has a way to detect the bottom of the stack, there is no need
75 to call this function from FRAME_CHAIN_VALID; the reason for
76 doing so is that some machines have no way of detecting bottom
79 A PC of zero is always considered to be the bottom of the stack. */
82 inside_entry_file (CORE_ADDR addr)
86 if (symfile_objfile == 0)
88 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
90 /* Do not stop backtracing if the pc is in the call dummy
91 at the entry point. */
92 /* FIXME: Won't always work with zeros for the last two arguments */
93 if (PC_IN_CALL_DUMMY (addr, 0, 0))
96 return (addr >= symfile_objfile->ei.entry_file_lowpc &&
97 addr < symfile_objfile->ei.entry_file_highpc);
100 /* Test a specified PC value to see if it is in the range of addresses
101 that correspond to the main() function. See comments above for why
102 we might want to do this.
104 Typically called from FRAME_CHAIN_VALID.
106 A PC of zero is always considered to be the bottom of the stack. */
109 inside_main_func (CORE_ADDR pc)
113 if (symfile_objfile == 0)
116 /* If the addr range is not set up at symbol reading time, set it up now.
117 This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
118 it is unable to set it up and symbol reading time. */
120 if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
121 symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
123 struct symbol *mainsym;
125 mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL);
126 if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK)
128 symfile_objfile->ei.main_func_lowpc =
129 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
130 symfile_objfile->ei.main_func_highpc =
131 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
134 return (symfile_objfile->ei.main_func_lowpc <= pc &&
135 symfile_objfile->ei.main_func_highpc > pc);
138 /* Test a specified PC value to see if it is in the range of addresses
139 that correspond to the process entry point function. See comments
140 in objfiles.h for why we might want to do this.
142 Typically called from FRAME_CHAIN_VALID.
144 A PC of zero is always considered to be the bottom of the stack. */
147 inside_entry_func (CORE_ADDR pc)
151 if (symfile_objfile == 0)
153 if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
155 /* Do not stop backtracing if the pc is in the call dummy
156 at the entry point. */
157 /* FIXME: Won't always work with zeros for the last two arguments */
158 if (PC_IN_CALL_DUMMY (pc, 0, 0))
161 return (symfile_objfile->ei.entry_func_lowpc <= pc &&
162 symfile_objfile->ei.entry_func_highpc > pc);
165 /* Info about the innermost stack frame (contents of FP register) */
167 static struct frame_info *current_frame;
169 /* Cache for frame addresses already read by gdb. Valid only while
170 inferior is stopped. Control variables for the frame cache should
171 be local to this module. */
173 static struct obstack frame_cache_obstack;
176 frame_obstack_alloc (unsigned long size)
178 return obstack_alloc (&frame_cache_obstack, size);
182 frame_saved_regs_zalloc (struct frame_info *fi)
184 fi->saved_regs = (CORE_ADDR *)
185 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
186 memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
190 /* Return the innermost (currently executing) stack frame. */
193 get_current_frame (void)
195 if (current_frame == NULL)
197 if (target_has_stack)
198 current_frame = create_new_frame (read_fp (), read_pc ());
202 return current_frame;
206 set_current_frame (struct frame_info *frame)
208 current_frame = frame;
211 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
212 Always returns a non-NULL value. */
215 create_new_frame (CORE_ADDR addr, CORE_ADDR pc)
217 struct frame_info *fi;
220 fi = (struct frame_info *)
221 obstack_alloc (&frame_cache_obstack,
222 sizeof (struct frame_info));
224 /* Zero all fields by default. */
225 memset (fi, 0, sizeof (struct frame_info));
229 find_pc_partial_function (pc, &name, (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
230 fi->signal_handler_caller = IN_SIGTRAMP (fi->pc, name);
232 if (INIT_EXTRA_FRAME_INFO_P ())
233 INIT_EXTRA_FRAME_INFO (0, fi);
238 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
242 get_next_frame (struct frame_info *frame)
247 /* Flush the entire frame cache. */
250 flush_cached_frames (void)
252 /* Since we can't really be sure what the first object allocated was */
253 obstack_free (&frame_cache_obstack, 0);
254 obstack_init (&frame_cache_obstack);
256 current_frame = NULL; /* Invalidate cache */
257 select_frame (NULL, -1);
258 annotate_frames_invalid ();
261 /* Flush the frame cache, and start a new one if necessary. */
264 reinit_frame_cache (void)
266 flush_cached_frames ();
268 /* FIXME: The inferior_ptid test is wrong if there is a corefile. */
269 if (PIDGET (inferior_ptid) != 0)
271 select_frame (get_current_frame (), 0);
275 /* Return nonzero if the function for this frame lacks a prologue. Many
276 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
280 frameless_look_for_prologue (struct frame_info *frame)
282 CORE_ADDR func_start, after_prologue;
284 func_start = get_pc_function_start (frame->pc);
287 func_start += FUNCTION_START_OFFSET;
288 /* This is faster, since only care whether there *is* a
289 prologue, not how long it is. */
290 return PROLOGUE_FRAMELESS_P (func_start);
292 else if (frame->pc == 0)
293 /* A frame with a zero PC is usually created by dereferencing a
294 NULL function pointer, normally causing an immediate core dump
295 of the inferior. Mark function as frameless, as the inferior
296 has no chance of setting up a stack frame. */
299 /* If we can't find the start of the function, we don't really
300 know whether the function is frameless, but we should be able
301 to get a reasonable (i.e. best we can do under the
302 circumstances) backtrace by saying that it isn't. */
306 /* Default a few macros that people seldom redefine. */
308 #ifndef FRAME_CHAIN_COMBINE
309 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
312 /* Return a structure containing various interesting information
313 about the frame that called NEXT_FRAME. Returns NULL
314 if there is no such frame. */
317 get_prev_frame (struct frame_info *next_frame)
319 CORE_ADDR address = 0;
320 struct frame_info *prev;
324 /* If the requested entry is in the cache, return it.
325 Otherwise, figure out what the address should be for the entry
326 we're about to add to the cache. */
331 /* This screws value_of_variable, which just wants a nice clean
332 NULL return from block_innermost_frame if there are no frames.
333 I don't think I've ever seen this message happen otherwise.
334 And returning NULL here is a perfectly legitimate thing to do. */
337 error ("You haven't set up a process's stack to examine.");
341 return current_frame;
344 /* If we have the prev one, return it */
345 if (next_frame->prev)
346 return next_frame->prev;
348 /* On some machines it is possible to call a function without
349 setting up a stack frame for it. On these machines, we
350 define this macro to take two args; a frameinfo pointer
351 identifying a frame and a variable to set or clear if it is
352 or isn't leafless. */
354 /* Still don't want to worry about this except on the innermost
355 frame. This macro will set FROMLEAF if NEXT_FRAME is a
356 frameless function invocation. */
357 if (!(next_frame->next))
359 fromleaf = FRAMELESS_FUNCTION_INVOCATION (next_frame);
361 address = FRAME_FP (next_frame);
366 /* Two macros defined in tm.h specify the machine-dependent
367 actions to be performed here.
368 First, get the frame's chain-pointer.
369 If that is zero, the frame is the outermost frame or a leaf
370 called by the outermost frame. This means that if start
371 calls main without a frame, we'll return 0 (which is fine
374 Nope; there's a problem. This also returns when the current
375 routine is a leaf of main. This is unacceptable. We move
376 this to after the ffi test; I'd rather have backtraces from
377 start go curfluy than have an abort called from main not show
379 address = FRAME_CHAIN (next_frame);
380 if (!FRAME_CHAIN_VALID (address, next_frame))
382 address = FRAME_CHAIN_COMBINE (address, next_frame);
387 prev = (struct frame_info *)
388 obstack_alloc (&frame_cache_obstack,
389 sizeof (struct frame_info));
391 /* Zero all fields by default. */
392 memset (prev, 0, sizeof (struct frame_info));
395 next_frame->prev = prev;
396 prev->next = next_frame;
397 prev->frame = address;
398 prev->level = next_frame->level + 1;
400 /* This change should not be needed, FIXME! We should
401 determine whether any targets *need* INIT_FRAME_PC to happen
402 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
403 express what goes on here.
405 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
406 (where the PC is already set up) and here (where it isn't).
407 INIT_FRAME_PC is only called from here, always after
408 INIT_EXTRA_FRAME_INFO.
410 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
411 value (which hasn't been set yet). Some other machines appear to
412 require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
414 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
415 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
417 Assuming that some machines need INIT_FRAME_PC after
418 INIT_EXTRA_FRAME_INFO, one possible scheme:
420 SETUP_INNERMOST_FRAME()
421 Default version is just create_new_frame (read_fp ()),
422 read_pc ()). Machines with extra frame info would do that (or the
423 local equivalent) and then set the extra fields.
424 SETUP_ARBITRARY_FRAME(argc, argv)
425 Only change here is that create_new_frame would no longer init extra
426 frame info; SETUP_ARBITRARY_FRAME would have to do that.
427 INIT_PREV_FRAME(fromleaf, prev)
428 Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
429 also return a flag saying whether to keep the new frame, or
430 whether to discard it, because on some machines (e.g. mips) it
431 is really awkward to have FRAME_CHAIN_VALID called *before*
432 INIT_EXTRA_FRAME_INFO (there is no good way to get information
433 deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
434 std_frame_pc(fromleaf, prev)
435 This is the default setting for INIT_PREV_FRAME. It just does what
436 the default INIT_FRAME_PC does. Some machines will call it from
437 INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
438 Some machines won't use it.
439 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
441 INIT_FRAME_PC_FIRST (fromleaf, prev);
443 if (INIT_EXTRA_FRAME_INFO_P ())
444 INIT_EXTRA_FRAME_INFO (fromleaf, prev);
446 /* This entry is in the frame queue now, which is good since
447 FRAME_SAVED_PC may use that queue to figure out its value
448 (see tm-sparc.h). We want the pc saved in the inferior frame. */
449 INIT_FRAME_PC (fromleaf, prev);
451 /* If ->frame and ->pc are unchanged, we are in the process of getting
452 ourselves into an infinite backtrace. Some architectures check this
453 in FRAME_CHAIN or thereabouts, but it seems like there is no reason
454 this can't be an architecture-independent check. */
455 if (next_frame != NULL)
457 if (prev->frame == next_frame->frame
458 && prev->pc == next_frame->pc)
460 next_frame->prev = NULL;
461 obstack_free (&frame_cache_obstack, prev);
466 find_pc_partial_function (prev->pc, &name,
467 (CORE_ADDR *) NULL, (CORE_ADDR *) NULL);
468 if (IN_SIGTRAMP (prev->pc, name))
469 prev->signal_handler_caller = 1;
475 get_frame_pc (struct frame_info *frame)
481 #ifdef FRAME_FIND_SAVED_REGS
482 /* XXX - deprecated. This is a compatibility function for targets
483 that do not yet implement FRAME_INIT_SAVED_REGS. */
484 /* Find the addresses in which registers are saved in FRAME. */
487 get_frame_saved_regs (struct frame_info *frame,
488 struct frame_saved_regs *saved_regs_addr)
490 if (frame->saved_regs == NULL)
492 frame->saved_regs = (CORE_ADDR *)
493 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
495 if (saved_regs_addr == NULL)
497 struct frame_saved_regs saved_regs;
498 FRAME_FIND_SAVED_REGS (frame, saved_regs);
499 memcpy (frame->saved_regs, &saved_regs, SIZEOF_FRAME_SAVED_REGS);
503 FRAME_FIND_SAVED_REGS (frame, *saved_regs_addr);
504 memcpy (frame->saved_regs, saved_regs_addr, SIZEOF_FRAME_SAVED_REGS);
509 /* Return the innermost lexical block in execution
510 in a specified stack frame. The frame address is assumed valid.
512 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
513 address we used to choose the block. We use this to find a source
514 line, to decide which macro definitions are in scope.
516 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
517 PC, and may not really be a valid PC at all. For example, in the
518 caller of a function declared to never return, the code at the
519 return address will never be reached, so the call instruction may
520 be the very last instruction in the block. So the address we use
521 to choose the block is actually one byte before the return address
522 --- hopefully pointing us at the call instruction, or its delay
526 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
531 if (frame->next != 0 && frame->next->signal_handler_caller == 0)
532 /* We are not in the innermost frame and we were not interrupted
533 by a signal. We need to subtract one to get the correct block,
534 in case the call instruction was the last instruction of the block.
535 If there are any machines on which the saved pc does not point to
536 after the call insn, we probably want to make frame->pc point after
537 the call insn anyway. */
543 return block_for_pc (pc);
547 get_current_block (CORE_ADDR *addr_in_block)
549 CORE_ADDR pc = read_pc ();
554 return block_for_pc (pc);
558 get_pc_function_start (CORE_ADDR pc)
560 register struct block *bl;
561 register struct symbol *symbol;
562 register struct minimal_symbol *msymbol;
565 if ((bl = block_for_pc (pc)) != NULL &&
566 (symbol = block_function (bl)) != NULL)
568 bl = SYMBOL_BLOCK_VALUE (symbol);
569 fstart = BLOCK_START (bl);
571 else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
573 fstart = SYMBOL_VALUE_ADDRESS (msymbol);
582 /* Return the symbol for the function executing in frame FRAME. */
585 get_frame_function (struct frame_info *frame)
587 register struct block *bl = get_frame_block (frame, 0);
590 return block_function (bl);
594 /* Return the blockvector immediately containing the innermost lexical block
595 containing the specified pc value and section, or 0 if there is none.
596 PINDEX is a pointer to the index value of the block. If PINDEX
597 is NULL, we don't pass this information back to the caller. */
600 blockvector_for_pc_sect (register CORE_ADDR pc, struct sec *section,
601 int *pindex, struct symtab *symtab)
603 register struct block *b;
604 register int bot, top, half;
605 struct blockvector *bl;
607 if (symtab == 0) /* if no symtab specified by caller */
609 /* First search all symtabs for one whose file contains our pc */
610 if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
614 bl = BLOCKVECTOR (symtab);
615 b = BLOCKVECTOR_BLOCK (bl, 0);
617 /* Then search that symtab for the smallest block that wins. */
618 /* Use binary search to find the last block that starts before PC. */
621 top = BLOCKVECTOR_NBLOCKS (bl);
623 while (top - bot > 1)
625 half = (top - bot + 1) >> 1;
626 b = BLOCKVECTOR_BLOCK (bl, bot + half);
627 if (BLOCK_START (b) <= pc)
633 /* Now search backward for a block that ends after PC. */
637 b = BLOCKVECTOR_BLOCK (bl, bot);
638 if (BLOCK_END (b) > pc)
649 /* Return the blockvector immediately containing the innermost lexical block
650 containing the specified pc value, or 0 if there is none.
651 Backward compatibility, no section. */
654 blockvector_for_pc (register CORE_ADDR pc, int *pindex)
656 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
660 /* Return the innermost lexical block containing the specified pc value
661 in the specified section, or 0 if there is none. */
664 block_for_pc_sect (register CORE_ADDR pc, struct sec *section)
666 register struct blockvector *bl;
669 bl = blockvector_for_pc_sect (pc, section, &index, NULL);
671 return BLOCKVECTOR_BLOCK (bl, index);
675 /* Return the innermost lexical block containing the specified pc value,
676 or 0 if there is none. Backward compatibility, no section. */
679 block_for_pc (register CORE_ADDR pc)
681 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
684 /* Return the function containing pc value PC in section SECTION.
685 Returns 0 if function is not known. */
688 find_pc_sect_function (CORE_ADDR pc, struct sec *section)
690 register struct block *b = block_for_pc_sect (pc, section);
693 return block_function (b);
696 /* Return the function containing pc value PC.
697 Returns 0 if function is not known. Backward compatibility, no section */
700 find_pc_function (CORE_ADDR pc)
702 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
705 /* These variables are used to cache the most recent result
706 * of find_pc_partial_function. */
708 static CORE_ADDR cache_pc_function_low = 0;
709 static CORE_ADDR cache_pc_function_high = 0;
710 static char *cache_pc_function_name = 0;
711 static struct sec *cache_pc_function_section = NULL;
713 /* Clear cache, e.g. when symbol table is discarded. */
716 clear_pc_function_cache (void)
718 cache_pc_function_low = 0;
719 cache_pc_function_high = 0;
720 cache_pc_function_name = (char *) 0;
721 cache_pc_function_section = NULL;
724 /* Finds the "function" (text symbol) that is smaller than PC but
725 greatest of all of the potential text symbols in SECTION. Sets
726 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
727 If ENDADDR is non-null, then set *ENDADDR to be the end of the
728 function (exclusive), but passing ENDADDR as non-null means that
729 the function might cause symbols to be read. This function either
730 succeeds or fails (not halfway succeeds). If it succeeds, it sets
731 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
732 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
736 find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
737 CORE_ADDR *address, CORE_ADDR *endaddr)
739 struct partial_symtab *pst;
741 struct minimal_symbol *msymbol;
742 struct partial_symbol *psb;
743 struct obj_section *osect;
747 mapped_pc = overlay_mapped_address (pc, section);
749 if (mapped_pc >= cache_pc_function_low &&
750 mapped_pc < cache_pc_function_high &&
751 section == cache_pc_function_section)
752 goto return_cached_value;
754 /* If sigtramp is in the u area, it counts as a function (especially
755 important for step_1). */
756 #if defined SIGTRAMP_START
757 if (IN_SIGTRAMP (mapped_pc, (char *) NULL))
759 cache_pc_function_low = SIGTRAMP_START (mapped_pc);
760 cache_pc_function_high = SIGTRAMP_END (mapped_pc);
761 cache_pc_function_name = "<sigtramp>";
762 cache_pc_function_section = section;
763 goto return_cached_value;
767 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
768 pst = find_pc_sect_psymtab (mapped_pc, section);
771 /* Need to read the symbols to get a good value for the end address. */
772 if (endaddr != NULL && !pst->readin)
774 /* Need to get the terminal in case symbol-reading produces
776 target_terminal_ours_for_output ();
777 PSYMTAB_TO_SYMTAB (pst);
782 /* Checking whether the msymbol has a larger value is for the
783 "pathological" case mentioned in print_frame_info. */
784 f = find_pc_sect_function (mapped_pc, section);
787 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
788 >= SYMBOL_VALUE_ADDRESS (msymbol))))
790 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
791 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
792 cache_pc_function_name = SYMBOL_NAME (f);
793 cache_pc_function_section = section;
794 goto return_cached_value;
799 /* Now that static symbols go in the minimal symbol table, perhaps
800 we could just ignore the partial symbols. But at least for now
801 we use the partial or minimal symbol, whichever is larger. */
802 psb = find_pc_sect_psymbol (pst, mapped_pc, section);
805 && (msymbol == NULL ||
806 (SYMBOL_VALUE_ADDRESS (psb)
807 >= SYMBOL_VALUE_ADDRESS (msymbol))))
809 /* This case isn't being cached currently. */
811 *address = SYMBOL_VALUE_ADDRESS (psb);
813 *name = SYMBOL_NAME (psb);
814 /* endaddr non-NULL can't happen here. */
820 /* Not in the normal symbol tables, see if the pc is in a known section.
821 If it's not, then give up. This ensures that anything beyond the end
822 of the text seg doesn't appear to be part of the last function in the
825 osect = find_pc_sect_section (mapped_pc, section);
830 /* Must be in the minimal symbol table. */
833 /* No available symbol. */
843 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
844 cache_pc_function_name = SYMBOL_NAME (msymbol);
845 cache_pc_function_section = section;
847 /* Use the lesser of the next minimal symbol in the same section, or
848 the end of the section, as the end of the function. */
850 /* Step over other symbols at this same address, and symbols in
851 other sections, to find the next symbol in this section with
852 a different address. */
854 for (i = 1; SYMBOL_NAME (msymbol + i) != NULL; i++)
856 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
857 && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
861 if (SYMBOL_NAME (msymbol + i) != NULL
862 && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
863 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
865 /* We got the start address from the last msymbol in the objfile.
866 So the end address is the end of the section. */
867 cache_pc_function_high = osect->endaddr;
873 if (pc_in_unmapped_range (pc, section))
874 *address = overlay_unmapped_address (cache_pc_function_low, section);
876 *address = cache_pc_function_low;
880 *name = cache_pc_function_name;
884 if (pc_in_unmapped_range (pc, section))
886 /* Because the high address is actually beyond the end of
887 the function (and therefore possibly beyond the end of
888 the overlay), we must actually convert (high - 1)
889 and then add one to that. */
891 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
895 *endaddr = cache_pc_function_high;
901 /* Backward compatibility, no section argument */
904 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
909 section = find_pc_overlay (pc);
910 return find_pc_sect_partial_function (pc, section, name, address, endaddr);
913 /* Return the innermost stack frame executing inside of BLOCK,
914 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
917 block_innermost_frame (struct block *block)
919 struct frame_info *frame;
920 register CORE_ADDR start;
921 register CORE_ADDR end;
926 start = BLOCK_START (block);
927 end = BLOCK_END (block);
932 frame = get_prev_frame (frame);
935 if (frame->pc >= start && frame->pc < end)
940 /* Return the full FRAME which corresponds to the given CORE_ADDR
941 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
944 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
946 struct frame_info *frame = NULL;
948 if (frame_addr == (CORE_ADDR) 0)
953 frame = get_prev_frame (frame);
956 if (FRAME_FP (frame) == frame_addr)
961 #ifdef SIGCONTEXT_PC_OFFSET
962 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
965 sigtramp_saved_pc (struct frame_info *frame)
967 CORE_ADDR sigcontext_addr;
969 int ptrbytes = TARGET_PTR_BIT / TARGET_CHAR_BIT;
970 int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
972 buf = alloca (ptrbytes);
973 /* Get sigcontext address, it is the third parameter on the stack. */
975 sigcontext_addr = read_memory_integer (FRAME_ARGS_ADDRESS (frame->next)
980 sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
984 /* Don't cause a memory_error when accessing sigcontext in case the stack
985 layout has changed or the stack is corrupt. */
986 target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
987 return extract_unsigned_integer (buf, ptrbytes);
989 #endif /* SIGCONTEXT_PC_OFFSET */
992 /* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK
993 below is for infrun.c, which may give the macro a pc without that
996 extern CORE_ADDR text_end;
999 pc_in_call_dummy_before_text_end (CORE_ADDR pc, CORE_ADDR sp,
1000 CORE_ADDR frame_address)
1002 return ((pc) >= text_end - CALL_DUMMY_LENGTH
1003 && (pc) <= text_end + DECR_PC_AFTER_BREAK);
1007 pc_in_call_dummy_after_text_end (CORE_ADDR pc, CORE_ADDR sp,
1008 CORE_ADDR frame_address)
1010 return ((pc) >= text_end
1011 && (pc) <= text_end + CALL_DUMMY_LENGTH + DECR_PC_AFTER_BREAK);
1014 /* Is the PC in a call dummy? SP and FRAME_ADDRESS are the bottom and
1015 top of the stack frame which we are checking, where "bottom" and
1016 "top" refer to some section of memory which contains the code for
1017 the call dummy. Calls to this macro assume that the contents of
1018 SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
1019 are the things to pass.
1021 This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
1022 have that meaning, but the 29k doesn't use ON_STACK. This could be
1023 fixed by generalizing this scheme, perhaps by passing in a frame
1024 and adding a few fields, at least on machines which need them for
1027 Something simpler, like checking for the stack segment, doesn't work,
1028 since various programs (threads implementations, gcc nested function
1029 stubs, etc) may either allocate stack frames in another segment, or
1030 allocate other kinds of code on the stack. */
1033 pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR frame_address)
1035 return (INNER_THAN ((sp), (pc))
1036 && (frame_address != 0)
1037 && INNER_THAN ((pc), (frame_address)));
1041 pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
1042 CORE_ADDR frame_address)
1044 return ((pc) >= CALL_DUMMY_ADDRESS ()
1045 && (pc) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK));
1050 * GENERIC DUMMY FRAMES
1052 * The following code serves to maintain the dummy stack frames for
1053 * inferior function calls (ie. when gdb calls into the inferior via
1054 * call_function_by_hand). This code saves the machine state before
1055 * the call in host memory, so we must maintain an independent stack
1056 * and keep it consistant etc. I am attempting to make this code
1057 * generic enough to be used by many targets.
1059 * The cheapest and most generic way to do CALL_DUMMY on a new target
1060 * is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to
1061 * zero, and CALL_DUMMY_LOCATION to AT_ENTRY. Then you must remember
1062 * to define PUSH_RETURN_ADDRESS, because no call instruction will be
1063 * being executed by the target. Also FRAME_CHAIN_VALID as
1064 * generic_{file,func}_frame_chain_valid and FIX_CALL_DUMMY as
1065 * generic_fix_call_dummy. */
1067 /* Dummy frame. This saves the processor state just prior to setting
1068 up the inferior function call. Older targets save the registers
1069 on the target stack (but that really slows down function calls). */
1073 struct dummy_frame *next;
1082 static struct dummy_frame *dummy_frame_stack = NULL;
1084 /* Function: find_dummy_frame(pc, fp, sp)
1085 Search the stack of dummy frames for one matching the given PC, FP and SP.
1086 This is the work-horse for pc_in_call_dummy and read_register_dummy */
1089 generic_find_dummy_frame (CORE_ADDR pc, CORE_ADDR fp)
1091 struct dummy_frame *dummyframe;
1093 if (pc != entry_point_address ())
1096 for (dummyframe = dummy_frame_stack; dummyframe != NULL;
1097 dummyframe = dummyframe->next)
1098 if (fp == dummyframe->fp
1099 || fp == dummyframe->sp
1100 || fp == dummyframe->top)
1101 /* The frame in question lies between the saved fp and sp, inclusive */
1102 return dummyframe->registers;
1107 /* Function: pc_in_call_dummy (pc, fp)
1108 Return true if this is a dummy frame created by gdb for an inferior call */
1111 generic_pc_in_call_dummy (CORE_ADDR pc, CORE_ADDR sp, CORE_ADDR fp)
1113 /* if find_dummy_frame succeeds, then PC is in a call dummy */
1114 /* Note: SP and not FP is passed on. */
1115 return (generic_find_dummy_frame (pc, sp) != 0);
1118 /* Function: read_register_dummy
1119 Find a saved register from before GDB calls a function in the inferior */
1122 generic_read_register_dummy (CORE_ADDR pc, CORE_ADDR fp, int regno)
1124 char *dummy_regs = generic_find_dummy_frame (pc, fp);
1127 return extract_address (&dummy_regs[REGISTER_BYTE (regno)],
1128 REGISTER_RAW_SIZE (regno));
1133 /* Save all the registers on the dummy frame stack. Most ports save the
1134 registers on the target stack. This results in lots of unnecessary memory
1135 references, which are slow when debugging via a serial line. Instead, we
1136 save all the registers internally, and never write them to the stack. The
1137 registers get restored when the called function returns to the entry point,
1138 where a breakpoint is laying in wait. */
1141 generic_push_dummy_frame (void)
1143 struct dummy_frame *dummy_frame;
1144 CORE_ADDR fp = (get_current_frame ())->frame;
1146 /* check to see if there are stale dummy frames,
1147 perhaps left over from when a longjump took us out of a
1148 function that was called by the debugger */
1150 dummy_frame = dummy_frame_stack;
1152 if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */
1154 dummy_frame_stack = dummy_frame->next;
1155 xfree (dummy_frame->registers);
1156 xfree (dummy_frame);
1157 dummy_frame = dummy_frame_stack;
1160 dummy_frame = dummy_frame->next;
1162 dummy_frame = xmalloc (sizeof (struct dummy_frame));
1163 dummy_frame->registers = xmalloc (REGISTER_BYTES);
1165 dummy_frame->pc = read_pc ();
1166 dummy_frame->sp = read_sp ();
1167 dummy_frame->top = dummy_frame->sp;
1168 dummy_frame->fp = fp;
1169 read_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
1170 dummy_frame->next = dummy_frame_stack;
1171 dummy_frame_stack = dummy_frame;
1175 generic_save_dummy_frame_tos (CORE_ADDR sp)
1177 dummy_frame_stack->top = sp;
1180 /* Restore the machine state from either the saved dummy stack or a
1181 real stack frame. */
1184 generic_pop_current_frame (void (*popper) (struct frame_info * frame))
1186 struct frame_info *frame = get_current_frame ();
1188 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1189 generic_pop_dummy_frame ();
1194 /* Function: pop_dummy_frame
1195 Restore the machine state from a saved dummy stack frame. */
1198 generic_pop_dummy_frame (void)
1200 struct dummy_frame *dummy_frame = dummy_frame_stack;
1202 /* FIXME: what if the first frame isn't the right one, eg..
1203 because one call-by-hand function has done a longjmp into another one? */
1206 error ("Can't pop dummy frame!");
1207 dummy_frame_stack = dummy_frame->next;
1208 write_register_bytes (0, dummy_frame->registers, REGISTER_BYTES);
1209 flush_cached_frames ();
1211 xfree (dummy_frame->registers);
1212 xfree (dummy_frame);
1215 /* Function: frame_chain_valid
1216 Returns true for a user frame or a call_function_by_hand dummy frame,
1217 and false for the CRT0 start-up frame. Purpose is to terminate backtrace */
1220 generic_file_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
1222 if (PC_IN_CALL_DUMMY (FRAME_SAVED_PC (fi), fp, fp))
1223 return 1; /* don't prune CALL_DUMMY frames */
1224 else /* fall back to default algorithm (see frame.h) */
1226 && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
1227 && !inside_entry_file (FRAME_SAVED_PC (fi)));
1231 generic_func_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
1233 if (PC_IN_CALL_DUMMY ((fi)->pc, fp, fp))
1234 return 1; /* don't prune CALL_DUMMY frames */
1235 else /* fall back to default algorithm (see frame.h) */
1237 && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
1238 && !inside_main_func ((fi)->pc)
1239 && !inside_entry_func ((fi)->pc));
1242 /* Function: fix_call_dummy
1243 Stub function. Generic dummy frames typically do not need to fix
1244 the frame being created */
1247 generic_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
1248 struct value **args, struct type *type, int gcc_p)
1253 /* Function: get_saved_register
1254 Find register number REGNUM relative to FRAME and put its (raw,
1255 target format) contents in *RAW_BUFFER.
1257 Set *OPTIMIZED if the variable was optimized out (and thus can't be
1258 fetched). Note that this is never set to anything other than zero
1259 in this implementation.
1261 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1262 whether the value was fetched from memory, from a register, or in a
1263 strange and non-modifiable way (e.g. a frame pointer which was
1264 calculated rather than fetched). We will use not_lval for values
1265 fetched from generic dummy frames.
1267 Set *ADDRP to the address, either in memory or as a REGISTER_BYTE
1268 offset into the registers array. If the value is stored in a dummy
1269 frame, set *ADDRP to zero.
1271 To use this implementation, define a function called
1272 "get_saved_register" in your target code, which simply passes all
1273 of its arguments to this function.
1275 The argument RAW_BUFFER must point to aligned memory. */
1278 generic_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
1279 struct frame_info *frame, int regnum,
1280 enum lval_type *lval)
1282 if (!target_has_registers)
1283 error ("No registers.");
1285 /* Normal systems don't optimize out things with register numbers. */
1286 if (optimized != NULL)
1289 if (addrp) /* default assumption: not found in memory */
1292 /* Note: since the current frame's registers could only have been
1293 saved by frames INTERIOR TO the current frame, we skip examining
1294 the current frame itself: otherwise, we would be getting the
1295 previous frame's registers which were saved by the current frame. */
1297 while (frame && ((frame = frame->next) != NULL))
1299 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1301 if (lval) /* found it in a CALL_DUMMY frame */
1305 generic_find_dummy_frame (frame->pc, frame->frame) +
1306 REGISTER_BYTE (regnum),
1307 REGISTER_RAW_SIZE (regnum));
1311 FRAME_INIT_SAVED_REGS (frame);
1312 if (frame->saved_regs != NULL
1313 && frame->saved_regs[regnum] != 0)
1315 if (lval) /* found it saved on the stack */
1316 *lval = lval_memory;
1317 if (regnum == SP_REGNUM)
1319 if (raw_buffer) /* SP register treated specially */
1320 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1321 frame->saved_regs[regnum]);
1325 if (addrp) /* any other register */
1326 *addrp = frame->saved_regs[regnum];
1328 read_memory (frame->saved_regs[regnum], raw_buffer,
1329 REGISTER_RAW_SIZE (regnum));
1335 /* If we get thru the loop to this point, it means the register was
1336 not saved in any frame. Return the actual live-register value. */
1338 if (lval) /* found it in a live register */
1339 *lval = lval_register;
1341 *addrp = REGISTER_BYTE (regnum);
1343 read_register_gen (regnum, raw_buffer);
1347 _initialize_blockframe (void)
1349 obstack_init (&frame_cache_obstack);