X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fblockframe.c;h=4f8fa42dc6bd0508e84d0df96d73f8d5f4e316e4;hb=abb78b78c4184d2ac968362229adae268385a21c;hp=f431b50a787b91a2bd35d244ca70be09491556c3;hpb=88a82a65e0c920f2b543fb1c9eed02b8554b2db2;p=deliverable%2Fbinutils-gdb.git
diff --git a/gdb/blockframe.c b/gdb/blockframe.c
index f431b50a78..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 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,200 +16,27 @@
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"
#include "bfd.h"
-#include "symfile.h"
#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);
-
-/* Is ADDR inside the startup file? Note that if your machine has a
- way to detect the bottom of the stack, there is no need to call
- this function from DEPRECATED_FRAME_CHAIN_VALID; the reason for
- doing so is that some machines have no way of detecting bottom of
- stack.
-
- A PC of zero is always considered to be the bottom of the stack. */
-
-int
-inside_entry_file (CORE_ADDR addr)
-{
- if (addr == 0)
- return 1;
- if (symfile_objfile == 0)
- return 0;
- if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT
- || CALL_DUMMY_LOCATION == AT_SYMBOL)
- {
- /* Do not stop backtracing if the pc is in the call dummy
- at the entry point. */
- /* FIXME: Won't always work with zeros for the last two arguments */
- if (DEPRECATED_PC_IN_CALL_DUMMY (addr, 0, 0))
- return 0;
- }
- return (addr >= symfile_objfile->ei.entry_file_lowpc &&
- addr < symfile_objfile->ei.entry_file_highpc);
-}
-
-/* Test a specified PC value to see if it is in the range of addresses
- that correspond to the main() function. See comments above for why
- we might want to do this.
-
- Typically called from DEPRECATED_FRAME_CHAIN_VALID.
-
- A PC of zero is always considered to be the bottom of the stack. */
-
-int
-inside_main_func (CORE_ADDR pc)
-{
- if (pc == 0)
- return 1;
- if (symfile_objfile == 0)
- return 0;
-
- /* If the addr range is not set up at symbol reading time, set it up
- now. This is for DEPRECATED_FRAME_CHAIN_VALID_ALTERNATE. I do
- this for coff, because it is unable to set it up and symbol
- reading time. */
-
- if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC &&
- symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC)
- {
- struct symbol *mainsym;
-
- mainsym = lookup_symbol (main_name (), NULL, VAR_DOMAIN, NULL, NULL);
- 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. */
- {
- struct minimal_symbol *msymbol
- = lookup_minimal_symbol (main_name (), NULL, symfile_objfile);
- if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text)
- {
- struct obj_section *osect
- = find_pc_sect_section (SYMBOL_VALUE_ADDRESS (msymbol),
- msymbol->ginfo.bfd_section);
- 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) != SYMBOL_VALUE_ADDRESS (msymbol)
- && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
- break;
- }
-
- symfile_objfile->ei.main_func_lowpc = SYMBOL_VALUE_ADDRESS (msymbol);
-
- /* 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 a specified PC value to see if it is in the range of addresses
- that correspond to the process entry point function. See comments
- in objfiles.h for why we might want to do this.
-
- Typically called from DEPRECATED_FRAME_CHAIN_VALID.
-
- A PC of zero is always considered to be the bottom of the stack. */
-
-int
-inside_entry_func (CORE_ADDR pc)
-{
- if (pc == 0)
- return 1;
- if (symfile_objfile == 0)
- return 0;
- if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
- {
- /* Do not stop backtracing if the pc is in the call dummy
- at the entry point. */
- /* FIXME: Won't always work with zeros for the last two arguments */
- if (DEPRECATED_PC_IN_CALL_DUMMY (pc, 0, 0))
- 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 FRAMELESS_FUNCTION_INVOCATION to just call this
- function. */
-
-int
-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;
- /* This is faster, since only care whether there *is* a
- prologue, not how long it is. */
- return PROLOGUE_FRAMELESS_P (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
@@ -226,39 +51,59 @@ 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;
@@ -272,10 +117,15 @@ get_pc_function_start (CORE_ADDR pc)
struct symbol *
get_frame_function (struct frame_info *frame)
{
- register 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);
}
@@ -283,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 sec *section)
+find_pc_sect_function (CORE_ADDR pc, struct obj_section *section)
{
- register 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)
@@ -300,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 sec *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)
@@ -317,31 +204,30 @@ 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. */
-
-int
-find_pc_sect_partial_function (CORE_ADDR pc, asection *section, 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 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 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)
+ section = find_pc_section (pc);
+
mapped_pc = overlay_mapped_address (pc, section);
if (mapped_pc >= cache_pc_function_low
@@ -349,82 +235,94 @@ find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
&& section == cache_pc_function_section)
goto return_cached_value;
- /* If sigtramp is in the u area, it counts as a function (especially
- important for step_1). */
- if (SIGTRAMP_START_P () && PC_IN_SIGTRAMP (mapped_pc, (char *) NULL))
- {
- cache_pc_function_low = SIGTRAMP_START (mapped_pc);
- cache_pc_function_high = SIGTRAMP_END (mapped_pc);
- cache_pc_function_name = "";
- cache_pc_function_section = section;
- 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)
@@ -433,34 +331,16 @@ find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
*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:
@@ -482,7 +362,7 @@ find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
/* 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);
@@ -491,128 +371,111 @@ find_pc_sect_partial_function (CORE_ADDR pc, asection *section, char **name,
*endaddr = cache_pc_function_high;
}
- return 1;
+ if (block != nullptr)
+ *block = cache_pc_function_block;
+
+ return true;
}
-/* Backward compatibility, no section argument. */
+/* See symtab.h. */
-int
-find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
- CORE_ADDR *endaddr)
+bool
+find_function_entry_range_from_pc (CORE_ADDR pc, const char **name,
+ CORE_ADDR *address, CORE_ADDR *endaddr)
{
- asection *section;
-
- section = find_pc_overlay (pc);
- return find_pc_sect_partial_function (pc, section, name, address, endaddr);
-}
+ const struct block *block;
+ bool status = find_pc_partial_function (pc, name, address, endaddr, &block);
-/* Return the innermost stack frame executing inside of BLOCK,
- or NULL if there is no such frame. If BLOCK is NULL, just return NULL. */
+ if (status && block != nullptr && !BLOCK_CONTIGUOUS_P (block))
+ {
+ CORE_ADDR entry_pc = BLOCK_ENTRY_PC (block);
-struct frame_info *
-block_innermost_frame (struct block *block)
-{
- struct frame_info *frame;
- register CORE_ADDR start;
- register CORE_ADDR end;
- CORE_ADDR calling_pc;
+ 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);
- if (block == NULL)
- return NULL;
+ if (endaddr != nullptr)
+ *endaddr = BLOCK_RANGE_END (block, i);
- start = BLOCK_START (block);
- end = BLOCK_END (block);
+ return status;
+ }
+ }
- 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;
+ /* 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. */
-
-/* Is the PC in a call dummy? SP and FRAME_ADDRESS are the bottom and
- top of the stack frame which we are checking, where "bottom" and
- "top" refer to some section of memory which contains the code for
- the call dummy. Calls to this macro assume that the contents of
- SP_REGNUM and DEPRECATED_FP_REGNUM (or the saved values thereof),
- respectively, are the things to pass.
-
- This won't work on the 29k, where SP_REGNUM and
- DEPRECATED_FP_REGNUM don't have that meaning, but the 29k doesn't
- use ON_STACK. This could be fixed by generalizing this scheme,
- perhaps by passing in a frame and adding a few fields, at least on
- machines which need them for DEPRECATED_PC_IN_CALL_DUMMY.
-
- Something simpler, like checking for the stack segment, doesn't work,
- since various programs (threads implementations, gcc nested function
- stubs, etc) may either allocate stack frames in another segment, or
- allocate other kinds of code on the stack. */
-
-int
-deprecated_pc_in_call_dummy_on_stack (CORE_ADDR pc, CORE_ADDR sp,
- CORE_ADDR frame_address)
+/* See symtab.h. */
+
+struct type *
+find_function_type (CORE_ADDR pc)
{
- return (INNER_THAN ((sp), (pc))
- && (frame_address != 0)
- && INNER_THAN ((pc), (frame_address)));
+ struct symbol *sym = find_pc_function (pc);
+
+ if (sym != NULL && BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym)) == pc)
+ return SYMBOL_TYPE (sym);
+
+ return NULL;
}
-int
-deprecated_pc_in_call_dummy_at_entry_point (CORE_ADDR pc, CORE_ADDR sp,
- CORE_ADDR frame_address)
+/* See symtab.h. */
+
+struct type *
+find_gnu_ifunc_target_type (CORE_ADDR resolver_funaddr)
{
- CORE_ADDR addr = entry_point_address ();
- if (DEPRECATED_CALL_DUMMY_ADDRESS_P ())
- addr = DEPRECATED_CALL_DUMMY_ADDRESS ();
- return ((pc) >= addr && (pc) <= (addr + DECR_PC_AFTER_BREAK));
+ 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 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;
}
-/* 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. */
+/* 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. */
-int
-legacy_frame_chain_valid (CORE_ADDR fp, struct frame_info *fi)
+struct frame_info *
+block_innermost_frame (const struct block *block)
{
- /* Don't prune CALL_DUMMY frames. */
- if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES
- && DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (fi), 0, 0))
- return 1;
+ struct frame_info *frame;
- /* 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 (inside_entry_func (get_frame_pc (fi)))
- return 0;
+ 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;
- /* If we're inside the entry file, it isn't valid. */
- /* NOTE/drow 2002-12-25: should there be a way to disable this check? It
- assumes a single small entry file, and the way some debug readers (e.g.
- dbxread) figure out which object is the entry file is somewhat hokey. */
- if (inside_entry_file (frame_pc_unwind (fi)))
- return 0;
+ frame = get_prev_frame (frame);
+ }
- return 1;
+ return NULL;
}