1 /* Get info from stack frames;
2 convert between frames, blocks, functions and pc values.
3 Copyright 1986, 87, 88, 89, 91, 94, 95, 96, 97, 1998
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
29 #include "value.h" /* for read_register */
30 #include "target.h" /* for target_has_stack */
31 #include "inferior.h" /* for read_pc */
34 /* Prototypes for exported functions. */
36 void _initialize_blockframe PARAMS ((void));
38 /* A default FRAME_CHAIN_VALID, in the form that is suitable for most
39 targets. If FRAME_CHAIN_VALID returns zero it means that the given
40 frame is the outermost one and has no caller. */
43 default_frame_chain_valid (chain, thisframe)
45 struct frame_info *thisframe;
48 && !inside_main_func ((thisframe) -> pc)
49 && !inside_entry_func ((thisframe) -> pc));
52 /* Use the alternate method of avoiding running up off the end of the
53 frame chain or following frames back into the startup code. See
54 the comments in objfiles.h. */
57 alternate_frame_chain_valid (chain, thisframe)
59 struct frame_info *thisframe;
62 && !inside_entry_file (FRAME_SAVED_PC (thisframe)));
65 /* A very simple method of determining a valid frame */
68 nonnull_frame_chain_valid (chain, thisframe)
70 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 (addr)
89 if (symfile_objfile == 0)
91 #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 (pc)
116 if (symfile_objfile == 0)
119 /* If the addr range is not set up at symbol reading time, set it up now.
120 This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
121 it is unable to set it up and symbol reading time. */
123 if (symfile_objfile -> ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
124 symfile_objfile -> ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
126 struct symbol *mainsym;
128 mainsym = lookup_symbol ("main", NULL, VAR_NAMESPACE, NULL, NULL);
129 if (mainsym && SYMBOL_CLASS(mainsym) == LOC_BLOCK)
131 symfile_objfile->ei.main_func_lowpc =
132 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym));
133 symfile_objfile->ei.main_func_highpc =
134 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym));
137 return (symfile_objfile -> ei.main_func_lowpc <= pc &&
138 symfile_objfile -> ei.main_func_highpc > pc);
141 /* Test a specified PC value to see if it is in the range of addresses
142 that correspond to the process entry point function. See comments
143 in objfiles.h for why we might want to do this.
145 Typically called from FRAME_CHAIN_VALID.
147 A PC of zero is always considered to be the bottom of the stack. */
150 inside_entry_func (pc)
155 if (symfile_objfile == 0)
157 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
158 /* Do not stop backtracing if the pc is in the call dummy
159 at the entry point. */
160 /* FIXME: Won't always work with zeros for the last two arguments */
161 if (PC_IN_CALL_DUMMY (pc, 0, 0))
164 return (symfile_objfile -> ei.entry_func_lowpc <= pc &&
165 symfile_objfile -> ei.entry_func_highpc > pc);
168 /* Info about the innermost stack frame (contents of FP register) */
170 static struct frame_info *current_frame;
172 /* Cache for frame addresses already read by gdb. Valid only while
173 inferior is stopped. Control variables for the frame cache should
174 be local to this module. */
176 static struct obstack frame_cache_obstack;
179 frame_obstack_alloc (size)
182 return obstack_alloc (&frame_cache_obstack, size);
186 frame_saved_regs_zalloc (fi)
187 struct frame_info *fi;
189 fi->saved_regs = (CORE_ADDR*)
190 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
191 memset (fi->saved_regs, 0, SIZEOF_FRAME_SAVED_REGS);
195 /* Return the innermost (currently executing) stack frame. */
200 if (current_frame == NULL)
202 if (target_has_stack)
203 current_frame = create_new_frame (read_fp (), read_pc ());
207 return current_frame;
211 set_current_frame (frame)
212 struct frame_info *frame;
214 current_frame = frame;
217 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
218 Always returns a non-NULL value. */
221 create_new_frame (addr, pc)
225 struct frame_info *fi;
228 fi = (struct frame_info *)
229 obstack_alloc (&frame_cache_obstack,
230 sizeof (struct frame_info));
232 /* Arbitrary frame */
233 fi->saved_regs = NULL;
238 find_pc_partial_function (pc, &name, (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
239 fi->signal_handler_caller = IN_SIGTRAMP (fi->pc, name);
241 #ifdef INIT_EXTRA_FRAME_INFO
242 INIT_EXTRA_FRAME_INFO (0, fi);
248 /* Return the frame that called FI.
249 If FI is the original frame (it has no caller), return 0. */
252 get_prev_frame (frame)
253 struct frame_info *frame;
255 return get_prev_frame_info (frame);
258 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
262 get_next_frame (frame)
263 struct frame_info *frame;
268 /* Flush the entire frame cache. */
271 flush_cached_frames ()
273 /* Since we can't really be sure what the first object allocated was */
274 obstack_free (&frame_cache_obstack, 0);
275 obstack_init (&frame_cache_obstack);
277 current_frame = NULL; /* Invalidate cache */
278 select_frame (NULL, -1);
279 annotate_frames_invalid ();
282 /* Flush the frame cache, and start a new one if necessary. */
285 reinit_frame_cache ()
287 flush_cached_frames ();
289 /* FIXME: The inferior_pid test is wrong if there is a corefile. */
290 if (inferior_pid != 0)
292 select_frame (get_current_frame (), 0);
296 /* If a machine allows frameless functions, it should define a macro
297 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
298 frame_info for the frame, and FRAMELESS should be set to nonzero
299 if it represents a frameless function invocation. */
301 /* Return nonzero if the function for this frame lacks a prologue. Many
302 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
306 frameless_look_for_prologue (frame)
307 struct frame_info *frame;
309 CORE_ADDR func_start, after_prologue;
310 func_start = get_pc_function_start (frame->pc);
313 func_start += FUNCTION_START_OFFSET;
314 after_prologue = func_start;
315 #ifdef SKIP_PROLOGUE_FRAMELESS_P
316 /* This is faster, since only care whether there *is* a prologue,
317 not how long it is. */
318 SKIP_PROLOGUE_FRAMELESS_P (after_prologue);
320 SKIP_PROLOGUE (after_prologue);
322 return after_prologue == func_start;
324 else if (frame->pc == 0)
325 /* A frame with a zero PC is usually created by dereferencing a NULL
326 function pointer, normally causing an immediate core dump of the
327 inferior. Mark function as frameless, as the inferior has no chance
328 of setting up a stack frame. */
331 /* If we can't find the start of the function, we don't really
332 know whether the function is frameless, but we should be able
333 to get a reasonable (i.e. best we can do under the
334 circumstances) backtrace by saying that it isn't. */
338 /* Default a few macros that people seldom redefine. */
340 #if !defined (INIT_FRAME_PC)
341 #define INIT_FRAME_PC(fromleaf, prev) \
342 prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
343 prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
346 #ifndef FRAME_CHAIN_COMBINE
347 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
350 /* Return a structure containing various interesting information
351 about the frame that called NEXT_FRAME. Returns NULL
352 if there is no such frame. */
355 get_prev_frame_info (next_frame)
356 struct frame_info *next_frame;
358 CORE_ADDR address = 0;
359 struct frame_info *prev;
363 /* If the requested entry is in the cache, return it.
364 Otherwise, figure out what the address should be for the entry
365 we're about to add to the cache. */
370 /* This screws value_of_variable, which just wants a nice clean
371 NULL return from block_innermost_frame if there are no frames.
372 I don't think I've ever seen this message happen otherwise.
373 And returning NULL here is a perfectly legitimate thing to do. */
376 error ("You haven't set up a process's stack to examine.");
380 return current_frame;
383 /* If we have the prev one, return it */
384 if (next_frame->prev)
385 return next_frame->prev;
387 /* On some machines it is possible to call a function without
388 setting up a stack frame for it. On these machines, we
389 define this macro to take two args; a frameinfo pointer
390 identifying a frame and a variable to set or clear if it is
391 or isn't leafless. */
392 #ifdef FRAMELESS_FUNCTION_INVOCATION
393 /* Still don't want to worry about this except on the innermost
394 frame. This macro will set FROMLEAF if NEXT_FRAME is a
395 frameless function invocation. */
396 if (!(next_frame->next))
398 FRAMELESS_FUNCTION_INVOCATION (next_frame, fromleaf);
400 address = FRAME_FP (next_frame);
406 /* Two macros defined in tm.h specify the machine-dependent
407 actions to be performed here.
408 First, get the frame's chain-pointer.
409 If that is zero, the frame is the outermost frame or a leaf
410 called by the outermost frame. This means that if start
411 calls main without a frame, we'll return 0 (which is fine
414 Nope; there's a problem. This also returns when the current
415 routine is a leaf of main. This is unacceptable. We move
416 this to after the ffi test; I'd rather have backtraces from
417 start go curfluy than have an abort called from main not show
419 address = FRAME_CHAIN (next_frame);
420 if (!FRAME_CHAIN_VALID (address, next_frame))
422 address = FRAME_CHAIN_COMBINE (address, next_frame);
427 prev = (struct frame_info *)
428 obstack_alloc (&frame_cache_obstack,
429 sizeof (struct frame_info));
431 prev->saved_regs = NULL;
433 next_frame->prev = prev;
434 prev->next = next_frame;
435 prev->prev = (struct frame_info *) 0;
436 prev->frame = address;
437 prev->signal_handler_caller = 0;
439 /* This change should not be needed, FIXME! We should
440 determine whether any targets *need* INIT_FRAME_PC to happen
441 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
442 express what goes on here.
444 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
445 (where the PC is already set up) and here (where it isn't).
446 INIT_FRAME_PC is only called from here, always after
447 INIT_EXTRA_FRAME_INFO.
449 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
450 value (which hasn't been set yet). Some other machines appear to
451 require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
453 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
454 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
456 Assuming that some machines need INIT_FRAME_PC after
457 INIT_EXTRA_FRAME_INFO, one possible scheme:
459 SETUP_INNERMOST_FRAME()
460 Default version is just create_new_frame (read_fp ()),
461 read_pc ()). Machines with extra frame info would do that (or the
462 local equivalent) and then set the extra fields.
463 SETUP_ARBITRARY_FRAME(argc, argv)
464 Only change here is that create_new_frame would no longer init extra
465 frame info; SETUP_ARBITRARY_FRAME would have to do that.
466 INIT_PREV_FRAME(fromleaf, prev)
467 Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
468 also return a flag saying whether to keep the new frame, or
469 whether to discard it, because on some machines (e.g. mips) it
470 is really awkward to have FRAME_CHAIN_VALID called *before*
471 INIT_EXTRA_FRAME_INFO (there is no good way to get information
472 deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
473 std_frame_pc(fromleaf, prev)
474 This is the default setting for INIT_PREV_FRAME. It just does what
475 the default INIT_FRAME_PC does. Some machines will call it from
476 INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
477 Some machines won't use it.
478 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
480 #ifdef INIT_FRAME_PC_FIRST
481 INIT_FRAME_PC_FIRST (fromleaf, prev);
484 #ifdef INIT_EXTRA_FRAME_INFO
485 INIT_EXTRA_FRAME_INFO(fromleaf, prev);
488 /* This entry is in the frame queue now, which is good since
489 FRAME_SAVED_PC may use that queue to figure out its value
490 (see tm-sparc.h). We want the pc saved in the inferior frame. */
491 INIT_FRAME_PC(fromleaf, prev);
493 /* If ->frame and ->pc are unchanged, we are in the process of getting
494 ourselves into an infinite backtrace. Some architectures check this
495 in FRAME_CHAIN or thereabouts, but it seems like there is no reason
496 this can't be an architecture-independent check. */
497 if (next_frame != NULL)
499 if (prev->frame == next_frame->frame
500 && prev->pc == next_frame->pc)
502 next_frame->prev = NULL;
503 obstack_free (&frame_cache_obstack, prev);
508 find_pc_partial_function (prev->pc, &name,
509 (CORE_ADDR *)NULL,(CORE_ADDR *)NULL);
510 if (IN_SIGTRAMP (prev->pc, name))
511 prev->signal_handler_caller = 1;
518 struct frame_info *frame;
524 #ifdef FRAME_FIND_SAVED_REGS
525 /* XXX - deprecated. This is a compatibility function for targets
526 that do not yet implement FRAME_INIT_SAVED_REGS. */
527 /* Find the addresses in which registers are saved in FRAME. */
530 get_frame_saved_regs (frame, saved_regs_addr)
531 struct frame_info *frame;
532 struct frame_saved_regs *saved_regs_addr;
534 if (frame->saved_regs == NULL)
536 frame->saved_regs = (CORE_ADDR*)
537 frame_obstack_alloc (SIZEOF_FRAME_SAVED_REGS);
539 if (saved_regs_addr == NULL)
541 struct frame_saved_regs saved_regs;
542 FRAME_FIND_SAVED_REGS (frame, saved_regs);
543 memcpy (frame->saved_regs, &saved_regs, SIZEOF_FRAME_SAVED_REGS);
547 FRAME_FIND_SAVED_REGS (frame, *saved_regs_addr);
548 memcpy (frame->saved_regs, saved_regs_addr, SIZEOF_FRAME_SAVED_REGS);
553 /* Return the innermost lexical block in execution
554 in a specified stack frame. The frame address is assumed valid. */
557 get_frame_block (frame)
558 struct frame_info *frame;
563 if (frame->next != 0 && frame->next->signal_handler_caller == 0)
564 /* We are not in the innermost frame and we were not interrupted
565 by a signal. We need to subtract one to get the correct block,
566 in case the call instruction was the last instruction of the block.
567 If there are any machines on which the saved pc does not point to
568 after the call insn, we probably want to make frame->pc point after
569 the call insn anyway. */
571 return block_for_pc (pc);
577 return block_for_pc (read_pc ());
581 get_pc_function_start (pc)
584 register struct block *bl;
585 register struct symbol *symbol;
586 register struct minimal_symbol *msymbol;
589 if ((bl = block_for_pc (pc)) != NULL &&
590 (symbol = block_function (bl)) != NULL)
592 bl = SYMBOL_BLOCK_VALUE (symbol);
593 fstart = BLOCK_START (bl);
595 else if ((msymbol = lookup_minimal_symbol_by_pc (pc)) != NULL)
597 fstart = SYMBOL_VALUE_ADDRESS (msymbol);
606 /* Return the symbol for the function executing in frame FRAME. */
609 get_frame_function (frame)
610 struct frame_info *frame;
612 register struct block *bl = get_frame_block (frame);
615 return block_function (bl);
619 /* Return the blockvector immediately containing the innermost lexical block
620 containing the specified pc value and section, or 0 if there is none.
621 PINDEX is a pointer to the index value of the block. If PINDEX
622 is NULL, we don't pass this information back to the caller. */
625 blockvector_for_pc_sect (pc, section, pindex, symtab)
626 register CORE_ADDR pc;
629 struct symtab *symtab;
632 register struct block *b;
633 register int bot, top, half;
634 struct blockvector *bl;
636 if (symtab == 0) /* if no symtab specified by caller */
638 /* First search all symtabs for one whose file contains our pc */
639 if ((symtab = find_pc_sect_symtab (pc, section)) == 0)
643 bl = BLOCKVECTOR (symtab);
644 b = BLOCKVECTOR_BLOCK (bl, 0);
646 /* Then search that symtab for the smallest block that wins. */
647 /* Use binary search to find the last block that starts before PC. */
650 top = BLOCKVECTOR_NBLOCKS (bl);
652 while (top - bot > 1)
654 half = (top - bot + 1) >> 1;
655 b = BLOCKVECTOR_BLOCK (bl, bot + half);
656 if (BLOCK_START (b) <= pc)
662 /* Now search backward for a block that ends after PC. */
666 b = BLOCKVECTOR_BLOCK (bl, bot);
667 if (BLOCK_END (b) >= pc)
678 /* Return the blockvector immediately containing the innermost lexical block
679 containing the specified pc value, or 0 if there is none.
680 Backward compatibility, no section. */
683 blockvector_for_pc (pc, pindex)
684 register CORE_ADDR pc;
687 return blockvector_for_pc_sect (pc, find_pc_mapped_section (pc),
691 /* Return the innermost lexical block containing the specified pc value
692 in the specified section, or 0 if there is none. */
695 block_for_pc_sect (pc, section)
696 register CORE_ADDR pc;
699 register struct blockvector *bl;
702 bl = blockvector_for_pc_sect (pc, section, &index, NULL);
704 return BLOCKVECTOR_BLOCK (bl, index);
708 /* Return the innermost lexical block containing the specified pc value,
709 or 0 if there is none. Backward compatibility, no section. */
713 register CORE_ADDR pc;
715 return block_for_pc_sect (pc, find_pc_mapped_section (pc));
718 /* Return the function containing pc value PC in section SECTION.
719 Returns 0 if function is not known. */
722 find_pc_sect_function (pc, section)
726 register struct block *b = block_for_pc_sect (pc, section);
729 return block_function (b);
732 /* Return the function containing pc value PC.
733 Returns 0 if function is not known. Backward compatibility, no section */
736 find_pc_function (pc)
739 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
742 /* These variables are used to cache the most recent result
743 * of find_pc_partial_function. */
745 static CORE_ADDR cache_pc_function_low = 0;
746 static CORE_ADDR cache_pc_function_high = 0;
747 static char *cache_pc_function_name = 0;
748 static struct sec *cache_pc_function_section = NULL;
750 /* Clear cache, e.g. when symbol table is discarded. */
753 clear_pc_function_cache()
755 cache_pc_function_low = 0;
756 cache_pc_function_high = 0;
757 cache_pc_function_name = (char *)0;
758 cache_pc_function_section = NULL;
761 /* Finds the "function" (text symbol) that is smaller than PC but
762 greatest of all of the potential text symbols in SECTION. Sets
763 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
764 If ENDADDR is non-null, then set *ENDADDR to be the end of the
765 function (exclusive), but passing ENDADDR as non-null means that
766 the function might cause symbols to be read. This function either
767 succeeds or fails (not halfway succeeds). If it succeeds, it sets
768 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
769 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
773 find_pc_sect_partial_function (pc, section, name, address, endaddr)
780 struct partial_symtab *pst;
782 struct minimal_symbol *msymbol;
783 struct partial_symbol *psb;
784 struct obj_section *osect;
788 mapped_pc = overlay_mapped_address (pc, section);
790 if (mapped_pc >= cache_pc_function_low &&
791 mapped_pc < cache_pc_function_high &&
792 section == cache_pc_function_section)
793 goto return_cached_value;
795 /* If sigtramp is in the u area, it counts as a function (especially
796 important for step_1). */
797 #if defined SIGTRAMP_START
798 if (IN_SIGTRAMP (mapped_pc, (char *)NULL))
800 cache_pc_function_low = SIGTRAMP_START (mapped_pc);
801 cache_pc_function_high = SIGTRAMP_END (mapped_pc);
802 cache_pc_function_name = "<sigtramp>";
803 cache_pc_function_section = section;
804 goto return_cached_value;
808 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
809 pst = find_pc_sect_psymtab (mapped_pc, section);
812 /* Need to read the symbols to get a good value for the end address. */
813 if (endaddr != NULL && !pst->readin)
815 /* Need to get the terminal in case symbol-reading produces
817 target_terminal_ours_for_output ();
818 PSYMTAB_TO_SYMTAB (pst);
823 /* Checking whether the msymbol has a larger value is for the
824 "pathological" case mentioned in print_frame_info. */
825 f = find_pc_sect_function (mapped_pc, section);
828 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
829 >= SYMBOL_VALUE_ADDRESS (msymbol))))
831 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
832 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
833 cache_pc_function_name = SYMBOL_NAME (f);
834 cache_pc_function_section = section;
835 goto return_cached_value;
840 /* Now that static symbols go in the minimal symbol table, perhaps
841 we could just ignore the partial symbols. But at least for now
842 we use the partial or minimal symbol, whichever is larger. */
843 psb = find_pc_sect_psymbol (pst, mapped_pc, section);
846 && (msymbol == NULL ||
847 (SYMBOL_VALUE_ADDRESS (psb)
848 >= SYMBOL_VALUE_ADDRESS (msymbol))))
850 /* This case isn't being cached currently. */
852 *address = SYMBOL_VALUE_ADDRESS (psb);
854 *name = SYMBOL_NAME (psb);
855 /* endaddr non-NULL can't happen here. */
861 /* Not in the normal symbol tables, see if the pc is in a known section.
862 If it's not, then give up. This ensures that anything beyond the end
863 of the text seg doesn't appear to be part of the last function in the
866 osect = find_pc_sect_section (mapped_pc, section);
871 /* Must be in the minimal symbol table. */
874 /* No available symbol. */
884 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
885 cache_pc_function_name = SYMBOL_NAME (msymbol);
886 cache_pc_function_section = section;
888 /* Use the lesser of the next minimal symbol in the same section, or
889 the end of the section, as the end of the function. */
891 /* Step over other symbols at this same address, and symbols in
892 other sections, to find the next symbol in this section with
893 a different address. */
895 for (i=1; SYMBOL_NAME (msymbol+i) != NULL; i++)
897 if (SYMBOL_VALUE_ADDRESS (msymbol+i) != SYMBOL_VALUE_ADDRESS (msymbol)
898 && SYMBOL_BFD_SECTION (msymbol+i) == SYMBOL_BFD_SECTION (msymbol))
902 if (SYMBOL_NAME (msymbol + i) != NULL
903 && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr)
904 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
906 /* We got the start address from the last msymbol in the objfile.
907 So the end address is the end of the section. */
908 cache_pc_function_high = osect->endaddr;
914 if (pc_in_unmapped_range (pc, section))
915 *address = overlay_unmapped_address (cache_pc_function_low, section);
917 *address = cache_pc_function_low;
921 *name = cache_pc_function_name;
925 if (pc_in_unmapped_range (pc, section))
927 /* Because the high address is actually beyond the end of
928 the function (and therefore possibly beyond the end of
929 the overlay), we must actually convert (high - 1)
930 and then add one to that. */
932 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
936 *endaddr = cache_pc_function_high;
942 /* Backward compatibility, no section argument */
945 find_pc_partial_function (pc, name, address, endaddr)
953 section = find_pc_overlay (pc);
954 return find_pc_sect_partial_function (pc, section, name, address, endaddr);
957 /* Return the innermost stack frame executing inside of BLOCK,
958 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
961 block_innermost_frame (block)
964 struct frame_info *frame;
965 register CORE_ADDR start;
966 register CORE_ADDR end;
971 start = BLOCK_START (block);
972 end = BLOCK_END (block);
977 frame = get_prev_frame (frame);
980 if (frame->pc >= start && frame->pc < end)
985 /* Return the full FRAME which corresponds to the given CORE_ADDR
986 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
989 find_frame_addr_in_frame_chain (frame_addr)
990 CORE_ADDR frame_addr;
992 struct frame_info *frame = NULL;
994 if (frame_addr == (CORE_ADDR)0)
999 frame = get_prev_frame (frame);
1002 if (FRAME_FP (frame) == frame_addr)
1007 #ifdef SIGCONTEXT_PC_OFFSET
1008 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
1011 sigtramp_saved_pc (frame)
1012 struct frame_info *frame;
1014 CORE_ADDR sigcontext_addr;
1015 char buf[TARGET_PTR_BIT / TARGET_CHAR_BIT];
1016 int ptrbytes = TARGET_PTR_BIT / TARGET_CHAR_BIT;
1017 int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
1019 /* Get sigcontext address, it is the third parameter on the stack. */
1021 sigcontext_addr = read_memory_integer (FRAME_ARGS_ADDRESS (frame->next)
1026 sigcontext_addr = read_memory_integer (read_register (SP_REGNUM)
1030 /* Don't cause a memory_error when accessing sigcontext in case the stack
1031 layout has changed or the stack is corrupt. */
1032 target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
1033 return extract_unsigned_integer (buf, ptrbytes);
1035 #endif /* SIGCONTEXT_PC_OFFSET */
1037 #ifdef USE_GENERIC_DUMMY_FRAMES
1040 * GENERIC DUMMY FRAMES
1042 * The following code serves to maintain the dummy stack frames for
1043 * inferior function calls (ie. when gdb calls into the inferior via
1044 * call_function_by_hand). This code saves the machine state before
1045 * the call in host memory, so we must maintain an independant stack
1046 * and keep it consistant etc. I am attempting to make this code
1047 * generic enough to be used by many targets.
1049 * The cheapest and most generic way to do CALL_DUMMY on a new target
1050 * is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to
1051 * zero, and CALL_DUMMY_LOCATION to AT_ENTRY. Then you must remember
1052 * to define PUSH_RETURN_ADDRESS, because no call instruction will be
1053 * being executed by the target. Also FRAME_CHAIN_VALID as
1054 * generic_frame_chain_valid. */
1056 static struct dummy_frame *dummy_frame_stack = NULL;
1058 /* Function: find_dummy_frame(pc, fp, sp)
1059 Search the stack of dummy frames for one matching the given PC, FP and SP.
1060 This is the work-horse for pc_in_call_dummy and read_register_dummy */
1063 generic_find_dummy_frame (pc, fp)
1067 struct dummy_frame * dummyframe;
1069 if (pc != entry_point_address ())
1072 for (dummyframe = dummy_frame_stack; dummyframe != NULL;
1073 dummyframe = dummyframe->next)
1074 if (fp == dummyframe->fp || fp == dummyframe->sp)
1075 /* The frame in question lies between the saved fp and sp, inclusive */
1076 return dummyframe->regs;
1081 /* Function: pc_in_call_dummy (pc, fp)
1082 Return true if this is a dummy frame created by gdb for an inferior call */
1085 generic_pc_in_call_dummy (pc, fp)
1089 /* if find_dummy_frame succeeds, then PC is in a call dummy */
1090 return (generic_find_dummy_frame (pc, fp) != 0);
1093 /* Function: read_register_dummy
1094 Find a saved register from before GDB calls a function in the inferior */
1097 generic_read_register_dummy (pc, fp, regno)
1102 char *dummy_regs = generic_find_dummy_frame (pc, fp);
1105 return extract_address (&dummy_regs[REGISTER_BYTE (regno)],
1106 REGISTER_RAW_SIZE(regno));
1111 /* Save all the registers on the dummy frame stack. Most ports save the
1112 registers on the target stack. This results in lots of unnecessary memory
1113 references, which are slow when debugging via a serial line. Instead, we
1114 save all the registers internally, and never write them to the stack. The
1115 registers get restored when the called function returns to the entry point,
1116 where a breakpoint is laying in wait. */
1119 generic_push_dummy_frame ()
1121 struct dummy_frame *dummy_frame;
1122 CORE_ADDR fp = (get_current_frame ())->frame;
1124 /* check to see if there are stale dummy frames,
1125 perhaps left over from when a longjump took us out of a
1126 function that was called by the debugger */
1128 dummy_frame = dummy_frame_stack;
1130 if (INNER_THAN (dummy_frame->fp, fp)) /* stale -- destroy! */
1132 dummy_frame_stack = dummy_frame->next;
1134 dummy_frame = dummy_frame_stack;
1137 dummy_frame = dummy_frame->next;
1139 dummy_frame = xmalloc (sizeof (struct dummy_frame));
1140 dummy_frame->pc = read_register (PC_REGNUM);
1141 dummy_frame->sp = read_register (SP_REGNUM);
1142 dummy_frame->fp = fp;
1143 read_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
1144 dummy_frame->next = dummy_frame_stack;
1145 dummy_frame_stack = dummy_frame;
1148 /* Function: pop_frame
1149 Restore the machine state from either the saved dummy stack or a
1150 real stack frame. */
1153 generic_pop_current_frame (pop)
1154 void (*pop) PARAMS ((struct frame_info *frame));
1156 struct frame_info *frame = get_current_frame ();
1157 if (PC_IN_CALL_DUMMY(frame->pc, frame->frame, frame->frame))
1158 generic_pop_dummy_frame ();
1163 /* Function: pop_dummy_frame
1164 Restore the machine state from a saved dummy stack frame. */
1167 generic_pop_dummy_frame ()
1169 struct dummy_frame *dummy_frame = dummy_frame_stack;
1171 /* FIXME: what if the first frame isn't the right one, eg..
1172 because one call-by-hand function has done a longjmp into another one? */
1175 error ("Can't pop dummy frame!");
1176 dummy_frame_stack = dummy_frame->next;
1177 write_register_bytes (0, dummy_frame->regs, REGISTER_BYTES);
1178 flush_cached_frames ();
1182 /* Function: frame_chain_valid
1183 Returns true for a user frame or a call_function_by_hand dummy frame,
1184 and false for the CRT0 start-up frame. Purpose is to terminate backtrace */
1187 generic_frame_chain_valid (fp, fi)
1189 struct frame_info *fi;
1191 if (PC_IN_CALL_DUMMY(FRAME_SAVED_PC(fi), fp, fp))
1192 return 1; /* don't prune CALL_DUMMY frames */
1193 else /* fall back to default algorithm (see frame.h) */
1195 && (INNER_THAN (fi->frame, fp) || fi->frame == fp)
1196 && !inside_entry_file (FRAME_SAVED_PC(fi)));
1199 /* Function: get_saved_register
1200 Find register number REGNUM relative to FRAME and put its (raw,
1201 target format) contents in *RAW_BUFFER.
1203 Set *OPTIMIZED if the variable was optimized out (and thus can't be
1204 fetched). Note that this is never set to anything other than zero
1205 in this implementation.
1207 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1208 whether the value was fetched from memory, from a register, or in a
1209 strange and non-modifiable way (e.g. a frame pointer which was
1210 calculated rather than fetched). We will use not_lval for values
1211 fetched from generic dummy frames.
1213 Set *ADDRP to the address, either in memory on as a REGISTER_BYTE
1214 offset into the registers array. If the value is stored in a dummy
1215 frame, set *ADDRP to zero.
1217 To use this implementation, define a function called
1218 "get_saved_register" in your target code, which simply passes all
1219 of its arguments to this function.
1221 The argument RAW_BUFFER must point to aligned memory. */
1224 generic_get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
1228 struct frame_info *frame;
1230 enum lval_type *lval;
1232 if (!target_has_registers)
1233 error ("No registers.");
1235 /* Normal systems don't optimize out things with register numbers. */
1236 if (optimized != NULL)
1239 if (addrp) /* default assumption: not found in memory */
1242 /* Note: since the current frame's registers could only have been
1243 saved by frames INTERIOR TO the current frame, we skip examining
1244 the current frame itself: otherwise, we would be getting the
1245 previous frame's registers which were saved by the current frame. */
1247 while (frame && ((frame = frame->next) != NULL))
1249 if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
1251 if (lval) /* found it in a CALL_DUMMY frame */
1255 generic_find_dummy_frame (frame->pc, frame->frame) +
1256 REGISTER_BYTE (regnum),
1257 REGISTER_RAW_SIZE (regnum));
1261 FRAME_INIT_SAVED_REGS (frame);
1262 if (frame->saved_regs != NULL
1263 && frame->saved_regs[regnum] != 0)
1265 if (lval) /* found it saved on the stack */
1266 *lval = lval_memory;
1267 if (regnum == SP_REGNUM)
1269 if (raw_buffer) /* SP register treated specially */
1270 store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
1271 frame->saved_regs[regnum]);
1275 if (addrp) /* any other register */
1276 *addrp = frame->saved_regs[regnum];
1278 read_memory (frame->saved_regs[regnum], raw_buffer,
1279 REGISTER_RAW_SIZE (regnum));
1285 /* If we get thru the loop to this point, it means the register was
1286 not saved in any frame. Return the actual live-register value. */
1288 if (lval) /* found it in a live register */
1289 *lval = lval_register;
1291 *addrp = REGISTER_BYTE (regnum);
1293 read_register_gen (regnum, raw_buffer);
1295 #endif /* USE_GENERIC_DUMMY_FRAMES */
1298 _initialize_blockframe ()
1300 obstack_init (&frame_cache_obstack);