/* 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, 2007, 2008, 2009,
- 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1986-2014 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "block.h"
#include "inline-frame.h"
-#include "psymtab.h"
/* Return the innermost lexical block in execution in a specified
stack frame. The frame address is assumed valid.
get_pc_function_start (CORE_ADDR pc)
{
struct block *bl;
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
bl = block_for_pc (pc);
if (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;
static CORE_ADDR cache_pc_function_low = 0;
static CORE_ADDR cache_pc_function_high = 0;
-static char *cache_pc_function_name = 0;
+static const char *cache_pc_function_name = 0;
static struct obj_section *cache_pc_function_section = NULL;
static int cache_pc_function_is_gnu_ifunc = 0;
/* Backward compatibility, no section argument. */
int
-find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name,
+find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, const char **name,
CORE_ADDR *address, CORE_ADDR *endaddr,
int *is_gnu_ifunc_p)
{
struct obj_section *section;
struct symbol *f;
- struct minimal_symbol *msymbol;
+ struct bound_minimal_symbol msymbol;
struct symtab *symtab = NULL;
struct objfile *objfile;
int i;
"pathological" case mentioned in print_frame_info. */
f = find_pc_sect_function (mapped_pc, section);
if (f != NULL
- && (msymbol == NULL
+ && (msymbol.minsym == NULL
|| (BLOCK_START (SYMBOL_BLOCK_VALUE (f))
- >= SYMBOL_VALUE_ADDRESS (msymbol))))
+ >= BMSYMBOL_VALUE_ADDRESS (msymbol))))
{
cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
last function in the text segment. */
if (!section)
- msymbol = NULL;
+ msymbol.minsym = NULL;
/* Must be in the minimal symbol table. */
- if (msymbol == NULL)
+ if (msymbol.minsym == NULL)
{
/* No available symbol. */
if (name != NULL)
return 0;
}
- cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
- cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
+ cache_pc_function_low = BMSYMBOL_VALUE_ADDRESS (msymbol);
+ cache_pc_function_name = MSYMBOL_LINKAGE_NAME (msymbol.minsym);
cache_pc_function_section = section;
- cache_pc_function_is_gnu_ifunc = MSYMBOL_TYPE (msymbol) == mst_text_gnu_ifunc;
-
- /* 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. */
-
- if (MSYMBOL_SIZE (msymbol) != 0)
- cache_pc_function_high = cache_pc_function_low + MSYMBOL_SIZE (msymbol);
- else
- {
- /* 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_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);
- }
+ cache_pc_function_is_gnu_ifunc = (MSYMBOL_TYPE (msymbol.minsym)
+ == mst_text_gnu_ifunc);
+ cache_pc_function_high = minimal_symbol_upper_bound (msymbol);
return_cached_value:
is omitted here for backward API compatibility. */
int
-find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address,
+find_pc_partial_function (CORE_ADDR pc, const char **name, CORE_ADDR *address,
CORE_ADDR *endaddr)
{
return find_pc_partial_function_gnu_ifunc (pc, name, address, endaddr, NULL);
}
-/* Return the innermost stack frame executing inside of BLOCK, or NULL
- if there is no such frame. If BLOCK is NULL, just 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 (struct block *block)
+block_innermost_frame (const struct block *block)
{
struct frame_info *frame;
- CORE_ADDR start;
- CORE_ADDR end;
if (block == NULL)
return NULL;
- start = BLOCK_START (block);
- end = BLOCK_END (block);
-
- frame = get_current_frame ();
+ frame = get_selected_frame_if_set ();
+ if (frame == NULL)
+ frame = get_current_frame ();
while (frame != NULL)
{
struct block *frame_block = get_frame_block (frame, NULL);
projects / binutils-gdb.git / blobdiff