1 /* Get info from stack frames; convert between frames, blocks,
2 functions and pc values.
4 Copyright (C) 1986-2020 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/>. */
32 #include "dummy-frame.h"
36 #include "inline-frame.h"
38 /* Return the innermost lexical block in execution in a specified
39 stack frame. The frame address is assumed valid.
41 If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code
42 address we used to choose the block. We use this to find a source
43 line, to decide which macro definitions are in scope.
45 The value returned in *ADDR_IN_BLOCK isn't necessarily the frame's
46 PC, and may not really be a valid PC at all. For example, in the
47 caller of a function declared to never return, the code at the
48 return address will never be reached, so the call instruction may
49 be the very last instruction in the block. So the address we use
50 to choose the block is actually one byte before the return address
51 --- hopefully pointing us at the call instruction, or its delay
55 get_frame_block (struct frame_info
*frame
, CORE_ADDR
*addr_in_block
)
58 const struct block
*bl
;
61 if (!get_frame_address_in_block_if_available (frame
, &pc
))
67 bl
= block_for_pc (pc
);
71 inline_count
= frame_inlined_callees (frame
);
73 while (inline_count
> 0)
75 if (block_inlined_p (bl
))
78 bl
= BLOCK_SUPERBLOCK (bl
);
79 gdb_assert (bl
!= NULL
);
86 get_pc_function_start (CORE_ADDR pc
)
88 const struct block
*bl
;
89 struct bound_minimal_symbol msymbol
;
91 bl
= block_for_pc (pc
);
94 struct symbol
*symbol
= block_linkage_function (bl
);
98 bl
= SYMBOL_BLOCK_VALUE (symbol
);
99 return BLOCK_ENTRY_PC (bl
);
103 msymbol
= lookup_minimal_symbol_by_pc (pc
);
106 CORE_ADDR fstart
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
108 if (find_pc_section (fstart
))
115 /* Return the symbol for the function executing in frame FRAME. */
118 get_frame_function (struct frame_info
*frame
)
120 const struct block
*bl
= get_frame_block (frame
, 0);
125 while (BLOCK_FUNCTION (bl
) == NULL
&& BLOCK_SUPERBLOCK (bl
) != NULL
)
126 bl
= BLOCK_SUPERBLOCK (bl
);
128 return BLOCK_FUNCTION (bl
);
132 /* Return the function containing pc value PC in section SECTION.
133 Returns 0 if function is not known. */
136 find_pc_sect_function (CORE_ADDR pc
, struct obj_section
*section
)
138 const 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.
147 Backward compatibility, no section */
150 find_pc_function (CORE_ADDR pc
)
152 return find_pc_sect_function (pc
, find_pc_mapped_section (pc
));
158 find_pc_sect_containing_function (CORE_ADDR pc
, struct obj_section
*section
)
160 const block
*bl
= block_for_pc_sect (pc
, section
);
165 return block_containing_function (bl
);
168 /* These variables are used to cache the most recent result of
169 find_pc_partial_function.
171 The addresses cache_pc_function_low and cache_pc_function_high
172 record the range in which PC was found during the most recent
173 successful lookup. When the function occupies a single contiguous
174 address range, these values correspond to the low and high
175 addresses of the function. (The high address is actually one byte
176 beyond the last byte of the function.) For a function with more
177 than one (non-contiguous) range, the range in which PC was found is
178 used to set the cache bounds.
180 When determining whether or not these cached values apply to a
181 particular PC value, PC must be within the range specified by
182 cache_pc_function_low and cache_pc_function_high. In addition to
183 PC being in that range, cache_pc_section must also match PC's
184 section. See find_pc_partial_function() for details on both the
185 comparison as well as how PC's section is determined.
187 The other values aren't used for determining whether the cache
188 applies, but are used for setting the outputs from
189 find_pc_partial_function. cache_pc_function_low and
190 cache_pc_function_high are used to set outputs as well. */
192 static CORE_ADDR cache_pc_function_low
= 0;
193 static CORE_ADDR cache_pc_function_high
= 0;
194 static const char *cache_pc_function_name
= 0;
195 static struct obj_section
*cache_pc_function_section
= NULL
;
196 static const struct block
*cache_pc_function_block
= nullptr;
198 /* Clear cache, e.g. when symbol table is discarded. */
201 clear_pc_function_cache (void)
203 cache_pc_function_low
= 0;
204 cache_pc_function_high
= 0;
205 cache_pc_function_name
= (char *) 0;
206 cache_pc_function_section
= NULL
;
207 cache_pc_function_block
= nullptr;
213 find_pc_partial_function (CORE_ADDR pc
, const char **name
, CORE_ADDR
*address
,
214 CORE_ADDR
*endaddr
, const struct block
**block
)
216 struct obj_section
*section
;
218 struct bound_minimal_symbol msymbol
;
219 struct compunit_symtab
*compunit_symtab
= NULL
;
222 /* To ensure that the symbol returned belongs to the correct section
223 (and that the last [random] symbol from the previous section
224 isn't returned) try to find the section containing PC. First try
225 the overlay code (which by default returns NULL); and second try
226 the normal section code (which almost always succeeds). */
227 section
= find_pc_overlay (pc
);
229 section
= find_pc_section (pc
);
231 mapped_pc
= overlay_mapped_address (pc
, section
);
233 if (mapped_pc
>= cache_pc_function_low
234 && mapped_pc
< cache_pc_function_high
235 && section
== cache_pc_function_section
)
236 goto return_cached_value
;
238 msymbol
= lookup_minimal_symbol_by_pc_section (mapped_pc
, section
);
239 compunit_symtab
= find_pc_sect_compunit_symtab (mapped_pc
, section
);
241 if (compunit_symtab
!= NULL
)
243 /* Checking whether the msymbol has a larger value is for the
244 "pathological" case mentioned in stack.c:find_frame_funname.
246 We use BLOCK_ENTRY_PC instead of BLOCK_START_PC for this
247 comparison because the minimal symbol should refer to the
248 function's entry pc which is not necessarily the lowest
249 address of the function. This will happen when the function
250 has more than one range and the entry pc is not within the
251 lowest range of addresses. */
252 f
= find_pc_sect_function (mapped_pc
, section
);
254 && (msymbol
.minsym
== NULL
255 || (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (f
))
256 >= BMSYMBOL_VALUE_ADDRESS (msymbol
))))
258 const struct block
*b
= SYMBOL_BLOCK_VALUE (f
);
260 cache_pc_function_name
= f
->linkage_name ();
261 cache_pc_function_section
= section
;
262 cache_pc_function_block
= b
;
264 /* For blocks occupying contiguous addresses (i.e. no gaps),
265 the low and high cache addresses are simply the start
266 and end of the block.
268 For blocks with non-contiguous ranges, we have to search
269 for the range containing mapped_pc and then use the start
270 and end of that range.
272 This causes the returned *ADDRESS and *ENDADDR values to
273 be limited to the range in which mapped_pc is found. See
274 comment preceding declaration of find_pc_partial_function
275 in symtab.h for more information. */
277 if (BLOCK_CONTIGUOUS_P (b
))
279 cache_pc_function_low
= BLOCK_START (b
);
280 cache_pc_function_high
= BLOCK_END (b
);
285 for (i
= 0; i
< BLOCK_NRANGES (b
); i
++)
287 if (BLOCK_RANGE_START (b
, i
) <= mapped_pc
288 && mapped_pc
< BLOCK_RANGE_END (b
, i
))
290 cache_pc_function_low
= BLOCK_RANGE_START (b
, i
);
291 cache_pc_function_high
= BLOCK_RANGE_END (b
, i
);
295 /* Above loop should exit via the break. */
296 gdb_assert (i
< BLOCK_NRANGES (b
));
300 goto return_cached_value
;
304 /* Not in the normal symbol tables, see if the pc is in a known
305 section. If it's not, then give up. This ensures that anything
306 beyond the end of the text seg doesn't appear to be part of the
307 last function in the text segment. */
310 msymbol
.minsym
= NULL
;
312 /* Must be in the minimal symbol table. */
313 if (msymbol
.minsym
== NULL
)
315 /* No available symbol. */
322 if (block
!= nullptr)
327 cache_pc_function_low
= BMSYMBOL_VALUE_ADDRESS (msymbol
);
328 cache_pc_function_name
= msymbol
.minsym
->linkage_name ();
329 cache_pc_function_section
= section
;
330 cache_pc_function_high
= minimal_symbol_upper_bound (msymbol
);
331 cache_pc_function_block
= nullptr;
337 if (pc_in_unmapped_range (pc
, section
))
338 *address
= overlay_unmapped_address (cache_pc_function_low
, section
);
340 *address
= cache_pc_function_low
;
344 *name
= cache_pc_function_name
;
348 if (pc_in_unmapped_range (pc
, section
))
350 /* Because the high address is actually beyond the end of
351 the function (and therefore possibly beyond the end of
352 the overlay), we must actually convert (high - 1) and
353 then add one to that. */
355 *endaddr
= 1 + overlay_unmapped_address (cache_pc_function_high
- 1,
359 *endaddr
= cache_pc_function_high
;
362 if (block
!= nullptr)
363 *block
= cache_pc_function_block
;
371 find_function_entry_range_from_pc (CORE_ADDR pc
, const char **name
,
372 CORE_ADDR
*address
, CORE_ADDR
*endaddr
)
374 const struct block
*block
;
375 bool status
= find_pc_partial_function (pc
, name
, address
, endaddr
, &block
);
377 if (status
&& block
!= nullptr && !BLOCK_CONTIGUOUS_P (block
))
379 CORE_ADDR entry_pc
= BLOCK_ENTRY_PC (block
);
381 for (int i
= 0; i
< BLOCK_NRANGES (block
); i
++)
383 if (BLOCK_RANGE_START (block
, i
) <= entry_pc
384 && entry_pc
< BLOCK_RANGE_END (block
, i
))
386 if (address
!= nullptr)
387 *address
= BLOCK_RANGE_START (block
, i
);
389 if (endaddr
!= nullptr)
390 *endaddr
= BLOCK_RANGE_END (block
, i
);
396 /* It's an internal error if we exit the above loop without finding
398 internal_error (__FILE__
, __LINE__
,
399 _("Entry block not found in find_function_entry_range_from_pc"));
408 find_function_type (CORE_ADDR pc
)
410 struct symbol
*sym
= find_pc_function (pc
);
412 if (sym
!= NULL
&& BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym
)) == pc
)
413 return SYMBOL_TYPE (sym
);
421 find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr
)
423 struct type
*resolver_type
= find_function_type (resolver_funaddr
);
424 if (resolver_type
!= NULL
)
426 /* Get the return type of the resolver. */
427 struct type
*resolver_ret_type
428 = check_typedef (TYPE_TARGET_TYPE (resolver_type
));
430 /* If we found a pointer to function, then the resolved type
431 is the type of the pointed-to function. */
432 if (resolver_ret_type
->code () == TYPE_CODE_PTR
)
434 struct type
*resolved_type
435 = TYPE_TARGET_TYPE (resolver_ret_type
);
436 if (check_typedef (resolved_type
)->code () == TYPE_CODE_FUNC
)
437 return resolved_type
;
444 /* Return the innermost stack frame that is executing inside of BLOCK and is
445 at least as old as the selected frame. Return NULL if there is no
446 such frame. If BLOCK is NULL, just return NULL. */
449 block_innermost_frame (const struct block
*block
)
451 struct frame_info
*frame
;
456 frame
= get_selected_frame_if_set ();
458 frame
= get_current_frame ();
459 while (frame
!= NULL
)
461 const struct block
*frame_block
= get_frame_block (frame
, NULL
);
462 if (frame_block
!= NULL
&& contained_in (frame_block
, block
))
465 frame
= get_prev_frame (frame
);