X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fblockframe.c;h=e395df46b9876251dce5a54dd77db308892355dc;hb=32b40af94e919e235c21486110311647cbeecf2e;hp=3b546a7875e93c10f4ed7d85ae1124e04dcaf5f4;hpb=11c8145561ebaf02170cf601bcd9b393cdb82916;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/blockframe.c b/gdb/blockframe.c index 3b546a7875..e395df46b9 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -1,9 +1,7 @@ /* 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-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -31,13 +29,11 @@ #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. @@ -55,11 +51,11 @@ --- 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)) @@ -89,8 +85,8 @@ get_frame_block (struct frame_info *frame, CORE_ADDR *addr_in_block) 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) @@ -105,9 +101,9 @@ get_pc_function_start (CORE_ADDR pc) } 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; @@ -121,7 +117,7 @@ get_pc_function_start (CORE_ADDR pc) 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; @@ -139,7 +135,7 @@ get_frame_function (struct frame_info *frame) 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; @@ -161,7 +157,7 @@ find_pc_function (CORE_ADDR 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 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; @@ -192,14 +188,14 @@ clear_pc_function_cache (void) /* 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; @@ -224,21 +220,25 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name, 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)); @@ -255,10 +255,10 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name, 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) @@ -272,42 +272,12 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name, 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: @@ -348,32 +318,30 @@ find_pc_partial_function_gnu_ifunc (CORE_ADDR pc, char **name, 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); + const struct block *frame_block = get_frame_block (frame, NULL); if (frame_block != NULL && contained_in (frame_block, block)) return frame;