X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fblockframe.c;h=4f8fa42dc6bd0508e84d0df96d73f8d5f4e316e4;hb=57d87c09a33acdce280f4c9ae4f55b885a5cee99;hp=cbe367485bbe432f274f6cfa0139ac3523fdfeef;hpb=30a4a8e027d143cca1ac159277d0652c1ed978e9;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/blockframe.c b/gdb/blockframe.c index cbe367485b..4f8fa42dc6 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -1,15 +1,13 @@ /* Get info from stack frames; convert between frames, blocks, functions and pc values. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright (C) 1986-2020 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -18,9 +16,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "symtab.h" @@ -28,173 +24,19 @@ #include "objfiles.h" #include "frame.h" #include "gdbcore.h" -#include "value.h" /* for read_register */ -#include "target.h" /* for target_has_stack */ -#include "inferior.h" /* for read_pc */ +#include "value.h" +#include "target.h" +#include "inferior.h" #include "annotate.h" #include "regcache.h" -#include "gdb_assert.h" #include "dummy-frame.h" #include "command.h" #include "gdbcmd.h" #include "block.h" +#include "inline-frame.h" -/* Prototypes for exported functions. */ - -void _initialize_blockframe (void); - -/* Test whether PC is in the range of addresses that corresponds to - the "main" function. */ - -int -inside_main_func (CORE_ADDR pc) -{ - struct minimal_symbol *msymbol; - - if (symfile_objfile == 0) - return 0; - - msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile); - - /* If the address range hasn't been set up at symbol reading time, - set it up now. */ - - if (msymbol != NULL - && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC - && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC) - { - /* brobecker/2003-10-10: We used to rely on lookup_symbol() to - search the symbol associated to the "main" function. - Unfortunately, lookup_symbol() uses the current-language - la_lookup_symbol_nonlocal function to do the global symbol - search. Depending on the language, this can introduce - certain side-effects, because certain languages, for instance - Ada, may find more than one match. Therefore we prefer to - search the "main" function symbol using its address rather - than its name. */ - struct symbol *mainsym = - find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol)); - - if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) - { - symfile_objfile->ei.main_func_lowpc = - BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); - symfile_objfile->ei.main_func_highpc = - BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); - } - } - - /* Not in the normal symbol tables, see if "main" is in the partial - symbol table. If it's not, then give up. */ - if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text) - { - CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol); - asection *msect = SYMBOL_BFD_SECTION (msymbol); - struct obj_section *osect = find_pc_sect_section (maddr, msect); - - if (osect != NULL) - { - int i; - - /* Step over other symbols at this same address, and symbols - in other sections, to find the next symbol in this - section with a different address. */ - for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) - { - if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr - && SYMBOL_BFD_SECTION (msymbol + i) == msect) - break; - } - - symfile_objfile->ei.main_func_lowpc = maddr; - - /* Use the lesser of the next minimal symbol in the same - section, or the end of the section, as the end of the - function. */ - if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL - && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr) - symfile_objfile->ei.main_func_highpc = - SYMBOL_VALUE_ADDRESS (msymbol + i); - else - /* We got the start address from the last msymbol in the - objfile. So the end address is the end of the - section. */ - symfile_objfile->ei.main_func_highpc = osect->endaddr; - } - } - - return (symfile_objfile->ei.main_func_lowpc <= pc - && symfile_objfile->ei.main_func_highpc > pc); -} - -/* Test whether THIS_FRAME is inside the process entry point function. */ - -int -inside_entry_func (struct frame_info *this_frame) -{ - return (get_frame_func (this_frame) == entry_point_address ()); -} - -/* Similar to inside_entry_func, but accomodating legacy frame code. */ - -static int -legacy_inside_entry_func (CORE_ADDR pc) -{ - if (symfile_objfile == 0) - return 0; - - if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT) - { - /* Do not stop backtracing if the program counter is in the call - dummy at the entry point. */ - if (deprecated_pc_in_call_dummy (pc)) - return 0; - } - - return (symfile_objfile->ei.entry_func_lowpc <= pc - && symfile_objfile->ei.entry_func_highpc > pc); -} - -/* Return nonzero if the function for this frame lacks a prologue. - Many machines can define DEPRECATED_FRAMELESS_FUNCTION_INVOCATION - to just call this function. */ - -int -legacy_frameless_look_for_prologue (struct frame_info *frame) -{ - CORE_ADDR func_start; - - func_start = get_frame_func (frame); - if (func_start) - { - func_start += FUNCTION_START_OFFSET; - /* NOTE: cagney/2004-02-09: Eliminated per-architecture - PROLOGUE_FRAMELESS_P call as architectures with custom - implementations had all been deleted. Eventually even this - function can go - GDB no longer tries to differentiate - between framed, frameless and stackless functions. They are - all now considered equally evil :-^. */ - /* If skipping the prologue ends up skips nothing, there must be - no prologue and hence no code creating a frame. There for - the function is "frameless" :-/. */ - return func_start == SKIP_PROLOGUE (func_start); - } - else if (get_frame_pc (frame) == 0) - /* A frame with a zero PC is usually created by dereferencing a - NULL function pointer, normally causing an immediate core dump - of the inferior. Mark function as frameless, as the inferior - has no chance of setting up a stack frame. */ - return 1; - else - /* If we can't find the start of the function, we don't really - know whether the function is frameless, but we should be able - to get a reasonable (i.e. best we can do under the - circumstances) backtrace by saying that it isn't. */ - return 0; -} - -/* Return the innermost lexical block in execution - in a specified stack frame. The frame address is assumed valid. +/* Return the innermost lexical block in execution in a specified + stack frame. The frame address is assumed valid. If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code address we used to choose the block. We use this to find a source @@ -209,39 +51,59 @@ legacy_frameless_look_for_prologue (struct frame_info *frame) --- hopefully pointing us at the call instruction, or its delay slot instruction. */ -struct block * +const struct block * get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block) { - const CORE_ADDR pc = get_frame_address_in_block (frame); + CORE_ADDR pc; + const struct block *bl; + int inline_count; + + if (!get_frame_address_in_block_if_available (frame, &pc)) + return NULL; if (addr_in_block) *addr_in_block = pc; - return block_for_pc (pc); + bl = block_for_pc (pc); + if (bl == NULL) + return NULL; + + inline_count = frame_inlined_callees (frame); + + while (inline_count > 0) + { + if (block_inlined_p (bl)) + inline_count--; + + bl = BLOCK_SUPERBLOCK (bl); + gdb_assert (bl != NULL); + } + + return bl; } CORE_ADDR get_pc_function_start (CORE_ADDR pc) { - struct block *bl; - struct minimal_symbol *msymbol; + const struct block *bl; + struct bound_minimal_symbol msymbol; bl = block_for_pc (pc); if (bl) { - struct symbol *symbol = block_function (bl); + struct symbol *symbol = block_linkage_function (bl); if (symbol) { bl = SYMBOL_BLOCK_VALUE (symbol); - return BLOCK_START (bl); + return BLOCK_ENTRY_PC (bl); } } msymbol = lookup_minimal_symbol_by_pc (pc); - if (msymbol) + if (msymbol.minsym) { - CORE_ADDR fstart = SYMBOL_VALUE_ADDRESS (msymbol); + CORE_ADDR fstart = BMSYMBOL_VALUE_ADDRESS (msymbol); if (find_pc_section (fstart)) return fstart; @@ -255,10 +117,15 @@ get_pc_function_start (CORE_ADDR pc) struct symbol * get_frame_function (struct frame_info *frame) { - struct block *bl = get_frame_block (frame, 0); - if (bl == 0) - return 0; - return block_function (bl); + const struct block *bl = get_frame_block (frame, 0); + + if (bl == NULL) + return NULL; + + while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL) + bl = BLOCK_SUPERBLOCK (bl); + + return BLOCK_FUNCTION (bl); } @@ -266,16 +133,18 @@ get_frame_function (struct frame_info *frame) Returns 0 if function is not known. */ struct symbol * -find_pc_sect_function (CORE_ADDR pc, struct bfd_section *section) +find_pc_sect_function (CORE_ADDR pc, struct obj_section *section) { - struct block *b = block_for_pc_sect (pc, section); + const struct block *b = block_for_pc_sect (pc, section); + if (b == 0) return 0; - return block_function (b); + return block_linkage_function (b); } /* Return the function containing pc value PC. - Returns 0 if function is not known. Backward compatibility, no section */ + Returns 0 if function is not known. + Backward compatibility, no section */ struct symbol * find_pc_function (CORE_ADDR pc) @@ -283,15 +152,50 @@ find_pc_function (CORE_ADDR pc) return find_pc_sect_function (pc, find_pc_mapped_section (pc)); } -/* These variables are used to cache the most recent result - * of find_pc_partial_function. */ +/* See symtab.h. */ + +struct symbol * +find_pc_sect_containing_function (CORE_ADDR pc, struct obj_section *section) +{ + const block *bl = block_for_pc_sect (pc, section); + + if (bl == nullptr) + return nullptr; + + return block_containing_function (bl); +} + +/* These variables are used to cache the most recent result of + find_pc_partial_function. + + The addresses cache_pc_function_low and cache_pc_function_high + record the range in which PC was found during the most recent + successful lookup. When the function occupies a single contiguous + address range, these values correspond to the low and high + addresses of the function. (The high address is actually one byte + beyond the last byte of the function.) For a function with more + than one (non-contiguous) range, the range in which PC was found is + used to set the cache bounds. + + When determining whether or not these cached values apply to a + particular PC value, PC must be within the range specified by + cache_pc_function_low and cache_pc_function_high. In addition to + PC being in that range, cache_pc_section must also match PC's + section. See find_pc_partial_function() for details on both the + comparison as well as how PC's section is determined. + + The other values aren't used for determining whether the cache + applies, but are used for setting the outputs from + find_pc_partial_function. cache_pc_function_low and + cache_pc_function_high are used to set outputs as well. */ static CORE_ADDR cache_pc_function_low = 0; static CORE_ADDR cache_pc_function_high = 0; -static char *cache_pc_function_name = 0; -static struct bfd_section *cache_pc_function_section = NULL; +static const char *cache_pc_function_name = 0; +static struct obj_section *cache_pc_function_section = NULL; +static const struct block *cache_pc_function_block = nullptr; -/* Clear cache, e.g. when symbol table is discarded. */ +/* Clear cache, e.g. when symbol table is discarded. */ void clear_pc_function_cache (void) @@ -300,48 +204,29 @@ clear_pc_function_cache (void) cache_pc_function_high = 0; cache_pc_function_name = (char *) 0; cache_pc_function_section = NULL; + cache_pc_function_block = nullptr; } -/* Finds the "function" (text symbol) that is smaller than PC but - greatest of all of the potential text symbols in SECTION. Sets - *NAME and/or *ADDRESS conditionally if that pointer is non-null. - If ENDADDR is non-null, then set *ENDADDR to be the end of the - function (exclusive), but passing ENDADDR as non-null means that - the function might cause symbols to be read. This function either - succeeds or fails (not halfway succeeds). If it succeeds, it sets - *NAME, *ADDRESS, and *ENDADDR to real information and returns 1. - If it fails, it sets *NAME, *ADDRESS, and *ENDADDR to zero and - returns 0. */ - -/* Backward compatibility, no section argument. */ - -int -find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, - CORE_ADDR *endaddr) +/* See symtab.h. */ + +bool +find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address, + CORE_ADDR *endaddr, const struct block **block) { - struct bfd_section *section; - struct partial_symtab *pst; + struct obj_section *section; struct symbol *f; - struct minimal_symbol *msymbol; - struct partial_symbol *psb; - struct obj_section *osect; - int i; + struct bound_minimal_symbol msymbol; + struct compunit_symtab *compunit_symtab = NULL; CORE_ADDR mapped_pc; - /* To ensure that the symbol returned belongs to the correct setion + /* To ensure that the symbol returned belongs to the correct section (and that the last [random] symbol from the previous section isn't returned) try to find the section containing PC. First try the overlay code (which by default returns NULL); and second try the normal section code (which almost always succeeds). */ section = find_pc_overlay (pc); if (section == NULL) - { - struct obj_section *obj_section = find_pc_section (pc); - if (obj_section == NULL) - section = NULL; - else - section = obj_section->the_bfd_section; - } + section = find_pc_section (pc); mapped_pc = overlay_mapped_address (pc, section); @@ -351,70 +236,93 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, goto return_cached_value; msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section); - pst = find_pc_sect_psymtab (mapped_pc, section); - if (pst) + for (objfile *objfile : current_program_space->objfiles ()) { - /* Need to read the symbols to get a good value for the end address. */ - if (endaddr != NULL && !pst->readin) + if (objfile->sf) { - /* Need to get the terminal in case symbol-reading produces - output. */ - target_terminal_ours_for_output (); - PSYMTAB_TO_SYMTAB (pst); + compunit_symtab + = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol, + mapped_pc, + section, + 0); } + if (compunit_symtab != NULL) + break; + } - if (pst->readin) + if (compunit_symtab != NULL) + { + /* Checking whether the msymbol has a larger value is for the + "pathological" case mentioned in stack.c:find_frame_funname. + + We use BLOCK_ENTRY_PC instead of BLOCK_START_PC for this + comparison because the minimal symbol should refer to the + function's entry pc which is not necessarily the lowest + address of the function. This will happen when the function + has more than one range and the entry pc is not within the + lowest range of addresses. */ + f = find_pc_sect_function (mapped_pc, section); + if (f != NULL + && (msymbol.minsym == NULL + || (BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (f)) + >= BMSYMBOL_VALUE_ADDRESS (msymbol)))) { - /* Checking whether the msymbol has a larger value is for the - "pathological" case mentioned in print_frame_info. */ - f = find_pc_sect_function (mapped_pc, section); - if (f != NULL - && (msymbol == NULL - || (BLOCK_START (SYMBOL_BLOCK_VALUE (f)) - >= SYMBOL_VALUE_ADDRESS (msymbol)))) + const struct block *b = SYMBOL_BLOCK_VALUE (f); + + cache_pc_function_name = f->linkage_name (); + cache_pc_function_section = section; + cache_pc_function_block = b; + + /* For blocks occupying contiguous addresses (i.e. no gaps), + the low and high cache addresses are simply the start + and end of the block. + + For blocks with non-contiguous ranges, we have to search + for the range containing mapped_pc and then use the start + and end of that range. + + This causes the returned *ADDRESS and *ENDADDR values to + be limited to the range in which mapped_pc is found. See + comment preceding declaration of find_pc_partial_function + in symtab.h for more information. */ + + if (BLOCK_CONTIGUOUS_P (b)) { - cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f)); - cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f)); - cache_pc_function_name = DEPRECATED_SYMBOL_NAME (f); - cache_pc_function_section = section; - goto return_cached_value; + cache_pc_function_low = BLOCK_START (b); + cache_pc_function_high = BLOCK_END (b); } - } - else - { - /* Now that static symbols go in the minimal symbol table, perhaps - we could just ignore the partial symbols. But at least for now - we use the partial or minimal symbol, whichever is larger. */ - psb = find_pc_sect_psymbol (pst, mapped_pc, section); - - if (psb - && (msymbol == NULL || - (SYMBOL_VALUE_ADDRESS (psb) - >= SYMBOL_VALUE_ADDRESS (msymbol)))) + else { - /* This case isn't being cached currently. */ - if (address) - *address = SYMBOL_VALUE_ADDRESS (psb); - if (name) - *name = DEPRECATED_SYMBOL_NAME (psb); - /* endaddr non-NULL can't happen here. */ - return 1; + int i; + for (i = 0; i < BLOCK_NRANGES (b); i++) + { + if (BLOCK_RANGE_START (b, i) <= mapped_pc + && mapped_pc < BLOCK_RANGE_END (b, i)) + { + cache_pc_function_low = BLOCK_RANGE_START (b, i); + cache_pc_function_high = BLOCK_RANGE_END (b, i); + break; + } + } + /* Above loop should exit via the break. */ + gdb_assert (i < BLOCK_NRANGES (b)); } + + + goto return_cached_value; } } - /* Not in the normal symbol tables, see if the pc is in a known section. - If it's not, then give up. This ensures that anything beyond the end - of the text seg doesn't appear to be part of the last function in the - text segment. */ - - osect = find_pc_sect_section (mapped_pc, section); + /* Not in the normal symbol tables, see if the pc is in a known + section. If it's not, then give up. This ensures that anything + beyond the end of the text seg doesn't appear to be part of the + last function in the text segment. */ - if (!osect) - msymbol = NULL; + if (!section) + msymbol.minsym = NULL; /* Must be in the minimal symbol table. */ - if (msymbol == NULL) + if (msymbol.minsym == NULL) { /* No available symbol. */ if (name != NULL) @@ -423,34 +331,16 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, *address = 0; if (endaddr != NULL) *endaddr = 0; - return 0; + if (block != nullptr) + *block = nullptr; + return false; } - cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol); - cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol); + cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol); + cache_pc_function_name = msymbol.minsym->linkage_name (); cache_pc_function_section = section; - - /* Use the lesser of the next minimal symbol in the same section, or - the end of the section, as the end of the function. */ - - /* Step over other symbols at this same address, and symbols in - other sections, to find the next symbol in this section with - a different address. */ - - for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++) - { - if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol) - && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol)) - break; - } - - if (DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL - && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr) - cache_pc_function_high = SYMBOL_VALUE_ADDRESS (msymbol + i); - else - /* We got the start address from the last msymbol in the objfile. - So the end address is the end of the section. */ - cache_pc_function_high = osect->endaddr; + cache_pc_function_high = minimal_symbol_upper_bound (msymbol); + cache_pc_function_block = nullptr; return_cached_value: @@ -472,7 +362,7 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, /* Because the high address is actually beyond the end of the function (and therefore possibly beyond the end of the overlay), we must actually convert (high - 1) and - then add one to that. */ + then add one to that. */ *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1, section); @@ -481,71 +371,111 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, *endaddr = cache_pc_function_high; } - return 1; + if (block != nullptr) + *block = cache_pc_function_block; + + return true; } -/* Return the innermost stack frame executing inside of BLOCK, - or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */ +/* See symtab.h. */ -struct frame_info * -block_innermost_frame (struct block *block) +bool +find_function_entry_range_from_pc (CORE_ADDR pc, const char **name, + CORE_ADDR *address, CORE_ADDR *endaddr) { - struct frame_info *frame; - CORE_ADDR start; - CORE_ADDR end; - CORE_ADDR calling_pc; + const struct block *block; + bool status = find_pc_partial_function (pc, name, address, endaddr, &block); - if (block == NULL) - return NULL; + if (status && block != nullptr && !BLOCK_CONTIGUOUS_P (block)) + { + CORE_ADDR entry_pc = BLOCK_ENTRY_PC (block); - start = BLOCK_START (block); - end = BLOCK_END (block); + for (int i = 0; i < BLOCK_NRANGES (block); i++) + { + if (BLOCK_RANGE_START (block, i) <= entry_pc + && entry_pc < BLOCK_RANGE_END (block, i)) + { + if (address != nullptr) + *address = BLOCK_RANGE_START (block, i); - frame = NULL; - while (1) - { - frame = get_prev_frame (frame); - if (frame == NULL) - return NULL; - calling_pc = get_frame_address_in_block (frame); - if (calling_pc >= start && calling_pc < end) - return frame; + if (endaddr != nullptr) + *endaddr = BLOCK_RANGE_END (block, i); + + return status; + } + } + + /* It's an internal error if we exit the above loop without finding + the range. */ + internal_error (__FILE__, __LINE__, + _("Entry block not found in find_function_entry_range_from_pc")); } + + return status; } -/* Are we in a call dummy? The code below which allows DECR_PC_AFTER_BREAK - below is for infrun.c, which may give the macro a pc without that - subtracted out. */ +/* See symtab.h. */ + +struct type * +find_function_type (CORE_ADDR pc) +{ + struct symbol *sym = find_pc_function (pc); + + if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc) + return SYMBOL_TYPE (sym); + + return NULL; +} -/* Returns true for a user frame or a call_function_by_hand dummy - frame, and false for the CRT0 start-up frame. Purpose is to - terminate backtrace. */ +/* See symtab.h. */ -int -legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi) +struct type * +find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr) { - /* Don't prune CALL_DUMMY frames. */ - if (deprecated_pc_in_call_dummy (get_frame_pc (fi))) - return 1; + struct type *resolver_type = find_function_type (resolver_funaddr); + if (resolver_type != NULL) + { + /* Get the return type of the resolver. */ + struct type *resolver_ret_type + = check_typedef (TYPE_TARGET_TYPE (resolver_type)); - /* If the new frame pointer is zero, then it isn't valid. */ - if (fp == 0) - return 0; - - /* If the new frame would be inside (younger than) the previous frame, - then it isn't valid. */ - if (INNER_THAN (fp, get_frame_base (fi))) - return 0; - - /* If the architecture has a custom DEPRECATED_FRAME_CHAIN_VALID, - call it now. */ - if (DEPRECATED_FRAME_CHAIN_VALID_P ()) - return DEPRECATED_FRAME_CHAIN_VALID (fp, fi); - - /* If we're already inside the entry function for the main objfile, then it - isn't valid. */ - if (legacy_inside_entry_func (get_frame_pc (fi))) - return 0; + /* If we found a pointer to function, then the resolved type + is the type of the pointed-to function. */ + if (TYPE_CODE (resolver_ret_type) == TYPE_CODE_PTR) + { + struct type *resolved_type + = TYPE_TARGET_TYPE (resolver_ret_type); + if (TYPE_CODE (check_typedef (resolved_type)) == TYPE_CODE_FUNC) + return resolved_type; + } + } + + return NULL; +} + +/* Return the innermost stack frame that is executing inside of BLOCK and is + at least as old as the selected frame. Return NULL if there is no + such frame. If BLOCK is NULL, just return NULL. */ + +struct frame_info * +block_innermost_frame (const struct block *block) +{ + struct frame_info *frame; + + if (block == NULL) + return NULL; + + frame = get_selected_frame_if_set (); + if (frame == NULL) + frame = get_current_frame (); + while (frame != NULL) + { + const struct block *frame_block = get_frame_block (frame, NULL); + if (frame_block != NULL && contained_in (frame_block, block)) + return frame; + + frame = get_prev_frame (frame); + } - return 1; + return NULL; }