1 /* Get info from stack frames; convert between frames, blocks,
2 functions and pc values.
4 Copyright (C) 1986-2019 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Local non-gdb includes. */
28 #include "dummy-frame.h"
33 #include "inline-frame.h"
40 /* Return the innermost lexical block in execution in a specified
41 stack frame. The frame address is assumed valid.
43 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
44 address we used to choose the block. We use this to find a source
45 line, to decide which macro definitions are in scope.
47 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
48 PC, and may not really be a valid PC at all. For example, in the
49 caller of a function declared to never return, the code at the
50 return address will never be reached, so the call instruction may
51 be the very last instruction in the block. So the address we use
52 to choose the block is actually one byte before the return address
53 --- hopefully pointing us at the call instruction, or its delay
57 get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block)
60 const struct block *bl;
63 if (!get_frame_address_in_block_if_available (frame, &pc))
69 bl = block_for_pc (pc);
73 inline_count = frame_inlined_callees (frame);
75 while (inline_count > 0)
77 if (block_inlined_p (bl))
80 bl = BLOCK_SUPERBLOCK (bl);
81 gdb_assert (bl != NULL);
88 get_pc_function_start (CORE_ADDR pc)
90 const struct block *bl;
91 struct bound_minimal_symbol msymbol;
93 bl = block_for_pc (pc);
96 struct symbol *symbol = block_linkage_function (bl);
100 bl = SYMBOL_BLOCK_VALUE (symbol);
101 return BLOCK_ENTRY_PC (bl);
105 msymbol = lookup_minimal_symbol_by_pc (pc);
108 CORE_ADDR fstart = BMSYMBOL_VALUE_ADDRESS (msymbol);
110 if (find_pc_section (fstart))
117 /* Return the symbol for the function executing in frame FRAME. */
120 get_frame_function (struct frame_info *frame)
122 const struct block *bl = get_frame_block (frame, 0);
127 while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL)
128 bl = BLOCK_SUPERBLOCK (bl);
130 return BLOCK_FUNCTION (bl);
134 /* Return the function containing pc value PC in section SECTION.
135 Returns 0 if function is not known. */
138 find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
140 const struct block *b = block_for_pc_sect (pc, section);
144 return block_linkage_function (b);
147 /* Return the function containing pc value PC.
148 Returns 0 if function is not known.
149 Backward compatibility, no section */
152 find_pc_function (CORE_ADDR pc)
154 return find_pc_sect_function (pc, find_pc_mapped_section (pc));
160 find_pc_sect_containing_function (CORE_ADDR pc, struct obj_section *section)
162 const block *bl = block_for_pc_sect (pc, section);
167 return block_containing_function (bl);
170 /* These variables are used to cache the most recent result of
171 find_pc_partial_function.
173 The addresses cache_pc_function_low and cache_pc_function_high
174 record the range in which PC was found during the most recent
175 successful lookup. When the function occupies a single contiguous
176 address range, these values correspond to the low and high
177 addresses of the function. (The high address is actually one byte
178 beyond the last byte of the function.) For a function with more
179 than one (non-contiguous) range, the range in which PC was found is
180 used to set the cache bounds.
182 When determining whether or not these cached values apply to a
183 particular PC value, PC must be within the range specified by
184 cache_pc_function_low and cache_pc_function_high. In addition to
185 PC being in that range, cache_pc_section must also match PC's
186 section. See find_pc_partial_function() for details on both the
187 comparison as well as how PC's section is determined.
189 The other values aren't used for determining whether the cache
190 applies, but are used for setting the outputs from
191 find_pc_partial_function. cache_pc_function_low and
192 cache_pc_function_high are used to set outputs as well. */
194 static CORE_ADDR cache_pc_function_low = 0;
195 static CORE_ADDR cache_pc_function_high = 0;
196 static const char *cache_pc_function_name = 0;
197 static struct obj_section *cache_pc_function_section = NULL;
198 static const struct block *cache_pc_function_block = nullptr;
200 /* Clear cache, e.g. when symbol table is discarded. */
203 clear_pc_function_cache (void)
205 cache_pc_function_low = 0;
206 cache_pc_function_high = 0;
207 cache_pc_function_name = (char *) 0;
208 cache_pc_function_section = NULL;
209 cache_pc_function_block = nullptr;
215 find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
216 CORE_ADDR *endaddr, const struct block **block)
218 struct obj_section *section;
220 struct bound_minimal_symbol msymbol;
221 struct compunit_symtab *compunit_symtab = NULL;
224 /* To ensure that the symbol returned belongs to the correct setion
225 (and that the last [random] symbol from the previous section
226 isn't returned) try to find the section containing PC. First try
227 the overlay code (which by default returns NULL); and second try
228 the normal section code (which almost always succeeds). */
229 section = find_pc_overlay (pc);
231 section = find_pc_section (pc);
233 mapped_pc = overlay_mapped_address (pc, section);
235 if (mapped_pc >= cache_pc_function_low
236 && mapped_pc < cache_pc_function_high
237 && section == cache_pc_function_section)
238 goto return_cached_value;
240 msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
241 for (objfile *objfile : current_program_space->objfiles ())
246 = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
251 if (compunit_symtab != NULL)
255 if (compunit_symtab != NULL)
257 /* Checking whether the msymbol has a larger value is for the
258 "pathological" case mentioned in stack.c:find_frame_funname.
260 We use BLOCK_ENTRY_PC instead of BLOCK_START_PC for this
261 comparison because the minimal symbol should refer to the
262 function's entry pc which is not necessarily the lowest
263 address of the function. This will happen when the function
264 has more than one range and the entry pc is not within the
265 lowest range of addresses. */
266 f = find_pc_sect_function (mapped_pc, section);
268 && (msymbol.minsym == NULL
269 || (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (f))
270 >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
272 const struct block *b = SYMBOL_BLOCK_VALUE (f);
274 cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
275 cache_pc_function_section = section;
276 cache_pc_function_block = b;
278 /* For blocks occupying contiguous addresses (i.e. no gaps),
279 the low and high cache addresses are simply the start
280 and end of the block.
282 For blocks with non-contiguous ranges, we have to search
283 for the range containing mapped_pc and then use the start
284 and end of that range.
286 This causes the returned *ADDRESS and *ENDADDR values to
287 be limited to the range in which mapped_pc is found. See
288 comment preceding declaration of find_pc_partial_function
289 in symtab.h for more information. */
291 if (BLOCK_CONTIGUOUS_P (b))
293 cache_pc_function_low = BLOCK_START (b);
294 cache_pc_function_high = BLOCK_END (b);
299 for (i = 0; i < BLOCK_NRANGES (b); i++)
301 if (BLOCK_RANGE_START (b, i) <= mapped_pc
302 && mapped_pc < BLOCK_RANGE_END (b, i))
304 cache_pc_function_low = BLOCK_RANGE_START (b, i);
305 cache_pc_function_high = BLOCK_RANGE_END (b, i);
309 /* Above loop should exit via the break. */
310 gdb_assert (i < BLOCK_NRANGES (b));
314 goto return_cached_value;
318 /* Not in the normal symbol tables, see if the pc is in a known
319 section. If it's not, then give up. This ensures that anything
320 beyond the end of the text seg doesn't appear to be part of the
321 last function in the text segment. */
324 msymbol.minsym = NULL;
326 /* Must be in the minimal symbol table. */
327 if (msymbol.minsym == NULL)
329 /* No available symbol. */
339 cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
340 cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
341 cache_pc_function_section = section;
342 cache_pc_function_high = minimal_symbol_upper_bound (msymbol);
343 cache_pc_function_block = nullptr;
349 if (pc_in_unmapped_range (pc, section))
350 *address = overlay_unmapped_address (cache_pc_function_low, section);
352 *address = cache_pc_function_low;
356 *name = cache_pc_function_name;
360 if (pc_in_unmapped_range (pc, section))
362 /* Because the high address is actually beyond the end of
363 the function (and therefore possibly beyond the end of
364 the overlay), we must actually convert (high - 1) and
365 then add one to that. */
367 *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1,
371 *endaddr = cache_pc_function_high;
374 if (block != nullptr)
375 *block = cache_pc_function_block;
383 find_function_entry_range_from_pc (CORE_ADDR pc, const char **name,
384 CORE_ADDR *address, CORE_ADDR *endaddr)
386 const struct block *block;
387 bool status = find_pc_partial_function (pc, name, address, endaddr, &block);
389 if (status && block != nullptr && !BLOCK_CONTIGUOUS_P (block))
391 CORE_ADDR entry_pc = BLOCK_ENTRY_PC (block);
393 for (int i = 0; i < BLOCK_NRANGES (block); i++)
395 if (BLOCK_RANGE_START (block, i) <= entry_pc
396 && entry_pc < BLOCK_RANGE_END (block, i))
398 if (address != nullptr)
399 *address = BLOCK_RANGE_START (block, i);
401 if (endaddr != nullptr)
402 *endaddr = BLOCK_RANGE_END (block, i);
408 /* It's an internal error if we exit the above loop without finding
410 internal_error (__FILE__, __LINE__,
411 _("Entry block not found in find_function_entry_range_from_pc"));
420 find_function_type (CORE_ADDR pc)
422 struct symbol *sym = find_pc_function (pc);
424 if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc)
425 return SYMBOL_TYPE (sym);
433 find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr)
435 struct type *resolver_type = find_function_type (resolver_funaddr);
436 if (resolver_type != NULL)
438 /* Get the return type of the resolver. */
439 struct type *resolver_ret_type
440 = check_typedef (TYPE_TARGET_TYPE (resolver_type));
442 /* If we found a pointer to function, then the resolved type
443 is the type of the pointed-to function. */
444 if (TYPE_CODE (resolver_ret_type) == TYPE_CODE_PTR)
446 struct type *resolved_type
447 = TYPE_TARGET_TYPE (resolver_ret_type);
448 if (TYPE_CODE (check_typedef (resolved_type)) == TYPE_CODE_FUNC)
449 return resolved_type;
456 /* Return the innermost stack frame that is executing inside of BLOCK and is
457 at least as old as the selected frame. Return NULL if there is no
458 such frame. If BLOCK is NULL, just return NULL. */
461 block_innermost_frame (const struct block *block)
463 struct frame_info *frame;
468 frame = get_selected_frame_if_set ();
470 frame = get_current_frame ();
471 while (frame != NULL)
473 const struct block *frame_block = get_frame_block (frame, NULL);
474 if (frame_block != NULL && contained_in (frame_block, block))
477 frame = get_prev_frame (frame);