1 /* Get info from stack frames; convert between frames, blocks,
2 functions and pc values.
4 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
5 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
32 #include "value.h" /* for read_register */
33 #include "target.h" /* for target_has_stack */
34 #include "inferior.h" /* for read_pc */
37 #include "gdb_assert.h"
38 #include "dummy-frame.h"
43 /* Prototypes for exported functions. */
45 void _initialize_blockframe (void);
47 /* Is ADDR inside the startup file? Note that if your machine
48 has a way to detect the bottom of the stack, there is no need
49 to call this function from FRAME_CHAIN_VALID; the reason for
50 doing so is that some machines have no way of detecting bottom
53 A PC of zero is always considered to be the bottom of the stack. */
56 inside_entry_file (CORE_ADDR addr
)
60 if (symfile_objfile
== 0)
62 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
64 /* Do not stop backtracing if the pc is in the call dummy
65 at the entry point. */
66 /* FIXME: Won't always work with zeros for the last two arguments */
67 if (DEPRECATED_PC_IN_CALL_DUMMY (addr
, 0, 0))
70 return (addr
>= symfile_objfile
->ei
.entry_file_lowpc
&&
71 addr
< symfile_objfile
->ei
.entry_file_highpc
);
74 /* Test a specified PC value to see if it is in the range of addresses
75 that correspond to the main() function. See comments above for why
76 we might want to do this.
78 Typically called from FRAME_CHAIN_VALID.
80 A PC of zero is always considered to be the bottom of the stack. */
83 inside_main_func (CORE_ADDR pc
)
87 if (symfile_objfile
== 0)
90 /* If the addr range is not set up at symbol reading time, set it up now.
91 This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because
92 it is unable to set it up and symbol reading time. */
94 if (symfile_objfile
->ei
.main_func_lowpc
== INVALID_ENTRY_LOWPC
&&
95 symfile_objfile
->ei
.main_func_highpc
== INVALID_ENTRY_HIGHPC
)
97 struct symbol
*mainsym
;
99 mainsym
= lookup_symbol (main_name (), NULL
, VAR_NAMESPACE
, NULL
, NULL
);
100 if (mainsym
&& SYMBOL_CLASS (mainsym
) == LOC_BLOCK
)
102 symfile_objfile
->ei
.main_func_lowpc
=
103 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym
));
104 symfile_objfile
->ei
.main_func_highpc
=
105 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym
));
108 return (symfile_objfile
->ei
.main_func_lowpc
<= pc
&&
109 symfile_objfile
->ei
.main_func_highpc
> pc
);
112 /* Test a specified PC value to see if it is in the range of addresses
113 that correspond to the process entry point function. See comments
114 in objfiles.h for why we might want to do this.
116 Typically called from FRAME_CHAIN_VALID.
118 A PC of zero is always considered to be the bottom of the stack. */
121 inside_entry_func (CORE_ADDR pc
)
125 if (symfile_objfile
== 0)
127 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
129 /* Do not stop backtracing if the pc is in the call dummy
130 at the entry point. */
131 /* FIXME: Won't always work with zeros for the last two arguments */
132 if (DEPRECATED_PC_IN_CALL_DUMMY (pc
, 0, 0))
135 return (symfile_objfile
->ei
.entry_func_lowpc
<= pc
&&
136 symfile_objfile
->ei
.entry_func_highpc
> pc
);
139 /* Return nonzero if the function for this frame lacks a prologue. Many
140 machines can define FRAMELESS_FUNCTION_INVOCATION to just call this
144 frameless_look_for_prologue (struct frame_info
*frame
)
146 CORE_ADDR func_start
, after_prologue
;
148 func_start
= get_pc_function_start (get_frame_pc (frame
));
151 func_start
+= FUNCTION_START_OFFSET
;
152 /* This is faster, since only care whether there *is* a
153 prologue, not how long it is. */
154 return PROLOGUE_FRAMELESS_P (func_start
);
156 else if (get_frame_pc (frame
) == 0)
157 /* A frame with a zero PC is usually created by dereferencing a
158 NULL function pointer, normally causing an immediate core dump
159 of the inferior. Mark function as frameless, as the inferior
160 has no chance of setting up a stack frame. */
163 /* If we can't find the start of the function, we don't really
164 know whether the function is frameless, but we should be able
165 to get a reasonable (i.e. best we can do under the
166 circumstances) backtrace by saying that it isn't. */
170 /* return the address of the PC for the given FRAME, ie the current PC value
171 if FRAME is the innermost frame, or the address adjusted to point to the
172 call instruction if not. */
175 frame_address_in_block (struct frame_info
*frame
)
177 CORE_ADDR pc
= get_frame_pc (frame
);
179 /* If we are not in the innermost frame, and we are not interrupted
180 by a signal, frame->pc points to the instruction following the
181 call. As a consequence, we need to get the address of the previous
182 instruction. Unfortunately, this is not straightforward to do, so
183 we just use the address minus one, which is a good enough
185 /* FIXME: cagney/2002-11-10: Should this instead test for
186 NORMAL_FRAME? A dummy frame (in fact all the abnormal frames)
187 save the PC value in the block. */
188 if (get_next_frame (frame
) != 0
189 && get_frame_type (get_next_frame (frame
)) != SIGTRAMP_FRAME
)
195 /* Return the innermost lexical block in execution
196 in a specified stack frame. The frame address is assumed valid.
198 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
199 address we used to choose the block. We use this to find a source
200 line, to decide which macro definitions are in scope.
202 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
203 PC, and may not really be a valid PC at all. For example, in the
204 caller of a function declared to never return, the code at the
205 return address will never be reached, so the call instruction may
206 be the very last instruction in the block. So the address we use
207 to choose the block is actually one byte before the return address
208 --- hopefully pointing us at the call instruction, or its delay
212 get_frame_block (struct frame_info
*frame
, CORE_ADDR
*addr_in_block
)
214 const CORE_ADDR pc
= frame_address_in_block (frame
);
219 return block_for_pc (pc
);
223 get_pc_function_start (CORE_ADDR pc
)
225 register struct block
*bl
;
226 register struct symbol
*symbol
;
227 register struct minimal_symbol
*msymbol
;
230 if ((bl
= block_for_pc (pc
)) != NULL
&&
231 (symbol
= block_function (bl
)) != NULL
)
233 bl
= SYMBOL_BLOCK_VALUE (symbol
);
234 fstart
= BLOCK_START (bl
);
236 else if ((msymbol
= lookup_minimal_symbol_by_pc (pc
)) != NULL
)
238 fstart
= SYMBOL_VALUE_ADDRESS (msymbol
);
239 if (!find_pc_section (fstart
))
249 /* Return the symbol for the function executing in frame FRAME. */
252 get_frame_function (struct frame_info
*frame
)
254 register struct block
*bl
= get_frame_block (frame
, 0);
257 return block_function (bl
);
261 /* Return the function containing pc value PC in section SECTION.
262 Returns 0 if function is not known. */
265 find_pc_sect_function (CORE_ADDR pc
, struct sec
*section
)
267 register struct block
*b
= block_for_pc_sect (pc
, section
);
270 return block_function (b
);
273 /* Return the function containing pc value PC.
274 Returns 0 if function is not known. Backward compatibility, no section */
277 find_pc_function (CORE_ADDR pc
)
279 return find_pc_sect_function (pc
, find_pc_mapped_section (pc
));
282 /* These variables are used to cache the most recent result
283 * of find_pc_partial_function. */
285 static CORE_ADDR cache_pc_function_low
= 0;
286 static CORE_ADDR cache_pc_function_high
= 0;
287 static char *cache_pc_function_name
= 0;
288 static struct sec
*cache_pc_function_section
= NULL
;
290 /* Clear cache, e.g. when symbol table is discarded. */
293 clear_pc_function_cache (void)
295 cache_pc_function_low
= 0;
296 cache_pc_function_high
= 0;
297 cache_pc_function_name
= (char *) 0;
298 cache_pc_function_section
= NULL
;
301 /* Finds the "function" (text symbol) that is smaller than PC but
302 greatest of all of the potential text symbols in SECTION. Sets
303 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
304 If ENDADDR is non-null, then set *ENDADDR to be the end of the
305 function (exclusive), but passing ENDADDR as non-null means that
306 the function might cause symbols to be read. This function either
307 succeeds or fails (not halfway succeeds). If it succeeds, it sets
308 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
309 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
313 find_pc_sect_partial_function (CORE_ADDR pc
, asection
*section
, char **name
,
314 CORE_ADDR
*address
, CORE_ADDR
*endaddr
)
316 struct partial_symtab
*pst
;
318 struct minimal_symbol
*msymbol
;
319 struct partial_symbol
*psb
;
320 struct obj_section
*osect
;
324 mapped_pc
= overlay_mapped_address (pc
, section
);
326 if (mapped_pc
>= cache_pc_function_low
327 && mapped_pc
< cache_pc_function_high
328 && section
== cache_pc_function_section
)
329 goto return_cached_value
;
331 /* If sigtramp is in the u area, it counts as a function (especially
332 important for step_1). */
333 if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc
, (char *) NULL
))
335 cache_pc_function_low
= SIGTRAMP_START (mapped_pc
);
336 cache_pc_function_high
= SIGTRAMP_END (mapped_pc
);
337 cache_pc_function_name
= "<sigtramp>";
338 cache_pc_function_section
= section
;
339 goto return_cached_value
;
342 msymbol
= lookup_minimal_symbol_by_pc_section (mapped_pc
, section
);
343 pst
= find_pc_sect_psymtab (mapped_pc
, section
);
346 /* Need to read the symbols to get a good value for the end address. */
347 if (endaddr
!= NULL
&& !pst
->readin
)
349 /* Need to get the terminal in case symbol-reading produces
351 target_terminal_ours_for_output ();
352 PSYMTAB_TO_SYMTAB (pst
);
357 /* Checking whether the msymbol has a larger value is for the
358 "pathological" case mentioned in print_frame_info. */
359 f
= find_pc_sect_function (mapped_pc
, section
);
362 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f
))
363 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
365 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
366 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
367 cache_pc_function_name
= SYMBOL_NAME (f
);
368 cache_pc_function_section
= section
;
369 goto return_cached_value
;
374 /* Now that static symbols go in the minimal symbol table, perhaps
375 we could just ignore the partial symbols. But at least for now
376 we use the partial or minimal symbol, whichever is larger. */
377 psb
= find_pc_sect_psymbol (pst
, mapped_pc
, section
);
380 && (msymbol
== NULL
||
381 (SYMBOL_VALUE_ADDRESS (psb
)
382 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
384 /* This case isn't being cached currently. */
386 *address
= SYMBOL_VALUE_ADDRESS (psb
);
388 *name
= SYMBOL_NAME (psb
);
389 /* endaddr non-NULL can't happen here. */
395 /* Not in the normal symbol tables, see if the pc is in a known section.
396 If it's not, then give up. This ensures that anything beyond the end
397 of the text seg doesn't appear to be part of the last function in the
400 osect
= find_pc_sect_section (mapped_pc
, section
);
405 /* Must be in the minimal symbol table. */
408 /* No available symbol. */
418 cache_pc_function_low
= SYMBOL_VALUE_ADDRESS (msymbol
);
419 cache_pc_function_name
= SYMBOL_NAME (msymbol
);
420 cache_pc_function_section
= section
;
422 /* Use the lesser of the next minimal symbol in the same section, or
423 the end of the section, as the end of the function. */
425 /* Step over other symbols at this same address, and symbols in
426 other sections, to find the next symbol in this section with
427 a different address. */
429 for (i
= 1; SYMBOL_NAME (msymbol
+ i
) != NULL
; i
++)
431 if (SYMBOL_VALUE_ADDRESS (msymbol
+ i
) != SYMBOL_VALUE_ADDRESS (msymbol
)
432 && SYMBOL_BFD_SECTION (msymbol
+ i
) == SYMBOL_BFD_SECTION (msymbol
))
436 if (SYMBOL_NAME (msymbol
+ i
) != NULL
437 && SYMBOL_VALUE_ADDRESS (msymbol
+ i
) < osect
->endaddr
)
438 cache_pc_function_high
= SYMBOL_VALUE_ADDRESS (msymbol
+ i
);
440 /* We got the start address from the last msymbol in the objfile.
441 So the end address is the end of the section. */
442 cache_pc_function_high
= osect
->endaddr
;
448 if (pc_in_unmapped_range (pc
, section
))
449 *address
= overlay_unmapped_address (cache_pc_function_low
, section
);
451 *address
= cache_pc_function_low
;
455 *name
= cache_pc_function_name
;
459 if (pc_in_unmapped_range (pc
, section
))
461 /* Because the high address is actually beyond the end of
462 the function (and therefore possibly beyond the end of
463 the overlay), we must actually convert (high - 1) and
464 then add one to that. */
466 *endaddr
= 1 + overlay_unmapped_address (cache_pc_function_high
- 1,
470 *endaddr
= cache_pc_function_high
;
476 /* Backward compatibility, no section argument. */
479 find_pc_partial_function (CORE_ADDR pc
, char **name
, CORE_ADDR
*address
,
484 section
= find_pc_overlay (pc
);
485 return find_pc_sect_partial_function (pc
, section
, name
, address
, endaddr
);
488 /* Return the innermost stack frame executing inside of BLOCK,
489 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
492 block_innermost_frame (struct block
*block
)
494 struct frame_info
*frame
;
495 register CORE_ADDR start
;
496 register CORE_ADDR end
;
497 CORE_ADDR calling_pc
;
502 start
= BLOCK_START (block
);
503 end
= BLOCK_END (block
);
508 frame
= get_prev_frame (frame
);
511 calling_pc
= frame_address_in_block (frame
);
512 if (calling_pc
>= start
&& calling_pc
< end
)
517 /* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK
518 below is for infrun.c, which may give the macro a pc without that
521 /* Is the PC in a call dummy? SP and FRAME_ADDRESS are the bottom and
522 top of the stack frame which we are checking, where "bottom" and
523 "top" refer to some section of memory which contains the code for
524 the call dummy. Calls to this macro assume that the contents of
525 SP_REGNUM and FP_REGNUM (or the saved values thereof), respectively,
526 are the things to pass.
528 This won't work on the 29k, where SP_REGNUM and FP_REGNUM don't
529 have that meaning, but the 29k doesn't use ON_STACK. This could be
530 fixed by generalizing this scheme, perhaps by passing in a frame
531 and adding a few fields, at least on machines which need them for
532 DEPRECATED_PC_IN_CALL_DUMMY.
534 Something simpler, like checking for the stack segment, doesn't work,
535 since various programs (threads implementations, gcc nested function
536 stubs, etc) may either allocate stack frames in another segment, or
537 allocate other kinds of code on the stack. */
540 deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc
, CORE_ADDR sp
,
541 CORE_ADDR frame_address
)
543 return (INNER_THAN ((sp
), (pc
))
544 && (frame_address
!= 0)
545 && INNER_THAN ((pc
), (frame_address
)));
549 deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc
, CORE_ADDR sp
,
550 CORE_ADDR frame_address
)
552 return ((pc
) >= CALL_DUMMY_ADDRESS ()
553 && (pc
) <= (CALL_DUMMY_ADDRESS () + DECR_PC_AFTER_BREAK
));
556 /* Function: frame_chain_valid
557 Returns true for a user frame or a call_function_by_hand dummy frame,
558 and false for the CRT0 start-up frame. Purpose is to terminate backtrace. */
561 frame_chain_valid (CORE_ADDR fp
, struct frame_info
*fi
)
563 /* Don't prune CALL_DUMMY frames. */
564 if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
565 && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi
), 0, 0))
568 /* If the new frame pointer is zero, then it isn't valid. */
572 /* If the new frame would be inside (younger than) the previous frame,
573 then it isn't valid. */
574 if (INNER_THAN (fp
, get_frame_base (fi
)))
577 /* If we're already inside the entry function for the main objfile, then it
579 if (inside_entry_func (get_frame_pc (fi
)))
582 /* If we're inside the entry file, it isn't valid. */
583 /* NOTE/drow 2002-12-25: should there be a way to disable this check? It
584 assumes a single small entry file, and the way some debug readers (e.g.
585 dbxread) figure out which object is the entry file is somewhat hokey. */
586 if (inside_entry_file (frame_pc_unwind (fi
)))
589 /* If the architecture has a custom FRAME_CHAIN_VALID, call it now. */
590 if (FRAME_CHAIN_VALID_P ())
591 return FRAME_CHAIN_VALID (fp
, fi
);