X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fblock.h;h=0e5d0bed68b2126d8bc982a8731327f8188bb26a;hb=bd30b2c856c9ae1fc3559d80fc8c8ccdf65e5fce;hp=17c726dc17f954e7ef1e0897de9eae98d2d117a9;hpb=89a9d1b1639d01840668fbc6937f79c433fad24b;p=platform%2Fupstream%2Fbinutils.git diff --git a/gdb/block.h b/gdb/block.h index 17c726d..0e5d0be 100644 --- a/gdb/block.h +++ b/gdb/block.h @@ -1,12 +1,12 @@ /* Code dealing with blocks for GDB. - Copyright 2003 Free Software Foundation, Inc. + Copyright (C) 2003-2014 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, @@ -15,13 +15,13 @@ 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 . */ #ifndef BLOCK_H #define BLOCK_H +#include "dictionary.h" + /* Opaque declarations. */ struct symbol; @@ -29,6 +29,7 @@ struct symtab; struct block_namespace_info; struct using_direct; struct obstack; +struct addrmap; /* All of the name-scope contours of the program are represented by `struct block' objects. @@ -65,7 +66,7 @@ struct block CORE_ADDR endaddr; /* The symbol that names this block, if the block is the body of a - function; otherwise, zero. */ + function (real or inlined); otherwise, zero. */ struct symbol *function; @@ -77,6 +78,10 @@ struct block struct block *superblock; + /* This is used to store the symbols in the block. */ + + struct dictionary *dict; + /* Used for language-specific info. */ union @@ -92,121 +97,187 @@ struct block cplus_specific; } language_specific; +}; - /* Version of GCC used to compile the function corresponding - to this block, or 0 if not compiled with GCC. When possible, - GCC should be compatible with the native compiler, or if that - is not feasible, the differences should be fixed during symbol - reading. As of 16 Apr 93, this flag is never used to distinguish - between gcc2 and the native compiler. - - If there is no function corresponding to this block, this meaning - of this flag is undefined. */ - - unsigned char gcc_compile_flag; - - /* The symbols for this block are either in a simple linear list or - in a simple hashtable. Blocks which correspond to a function - (which have a list of symbols corresponding to arguments) use - a linear list, as do some older symbol readers (currently only - mdebugread and dstread). Other blocks are hashed. - - The hashtable uses the same hash function as the minsym hashtables, - found in minsyms.c:minsym_hash_iw. Symbols are hashed based on - their demangled name if appropriate, and on their name otherwise. - The hash function ignores space, and stops at the beginning of the - argument list if any. - - The table is laid out in NSYMS/5 buckets and symbols are chained via - their hash_next field. */ - - /* If this is really a hashtable of the symbols, this flag is 1. */ - - unsigned char hashtable; +/* The global block is singled out so that we can provide a back-link + to the primary symtab. */ - /* Number of local symbols. */ +struct global_block +{ + /* The block. */ - int nsyms; + struct block block; - /* The symbols. If some of them are arguments, then they must be - in the order in which we would like to print them. */ + /* This holds a pointer to the primary symtab holding this + block. */ - struct symbol *sym[1]; + struct symtab *symtab; }; #define BLOCK_START(bl) (bl)->startaddr #define BLOCK_END(bl) (bl)->endaddr #define BLOCK_FUNCTION(bl) (bl)->function #define BLOCK_SUPERBLOCK(bl) (bl)->superblock -#define BLOCK_GCC_COMPILED(bl) (bl)->gcc_compile_flag +#define BLOCK_DICT(bl) (bl)->dict #define BLOCK_NAMESPACE(bl) (bl)->language_specific.cplus_specific.namespace -#define BLOCK_HASHTABLE(bl) (bl)->hashtable - -/* For blocks without a hashtable (BLOCK_HASHTABLE (bl) == 0) only. */ -#define BLOCK_NSYMS(bl) (bl)->nsyms -#define BLOCK_SYM(bl, n) (bl)->sym[n] - -/* For blocks with a hashtable, but these are valid for non-hashed blocks as - well - each symbol will appear to be one bucket by itself. */ -#define BLOCK_BUCKETS(bl) (bl)->nsyms -#define BLOCK_BUCKET(bl, n) (bl)->sym[n] - -/* Macro used to set the size of a hashtable for N symbols. */ -#define BLOCK_HASHTABLE_SIZE(n) ((n)/5 + 1) - -/* Macro to loop through all symbols in a block BL, in no particular order. - i counts which bucket we are in, and sym points to the current symbol. */ - -#define ALL_BLOCK_SYMBOLS(bl, i, sym) \ - for ((i) = 0; (i) < BLOCK_BUCKETS ((bl)); (i)++) \ - for ((sym) = BLOCK_BUCKET ((bl), (i)); (sym); \ - (sym) = (sym)->hash_next) - -/* Nonzero if symbols of block BL should be sorted alphabetically. - Don't sort a block which corresponds to a function. If we did the - sorting would have to preserve the order of the symbols for the - arguments. Also don't sort any block that we chose to hash. */ - -#define BLOCK_SHOULD_SORT(bl) (! BLOCK_HASHTABLE (bl) \ - && BLOCK_FUNCTION (bl) == NULL) struct blockvector { /* Number of blocks in the list. */ int nblocks; + /* An address map mapping addresses to blocks in this blockvector. + This pointer is zero if the blocks' start and end addresses are + enough. */ + struct addrmap *map; /* The blocks themselves. */ struct block *block[1]; }; #define BLOCKVECTOR_NBLOCKS(blocklist) (blocklist)->nblocks #define BLOCKVECTOR_BLOCK(blocklist,n) (blocklist)->block[n] +#define BLOCKVECTOR_MAP(blocklist) ((blocklist)->map) + +extern struct symbol *block_linkage_function (const struct block *); + +extern struct symbol *block_containing_function (const struct block *); -/* Special block numbers */ +extern int block_inlined_p (const struct block *block); -#define GLOBAL_BLOCK 0 -#define STATIC_BLOCK 1 -#define FIRST_LOCAL_BLOCK 2 +extern int contained_in (const struct block *, const struct block *); -extern struct symbol *block_function (struct block *); +extern const struct blockvector *blockvector_for_pc (CORE_ADDR, + const struct block **); -extern int contained_in (struct block *, struct block *); +extern const struct blockvector *blockvector_for_pc_sect (CORE_ADDR, + struct obj_section *, + const struct block **, + struct symtab *); -extern struct blockvector *blockvector_for_pc (CORE_ADDR, int *); +extern int blockvector_contains_pc (const struct blockvector *bv, CORE_ADDR pc); -extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, asection *, - int *, struct symtab *); +extern struct call_site *call_site_for_pc (struct gdbarch *gdbarch, + CORE_ADDR pc); -extern struct block *block_for_pc (CORE_ADDR); +extern const struct block *block_for_pc (CORE_ADDR); -extern struct block *block_for_pc_sect (CORE_ADDR, asection *); +extern const struct block *block_for_pc_sect (CORE_ADDR, struct obj_section *); + +extern const char *block_scope (const struct block *block); extern void block_set_scope (struct block *block, const char *scope, struct obstack *obstack); +extern struct using_direct *block_using (const struct block *block); + extern void block_set_using (struct block *block, struct using_direct *using, struct obstack *obstack); extern const struct block *block_static_block (const struct block *block); +extern const struct block *block_global_block (const struct block *block); + +extern struct block *allocate_block (struct obstack *obstack); + +extern struct block *allocate_global_block (struct obstack *obstack); + +extern void set_block_symtab (struct block *, struct symtab *); + +/* A block iterator. This structure should be treated as though it + were opaque; it is only defined here because we want to support + stack allocation of iterators. */ + +struct block_iterator +{ + /* If we're iterating over a single block, this holds the block. + Otherwise, it holds the canonical symtab. */ + + union + { + struct symtab *symtab; + const struct block *block; + } d; + + /* If we're iterating over a single block, this is always -1. + Otherwise, it holds the index of the current "included" symtab in + the canonical symtab (that is, d.symtab->includes[idx]), with -1 + meaning the canonical symtab itself. */ + + int idx; + + /* Which block, either static or global, to iterate over. If this + is FIRST_LOCAL_BLOCK, then we are iterating over a single block. + This is used to select which field of 'd' is in use. */ + + enum block_enum which; + + /* The underlying dictionary iterator. */ + + struct dict_iterator dict_iter; +}; + +/* Initialize ITERATOR to point at the first symbol in BLOCK, and + return that first symbol, or NULL if BLOCK is empty. */ + +extern struct symbol *block_iterator_first (const struct block *block, + struct block_iterator *iterator); + +/* Advance ITERATOR, and return the next symbol, or NULL if there are + no more symbols. Don't call this if you've previously received + NULL from block_iterator_first or block_iterator_next on this + iteration. */ + +extern struct symbol *block_iterator_next (struct block_iterator *iterator); + +/* Initialize ITERATOR to point at the first symbol in BLOCK whose + SYMBOL_SEARCH_NAME is NAME (as tested using strcmp_iw), and return + that first symbol, or NULL if there are no such symbols. */ + +extern struct symbol *block_iter_name_first (const struct block *block, + const char *name, + struct block_iterator *iterator); + +/* Advance ITERATOR to point at the next symbol in BLOCK whose + SYMBOL_SEARCH_NAME is NAME (as tested using strcmp_iw), or NULL if + there are no more such symbols. Don't call this if you've + previously received NULL from block_iterator_first or + block_iterator_next on this iteration. And don't call it unless + ITERATOR was created by a previous call to block_iter_name_first + with the same NAME. */ + +extern struct symbol *block_iter_name_next (const char *name, + struct block_iterator *iterator); + +/* Initialize ITERATOR to point at the first symbol in BLOCK whose + SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use + the same conventions as strcmp_iw and be compatible with any + block hashing function), and return that first symbol, or NULL + if there are no such symbols. */ + +extern struct symbol *block_iter_match_first (const struct block *block, + const char *name, + symbol_compare_ftype *compare, + struct block_iterator *iterator); + +/* Advance ITERATOR to point at the next symbol in BLOCK whose + SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see + block_iter_match_first), or NULL if there are no more such symbols. + Don't call this if you've previously received NULL from + block_iterator_match_first or block_iterator_match_next on this + iteration. And don't call it unless ITERATOR was created by a + previous call to block_iter_match_first with the same NAME and COMPARE. */ + +extern struct symbol *block_iter_match_next (const char *name, + symbol_compare_ftype *compare, + struct block_iterator *iterator); + +/* Macro to loop through all symbols in a block BL, in no particular + order. ITER helps keep track of the iteration, and should be a + struct block_iterator. SYM points to the current symbol. */ + +#define ALL_BLOCK_SYMBOLS(block, iter, sym) \ + for ((sym) = block_iterator_first ((block), &(iter)); \ + (sym); \ + (sym) = block_iterator_next (&(iter))) + #endif /* BLOCK_H */