/* Get info from stack frames; convert between frames, blocks,
functions and pc values.
- Copyright (C) 1986-2004, 2007-2012 Free Software Foundation, Inc.
+ Copyright (C) 1986-2016 Free Software Foundation, Inc.
This file is part of GDB.
#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"
-#include "psymtab.h"
/* Return the innermost lexical block in execution in a specified
stack frame. The frame address is assumed valid.
--- 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)
{
CORE_ADDR pc;
- struct block *bl;
+ const struct block *bl;
int inline_count;
if (!get_frame_address_in_block_if_available (frame, &pc))
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)
}
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;
struct symbol *
get_frame_function (struct frame_info *frame)
{
- struct block *bl = get_frame_block (frame, 0);
+ const struct block *bl = get_frame_block (frame, 0);
if (bl == NULL)
return NULL;
struct symbol *
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;
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 symtab *symtab = NULL;
+ struct bound_minimal_symbol msymbol;
+ struct compunit_symtab *compunit_symtab = NULL;
struct objfile *objfile;
- int i;
CORE_ADDR mapped_pc;
/* To ensure that the symbol returned belongs to the correct setion
ALL_OBJFILES (objfile)
{
if (objfile->sf)
- symtab = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
- mapped_pc, section, 0);
- if (symtab)
+ {
+ compunit_symtab
+ = objfile->sf->qf->find_pc_sect_compunit_symtab (objfile, msymbol,
+ mapped_pc, section,
+ 0);
+ }
+ if (compunit_symtab != NULL)
break;
}
- if (symtab)
+ if (compunit_symtab != NULL)
{
/* 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
+ && (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);
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_selected_frame_if_set ();
if (frame == NULL)
frame = get_current_frame ();
while (frame != NULL)
{
- struct block *frame_block = get_frame_block (frame, NULL);
+ const struct block *frame_block = get_frame_block (frame, NULL);
if (frame_block != NULL && contained_in (frame_block, block))
return frame;
projects / deliverable / binutils-gdb.git / blobdiff