1 /* Get info from stack frames; convert between frames, blocks,
2 functions and pc values.
4 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
5 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009,
6 2010 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 3 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, see <http://www.gnu.org/licenses/>. */
34 #include "gdb_assert.h"
35 #include "dummy-frame.h"
39 #include "inline-frame.h"
41 /* Return the innermost lexical block in execution
42 in a specified stack frame. The frame address is assumed valid.
44 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
45 address we used to choose the block. We use this to find a source
46 line, to decide which macro definitions are in scope.
48 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
49 PC, and may not really be a valid PC at all. For example, in the
50 caller of a function declared to never return, the code at the
51 return address will never be reached, so the call instruction may
52 be the very last instruction in the block. So the address we use
53 to choose the block is actually one byte before the return address
54 --- hopefully pointing us at the call instruction, or its delay
58 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
60 const CORE_ADDR pc = get_frame_address_in_block (frame);
61 struct frame_info *next_frame;
68 bl = block_for_pc (pc);
72 inline_count = frame_inlined_callees (frame);
74 while (inline_count > 0)
76 if (block_inlined_p (bl))
79 bl = BLOCK_SUPERBLOCK (bl);
80 gdb_assert (bl != NULL);
87 get_pc_function_start (CORE_ADDR pc)
90 struct minimal_symbol *msymbol;
92 bl = block_for_pc (pc);
95 struct symbol *symbol = block_linkage_function (bl);
99 bl = SYMBOL_BLOCK_VALUE (symbol);
100 return BLOCK_START (bl);
104 msymbol = lookup_minimal_symbol_by_pc (pc);
107 CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol);
109 if (find_pc_section (fstart))
116 /* Return the symbol for the function executing in frame FRAME. */
119 get_frame_function (struct frame_info *frame)
121 struct block *bl = get_frame_block (frame, 0);
126 while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
127 bl = BLOCK_SUPERBLOCK (bl);
129 return BLOCK_FUNCTION (bl);
133 /* Return the function containing pc value PC in section SECTION.
134 Returns 0 if function is not known. */
137 find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
139 struct block *b = block_for_pc_sect (pc, section);
142 return block_linkage_function (b);
145 /* Return the function containing pc value PC.
146 Returns 0 if function is not known. Backward compatibility, no section */
149 find_pc_function (CORE_ADDR pc)
151 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
154 /* These variables are used to cache the most recent result
155 * of find_pc_partial_function. */
157 static CORE_ADDR cache_pc_function_low = 0;
158 static CORE_ADDR cache_pc_function_high = 0;
159 static char *cache_pc_function_name = 0;
160 static struct obj_section *cache_pc_function_section = NULL;
162 /* Clear cache, e.g. when symbol table is discarded. */
165 clear_pc_function_cache (void)
167 cache_pc_function_low = 0;
168 cache_pc_function_high = 0;
169 cache_pc_function_name = (char *) 0;
170 cache_pc_function_section = NULL;
173 /* Finds the "function" (text symbol) that is smaller than PC but
174 greatest of all of the potential text symbols in SECTION. Sets
175 *NAME and/or *ADDRESS conditionally if that pointer is non-null.
176 If ENDADDR is non-null, then set *ENDADDR to be the end of the
177 function (exclusive), but passing ENDADDR as non-null means that
178 the function might cause symbols to be read. This function either
179 succeeds or fails (not halfway succeeds). If it succeeds, it sets
180 *NAME, *ADDRESS, and *ENDADDR to real information and returns 1.
181 If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and
184 /* Backward compatibility, no section argument. */
187 find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
190 struct obj_section *section;
191 struct partial_symtab *pst;
193 struct minimal_symbol *msymbol;
194 struct partial_symbol *psb;
198 /* To ensure that the symbol returned belongs to the correct setion
199 (and that the last [random] symbol from the previous section
200 isn't returned) try to find the section containing PC. First try
201 the overlay code (which by default returns NULL); and second try
202 the normal section code (which almost always succeeds). */
203 section = find_pc_overlay (pc);
205 section = find_pc_section (pc);
207 mapped_pc = overlay_mapped_address (pc, section);
209 if (mapped_pc >= cache_pc_function_low
210 && mapped_pc < cache_pc_function_high
211 && section == cache_pc_function_section)
212 goto return_cached_value;
214 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
215 pst = find_pc_sect_psymtab (mapped_pc, section);
218 /* Need to read the symbols to get a good value for the end address. */
219 if (endaddr != NULL && !pst->readin)
221 /* Need to get the terminal in case symbol-reading produces
223 target_terminal_ours_for_output ();
224 PSYMTAB_TO_SYMTAB (pst);
229 /* Checking whether the msymbol has a larger value is for the
230 "pathological" case mentioned in print_frame_info. */
231 f = find_pc_sect_function (mapped_pc, section);
234 || (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
235 >= SYMBOL_VALUE_ADDRESS (msymbol))))
237 cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
238 cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
239 cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
240 cache_pc_function_section = section;
241 goto return_cached_value;
246 /* Now that static symbols go in the minimal symbol table, perhaps
247 we could just ignore the partial symbols. But at least for now
248 we use the partial or minimal symbol, whichever is larger. */
249 psb = find_pc_sect_psymbol (pst, mapped_pc, section);
253 || (SYMBOL_VALUE_ADDRESS (psb)
254 >= SYMBOL_VALUE_ADDRESS (msymbol))))
256 /* This case isn't being cached currently. */
258 *address = SYMBOL_VALUE_ADDRESS (psb);
260 *name = SYMBOL_LINKAGE_NAME (psb);
261 /* endaddr non-NULL can't happen here. */
267 /* Not in the normal symbol tables, see if the pc is in a known section.
268 If it's not, then give up. This ensures that anything beyond the end
269 of the text seg doesn't appear to be part of the last function in the
275 /* Must be in the minimal symbol table. */
278 /* No available symbol. */
288 cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
289 cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
290 cache_pc_function_section = section;
292 /* If the minimal symbol has a size, use it for the cache.
293 Otherwise use the lesser of the next minimal symbol in the same
294 section, or the end of the section, as the end of the
297 if (MSYMBOL_SIZE (msymbol) != 0)
298 cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
301 /* Step over other symbols at this same address, and symbols in
302 other sections, to find the next symbol in this section with
303 a different address. */
305 for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
307 if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
308 && SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol))
312 if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
313 && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section))
314 cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i);
316 /* We got the start address from the last msymbol in the objfile.
317 So the end address is the end of the section. */
318 cache_pc_function_high = obj_section_endaddr (section);
325 if (pc_in_unmapped_range (pc, section))
326 *address = overlay_unmapped_address (cache_pc_function_low, section);
328 *address = cache_pc_function_low;
332 *name = cache_pc_function_name;
336 if (pc_in_unmapped_range (pc, section))
338 /* Because the high address is actually beyond the end of
339 the function (and therefore possibly beyond the end of
340 the overlay), we must actually convert (high - 1) and
341 then add one to that. */
343 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
347 *endaddr = cache_pc_function_high;
353 /* Return the innermost stack frame executing inside of BLOCK,
354 or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
357 block_innermost_frame (struct block *block)
359 struct frame_info *frame;
366 start = BLOCK_START (block);
367 end = BLOCK_END (block);
369 frame = get_current_frame ();
370 while (frame != NULL)
372 struct block *frame_block = get_frame_block (frame, NULL);
373 if (frame_block != NULL && contained_in (frame_block, block))
376 frame = get_prev_frame (frame);