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 /* Is ADDR inside the startup file? Note that if your machine
35 has a way to detect the bottom of the stack, there is no need
36 to call this function from FRAME_CHAIN_VALID; the reason for
37 doing so is that some machines have no way of detecting bottom
40 A PC of zero is always considered to be the bottom of the stack. */
43 inside_entry_file (addr
)
48 if (symfile_objfile
== 0)
50 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
51 /* Do not stop backtracing if the pc is in the call dummy
52 at the entry point. */
53 /* FIXME: Won't always work with zeros for the last two arguments */
54 if (PC_IN_CALL_DUMMY (addr
, 0, 0))
57 return (addr
>= symfile_objfile
-> ei
.entry_file_lowpc
&&
58 addr
< symfile_objfile
-> ei
.entry_file_highpc
);
61 /* Test a specified PC value to see if it is in the range of addresses
62 that correspond to the main() function. See comments above for why
63 we might want to do this.
65 Typically called from FRAME_CHAIN_VALID.
67 A PC of zero is always considered to be the bottom of the stack. */
75 if (symfile_objfile
== 0)
78 /* If the addr range is not set up at symbol reading time, set it up now.
79 This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
80 it is unable to set it up and symbol reading time. */
82 if (symfile_objfile
-> ei
.main_func_lowpc
== INVALID_ENTRY_LOWPC
&&
83 symfile_objfile
-> ei
.main_func_highpc
== INVALID_ENTRY_HIGHPC
)
85 struct symbol
*mainsym
;
87 mainsym
= lookup_symbol ("main", NULL
, VAR_NAMESPACE
, NULL
, NULL
);
88 if (mainsym
&& SYMBOL_CLASS(mainsym
) == LOC_BLOCK
)
90 symfile_objfile
->ei
.main_func_lowpc
=
91 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym
));
92 symfile_objfile
->ei
.main_func_highpc
=
93 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym
));
96 return (symfile_objfile
-> ei
.main_func_lowpc
<= pc
&&
97 symfile_objfile
-> ei
.main_func_highpc
> pc
);
100 /* Test a specified PC value to see if it is in the range of addresses
101 that correspond to the process entry point function. See comments
102 in objfiles.h for why 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_entry_func (pc
)
114 if (symfile_objfile
== 0)
116 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
117 /* Do not stop backtracing if the pc is in the call dummy
118 at the entry point. */
119 /* FIXME: Won't always work with zeros for the last two arguments */
120 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
123 return (symfile_objfile
-> ei
.entry_func_lowpc
<= pc
&&
124 symfile_objfile
-> ei
.entry_func_highpc
> pc
);
127 /* Info about the innermost stack frame (contents of FP register) */
129 static struct frame_info
*current_frame
;
131 /* Cache for frame addresses already read by gdb. Valid only while
132 inferior is stopped. Control variables for the frame cache should
133 be local to this module. */
135 struct obstack frame_cache_obstack
;
137 /* Return the innermost (currently executing) stack frame. */
142 if (current_frame
== NULL
)
144 if (target_has_stack
)
145 current_frame
= create_new_frame (read_fp (), read_pc ());
149 return current_frame
;
153 set_current_frame (frame
)
154 struct frame_info
*frame
;
156 current_frame
= frame
;
159 /* Create an arbitrary (i.e. address specified by user) or innermost frame.
160 Always returns a non-NULL value. */
163 create_new_frame (addr
, pc
)
167 struct frame_info
*fi
;
170 fi
= (struct frame_info
*)
171 obstack_alloc (&frame_cache_obstack
,
172 sizeof (struct frame_info
));
174 /* Arbitrary frame */
179 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*)NULL
,(CORE_ADDR
*)NULL
);
180 fi
->signal_handler_caller
= IN_SIGTRAMP (fi
->pc
, name
);
182 #ifdef INIT_EXTRA_FRAME_INFO
183 INIT_EXTRA_FRAME_INFO (0, fi
);
189 /* Return the frame that called FI.
190 If FI is the original frame (it has no caller), return 0. */
193 get_prev_frame (frame
)
194 struct frame_info
*frame
;
196 return get_prev_frame_info (frame
);
199 /* Return the frame that FRAME calls (NULL if FRAME is the innermost
203 get_next_frame (frame
)
204 struct frame_info
*frame
;
209 /* Flush the entire frame cache. */
212 flush_cached_frames ()
214 /* Since we can't really be sure what the first object allocated was */
215 obstack_free (&frame_cache_obstack
, 0);
216 obstack_init (&frame_cache_obstack
);
218 current_frame
= NULL
; /* Invalidate cache */
219 select_frame (NULL
, -1);
220 annotate_frames_invalid ();
223 /* Flush the frame cache, and start a new one if necessary. */
226 reinit_frame_cache ()
228 flush_cached_frames ();
230 /* FIXME: The inferior_pid test is wrong if there is a corefile. */
231 if (inferior_pid
!= 0)
233 select_frame (get_current_frame (), 0);
237 /* If a machine allows frameless functions, it should define a macro
238 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
239 frame_info for the frame, and FRAMELESS should be set to nonzero
240 if it represents a frameless function invocation. */
242 /* Return nonzero if the function for this frame lacks a prologue. Many
243 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
247 frameless_look_for_prologue (frame
)
248 struct frame_info
*frame
;
250 CORE_ADDR func_start
, after_prologue
;
251 func_start
= get_pc_function_start (frame
->pc
);
254 func_start
+= FUNCTION_START_OFFSET
;
255 after_prologue
= func_start
;
256 #ifdef SKIP_PROLOGUE_FRAMELESS_P
257 /* This is faster, since only care whether there *is* a prologue,
258 not how long it is. */
259 SKIP_PROLOGUE_FRAMELESS_P (after_prologue
);
261 SKIP_PROLOGUE (after_prologue
);
263 return after_prologue
== func_start
;
265 else if (frame
->pc
== 0)
266 /* A frame with a zero PC is usually created by dereferencing a NULL
267 function pointer, normally causing an immediate core dump of the
268 inferior. Mark function as frameless, as the inferior has no chance
269 of setting up a stack frame. */
272 /* If we can't find the start of the function, we don't really
273 know whether the function is frameless, but we should be able
274 to get a reasonable (i.e. best we can do under the
275 circumstances) backtrace by saying that it isn't. */
279 /* Default a few macros that people seldom redefine. */
281 #if !defined (INIT_FRAME_PC)
282 #define INIT_FRAME_PC(fromleaf, prev) \
283 prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
284 prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
287 #ifndef FRAME_CHAIN_COMBINE
288 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
291 /* Return a structure containing various interesting information
292 about the frame that called NEXT_FRAME. Returns NULL
293 if there is no such frame. */
296 get_prev_frame_info (next_frame
)
297 struct frame_info
*next_frame
;
299 CORE_ADDR address
= 0;
300 struct frame_info
*prev
;
304 /* If the requested entry is in the cache, return it.
305 Otherwise, figure out what the address should be for the entry
306 we're about to add to the cache. */
311 /* This screws value_of_variable, which just wants a nice clean
312 NULL return from block_innermost_frame if there are no frames.
313 I don't think I've ever seen this message happen otherwise.
314 And returning NULL here is a perfectly legitimate thing to do. */
317 error ("You haven't set up a process's stack to examine.");
321 return current_frame
;
324 /* If we have the prev one, return it */
325 if (next_frame
->prev
)
326 return next_frame
->prev
;
328 /* On some machines it is possible to call a function without
329 setting up a stack frame for it. On these machines, we
330 define this macro to take two args; a frameinfo pointer
331 identifying a frame and a variable to set or clear if it is
332 or isn't leafless. */
333 #ifdef FRAMELESS_FUNCTION_INVOCATION
334 /* Still don't want to worry about this except on the innermost
335 frame. This macro will set FROMLEAF if NEXT_FRAME is a
336 frameless function invocation. */
337 if (!(next_frame
->next
))
339 FRAMELESS_FUNCTION_INVOCATION (next_frame
, fromleaf
);
341 address
= FRAME_FP (next_frame
);
347 /* Two macros defined in tm.h specify the machine-dependent
348 actions to be performed here.
349 First, get the frame's chain-pointer.
350 If that is zero, the frame is the outermost frame or a leaf
351 called by the outermost frame. This means that if start
352 calls main without a frame, we'll return 0 (which is fine
355 Nope; there's a problem. This also returns when the current
356 routine is a leaf of main. This is unacceptable. We move
357 this to after the ffi test; I'd rather have backtraces from
358 start go curfluy than have an abort called from main not show
360 address
= FRAME_CHAIN (next_frame
);
361 if (!FRAME_CHAIN_VALID (address
, next_frame
))
363 address
= FRAME_CHAIN_COMBINE (address
, next_frame
);
368 prev
= (struct frame_info
*)
369 obstack_alloc (&frame_cache_obstack
,
370 sizeof (struct frame_info
));
373 next_frame
->prev
= prev
;
374 prev
->next
= next_frame
;
375 prev
->prev
= (struct frame_info
*) 0;
376 prev
->frame
= address
;
377 prev
->signal_handler_caller
= 0;
379 /* This change should not be needed, FIXME! We should
380 determine whether any targets *need* INIT_FRAME_PC to happen
381 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
382 express what goes on here.
384 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
385 (where the PC is already set up) and here (where it isn't).
386 INIT_FRAME_PC is only called from here, always after
387 INIT_EXTRA_FRAME_INFO.
389 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
390 value (which hasn't been set yet). Some other machines appear to
391 require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
393 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
394 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
396 Assuming that some machines need INIT_FRAME_PC after
397 INIT_EXTRA_FRAME_INFO, one possible scheme:
399 SETUP_INNERMOST_FRAME()
400 Default version is just create_new_frame (read_fp ()),
401 read_pc ()). Machines with extra frame info would do that (or the
402 local equivalent) and then set the extra fields.
403 SETUP_ARBITRARY_FRAME(argc, argv)
404 Only change here is that create_new_frame would no longer init extra
405 frame info; SETUP_ARBITRARY_FRAME would have to do that.
406 INIT_PREV_FRAME(fromleaf, prev)
407 Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
408 also return a flag saying whether to keep the new frame, or
409 whether to discard it, because on some machines (e.g. mips) it
410 is really awkward to have FRAME_CHAIN_VALID called *before*
411 INIT_EXTRA_FRAME_INFO (there is no good way to get information
412 deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
413 std_frame_pc(fromleaf, prev)
414 This is the default setting for INIT_PREV_FRAME. It just does what
415 the default INIT_FRAME_PC does. Some machines will call it from
416 INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
417 Some machines won't use it.
418 kingdon@cygnus.com, 13Apr93, 31Jan94, 14Dec94. */
420 #ifdef INIT_FRAME_PC_FIRST
421 INIT_FRAME_PC_FIRST (fromleaf
, prev
);
424 #ifdef INIT_EXTRA_FRAME_INFO
425 INIT_EXTRA_FRAME_INFO(fromleaf
, prev
);
428 /* This entry is in the frame queue now, which is good since
429 FRAME_SAVED_PC may use that queue to figure out its value
430 (see tm-sparc.h). We want the pc saved in the inferior frame. */
431 INIT_FRAME_PC(fromleaf
, prev
);
433 /* If ->frame and ->pc are unchanged, we are in the process of getting
434 ourselves into an infinite backtrace. Some architectures check this
435 in FRAME_CHAIN or thereabouts, but it seems like there is no reason
436 this can't be an architecture-independent check. */
437 if (next_frame
!= NULL
)
439 if (prev
->frame
== next_frame
->frame
440 && prev
->pc
== next_frame
->pc
)
442 next_frame
->prev
= NULL
;
443 obstack_free (&frame_cache_obstack
, prev
);
448 find_pc_partial_function (prev
->pc
, &name
,
449 (CORE_ADDR
*)NULL
,(CORE_ADDR
*)NULL
);
450 if (IN_SIGTRAMP (prev
->pc
, name
))
451 prev
->signal_handler_caller
= 1;
458 struct frame_info
*frame
;
463 #if defined (FRAME_FIND_SAVED_REGS)
464 /* Find the addresses in which registers are saved in FRAME. */
467 get_frame_saved_regs (frame
, saved_regs_addr
)
468 struct frame_info
*frame
;
469 struct frame_saved_regs
*saved_regs_addr
;
471 FRAME_FIND_SAVED_REGS (frame
, *saved_regs_addr
);
475 /* Return the innermost lexical block in execution
476 in a specified stack frame. The frame address is assumed valid. */
479 get_frame_block (frame
)
480 struct frame_info
*frame
;
485 if (frame
->next
!= 0 && frame
->next
->signal_handler_caller
== 0)
486 /* We are not in the innermost frame and we were not interrupted
487 by a signal. We need to subtract one to get the correct block,
488 in case the call instruction was the last instruction of the block.
489 If there are any machines on which the saved pc does not point to
490 after the call insn, we probably want to make frame->pc point after
491 the call insn anyway. */
493 return block_for_pc (pc
);
499 return block_for_pc (read_pc ());
503 get_pc_function_start (pc
)
506 register struct block
*bl
;
507 register struct symbol
*symbol
;
508 register struct minimal_symbol
*msymbol
;
511 if ((bl
= block_for_pc (pc
)) != NULL
&&
512 (symbol
= block_function (bl
)) != NULL
)
514 bl
= SYMBOL_BLOCK_VALUE (symbol
);
515 fstart
= BLOCK_START (bl
);
517 else if ((msymbol
= lookup_minimal_symbol_by_pc (pc
)) != NULL
)
519 fstart
= SYMBOL_VALUE_ADDRESS (msymbol
);
528 /* Return the symbol for the function executing in frame FRAME. */
531 get_frame_function (frame
)
532 struct frame_info
*frame
;
534 register struct block
*bl
= get_frame_block (frame
);
537 return block_function (bl
);
541 /* Return the blockvector immediately containing the innermost lexical block
542 containing the specified pc value and section, or 0 if there is none.
543 PINDEX is a pointer to the index value of the block. If PINDEX
544 is NULL, we don't pass this information back to the caller. */
547 blockvector_for_pc_sect (pc
, section
, pindex
, symtab
)
548 register CORE_ADDR pc
;
551 struct symtab
*symtab
;
554 register struct block
*b
;
555 register int bot
, top
, half
;
556 struct blockvector
*bl
;
558 if (symtab
== 0) /* if no symtab specified by caller */
560 /* First search all symtabs for one whose file contains our pc */
561 if ((symtab
= find_pc_sect_symtab (pc
, section
)) == 0)
565 bl
= BLOCKVECTOR (symtab
);
566 b
= BLOCKVECTOR_BLOCK (bl
, 0);
568 /* Then search that symtab for the smallest block that wins. */
569 /* Use binary search to find the last block that starts before PC. */
572 top
= BLOCKVECTOR_NBLOCKS (bl
);
574 while (top
- bot
> 1)
576 half
= (top
- bot
+ 1) >> 1;
577 b
= BLOCKVECTOR_BLOCK (bl
, bot
+ half
);
578 if (BLOCK_START (b
) <= pc
)
584 /* Now search backward for a block that ends after PC. */
588 b
= BLOCKVECTOR_BLOCK (bl
, bot
);
589 if (BLOCK_END (b
) > pc
)
600 /* Return the blockvector immediately containing the innermost lexical block
601 containing the specified pc value, or 0 if there is none.
602 Backward compatibility, no section. */
605 blockvector_for_pc (pc
, pindex
)
606 register CORE_ADDR pc
;
609 return blockvector_for_pc_sect (pc
, find_pc_mapped_section (pc
),
613 /* Return the innermost lexical block containing the specified pc value
614 in the specified section, or 0 if there is none. */
617 block_for_pc_sect (pc
, section
)
618 register CORE_ADDR pc
;
621 register struct blockvector
*bl
;
624 bl
= blockvector_for_pc_sect (pc
, section
, &index
, NULL
);
626 return BLOCKVECTOR_BLOCK (bl
, index
);
630 /* Return the innermost lexical block containing the specified pc value,
631 or 0 if there is none. Backward compatibility, no section. */
635 register CORE_ADDR pc
;
637 return block_for_pc_sect (pc
, find_pc_mapped_section (pc
));
640 /* Return the function containing pc value PC in section SECTION.
641 Returns 0 if function is not known. */
644 find_pc_sect_function (pc
, section
)
648 register struct block
*b
= block_for_pc_sect (pc
, section
);
651 return block_function (b
);
654 /* Return the function containing pc value PC.
655 Returns 0 if function is not known. Backward compatibility, no section */
658 find_pc_function (pc
)
661 return find_pc_sect_function (pc
, find_pc_mapped_section (pc
));
664 /* These variables are used to cache the most recent result
665 * of find_pc_partial_function. */
667 static CORE_ADDR cache_pc_function_low
= 0;
668 static CORE_ADDR cache_pc_function_high
= 0;
669 static char *cache_pc_function_name
= 0;
670 static struct sec
*cache_pc_function_section
= NULL
;
672 /* Clear cache, e.g. when symbol table is discarded. */
675 clear_pc_function_cache()
677 cache_pc_function_low
= 0;
678 cache_pc_function_high
= 0;
679 cache_pc_function_name
= (char *)0;
680 cache_pc_function_section
= NULL
;
683 /* Finds the "function" (text symbol) that is smaller than PC but
684 greatest of all of the potential text symbols in SECTION. Sets
685 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
686 If ENDADDR is non-null, then set *ENDADDR to be the end of the
687 function (exclusive), but passing ENDADDR as non-null means that
688 the function might cause symbols to be read. This function either
689 succeeds or fails (not halfway succeeds). If it succeeds, it sets
690 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
691 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
695 find_pc_sect_partial_function (pc
, section
, name
, address
, endaddr
)
702 struct partial_symtab
*pst
;
704 struct minimal_symbol
*msymbol
;
705 struct partial_symbol
*psb
;
706 struct obj_section
*osect
;
710 mapped_pc
= overlay_mapped_address (pc
, section
);
712 if (mapped_pc
>= cache_pc_function_low
&&
713 mapped_pc
< cache_pc_function_high
&&
714 section
== cache_pc_function_section
)
715 goto return_cached_value
;
717 /* If sigtramp is in the u area, it counts as a function (especially
718 important for step_1). */
719 #if defined SIGTRAMP_START
720 if (IN_SIGTRAMP (mapped_pc
, (char *)NULL
))
722 cache_pc_function_low
= SIGTRAMP_START (mapped_pc
);
723 cache_pc_function_high
= SIGTRAMP_END (mapped_pc
);
724 cache_pc_function_name
= "<sigtramp>";
725 cache_pc_function_section
= section
;
726 goto return_cached_value
;
730 msymbol
= lookup_minimal_symbol_by_pc_section (mapped_pc
, section
);
731 pst
= find_pc_sect_psymtab (mapped_pc
, section
);
734 /* Need to read the symbols to get a good value for the end address. */
735 if (endaddr
!= NULL
&& !pst
->readin
)
737 /* Need to get the terminal in case symbol-reading produces
739 target_terminal_ours_for_output ();
740 PSYMTAB_TO_SYMTAB (pst
);
745 /* Checking whether the msymbol has a larger value is for the
746 "pathological" case mentioned in print_frame_info. */
747 f
= find_pc_sect_function (mapped_pc
, section
);
750 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f
))
751 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
753 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
754 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
755 cache_pc_function_name
= SYMBOL_NAME (f
);
756 cache_pc_function_section
= section
;
757 goto return_cached_value
;
762 /* Now that static symbols go in the minimal symbol table, perhaps
763 we could just ignore the partial symbols. But at least for now
764 we use the partial or minimal symbol, whichever is larger. */
765 psb
= find_pc_sect_psymbol (pst
, mapped_pc
, section
);
768 && (msymbol
== NULL
||
769 (SYMBOL_VALUE_ADDRESS (psb
)
770 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
772 /* This case isn't being cached currently. */
774 *address
= SYMBOL_VALUE_ADDRESS (psb
);
776 *name
= SYMBOL_NAME (psb
);
777 /* endaddr non-NULL can't happen here. */
783 /* Not in the normal symbol tables, see if the pc is in a known section.
784 If it's not, then give up. This ensures that anything beyond the end
785 of the text seg doesn't appear to be part of the last function in the
788 osect
= find_pc_sect_section (mapped_pc
, section
);
793 /* Must be in the minimal symbol table. */
796 /* No available symbol. */
806 cache_pc_function_low
= SYMBOL_VALUE_ADDRESS (msymbol
);
807 cache_pc_function_name
= SYMBOL_NAME (msymbol
);
808 cache_pc_function_section
= section
;
810 /* Use the lesser of the next minimal symbol in the same section, or
811 the end of the section, as the end of the function. */
813 /* Step over other symbols at this same address, and symbols in
814 other sections, to find the next symbol in this section with
815 a different address. */
817 for (i
=1; SYMBOL_NAME (msymbol
+i
) != NULL
; i
++)
819 if (SYMBOL_VALUE_ADDRESS (msymbol
+i
) != SYMBOL_VALUE_ADDRESS (msymbol
)
820 && SYMBOL_BFD_SECTION (msymbol
+i
) == SYMBOL_BFD_SECTION (msymbol
))
824 if (SYMBOL_NAME (msymbol
+ i
) != NULL
825 && SYMBOL_VALUE_ADDRESS (msymbol
+ i
) < osect
->endaddr
)
826 cache_pc_function_high
= SYMBOL_VALUE_ADDRESS (msymbol
+ i
);
828 /* We got the start address from the last msymbol in the objfile.
829 So the end address is the end of the section. */
830 cache_pc_function_high
= osect
->endaddr
;
836 if (pc_in_unmapped_range (pc
, section
))
837 *address
= overlay_unmapped_address (cache_pc_function_low
, section
);
839 *address
= cache_pc_function_low
;
843 *name
= cache_pc_function_name
;
847 if (pc_in_unmapped_range (pc
, section
))
849 /* Because the high address is actually beyond the end of
850 the function (and therefore possibly beyond the end of
851 the overlay), we must actually convert (high - 1)
852 and then add one to that. */
854 *endaddr
= 1 + overlay_unmapped_address (cache_pc_function_high
- 1,
858 *endaddr
= cache_pc_function_high
;
864 /* Backward compatibility, no section argument */
867 find_pc_partial_function (pc
, name
, address
, endaddr
)
875 section
= find_pc_overlay (pc
);
876 return find_pc_sect_partial_function (pc
, section
, name
, address
, endaddr
);
879 /* Return the innermost stack frame executing inside of BLOCK,
880 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
883 block_innermost_frame (block
)
886 struct frame_info
*frame
;
887 register CORE_ADDR start
;
888 register CORE_ADDR end
;
893 start
= BLOCK_START (block
);
894 end
= BLOCK_END (block
);
899 frame
= get_prev_frame (frame
);
902 if (frame
->pc
>= start
&& frame
->pc
< end
)
907 /* Return the full FRAME which corresponds to the given CORE_ADDR
908 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
911 find_frame_addr_in_frame_chain (frame_addr
)
912 CORE_ADDR frame_addr
;
914 struct frame_info
*frame
= NULL
;
916 if (frame_addr
== (CORE_ADDR
)0)
921 frame
= get_prev_frame (frame
);
924 if (FRAME_FP (frame
) == frame_addr
)
929 #ifdef SIGCONTEXT_PC_OFFSET
930 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
933 sigtramp_saved_pc (frame
)
934 struct frame_info
*frame
;
936 CORE_ADDR sigcontext_addr
;
937 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
938 int ptrbytes
= TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
939 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
941 /* Get sigcontext address, it is the third parameter on the stack. */
943 sigcontext_addr
= read_memory_integer (FRAME_ARGS_ADDRESS (frame
->next
)
948 sigcontext_addr
= read_memory_integer (read_register (SP_REGNUM
)
952 /* Don't cause a memory_error when accessing sigcontext in case the stack
953 layout has changed or the stack is corrupt. */
954 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
955 return extract_unsigned_integer (buf
, ptrbytes
);
957 #endif /* SIGCONTEXT_PC_OFFSET */
959 #ifdef USE_GENERIC_DUMMY_FRAMES
962 * GENERIC DUMMY FRAMES
964 * The following code serves to maintain the dummy stack frames for
965 * inferior function calls (ie. when gdb calls into the inferior via
966 * call_function_by_hand). This code saves the machine state before
967 * the call in host memory, so we must maintain an independant stack
968 * and keep it consistant etc. I am attempting to make this code
969 * generic enough to be used by many targets.
971 * The cheapest and most generic way to do CALL_DUMMY on a new target
972 * is probably to define CALL_DUMMY to be empty, CALL_DUMMY_LENGTH to zero,
973 * and CALL_DUMMY_LOCATION to AT_ENTRY. Then you must remember to define
974 * PUSH_RETURN_ADDRESS, because no call instruction will be being
975 * executed by the target.
978 static struct dummy_frame
*dummy_frame_stack
= NULL
;
980 /* Function: find_dummy_frame(pc, fp, sp)
981 Search the stack of dummy frames for one matching the given PC, FP and SP.
982 This is the work-horse for pc_in_call_dummy and read_register_dummy */
985 generic_find_dummy_frame (pc
, fp
)
989 struct dummy_frame
* dummyframe
;
991 if (pc
!= entry_point_address ())
994 for (dummyframe
= dummy_frame_stack
; dummyframe
!= NULL
;
995 dummyframe
= dummyframe
->next
)
996 if (fp
== dummyframe
->fp
|| fp
== dummyframe
->sp
)
997 /* The frame in question lies between the saved fp and sp, inclusive */
998 return dummyframe
->regs
;
1003 /* Function: pc_in_call_dummy (pc, fp)
1004 Return true if this is a dummy frame created by gdb for an inferior call */
1007 generic_pc_in_call_dummy (pc
, fp
)
1011 /* if find_dummy_frame succeeds, then PC is in a call dummy */
1012 return (generic_find_dummy_frame (pc
, fp
) != 0);
1015 /* Function: read_register_dummy
1016 Find a saved register from before GDB calls a function in the inferior */
1019 generic_read_register_dummy (pc
, fp
, regno
)
1024 char *dummy_regs
= generic_find_dummy_frame (pc
, fp
);
1027 return extract_address (&dummy_regs
[REGISTER_BYTE (regno
)],
1028 REGISTER_RAW_SIZE(regno
));
1033 /* Save all the registers on the dummy frame stack. Most ports save the
1034 registers on the target stack. This results in lots of unnecessary memory
1035 references, which are slow when debugging via a serial line. Instead, we
1036 save all the registers internally, and never write them to the stack. The
1037 registers get restored when the called function returns to the entry point,
1038 where a breakpoint is laying in wait. */
1041 generic_push_dummy_frame ()
1043 struct dummy_frame
*dummy_frame
;
1044 CORE_ADDR fp
= (get_current_frame ())->frame
;
1046 /* check to see if there are stale dummy frames,
1047 perhaps left over from when a longjump took us out of a
1048 function that was called by the debugger */
1050 dummy_frame
= dummy_frame_stack
;
1052 if (dummy_frame
->fp INNER_THAN fp
) /* stale -- destroy! */
1054 dummy_frame_stack
= dummy_frame
->next
;
1056 dummy_frame
= dummy_frame_stack
;
1059 dummy_frame
= dummy_frame
->next
;
1061 dummy_frame
= xmalloc (sizeof (struct dummy_frame
));
1062 dummy_frame
->pc
= read_register (PC_REGNUM
);
1063 dummy_frame
->sp
= read_register (SP_REGNUM
);
1064 dummy_frame
->fp
= fp
;
1065 read_register_bytes (0, dummy_frame
->regs
, REGISTER_BYTES
);
1066 dummy_frame
->next
= dummy_frame_stack
;
1067 dummy_frame_stack
= dummy_frame
;
1070 /* Function: pop_frame
1071 Restore the machine state from either the saved dummy stack or a
1072 real stack frame. */
1075 generic_pop_current_frame (pop
)
1076 void (*pop
) PARAMS ((struct frame_info
*frame
));
1078 struct frame_info
*frame
= get_current_frame ();
1079 if (PC_IN_CALL_DUMMY(frame
->pc
, frame
->frame
, frame
->frame
))
1080 generic_pop_dummy_frame ();
1085 /* Function: pop_dummy_frame
1086 Restore the machine state from a saved dummy stack frame. */
1089 generic_pop_dummy_frame ()
1091 struct dummy_frame
*dummy_frame
= dummy_frame_stack
;
1093 /* FIXME: what if the first frame isn't the right one, eg..
1094 because one call-by-hand function has done a longjmp into another one? */
1097 error ("Can't pop dummy frame!");
1098 dummy_frame_stack
= dummy_frame
->next
;
1099 write_register_bytes (0, dummy_frame
->regs
, REGISTER_BYTES
);
1100 flush_cached_frames ();
1104 /* Function: frame_chain_valid
1105 Returns true for a user frame or a call_function_by_hand dummy frame,
1106 and false for the CRT0 start-up frame. Purpose is to terminate backtrace */
1109 generic_frame_chain_valid (fp
, fi
)
1111 struct frame_info
*fi
;
1113 if (PC_IN_CALL_DUMMY(FRAME_SAVED_PC(fi
), fp
, fp
))
1114 return 1; /* don't prune CALL_DUMMY frames */
1115 else /* fall back to default algorithm (see frame.h) */
1117 && (fi
->frame INNER_THAN fp
|| fi
->frame
== fp
)
1118 && !inside_entry_file (FRAME_SAVED_PC(fi
)));
1121 /* Function: get_saved_register
1122 Find register number REGNUM relative to FRAME and put its (raw,
1123 target format) contents in *RAW_BUFFER.
1125 Set *OPTIMIZED if the variable was optimized out (and thus can't be
1126 fetched). Note that this is never set to anything other than zero
1127 in this implementation.
1129 Set *LVAL to lval_memory, lval_register, or not_lval, depending on
1130 whether the value was fetched from memory, from a register, or in a
1131 strange and non-modifiable way (e.g. a frame pointer which was
1132 calculated rather than fetched). We will use not_lval for values
1133 fetched from generic dummy frames.
1135 Set *ADDRP to the address, either in memory on as a REGISTER_BYTE
1136 offset into the registers array. If the value is stored in a dummy
1137 frame, set *ADDRP to zero.
1139 To use this implementation, define a function called
1140 "get_saved_register" in your target code, which simply passes all
1141 of its arguments to this function.
1143 The argument RAW_BUFFER must point to aligned memory. */
1146 generic_get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
1150 struct frame_info
*frame
;
1152 enum lval_type
*lval
;
1154 struct frame_saved_regs fsr
;
1156 if (!target_has_registers
)
1157 error ("No registers.");
1159 /* Normal systems don't optimize out things with register numbers. */
1160 if (optimized
!= NULL
)
1163 if (addrp
) /* default assumption: not found in memory */
1166 /* Note: since the current frame's registers could only have been
1167 saved by frames INTERIOR TO the current frame, we skip examining
1168 the current frame itself: otherwise, we would be getting the
1169 previous frame's registers which were saved by the current frame. */
1171 while (frame
&& ((frame
= frame
->next
) != NULL
))
1173 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
1175 if (lval
) /* found it in a CALL_DUMMY frame */
1179 generic_find_dummy_frame (frame
->pc
, frame
->frame
) +
1180 REGISTER_BYTE (regnum
),
1181 REGISTER_RAW_SIZE (regnum
));
1185 FRAME_FIND_SAVED_REGS(frame
, fsr
);
1186 if (fsr
.regs
[regnum
] != 0)
1188 if (lval
) /* found it saved on the stack */
1189 *lval
= lval_memory
;
1190 if (regnum
== SP_REGNUM
)
1192 if (raw_buffer
) /* SP register treated specially */
1193 store_address (raw_buffer
, REGISTER_RAW_SIZE (regnum
),
1198 if (addrp
) /* any other register */
1199 *addrp
= fsr
.regs
[regnum
];
1201 read_memory (fsr
.regs
[regnum
], raw_buffer
,
1202 REGISTER_RAW_SIZE (regnum
));
1208 /* If we get thru the loop to this point, it means the register was
1209 not saved in any frame. Return the actual live-register value. */
1211 if (lval
) /* found it in a live register */
1212 *lval
= lval_register
;
1214 *addrp
= REGISTER_BYTE (regnum
);
1216 read_register_gen (regnum
, raw_buffer
);
1218 #endif /* USE_GENERIC_DUMMY_FRAMES */
1221 _initialize_blockframe ()
1223 obstack_init (&frame_cache_obstack
);