/* 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-2013 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.
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;
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;
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 = SYMBOL_VALUE_ADDRESS (msymbol.minsym);
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;
/* Clear cache, e.g. when symbol table is discarded. */
cache_pc_function_high = 0;
cache_pc_function_name = (char *) 0;
cache_pc_function_section = NULL;
+ cache_pc_function_is_gnu_ifunc = 0;
}
/* Finds the "function" (text symbol) that is smaller than PC but
*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. */
+ the function might cause symbols to be read. If IS_GNU_IFUNC_P is provided
+ *IS_GNU_IFUNC_P is set to 1 on return if the function is STT_GNU_IFUNC.
+ 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, *ENDADDR and
+ *IS_GNU_IFUNC_P 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)
+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;
&& section == cache_pc_function_section)
goto return_cached_value;
- msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section);
+ msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section).minsym;
ALL_OBJFILES (objfile)
{
if (objfile->sf)
cache_pc_function_high = BLOCK_END (SYMBOL_BLOCK_VALUE (f));
cache_pc_function_name = SYMBOL_LINKAGE_NAME (f);
cache_pc_function_section = section;
+ cache_pc_function_is_gnu_ifunc = TYPE_GNU_IFUNC (SYMBOL_TYPE (f));
goto return_cached_value;
}
}
*address = 0;
if (endaddr != NULL)
*endaddr = 0;
+ if (is_gnu_ifunc_p != NULL)
+ *is_gnu_ifunc_p = 0;
return 0;
}
cache_pc_function_low = SYMBOL_VALUE_ADDRESS (msymbol);
cache_pc_function_name = SYMBOL_LINKAGE_NAME (msymbol);
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
{
if (SYMBOL_VALUE_ADDRESS (msymbol + i)
!= SYMBOL_VALUE_ADDRESS (msymbol)
- && SYMBOL_OBJ_SECTION (msymbol + i)
- == SYMBOL_OBJ_SECTION (msymbol))
+ && SYMBOL_SECTION (msymbol + i)
+ == SYMBOL_SECTION (msymbol))
break;
}
*endaddr = cache_pc_function_high;
}
+ if (is_gnu_ifunc_p)
+ *is_gnu_ifunc_p = cache_pc_function_is_gnu_ifunc;
+
return 1;
}
-/* 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 find_pc_partial_function_gnu_ifunc, only the IS_GNU_IFUNC_P parameter
+ is omitted here for backward API compatibility. */
+
+int
+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 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);