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 */
195 if (annotation_level
> 1)
197 target_terminal_ours ();
198 printf_unfiltered ("\n\032\032frames-invalid\n");
202 /* Flush the frame cache, and start a new one if necessary. */
204 reinit_frame_cache ()
206 flush_cached_frames ();
207 if (target_has_stack
)
209 set_current_frame (create_new_frame (read_fp (), read_pc ()));
210 select_frame (get_current_frame (), 0);
214 set_current_frame (0);
215 select_frame ((FRAME
) 0, -1);
219 /* Return a structure containing various interesting information
220 about a specified stack frame. */
221 /* How do I justify including this function? Well, the FRAME
222 identifier format has gone through several changes recently, and
223 it's not completely inconceivable that it could happen again. If
224 it does, have this routine around will help */
227 get_frame_info (frame
)
233 /* If a machine allows frameless functions, it should define a macro
234 FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) in param.h. FI is the struct
235 frame_info for the frame, and FRAMELESS should be set to nonzero
236 if it represents a frameless function invocation. */
238 /* Return nonzero if the function for this frame lacks a prologue. Many
239 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
243 frameless_look_for_prologue (frame
)
246 CORE_ADDR func_start
, after_prologue
;
247 func_start
= (get_pc_function_start (frame
->pc
) +
248 FUNCTION_START_OFFSET
);
251 after_prologue
= func_start
;
252 #ifdef SKIP_PROLOGUE_FRAMELESS_P
253 /* This is faster, since only care whether there *is* a prologue,
254 not how long it is. */
255 SKIP_PROLOGUE_FRAMELESS_P (after_prologue
);
257 SKIP_PROLOGUE (after_prologue
);
259 return after_prologue
== func_start
;
262 /* If we can't find the start of the function, we don't really
263 know whether the function is frameless, but we should be able
264 to get a reasonable (i.e. best we can do under the
265 circumstances) backtrace by saying that it isn't. */
269 /* Default a few macros that people seldom redefine. */
271 #if !defined (INIT_FRAME_PC)
272 #define INIT_FRAME_PC(fromleaf, prev) \
273 prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
274 prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
277 #ifndef FRAME_CHAIN_COMBINE
278 #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
281 /* Return a structure containing various interesting information
282 about the frame that called NEXT_FRAME. Returns NULL
283 if there is no such frame. */
286 get_prev_frame_info (next_frame
)
289 FRAME_ADDR address
= 0;
290 struct frame_info
*prev
;
294 /* If the requested entry is in the cache, return it.
295 Otherwise, figure out what the address should be for the entry
296 we're about to add to the cache. */
301 /* This screws value_of_variable, which just wants a nice clean
302 NULL return from block_innermost_frame if there are no frames.
303 I don't think I've ever seen this message happen otherwise.
304 And returning NULL here is a perfectly legitimate thing to do. */
307 error ("You haven't set up a process's stack to examine.");
311 return current_frame
;
314 /* If we have the prev one, return it */
315 if (next_frame
->prev
)
316 return next_frame
->prev
;
318 /* On some machines it is possible to call a function without
319 setting up a stack frame for it. On these machines, we
320 define this macro to take two args; a frameinfo pointer
321 identifying a frame and a variable to set or clear if it is
322 or isn't leafless. */
323 #ifdef FRAMELESS_FUNCTION_INVOCATION
324 /* Still don't want to worry about this except on the innermost
325 frame. This macro will set FROMLEAF if NEXT_FRAME is a
326 frameless function invocation. */
327 if (!(next_frame
->next
))
329 FRAMELESS_FUNCTION_INVOCATION (next_frame
, fromleaf
);
331 address
= next_frame
->frame
;
337 /* Two macros defined in tm.h specify the machine-dependent
338 actions to be performed here.
339 First, get the frame's chain-pointer.
340 If that is zero, the frame is the outermost frame or a leaf
341 called by the outermost frame. This means that if start
342 calls main without a frame, we'll return 0 (which is fine
345 Nope; there's a problem. This also returns when the current
346 routine is a leaf of main. This is unacceptable. We move
347 this to after the ffi test; I'd rather have backtraces from
348 start go curfluy than have an abort called from main not show
350 address
= FRAME_CHAIN (next_frame
);
351 if (!FRAME_CHAIN_VALID (address
, next_frame
))
353 address
= FRAME_CHAIN_COMBINE (address
, next_frame
);
358 prev
= (struct frame_info
*)
359 obstack_alloc (&frame_cache_obstack
,
360 sizeof (struct frame_info
));
363 next_frame
->prev
= prev
;
364 prev
->next
= next_frame
;
365 prev
->prev
= (struct frame_info
*) 0;
366 prev
->frame
= address
;
367 prev
->signal_handler_caller
= 0;
369 /* This change should not be needed, FIXME! We should
370 determine whether any targets *need* INIT_FRAME_PC to happen
371 after INIT_EXTRA_FRAME_INFO and come up with a simple way to
372 express what goes on here.
374 INIT_EXTRA_FRAME_INFO is called from two places: create_new_frame
375 (where the PC is already set up) and here (where it isn't).
376 INIT_FRAME_PC is only called from here, always after
377 INIT_EXTRA_FRAME_INFO.
379 The catch is the MIPS, where INIT_EXTRA_FRAME_INFO requires the PC
380 value (which hasn't been set yet). Some other machines appear to
381 require INIT_EXTRA_FRAME_INFO before they can do INIT_FRAME_PC. Phoo.
383 We shouldn't need INIT_FRAME_PC_FIRST to add more complication to
384 an already overcomplicated part of GDB. gnu@cygnus.com, 15Sep92.
386 To answer the question, yes the sparc needs INIT_FRAME_PC after
387 INIT_EXTRA_FRAME_INFO. Suggested scheme:
389 SETUP_INNERMOST_FRAME()
390 Default version is just create_new_frame (read_fp ()),
391 read_pc ()). Machines with extra frame info would do that (or the
392 local equivalent) and then set the extra fields.
393 SETUP_ARBITRARY_FRAME(argc, argv)
394 Only change here is that create_new_frame would no longer init extra
395 frame info; SETUP_ARBITRARY_FRAME would have to do that.
396 INIT_PREV_FRAME(fromleaf, prev)
397 Replace INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC. This should
398 also return a flag saying whether to keep the new frame, or
399 whether to discard it, because on some machines (e.g. mips) it
400 is really awkward to have FRAME_CHAIN_VALID called *before*
401 INIT_EXTRA_FRAME_INFO (there is no good way to get information
402 deduced in FRAME_CHAIN_VALID into the extra fields of the new frame).
403 std_frame_pc(fromleaf, prev)
404 This is the default setting for INIT_PREV_FRAME. It just does what
405 the default INIT_FRAME_PC does. Some machines will call it from
406 INIT_PREV_FRAME (either at the beginning, the end, or in the middle).
407 Some machines won't use it.
408 kingdon@cygnus.com, 13Apr93, 31Jan94. */
410 #ifdef INIT_FRAME_PC_FIRST
411 INIT_FRAME_PC_FIRST (fromleaf
, prev
);
414 #ifdef INIT_EXTRA_FRAME_INFO
415 INIT_EXTRA_FRAME_INFO(fromleaf
, prev
);
418 /* This entry is in the frame queue now, which is good since
419 FRAME_SAVED_PC may use that queue to figure out its value
420 (see tm-sparc.h). We want the pc saved in the inferior frame. */
421 INIT_FRAME_PC(fromleaf
, prev
);
423 /* If ->frame and ->pc are unchanged, we are in the process of getting
424 ourselves into an infinite backtrace. Some architectures check this
425 in FRAME_CHAIN or thereabouts, but it seems like there is no reason
426 this can't be an architecture-independent check. */
427 if (next_frame
!= NULL
)
429 if (prev
->frame
== next_frame
->frame
430 && prev
->pc
== next_frame
->pc
)
432 next_frame
->prev
= NULL
;
433 obstack_free (&frame_cache_obstack
, prev
);
438 find_pc_partial_function (prev
->pc
, &name
,
439 (CORE_ADDR
*)NULL
,(CORE_ADDR
*)NULL
);
440 if (IN_SIGTRAMP (prev
->pc
, name
))
441 prev
->signal_handler_caller
= 1;
450 struct frame_info
*fi
;
451 fi
= get_frame_info (frame
);
455 #if defined (FRAME_FIND_SAVED_REGS)
456 /* Find the addresses in which registers are saved in FRAME. */
459 get_frame_saved_regs (frame_info_addr
, saved_regs_addr
)
460 struct frame_info
*frame_info_addr
;
461 struct frame_saved_regs
*saved_regs_addr
;
463 FRAME_FIND_SAVED_REGS (frame_info_addr
, *saved_regs_addr
);
467 /* Return the innermost lexical block in execution
468 in a specified stack frame. The frame address is assumed valid. */
471 get_frame_block (frame
)
474 struct frame_info
*fi
;
477 fi
= get_frame_info (frame
);
480 if (fi
->next
!= 0 && fi
->next
->signal_handler_caller
== 0)
481 /* We are not in the innermost frame and we were not interrupted
482 by a signal. We need to subtract one to get the correct block,
483 in case the call instruction was the last instruction of the block.
484 If there are any machines on which the saved pc does not point to
485 after the call insn, we probably want to make fi->pc point after
486 the call insn anyway. */
488 return block_for_pc (pc
);
494 return block_for_pc (read_pc ());
498 get_pc_function_start (pc
)
501 register struct block
*bl
;
502 register struct symbol
*symbol
;
503 register struct minimal_symbol
*msymbol
;
506 if ((bl
= block_for_pc (pc
)) != NULL
&&
507 (symbol
= block_function (bl
)) != NULL
)
509 bl
= SYMBOL_BLOCK_VALUE (symbol
);
510 fstart
= BLOCK_START (bl
);
512 else if ((msymbol
= lookup_minimal_symbol_by_pc (pc
)) != NULL
)
514 fstart
= SYMBOL_VALUE_ADDRESS (msymbol
);
523 /* Return the symbol for the function executing in frame FRAME. */
526 get_frame_function (frame
)
529 register struct block
*bl
= get_frame_block (frame
);
532 return block_function (bl
);
535 /* Return the blockvector immediately containing the innermost lexical block
536 containing the specified pc value, or 0 if there is none.
537 PINDEX is a pointer to the index value of the block. If PINDEX
538 is NULL, we don't pass this information back to the caller. */
541 blockvector_for_pc (pc
, pindex
)
542 register CORE_ADDR pc
;
545 register struct block
*b
;
546 register int bot
, top
, half
;
547 register struct symtab
*s
;
548 struct blockvector
*bl
;
550 /* First search all symtabs for one whose file contains our pc */
551 s
= find_pc_symtab (pc
);
555 bl
= BLOCKVECTOR (s
);
556 b
= BLOCKVECTOR_BLOCK (bl
, 0);
558 /* Then search that symtab for the smallest block that wins. */
559 /* Use binary search to find the last block that starts before PC. */
562 top
= BLOCKVECTOR_NBLOCKS (bl
);
564 while (top
- bot
> 1)
566 half
= (top
- bot
+ 1) >> 1;
567 b
= BLOCKVECTOR_BLOCK (bl
, bot
+ half
);
568 if (BLOCK_START (b
) <= pc
)
574 /* Now search backward for a block that ends after PC. */
578 b
= BLOCKVECTOR_BLOCK (bl
, bot
);
579 if (BLOCK_END (b
) > pc
)
591 /* Return the innermost lexical block containing the specified pc value,
592 or 0 if there is none. */
596 register CORE_ADDR pc
;
598 register struct blockvector
*bl
;
601 bl
= blockvector_for_pc (pc
, &index
);
603 return BLOCKVECTOR_BLOCK (bl
, index
);
607 /* Return the function containing pc value PC.
608 Returns 0 if function is not known. */
611 find_pc_function (pc
)
614 register struct block
*b
= block_for_pc (pc
);
617 return block_function (b
);
620 /* These variables are used to cache the most recent result
621 * of find_pc_partial_function. */
623 static CORE_ADDR cache_pc_function_low
= 0;
624 static CORE_ADDR cache_pc_function_high
= 0;
625 static char *cache_pc_function_name
= 0;
627 /* Clear cache, e.g. when symbol table is discarded. */
630 clear_pc_function_cache()
632 cache_pc_function_low
= 0;
633 cache_pc_function_high
= 0;
634 cache_pc_function_name
= (char *)0;
637 /* Finds the "function" (text symbol) that is smaller than PC but
638 greatest of all of the potential text symbols. Sets *NAME and/or
639 *ADDRESS conditionally if that pointer is non-null. If ENDADDR is
640 non-null, then set *ENDADDR to be the end of the function
641 (exclusive), but passing ENDADDR as non-null means that the
642 function might cause symbols to be read. This function either
643 succeeds or fails (not halfway succeeds). If it succeeds, it sets
644 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
645 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero
649 find_pc_partial_function (pc
, name
, address
, endaddr
)
655 struct partial_symtab
*pst
;
657 struct minimal_symbol
*msymbol
;
658 struct partial_symbol
*psb
;
659 struct obj_section
*sec
;
661 if (pc
>= cache_pc_function_low
&& pc
< cache_pc_function_high
)
662 goto return_cached_value
;
664 /* If sigtramp is in the u area, it counts as a function (especially
665 important for step_1). */
666 #if defined SIGTRAMP_START
667 if (IN_SIGTRAMP (pc
, (char *)NULL
))
669 cache_pc_function_low
= SIGTRAMP_START
;
670 cache_pc_function_high
= SIGTRAMP_END
;
671 cache_pc_function_name
= "<sigtramp>";
673 goto return_cached_value
;
677 msymbol
= lookup_minimal_symbol_by_pc (pc
);
678 pst
= find_pc_psymtab (pc
);
681 /* Need to read the symbols to get a good value for the end address. */
682 if (endaddr
!= NULL
&& !pst
->readin
)
684 /* Need to get the terminal in case symbol-reading produces
686 target_terminal_ours_for_output ();
687 PSYMTAB_TO_SYMTAB (pst
);
692 /* Checking whether the msymbol has a larger value is for the
693 "pathological" case mentioned in print_frame_info. */
694 f
= find_pc_function (pc
);
697 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f
))
698 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
700 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
701 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
702 cache_pc_function_name
= SYMBOL_NAME (f
);
703 goto return_cached_value
;
708 /* Now that static symbols go in the minimal symbol table, perhaps
709 we could just ignore the partial symbols. But at least for now
710 we use the partial or minimal symbol, whichever is larger. */
711 psb
= find_pc_psymbol (pst
, pc
);
714 && (msymbol
== NULL
||
715 (SYMBOL_VALUE_ADDRESS (psb
)
716 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
718 /* This case isn't being cached currently. */
720 *address
= SYMBOL_VALUE_ADDRESS (psb
);
722 *name
= SYMBOL_NAME (psb
);
723 /* endaddr non-NULL can't happen here. */
729 /* Not in the normal symbol tables, see if the pc is in a known section.
730 If it's not, then give up. This ensures that anything beyond the end
731 of the text seg doesn't appear to be part of the last function in the
734 sec
= find_pc_section (pc
);
739 /* Must be in the minimal symbol table. */
742 /* No available symbol. */
752 /* See if we're in a transfer table for Sun shared libs. */
754 if (msymbol
-> type
== mst_text
|| msymbol
-> type
== mst_file_text
)
755 cache_pc_function_low
= SYMBOL_VALUE_ADDRESS (msymbol
);
757 /* It is a transfer table for Sun shared libraries. */
758 cache_pc_function_low
= pc
- FUNCTION_START_OFFSET
;
760 cache_pc_function_name
= SYMBOL_NAME (msymbol
);
762 /* Use the lesser of the next minimal symbol, or the end of the section, as
763 the end of the function. */
765 if (SYMBOL_NAME (msymbol
+ 1) != NULL
766 && SYMBOL_VALUE_ADDRESS (msymbol
+ 1) < sec
->endaddr
)
767 cache_pc_function_high
= SYMBOL_VALUE_ADDRESS (msymbol
+ 1);
769 /* We got the start address from the last msymbol in the objfile.
770 So the end address is the end of the section. */
771 cache_pc_function_high
= sec
->endaddr
;
775 *address
= cache_pc_function_low
;
777 *name
= cache_pc_function_name
;
779 *endaddr
= cache_pc_function_high
;
783 /* Return the innermost stack frame executing inside of BLOCK,
784 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
787 block_innermost_frame (block
)
790 struct frame_info
*fi
;
791 register FRAME frame
;
792 register CORE_ADDR start
;
793 register CORE_ADDR end
;
798 start
= BLOCK_START (block
);
799 end
= BLOCK_END (block
);
804 frame
= get_prev_frame (frame
);
807 fi
= get_frame_info (frame
);
808 if (fi
->pc
>= start
&& fi
->pc
< end
)
813 /* Return the full FRAME which corresponds to the given FRAME_ADDR
814 or NULL if no FRAME on the chain corresponds to FRAME_ADDR. */
817 find_frame_addr_in_frame_chain (frame_addr
)
818 FRAME_ADDR frame_addr
;
822 if (frame_addr
== NULL
)
827 frame
= get_prev_frame (frame
);
831 if (FRAME_FP (frame
) == frame_addr
)
836 #ifdef SIGCONTEXT_PC_OFFSET
837 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp. */
840 sigtramp_saved_pc (frame
)
843 CORE_ADDR sigcontext_addr
;
844 char buf
[TARGET_PTR_BIT
/ TARGET_CHAR_BIT
];
845 int ptrbytes
= TARGET_PTR_BIT
/ TARGET_CHAR_BIT
;
846 int sigcontext_offs
= (2 * TARGET_INT_BIT
) / TARGET_CHAR_BIT
;
848 /* Get sigcontext address, it is the third parameter on the stack. */
850 sigcontext_addr
= read_memory_integer (FRAME_ARGS_ADDRESS (frame
->next
)
851 + FRAME_ARGS_SKIP
+ sigcontext_offs
,
854 sigcontext_addr
= read_memory_integer (read_register (SP_REGNUM
)
858 /* Don't cause a memory_error when accessing sigcontext in case the stack
859 layout has changed or the stack is corrupt. */
860 target_read_memory (sigcontext_addr
+ SIGCONTEXT_PC_OFFSET
, buf
, ptrbytes
);
861 return extract_unsigned_integer (buf
, ptrbytes
);
863 #endif /* SIGCONTEXT_PC_OFFSET */
866 _initialize_blockframe ()
868 obstack_init (&frame_cache_obstack
);