1 /* Get info from stack frames;
2 convert between frames, blocks, functions and pc values.
3 Copyright 1986, 1987, 1988, 1989, 1991 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
28 #include "value.h" /* for read_register */
29 #include "target.h" /* for target_has_stack */
30 #include "inferior.h" /* for read_pc */
32 /* Is ADDR inside the startup file? Note that if your machine
33 has a way to detect the bottom of the stack, there is no need
34 to call this function from FRAME_CHAIN_VALID; the reason for
35 doing so is that some machines have no way of detecting bottom
38 A PC of zero is always considered to be the bottom of the stack. */
41 inside_entry_file (addr
)
46 if (symfile_objfile
== 0)
48 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
49 /* Do not stop backtracing if the pc is in the call dummy
50 at the entry point. */
51 if (PC_IN_CALL_DUMMY (addr
, 0, 0))
54 return (addr
>= symfile_objfile
-> ei
.entry_file_lowpc
&&
55 addr
< symfile_objfile
-> ei
.entry_file_highpc
);
58 /* Test a specified PC value to see if it is in the range of addresses
59 that correspond to the main() function. See comments above for why
60 we might want to do this.
62 Typically called from FRAME_CHAIN_VALID.
64 A PC of zero is always considered to be the bottom of the stack. */
72 if (symfile_objfile
== 0)
74 return (symfile_objfile
-> ei
.main_func_lowpc
<= pc
&&
75 symfile_objfile
-> ei
.main_func_highpc
> pc
);
78 /* Test a specified PC value to see if it is in the range of addresses
79 that correspond to the process entry point function. See comments
80 in objfiles.h for why we might want to do this.
82 Typically called from FRAME_CHAIN_VALID.
84 A PC of zero is always considered to be the bottom of the stack. */
87 inside_entry_func (pc
)
92 if (symfile_objfile
== 0)
94 #if CALL_DUMMY_LOCATION == AT_ENTRY_POINT
95 /* Do not stop backtracing if the pc is in the call dummy
96 at the entry point. */
97 if (PC_IN_CALL_DUMMY (pc
, 0, 0))
100 return (symfile_objfile
-> ei
.entry_func_lowpc
<= pc
&&
101 symfile_objfile
-> ei
.entry_func_highpc
> pc
);
104 /* Address of innermost stack frame (contents of FP register) */
106 static FRAME current_frame
;
109 * Cache for frame addresses already read by gdb. Valid only while
110 * inferior is stopped. Control variables for the frame cache should
111 * be local to this module.
113 struct obstack frame_cache_obstack
;
115 /* Return the innermost (currently executing) stack frame. */
120 /* We assume its address is kept in a general register;
121 param.h says which register. */
123 return current_frame
;
127 set_current_frame (frame
)
130 current_frame
= frame
;
134 create_new_frame (addr
, pc
)
138 struct frame_info
*fci
; /* Same type as FRAME */
141 fci
= (struct frame_info
*)
142 obstack_alloc (&frame_cache_obstack
,
143 sizeof (struct frame_info
));
145 /* Arbitrary frame */
146 fci
->next
= (struct frame_info
*) 0;
147 fci
->prev
= (struct frame_info
*) 0;
150 find_pc_partial_function (pc
, &name
, (CORE_ADDR
*)NULL
,(CORE_ADDR
*)NULL
);
151 fci
->signal_handler_caller
= IN_SIGTRAMP (fci
->pc
, name
);
153 #ifdef INIT_EXTRA_FRAME_INFO
154 INIT_EXTRA_FRAME_INFO (0, fci
);
160 /* Return the frame that called FRAME.
161 If FRAME is the original frame (it has no caller), return 0. */
164 get_prev_frame (frame
)
167 /* We're allowed to know that FRAME and "struct frame_info *" are
169 return get_prev_frame_info (frame
);
172 /* Return the frame that FRAME calls (0 if FRAME is the innermost
176 get_next_frame (frame
)
179 /* We're allowed to know that FRAME and "struct frame_info *" are
185 * Flush the entire frame cache.
188 flush_cached_frames ()
190 /* Since we can't really be sure what the first object allocated was */
191 obstack_free (&frame_cache_obstack
, 0);
192 obstack_init (&frame_cache_obstack
);
194 current_frame
= (struct frame_info
*) 0; /* Invalidate cache */
197 /* Flush the frame cache, and start a new one if necessary. */
199 reinit_frame_cache ()
201 flush_cached_frames ();
202 if (target_has_stack
)
204 set_current_frame (create_new_frame (read_fp (), read_pc ()));
205 select_frame (get_current_frame (), 0);
209 set_current_frame (0);
210 select_frame ((FRAME
) 0, -1);
214 /* Return a structure containing various interesting information
215 about a specified stack frame. */
216 /* How do I justify including this function? Well, the FRAME
217 identifier format has gone through several changes recently, and
218 it's not completely inconceivable that it could happen again. If
219 it does, have this routine around will help */
222 get_frame_info (frame
)
228 /* If a machine allows frameless functions, it should define a macro
229 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
230 frame_info for the frame, and FRAMELESS should be set to nonzero
231 if it represents a frameless function invocation. */
233 /* Return nonzero if the function for this frame lacks a prologue. Many
234 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
238 frameless_look_for_prologue (frame
)
241 CORE_ADDR func_start
, after_prologue
;
242 func_start
= (get_pc_function_start (frame
->pc
) +
243 FUNCTION_START_OFFSET
);
246 after_prologue
= func_start
;
247 #ifdef SKIP_PROLOGUE_FRAMELESS_P
248 /* This is faster, since only care whether there *is* a prologue,
249 not how long it is. */
250 SKIP_PROLOGUE_FRAMELESS_P (after_prologue
);
252 SKIP_PROLOGUE (after_prologue
);
254 return after_prologue
== func_start
;
257 /* If we can't find the start of the function, we don't really
258 know whether the function is frameless, but we should be able
259 to get a reasonable (i.e. best we can do under the
260 circumstances) backtrace by saying that it isn't. */
264 /* Default a few macros that people seldom redefine. */
266 #if !defined (INIT_FRAME_PC)
267 #define INIT_FRAME_PC(fromleaf, prev) \
268 prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
269 prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
272 #ifndef FRAME_CHAIN_COMBINE
273 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
276 /* Return a structure containing various interesting information
277 about the frame that called NEXT_FRAME. Returns NULL
278 if there is no such frame. */
281 get_prev_frame_info (next_frame
)
284 FRAME_ADDR address
= 0;
285 struct frame_info
*prev
;
289 /* If the requested entry is in the cache, return it.
290 Otherwise, figure out what the address should be for the entry
291 we're about to add to the cache. */
296 /* This screws value_of_variable, which just wants a nice clean
297 NULL return from block_innermost_frame if there are no frames.
298 I don't think I've ever seen this message happen otherwise.
299 And returning NULL here is a perfectly legitimate thing to do. */
302 error ("You haven't set up a process's stack to examine.");
306 return current_frame
;
309 /* If we have the prev one, return it */
310 if (next_frame
->prev
)
311 return next_frame
->prev
;
313 /* On some machines it is possible to call a function without
314 setting up a stack frame for it. On these machines, we
315 define this macro to take two args; a frameinfo pointer
316 identifying a frame and a variable to set or clear if it is
317 or isn't leafless. */
318 #ifdef FRAMELESS_FUNCTION_INVOCATION
319 /* Still don't want to worry about this except on the innermost
320 frame. This macro will set FROMLEAF if NEXT_FRAME is a
321 frameless function invocation. */
322 if (!(next_frame
->next
))
324 FRAMELESS_FUNCTION_INVOCATION (next_frame
, fromleaf
);
326 address
= next_frame
->frame
;
332 /* Two macros defined in tm.h specify the machine-dependent
333 actions to be performed here.
334 First, get the frame's chain-pointer.
335 If that is zero, the frame is the outermost frame or a leaf
336 called by the outermost frame. This means that if start
337 calls main without a frame, we'll return 0 (which is fine
340 Nope; there's a problem. This also returns when the current
341 routine is a leaf of main. This is unacceptable. We move
342 this to after the ffi test; I'd rather have backtraces from
343 start go curfluy than have an abort called from main not show
345 address
= FRAME_CHAIN (next_frame
);
346 if (!FRAME_CHAIN_VALID (address
, next_frame
))
348 address
= FRAME_CHAIN_COMBINE (address
, next_frame
);
353 prev
= (struct frame_info
*)
354 obstack_alloc (&frame_cache_obstack
,
355 sizeof (struct frame_info
));
358 next_frame
->prev
= prev
;
359 prev
->next
= next_frame
;
360 prev
->prev
= (struct frame_info
*) 0;
361 prev
->frame
= address
;
362 prev
->signal_handler_caller
= 0;
364 /* This change should not be needed, FIXME! We should
365 determine whether any targets *need* INIT_FRAME_PC to happen
366 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
367 express what goes on here.
369 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
370 (where the PC is already set up) and here (where it isn't).
371 INIT_FRAME_PC is only called from here, always after
372 INIT_EXTRA_FRAME_INFO.
374 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
375 value (which hasn't been set yet). Some other machines appear to
376 require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
378 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
379 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
381 To answer the question, yes the sparc needs INIT_FRAME_PC after
382 INIT_EXTRA_FRAME_INFO. Suggested scheme:
384 SETUP_INNERMOST_FRAME()
385 Default version is just create_new_frame (read_fp ()),
386 read_pc ()). Machines with extra frame info would do that (or the
387 local equivalent) and then set the extra fields.
388 SETUP_ARBITRARY_FRAME(argc, argv)
389 Only change here is that create_new_frame would no longer init extra
390 frame info; SETUP_ARBITRARY_FRAME would have to do that.
391 INIT_PREV_FRAME(fromleaf, prev)
392 Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
393 also return a flag saying whether to keep the new frame, or
394 whether to discard it, because on some machines (e.g. mips) it
395 is really awkward to have FRAME_CHAIN_VALID called *before*
396 INIT_EXTRA_FRAME_INFO (there is no good way to get information
397 deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
398 std_frame_pc(fromleaf, prev)
399 This is the default setting for INIT_PREV_FRAME. It just does what
400 the default INIT_FRAME_PC does. Some machines will call it from
401 INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
402 Some machines won't use it.
403 kingdon@cygnus.com, 13Apr93, 31Jan94. */
405 #ifdef INIT_FRAME_PC_FIRST
406 INIT_FRAME_PC_FIRST (fromleaf
, prev
);
409 #ifdef INIT_EXTRA_FRAME_INFO
410 INIT_EXTRA_FRAME_INFO(fromleaf
, prev
);
413 /* This entry is in the frame queue now, which is good since
414 FRAME_SAVED_PC may use that queue to figure out its value
415 (see tm-sparc.h). We want the pc saved in the inferior frame. */
416 INIT_FRAME_PC(fromleaf
, prev
);
418 /* If ->frame and ->pc are unchanged, we are in the process of getting
419 ourselves into an infinite backtrace. Some architectures check this
420 in FRAME_CHAIN or thereabouts, but it seems like there is no reason
421 this can't be an architecture-independent check. */
422 if (next_frame
!= NULL
)
424 if (prev
->frame
== next_frame
->frame
425 && prev
->pc
== next_frame
->pc
)
427 next_frame
->prev
= NULL
;
428 obstack_free (&frame_cache_obstack
, prev
);
433 find_pc_partial_function (prev
->pc
, &name
,
434 (CORE_ADDR
*)NULL
,(CORE_ADDR
*)NULL
);
435 if (IN_SIGTRAMP (prev
->pc
, name
))
436 prev
->signal_handler_caller
= 1;
445 struct frame_info
*fi
;
446 fi
= get_frame_info (frame
);
450 #if defined (FRAME_FIND_SAVED_REGS)
451 /* Find the addresses in which registers are saved in FRAME. */
454 get_frame_saved_regs (frame_info_addr
, saved_regs_addr
)
455 struct frame_info
*frame_info_addr
;
456 struct frame_saved_regs
*saved_regs_addr
;
458 FRAME_FIND_SAVED_REGS (frame_info_addr
, *saved_regs_addr
);
462 /* Return the innermost lexical block in execution
463 in a specified stack frame. The frame address is assumed valid. */
466 get_frame_block (frame
)
469 struct frame_info
*fi
;
472 fi
= get_frame_info (frame
);
475 if (fi
->next
!= 0 && fi
->next
->signal_handler_caller
== 0)
476 /* We are not in the innermost frame and we were not interrupted
477 by a signal. We need to subtract one to get the correct block,
478 in case the call instruction was the last instruction of the block.
479 If there are any machines on which the saved pc does not point to
480 after the call insn, we probably want to make fi->pc point after
481 the call insn anyway. */
483 return block_for_pc (pc
);
489 return block_for_pc (read_pc ());
493 get_pc_function_start (pc
)
496 register struct block
*bl
;
497 register struct symbol
*symbol
;
498 register struct minimal_symbol
*msymbol
;
501 if ((bl
= block_for_pc (pc
)) != NULL
&&
502 (symbol
= block_function (bl
)) != NULL
)
504 bl
= SYMBOL_BLOCK_VALUE (symbol
);
505 fstart
= BLOCK_START (bl
);
507 else if ((msymbol
= lookup_minimal_symbol_by_pc (pc
)) != NULL
)
509 fstart
= SYMBOL_VALUE_ADDRESS (msymbol
);
518 /* Return the symbol for the function executing in frame FRAME. */
521 get_frame_function (frame
)
524 register struct block
*bl
= get_frame_block (frame
);
527 return block_function (bl
);
530 /* Return the blockvector immediately containing the innermost lexical block
531 containing the specified pc value, or 0 if there is none.
532 PINDEX is a pointer to the index value of the block. If PINDEX
533 is NULL, we don't pass this information back to the caller. */
536 blockvector_for_pc (pc
, pindex
)
537 register CORE_ADDR pc
;
540 register struct block
*b
;
541 register int bot
, top
, half
;
542 register struct symtab
*s
;
543 struct blockvector
*bl
;
545 /* First search all symtabs for one whose file contains our pc */
546 s
= find_pc_symtab (pc
);
550 bl
= BLOCKVECTOR (s
);
551 b
= BLOCKVECTOR_BLOCK (bl
, 0);
553 /* Then search that symtab for the smallest block that wins. */
554 /* Use binary search to find the last block that starts before PC. */
557 top
= BLOCKVECTOR_NBLOCKS (bl
);
559 while (top
- bot
> 1)
561 half
= (top
- bot
+ 1) >> 1;
562 b
= BLOCKVECTOR_BLOCK (bl
, bot
+ half
);
563 if (BLOCK_START (b
) <= pc
)
569 /* Now search backward for a block that ends after PC. */
573 b
= BLOCKVECTOR_BLOCK (bl
, bot
);
574 if (BLOCK_END (b
) > pc
)
586 /* Return the innermost lexical block containing the specified pc value,
587 or 0 if there is none. */
591 register CORE_ADDR pc
;
593 register struct blockvector
*bl
;
596 bl
= blockvector_for_pc (pc
, &index
);
598 return BLOCKVECTOR_BLOCK (bl
, index
);
602 /* Return the function containing pc value PC.
603 Returns 0 if function is not known. */
606 find_pc_function (pc
)
609 register struct block
*b
= block_for_pc (pc
);
612 return block_function (b
);
615 /* These variables are used to cache the most recent result
616 * of find_pc_partial_function. */
618 static CORE_ADDR cache_pc_function_low
= 0;
619 static CORE_ADDR cache_pc_function_high
= 0;
620 static char *cache_pc_function_name
= 0;
622 /* Clear cache, e.g. when symbol table is discarded. */
625 clear_pc_function_cache()
627 cache_pc_function_low
= 0;
628 cache_pc_function_high
= 0;
629 cache_pc_function_name
= (char *)0;
632 /* Finds the "function" (text symbol) that is smaller than PC but
633 greatest of all of the potential text symbols. Sets *NAME and/or
634 *ADDRESS conditionally if that pointer is non-null. If ENDADDR is
635 non-null, then set *ENDADDR to be the end of the function
636 (exclusive), but passing ENDADDR as non-null means that the
637 function might cause symbols to be read. This function either
638 succeeds or fails (not halfway succeeds). If it succeeds, it sets
639 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
640 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero
644 find_pc_partial_function (pc
, name
, address
, endaddr
)
650 struct partial_symtab
*pst
;
652 struct minimal_symbol
*msymbol
;
653 struct partial_symbol
*psb
;
654 struct obj_section
*sec
;
656 if (pc
>= cache_pc_function_low
&& pc
< cache_pc_function_high
)
657 goto return_cached_value
;
659 /* If sigtramp is in the u area, it counts as a function (especially
660 important for step_1). */
661 #if defined SIGTRAMP_START
662 if (IN_SIGTRAMP (pc
, (char *)NULL
))
664 cache_pc_function_low
= SIGTRAMP_START
;
665 cache_pc_function_high
= SIGTRAMP_END
;
666 cache_pc_function_name
= "<sigtramp>";
668 goto return_cached_value
;
672 msymbol
= lookup_minimal_symbol_by_pc (pc
);
673 pst
= find_pc_psymtab (pc
);
676 /* Need to read the symbols to get a good value for the end address. */
677 if (endaddr
!= NULL
&& !pst
->readin
)
679 /* Need to get the terminal in case symbol-reading produces
681 target_terminal_ours_for_output ();
682 PSYMTAB_TO_SYMTAB (pst
);
687 /* Checking whether the msymbol has a larger value is for the
688 "pathological" case mentioned in print_frame_info. */
689 f
= find_pc_function (pc
);
692 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f
))
693 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
695 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
696 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
697 cache_pc_function_name
= SYMBOL_NAME (f
);
698 goto return_cached_value
;
703 /* Now that static symbols go in the minimal symbol table, perhaps
704 we could just ignore the partial symbols. But at least for now
705 we use the partial or minimal symbol, whichever is larger. */
706 psb
= find_pc_psymbol (pst
, pc
);
709 && (msymbol
== NULL
||
710 (SYMBOL_VALUE_ADDRESS (psb
)
711 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
713 /* This case isn't being cached currently. */
715 *address
= SYMBOL_VALUE_ADDRESS (psb
);
717 *name
= SYMBOL_NAME (psb
);
718 /* endaddr non-NULL can't happen here. */
724 /* Not in the normal symbol tables, see if the pc is in a known section.
725 If it's not, then give up. This ensures that anything beyond the end
726 of the text seg doesn't appear to be part of the last function in the
729 sec
= find_pc_section (pc
);
734 /* Must be in the minimal symbol table. */
737 /* No available symbol. */
747 /* See if we're in a transfer table for Sun shared libs. */
749 if (msymbol
-> type
== mst_text
|| msymbol
-> type
== mst_file_text
)
750 cache_pc_function_low
= SYMBOL_VALUE_ADDRESS (msymbol
);
752 /* It is a transfer table for Sun shared libraries. */
753 cache_pc_function_low
= pc
- FUNCTION_START_OFFSET
;
755 cache_pc_function_name
= SYMBOL_NAME (msymbol
);
757 /* Use the lesser of the next minimal symbol, or the end of the section, as
758 the end of the function. */
760 if (SYMBOL_NAME (msymbol
+ 1) != NULL
761 && SYMBOL_VALUE_ADDRESS (msymbol
+ 1) < sec
->endaddr
)
762 cache_pc_function_high
= SYMBOL_VALUE_ADDRESS (msymbol
+ 1);
764 /* We got the start address from the last msymbol in the objfile.
765 So the end address is the end of the section. */
766 cache_pc_function_high
= sec
->endaddr
;
770 *address
= cache_pc_function_low
;
772 *name
= cache_pc_function_name
;
774 *endaddr
= cache_pc_function_high
;
778 /* Return the innermost stack frame executing inside of BLOCK,
779 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
782 block_innermost_frame (block
)
785 struct frame_info
*fi
;
786 register FRAME frame
;
787 register CORE_ADDR start
;
788 register CORE_ADDR end
;
793 start
= BLOCK_START (block
);
794 end
= BLOCK_END (block
);
799 frame
= get_prev_frame (frame
);
802 fi
= get_frame_info (frame
);
803 if (fi
->pc
>= start
&& fi
->pc
< end
)
808 /* Return the full FRAME which corresponds to the given FRAME_ADDR
809 or NULL if no FRAME on the chain corresponds to FRAME_ADDR. */
812 find_frame_addr_in_frame_chain (frame_addr
)
813 FRAME_ADDR frame_addr
;
817 if (frame_addr
== NULL
)
822 frame
= get_prev_frame (frame
);
826 if (FRAME_FP (frame
) == frame_addr
)
831 #ifdef SIGCONTEXT_PC_OFFSET
832 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
835 sigtramp_saved_pc (frame
)
838 CORE_ADDR sigcontext_addr
;
839 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
840 int ptrbytes
= TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
841 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
843 /* Get sigcontext address, it is the third parameter on the stack. */
845 sigcontext_addr
= read_memory_integer (FRAME_ARGS_ADDRESS (frame
->next
)
846 + FRAME_ARGS_SKIP
+ sigcontext_offs
,
849 sigcontext_addr
= read_memory_integer (read_register (SP_REGNUM
)
853 /* Don't cause a memory_error when accessing sigcontext in case the stack
854 layout has changed or the stack is corrupt. */
855 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
856 return extract_unsigned_integer (buf
, ptrbytes
);
858 #endif /* SIGCONTEXT_PC_OFFSET */
861 _initialize_blockframe ()
863 obstack_init (&frame_cache_obstack
);