X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fblock.h;h=ca143a96d205894908cb9e69b522d9a4cdfd0702;hb=2117c711ae07700adb57ea5b5ca61e4c32d7e3d2;hp=a36821305ca5f99a55edc4c7cdb346a7e9050749;hpb=887432a5a562b3c5b743a4e9ef26f95f9ca772f7;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/block.h b/gdb/block.h index a36821305c..ca143a96d2 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,7 +29,7 @@ struct symtab; struct block_namespace_info; struct using_direct; struct obstack; -struct dictionary; +struct addrmap; /* All of the name-scope contours of the program are represented by `struct block' objects. @@ -66,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; @@ -97,62 +97,69 @@ struct block cplus_specific; } language_specific; +}; + +/* The global block is singled out so that we can provide a back-link + to the primary symtab. */ + +struct global_block +{ + /* The block. */ - /* 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. + struct block block; - If there is no function corresponding to this block, this meaning - of this flag is undefined. */ + /* This holds a pointer to the primary symtab holding this + block. */ - unsigned char gcc_compile_flag; + 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 -/* 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 dict_iterator. SYM points to the current symbol. */ - -#define ALL_BLOCK_SYMBOLS(block, iter, sym) \ - ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym) - 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) -/* Special block numbers */ +extern struct symbol *block_linkage_function (const struct block *); -enum { GLOBAL_BLOCK = 0, STATIC_BLOCK = 1, FIRST_LOCAL_BLOCK = 2 }; +extern struct symbol *block_containing_function (const struct block *); -extern struct symbol *block_function (const struct block *); +extern int block_inlined_p (const struct block *block); extern int contained_in (const struct block *, const struct block *); -extern struct blockvector *blockvector_for_pc (CORE_ADDR, int *); +extern struct blockvector *blockvector_for_pc (CORE_ADDR, struct block **); + +extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, + struct obj_section *, + struct block **, + struct symtab *); -extern struct blockvector *blockvector_for_pc_sect (CORE_ADDR, asection *, - int *, struct symtab *); +extern int blockvector_contains_pc (struct blockvector *bv, CORE_ADDR pc); + +extern struct call_site *call_site_for_pc (struct gdbarch *gdbarch, + CORE_ADDR pc); extern struct block *block_for_pc (CORE_ADDR); -extern struct block *block_for_pc_sect (CORE_ADDR, asection *); +extern struct block *block_for_pc_sect (CORE_ADDR, struct obj_section *); extern const char *block_scope (const struct block *block); @@ -171,4 +178,105 @@ 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 */