/* Get info from stack frames; convert between frames, blocks,
functions and pc values.
- Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009
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,
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., 51 Franklin Street, Fifth Floor,
- Boston, MA 02110-1301, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "symtab.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"
bl = block_for_pc (pc);
if (bl)
{
- struct symbol *symbol = block_function (bl);
+ struct symbol *symbol = block_linkage_function (bl);
if (symbol)
{
struct block *bl = get_frame_block (frame, 0);
if (bl == 0)
return 0;
- return block_function (bl);
+ return block_linkage_function (bl);
}
\f
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);
if (b == 0)
return 0;
- return block_function (b);
+ return block_linkage_function (b);
}
/* Return the function containing pc value PC.
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 struct obj_section *cache_pc_function_section = NULL;
/* Clear cache, e.g. when symbol table is discarded. */
find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
CORE_ADDR *endaddr)
{
- struct bfd_section *section;
+ struct obj_section *section;
struct partial_symtab *pst;
struct symbol *f;
struct minimal_symbol *msymbol;
struct partial_symbol *psb;
- struct obj_section *osect;
int i;
CORE_ADDR mapped_pc;
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);
{
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_name = SYMBOL_LINKAGE_NAME (f);
cache_pc_function_section = section;
goto return_cached_value;
}
if (address)
*address = SYMBOL_VALUE_ADDRESS (psb);
if (name)
- *name = DEPRECATED_SYMBOL_NAME (psb);
+ *name = SYMBOL_LINKAGE_NAME (psb);
/* endaddr non-NULL can't happen here. */
return 1;
}
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);
-
- if (!osect)
+ if (!section)
msymbol = NULL;
/* Must be in the minimal symbol table. */
}
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
- cache_pc_function_name = DEPRECATED_SYMBOL_NAME (msymbol);
+ cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
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. */
+ /* If the minimal symbol has a size, use it for the cache.
+ Otherwise use the lesser of the next minimal symbol in the same
+ section, or the end of the section, as the end of the
+ function. */
- for (i = 1; DEPRECATED_SYMBOL_NAME (msymbol + i) != NULL; i++)
+ if (MSYMBOL_SIZE (msymbol) != 0)
+ cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
+ else
{
- if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
- && SYMBOL_BFD_SECTION (msymbol + i) == SYMBOL_BFD_SECTION (msymbol))
- break;
- }
+ /* 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. */
- 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;
+ for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++)
+ {
+ if (SYMBOL_VALUE_ADDRESS (msymbol + i) != SYMBOL_VALUE_ADDRESS (msymbol)
+ && SYMBOL_OBJ_SECTION (msymbol + i) == SYMBOL_OBJ_SECTION (msymbol))
+ break;
+ }
+
+ if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL
+ && SYMBOL_VALUE_ADDRESS (msymbol + i) < obj_section_endaddr (section))
+ 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 = obj_section_endaddr (section);
+ }
return_cached_value:
start = BLOCK_START (block);
end = BLOCK_END (block);
- frame = NULL;
- while (1)
+ frame = get_current_frame ();
+ while (frame != NULL)
{
- 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;
+
+ frame = get_prev_frame (frame);
}
+
+ return NULL;
}