X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fblockframe.c;h=ba755a1a7091915c6af8f483e17ca343bf85fdda;hb=533eaa5e3f1b445bb7359636932d257e077b7fb9;hp=d752c8dd27fc3dd53aba4724c2865bc0f6aac6e8;hpb=c8cd9f6c4cdd895e65e4feb4b2402a2dfdbc3822;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/blockframe.c b/gdb/blockframe.c index d752c8dd27..ba755a1a70 100644 --- a/gdb/blockframe.c +++ b/gdb/blockframe.c @@ -1,15 +1,13 @@ /* Get info from stack frames; convert between frames, blocks, functions and pc values. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 - Free Software Foundation, Inc. + Copyright (C) 1986-2004, 2007-2012 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, @@ -18,9 +16,7 @@ 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., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "symtab.h" @@ -28,9 +24,9 @@ #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" @@ -38,21 +34,11 @@ #include "command.h" #include "gdbcmd.h" #include "block.h" +#include "inline-frame.h" +#include "psymtab.h" -/* Prototypes for exported functions. */ - -void _initialize_blockframe (void); - -/* Test whether THIS_FRAME is inside the process entry point function. */ - -int -inside_entry_func (struct frame_info *this_frame) -{ - return (get_frame_func (this_frame) == entry_point_address ()); -} - -/* Return the innermost lexical block in execution - in a specified stack frame. The frame address is assumed valid. +/* Return the innermost lexical block in execution in a specified + stack frame. The frame address is assumed valid. If ADDR_IN_BLOCK is non-zero, set *ADDR_IN_BLOCK to the exact code address we used to choose the block. We use this to find a source @@ -70,12 +56,32 @@ inside_entry_func (struct frame_info *this_frame) 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; - return block_for_pc (pc); + bl = block_for_pc (pc); + if (bl == NULL) + return NULL; + + inline_count = frame_inlined_callees (frame); + + while (inline_count > 0) + { + if (block_inlined_p (bl)) + inline_count--; + + bl = BLOCK_SUPERBLOCK (bl); + gdb_assert (bl != NULL); + } + + return bl; } CORE_ADDR @@ -87,7 +93,7 @@ get_pc_function_start (CORE_ADDR pc) bl = block_for_pc (pc); if (bl) { - struct symbol *symbol = block_function (bl); + struct symbol *symbol = block_linkage_function (bl); if (symbol) { @@ -114,9 +120,14 @@ struct symbol * get_frame_function (struct frame_info *frame) { struct block *bl = get_frame_block (frame, 0); - if (bl == 0) - return 0; - return block_function (bl); + + if (bl == NULL) + return NULL; + + while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL) + bl = BLOCK_SUPERBLOCK (bl); + + return BLOCK_FUNCTION (bl); } @@ -124,16 +135,18 @@ get_frame_function (struct frame_info *frame) 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. - Returns 0 if function is not known. Backward compatibility, no section */ + Returns 0 if function is not known. + Backward compatibility, no section */ struct symbol * find_pc_function (CORE_ADDR pc) @@ -142,14 +155,15 @@ find_pc_function (CORE_ADDR pc) } /* These variables are used to cache the most recent result - * of find_pc_partial_function. */ + of find_pc_partial_function. */ 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 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. */ +/* Clear cache, e.g. when symbol table is discarded. */ void clear_pc_function_cache (void) @@ -158,6 +172,7 @@ clear_pc_function_cache (void) 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 @@ -165,24 +180,25 @@ clear_pc_function_cache (void) *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 bfd_section *section; - struct partial_symtab *pst; + struct obj_section *section; struct symbol *f; struct minimal_symbol *msymbol; - struct partial_symbol *psb; - struct obj_section *osect; + struct symtab *symtab = NULL; + struct objfile *objfile; int i; CORE_ADDR mapped_pc; @@ -193,13 +209,7 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, 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); @@ -209,66 +219,40 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, goto return_cached_value; msymbol = lookup_minimal_symbol_by_pc_section (mapped_pc, section); - pst = find_pc_sect_psymtab (mapped_pc, section); - if (pst) + ALL_OBJFILES (objfile) + { + if (objfile->sf) + symtab = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol, + mapped_pc, section, 0); + if (symtab) + break; + } + + if (symtab) { - /* Need to read the symbols to get a good value for the end address. */ - if (endaddr != NULL && !pst->readin) + /* 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 + || (BLOCK_START (SYMBOL_BLOCK_VALUE (f)) + >= SYMBOL_VALUE_ADDRESS (msymbol)))) { - /* Need to get the terminal in case symbol-reading produces - output. */ - target_terminal_ours_for_output (); - PSYMTAB_TO_SYMTAB (pst); - } - - if (pst->readin) - { - /* 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 - || (BLOCK_START (SYMBOL_BLOCK_VALUE (f)) - >= SYMBOL_VALUE_ADDRESS (msymbol)))) - { - 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_section = section; - goto return_cached_value; - } - } - else - { - /* Now that static symbols go in the minimal symbol table, perhaps - we could just ignore the partial symbols. But at least for now - we use the partial or minimal symbol, whichever is larger. */ - psb = find_pc_sect_psymbol (pst, mapped_pc, section); - - if (psb - && (msymbol == NULL || - (SYMBOL_VALUE_ADDRESS (psb) - >= SYMBOL_VALUE_ADDRESS (msymbol)))) - { - /* This case isn't being cached currently. */ - if (address) - *address = SYMBOL_VALUE_ADDRESS (psb); - if (name) - *name = DEPRECATED_SYMBOL_NAME (psb); - /* endaddr non-NULL can't happen here. */ - return 1; - } + cache_pc_function_low = BLOCK_START (SYMBOL_BLOCK_VALUE (f)); + 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; } } - /* Not in the normal symbol tables, see if the pc is in a known section. - If it's not, then give up. This ensures that anything beyond the end - 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); + /* Not in the normal symbol tables, see if the pc is in a known + section. If it's not, then give up. This ensures that anything + beyond the end of the text seg doesn't appear to be part of the + last function in the text segment. */ - if (!osect) + if (!section) msymbol = NULL; /* Must be in the minimal symbol table. */ @@ -281,34 +265,47 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, *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 = DEPRECATED_SYMBOL_NAME (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; - /* 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 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. */ - /* 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; 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: @@ -330,7 +327,7 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, /* Because the high address is actually beyond the end of the function (and therefore possibly beyond the end of the overlay), we must actually convert (high - 1) and - then add one to that. */ + then add one to that. */ *endaddr = 1 + overlay_unmapped_address (cache_pc_function_high - 1, section); @@ -339,19 +336,32 @@ find_pc_partial_function (CORE_ADDR pc, char **name, CORE_ADDR *address, *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; - CORE_ADDR calling_pc; if (block == NULL) return NULL; @@ -359,14 +369,17 @@ block_innermost_frame (struct block *block) start = BLOCK_START (block); end = BLOCK_END (block); - frame = NULL; - while (1) + frame = get_selected_frame_if_set (); + if (frame == NULL) + 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) + struct block *frame_block = get_frame_block (frame, NULL); + if (frame_block != NULL && contained_in (frame_block, block)) return frame; + + frame = get_prev_frame (frame); } + + return NULL; }