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, 2004
6 Free Software Foundation, Inc.
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. */
31 #include "value.h" /* for read_register */
32 #include "target.h" /* for target_has_stack */
33 #include "inferior.h" /* for read_pc */
36 #include "gdb_assert.h"
37 #include "dummy-frame.h"
42 /* Prototypes for exported functions. */
44 void _initialize_blockframe (void);
46 /* Test whether PC is in the range of addresses that corresponds to
47 the "main" function. */
50 inside_main_func (CORE_ADDR pc
)
52 struct minimal_symbol
*msymbol
;
54 if (symfile_objfile
== 0)
57 msymbol
= lookup_minimal_symbol (main_name (), NULL
, symfile_objfile
);
59 /* If the address range hasn't been set up at symbol reading time,
63 && symfile_objfile
->ei
.main_func_lowpc
== INVALID_ENTRY_LOWPC
64 && symfile_objfile
->ei
.main_func_highpc
== INVALID_ENTRY_HIGHPC
)
66 /* brobecker/2003-10-10: We used to rely on lookup_symbol() to
67 search the symbol associated to the "main" function.
68 Unfortunately, lookup_symbol() uses the current-language
69 la_lookup_symbol_nonlocal function to do the global symbol
70 search. Depending on the language, this can introduce
71 certain side-effects, because certain languages, for instance
72 Ada, may find more than one match. Therefore we prefer to
73 search the "main" function symbol using its address rather
75 struct symbol
*mainsym
=
76 find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol
));
78 if (mainsym
&& SYMBOL_CLASS (mainsym
) == LOC_BLOCK
)
80 symfile_objfile
->ei
.main_func_lowpc
=
81 BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym
));
82 symfile_objfile
->ei
.main_func_highpc
=
83 BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym
));
87 /* Not in the normal symbol tables, see if "main" is in the partial
88 symbol table. If it's not, then give up. */
89 if (msymbol
!= NULL
&& MSYMBOL_TYPE (msymbol
) == mst_text
)
91 CORE_ADDR maddr
= SYMBOL_VALUE_ADDRESS (msymbol
);
92 asection
*msect
= SYMBOL_BFD_SECTION (msymbol
);
93 struct obj_section
*osect
= find_pc_sect_section (maddr
, msect
);
99 /* Step over other symbols at this same address, and symbols
100 in other sections, to find the next symbol in this
101 section with a different address. */
102 for (i
= 1; SYMBOL_LINKAGE_NAME (msymbol
+ i
) != NULL
; i
++)
104 if (SYMBOL_VALUE_ADDRESS (msymbol
+ i
) != maddr
105 && SYMBOL_BFD_SECTION (msymbol
+ i
) == msect
)
109 symfile_objfile
->ei
.main_func_lowpc
= maddr
;
111 /* Use the lesser of the next minimal symbol in the same
112 section, or the end of the section, as the end of the
114 if (SYMBOL_LINKAGE_NAME (msymbol
+ i
) != NULL
115 && SYMBOL_VALUE_ADDRESS (msymbol
+ i
) < osect
->endaddr
)
116 symfile_objfile
->ei
.main_func_highpc
=
117 SYMBOL_VALUE_ADDRESS (msymbol
+ i
);
119 /* We got the start address from the last msymbol in the
120 objfile. So the end address is the end of the
122 symfile_objfile
->ei
.main_func_highpc
= osect
->endaddr
;
126 return (symfile_objfile
->ei
.main_func_lowpc
<= pc
127 && symfile_objfile
->ei
.main_func_highpc
> pc
);
130 /* Test whether THIS_FRAME is inside the process entry point function. */
133 inside_entry_func (struct frame_info
*this_frame
)
135 return (get_frame_func (this_frame
) == entry_point_address ());
138 /* Similar to inside_entry_func, but accomodating legacy frame code. */
141 legacy_inside_entry_func (CORE_ADDR pc
)
143 if (symfile_objfile
== 0)
146 if (CALL_DUMMY_LOCATION
== AT_ENTRY_POINT
)
148 /* Do not stop backtracing if the program counter is in the call
149 dummy at the entry point. */
150 if (deprecated_pc_in_call_dummy (pc
))
154 return (symfile_objfile
->ei
.entry_func_lowpc
<= pc
155 && symfile_objfile
->ei
.entry_func_highpc
> pc
);
158 /* Return nonzero if the function for this frame lacks a prologue.
159 Many machines can define DEPRECATED_FRAMELESS_FUNCTION_INVOCATION
160 to just call this function. */
163 legacy_frameless_look_for_prologue (struct frame_info
*frame
)
165 CORE_ADDR func_start
;
167 func_start
= get_frame_func (frame
);
170 func_start
+= FUNCTION_START_OFFSET
;
171 /* NOTE: cagney/2004-02-09: Eliminated per-architecture
172 PROLOGUE_FRAMELESS_P call as architectures with custom
173 implementations had all been deleted. Eventually even this
174 function can go - GDB no longer tries to differentiate
175 between framed, frameless and stackless functions. They are
176 all now considered equally evil :-^. */
177 /* If skipping the prologue ends up skips nothing, there must be
178 no prologue and hence no code creating a frame. There for
179 the function is "frameless" :-/. */
180 return func_start
== SKIP_PROLOGUE (func_start
);
182 else if (get_frame_pc (frame
) == 0)
183 /* A frame with a zero PC is usually created by dereferencing a
184 NULL function pointer, normally causing an immediate core dump
185 of the inferior. Mark function as frameless, as the inferior
186 has no chance of setting up a stack frame. */
189 /* If we can't find the start of the function, we don't really
190 know whether the function is frameless, but we should be able
191 to get a reasonable (i.e. best we can do under the
192 circumstances) backtrace by saying that it isn't. */
196 /* Return the innermost lexical block in execution
197 in a specified stack frame. The frame address is assumed valid.
199 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
200 address we used to choose the block. We use this to find a source
201 line, to decide which macro definitions are in scope.
203 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
204 PC, and may not really be a valid PC at all. For example, in the
205 caller of a function declared to never return, the code at the
206 return address will never be reached, so the call instruction may
207 be the very last instruction in the block. So the address we use
208 to choose the block is actually one byte before the return address
209 --- hopefully pointing us at the call instruction, or its delay
213 get_frame_block (struct frame_info
*frame
, CORE_ADDR
*addr_in_block
)
215 const CORE_ADDR pc
= get_frame_address_in_block (frame
);
220 return block_for_pc (pc
);
224 get_pc_function_start (CORE_ADDR pc
)
227 struct minimal_symbol
*msymbol
;
229 bl
= block_for_pc (pc
);
232 struct symbol
*symbol
= block_function (bl
);
236 bl
= SYMBOL_BLOCK_VALUE (symbol
);
237 return BLOCK_START (bl
);
241 msymbol
= lookup_minimal_symbol_by_pc (pc
);
244 CORE_ADDR fstart
= SYMBOL_VALUE_ADDRESS (msymbol
);
246 if (find_pc_section (fstart
))
253 /* Return the symbol for the function executing in frame FRAME. */
256 get_frame_function (struct frame_info
*frame
)
258 struct block
*bl
= get_frame_block (frame
, 0);
261 return block_function (bl
);
265 /* Return the function containing pc value PC in section SECTION.
266 Returns 0 if function is not known. */
269 find_pc_sect_function (CORE_ADDR pc
, struct bfd_section
*section
)
271 struct block
*b
= block_for_pc_sect (pc
, section
);
274 return block_function (b
);
277 /* Return the function containing pc value PC.
278 Returns 0 if function is not known. Backward compatibility, no section */
281 find_pc_function (CORE_ADDR pc
)
283 return find_pc_sect_function (pc
, find_pc_mapped_section (pc
));
286 /* These variables are used to cache the most recent result
287 * of find_pc_partial_function. */
289 static CORE_ADDR cache_pc_function_low
= 0;
290 static CORE_ADDR cache_pc_function_high
= 0;
291 static char *cache_pc_function_name
= 0;
292 static struct bfd_section
*cache_pc_function_section
= NULL
;
294 /* Clear cache, e.g. when symbol table is discarded. */
297 clear_pc_function_cache (void)
299 cache_pc_function_low
= 0;
300 cache_pc_function_high
= 0;
301 cache_pc_function_name
= (char *) 0;
302 cache_pc_function_section
= NULL
;
305 /* Finds the "function" (text symbol) that is smaller than PC but
306 greatest of all of the potential text symbols in SECTION. Sets
307 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
308 If ENDADDR is non-null, then set *ENDADDR to be the end of the
309 function (exclusive), but passing ENDADDR as non-null means that
310 the function might cause symbols to be read. This function either
311 succeeds or fails (not halfway succeeds). If it succeeds, it sets
312 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
313 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
316 /* Backward compatibility, no section argument. */
319 find_pc_partial_function (CORE_ADDR pc
, char **name
, CORE_ADDR
*address
,
322 struct bfd_section
*section
;
323 struct partial_symtab
*pst
;
325 struct minimal_symbol
*msymbol
;
326 struct partial_symbol
*psb
;
327 struct obj_section
*osect
;
331 /* To ensure that the symbol returned belongs to the correct setion
332 (and that the last [random] symbol from the previous section
333 isn't returned) try to find the section containing PC. First try
334 the overlay code (which by default returns NULL); and second try
335 the normal section code (which almost always succeeds). */
336 section
= find_pc_overlay (pc
);
339 struct obj_section
*obj_section
= find_pc_section (pc
);
340 if (obj_section
== NULL
)
343 section
= obj_section
->the_bfd_section
;
346 mapped_pc
= overlay_mapped_address (pc
, section
);
348 if (mapped_pc
>= cache_pc_function_low
349 && mapped_pc
< cache_pc_function_high
350 && section
== cache_pc_function_section
)
351 goto return_cached_value
;
353 msymbol
= lookup_minimal_symbol_by_pc_section (mapped_pc
, section
);
354 pst
= find_pc_sect_psymtab (mapped_pc
, section
);
357 /* Need to read the symbols to get a good value for the end address. */
358 if (endaddr
!= NULL
&& !pst
->readin
)
360 /* Need to get the terminal in case symbol-reading produces
362 target_terminal_ours_for_output ();
363 PSYMTAB_TO_SYMTAB (pst
);
368 /* Checking whether the msymbol has a larger value is for the
369 "pathological" case mentioned in print_frame_info. */
370 f
= find_pc_sect_function (mapped_pc
, section
);
373 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f
))
374 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
376 cache_pc_function_low
= BLOCK_START (SYMBOL_BLOCK_VALUE (f
));
377 cache_pc_function_high
= BLOCK_END (SYMBOL_BLOCK_VALUE (f
));
378 cache_pc_function_name
= DEPRECATED_SYMBOL_NAME (f
);
379 cache_pc_function_section
= section
;
380 goto return_cached_value
;
385 /* Now that static symbols go in the minimal symbol table, perhaps
386 we could just ignore the partial symbols. But at least for now
387 we use the partial or minimal symbol, whichever is larger. */
388 psb
= find_pc_sect_psymbol (pst
, mapped_pc
, section
);
391 && (msymbol
== NULL
||
392 (SYMBOL_VALUE_ADDRESS (psb
)
393 >= SYMBOL_VALUE_ADDRESS (msymbol
))))
395 /* This case isn't being cached currently. */
397 *address
= SYMBOL_VALUE_ADDRESS (psb
);
399 *name
= DEPRECATED_SYMBOL_NAME (psb
);
400 /* endaddr non-NULL can't happen here. */
406 /* Not in the normal symbol tables, see if the pc is in a known section.
407 If it's not, then give up. This ensures that anything beyond the end
408 of the text seg doesn't appear to be part of the last function in the
411 osect
= find_pc_sect_section (mapped_pc
, section
);
416 /* Must be in the minimal symbol table. */
419 /* No available symbol. */
429 cache_pc_function_low
= SYMBOL_VALUE_ADDRESS (msymbol
);
430 cache_pc_function_name
= DEPRECATED_SYMBOL_NAME (msymbol
);
431 cache_pc_function_section
= section
;
433 /* Use the lesser of the next minimal symbol in the same section, or
434 the end of the section, as the end of the function. */
436 /* Step over other symbols at this same address, and symbols in
437 other sections, to find the next symbol in this section with
438 a different address. */
440 for (i
= 1; DEPRECATED_SYMBOL_NAME (msymbol
+ i
) != NULL
; i
++)
442 if (SYMBOL_VALUE_ADDRESS (msymbol
+ i
) != SYMBOL_VALUE_ADDRESS (msymbol
)
443 && SYMBOL_BFD_SECTION (msymbol
+ i
) == SYMBOL_BFD_SECTION (msymbol
))
447 if (DEPRECATED_SYMBOL_NAME (msymbol
+ i
) != NULL
448 && SYMBOL_VALUE_ADDRESS (msymbol
+ i
) < osect
->endaddr
)
449 cache_pc_function_high
= SYMBOL_VALUE_ADDRESS (msymbol
+ i
);
451 /* We got the start address from the last msymbol in the objfile.
452 So the end address is the end of the section. */
453 cache_pc_function_high
= osect
->endaddr
;
459 if (pc_in_unmapped_range (pc
, section
))
460 *address
= overlay_unmapped_address (cache_pc_function_low
, section
);
462 *address
= cache_pc_function_low
;
466 *name
= cache_pc_function_name
;
470 if (pc_in_unmapped_range (pc
, section
))
472 /* Because the high address is actually beyond the end of
473 the function (and therefore possibly beyond the end of
474 the overlay), we must actually convert (high - 1) and
475 then add one to that. */
477 *endaddr
= 1 + overlay_unmapped_address (cache_pc_function_high
- 1,
481 *endaddr
= cache_pc_function_high
;
487 /* Return the innermost stack frame executing inside of BLOCK,
488 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
491 block_innermost_frame (struct block
*block
)
493 struct frame_info
*frame
;
496 CORE_ADDR calling_pc
;
501 start
= BLOCK_START (block
);
502 end
= BLOCK_END (block
);
507 frame
= get_prev_frame (frame
);
510 calling_pc
= get_frame_address_in_block (frame
);
511 if (calling_pc
>= start
&& calling_pc
< end
)
516 /* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK
517 below is for infrun.c, which may give the macro a pc without that
520 /* Returns true for a user frame or a call_function_by_hand dummy
521 frame, and false for the CRT0 start-up frame. Purpose is to
522 terminate backtrace. */
525 legacy_frame_chain_valid (CORE_ADDR fp
, struct frame_info
*fi
)
527 /* Don't prune CALL_DUMMY frames. */
528 if (deprecated_pc_in_call_dummy (get_frame_pc (fi
)))
531 /* If the new frame pointer is zero, then it isn't valid. */
535 /* If the new frame would be inside (younger than) the previous frame,
536 then it isn't valid. */
537 if (INNER_THAN (fp
, get_frame_base (fi
)))
540 /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID,
542 if (DEPRECATED_FRAME_CHAIN_VALID_P ())
543 return DEPRECATED_FRAME_CHAIN_VALID (fp
, fi
);
545 /* If we're already inside the entry function for the main objfile, then it
547 if (legacy_inside_entry_func (get_frame_pc (fi
)))