+2019-01-10 Keith Seitz <keiths@redhat.com>
+
+ PR gdb/23712
+ PR symtab/23010
+ * dictionary.h (struct dictionary): Replace declaration with
+ multidictionary.
+ (dict_create_hashed, dict_create_hashed_expandable)
+ (dict_create_linear, dict_create_linear_expandable)
+ (dict_free, dict_add_symbol, dict_add_pending, dict_empty)
+ (dict_iterator_first, dict_iterator_next, dict_iter_match_first)
+ (dict_iter_match_next, dict_size): Rename to "mdict_" versions
+ taking multidictionary argument.
+ [ALL_DICT_SYMBOLS]: Update for multidictionary.
+ * block.h (struct block) <dict>: Change to multidictionary
+ and rename `multidict'.
+ * block.c, buildsym.c, jit.c, mdebugread.c, objfiles.c,
+ symmisc.c: Update all dictionary references to multidictionary.
+
2019-01-10 Keith Seitz <keiths@redhat.com>
PR gdb/23712
zero/NULL. This is useful for creating "dummy" blocks that don't
correspond to actual source files.
- Warning: it sets the block's BLOCK_DICT to NULL, which isn't a
+ Warning: it sets the block's BLOCK_MULTIDICT to NULL, which isn't a
valid value. If you really don't want the block to have a
- dictionary, then you should subsequently set its BLOCK_DICT to
+ dictionary, then you should subsequently set its BLOCK_MULTIDICT to
dict_create_linear (obstack, NULL). */
struct block *
block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
iterator->which);
- sym = dict_iterator_first (BLOCK_DICT (block), &iterator->dict_iter);
+ sym = mdict_iterator_first (BLOCK_MULTIDICT (block),
+ &iterator->mdict_iter);
}
else
- sym = dict_iterator_next (&iterator->dict_iter);
+ sym = mdict_iterator_next (&iterator->mdict_iter);
if (sym != NULL)
return sym;
initialize_block_iterator (block, iterator);
if (iterator->which == FIRST_LOCAL_BLOCK)
- return dict_iterator_first (block->dict, &iterator->dict_iter);
+ return mdict_iterator_first (block->multidict, &iterator->mdict_iter);
return block_iterator_step (iterator, 1);
}
block_iterator_next (struct block_iterator *iterator)
{
if (iterator->which == FIRST_LOCAL_BLOCK)
- return dict_iterator_next (&iterator->dict_iter);
+ return mdict_iterator_next (&iterator->mdict_iter);
return block_iterator_step (iterator, 0);
}
block = BLOCKVECTOR_BLOCK (COMPUNIT_BLOCKVECTOR (cust),
iterator->which);
- sym = dict_iter_match_first (BLOCK_DICT (block), name,
- &iterator->dict_iter);
+ sym = mdict_iter_match_first (BLOCK_MULTIDICT (block), name,
+ &iterator->mdict_iter);
}
else
- sym = dict_iter_match_next (name, &iterator->dict_iter);
+ sym = mdict_iter_match_next (name, &iterator->mdict_iter);
if (sym != NULL)
return sym;
initialize_block_iterator (block, iterator);
if (iterator->which == FIRST_LOCAL_BLOCK)
- return dict_iter_match_first (block->dict, name, &iterator->dict_iter);
+ return mdict_iter_match_first (block->multidict, name,
+ &iterator->mdict_iter);
return block_iter_match_step (iterator, name, 1);
}
struct block_iterator *iterator)
{
if (iterator->which == FIRST_LOCAL_BLOCK)
- return dict_iter_match_next (name, &iterator->dict_iter);
+ return mdict_iter_match_next (name, &iterator->mdict_iter);
return block_iter_match_step (iterator, name, 0);
}
const domain_enum domain)
{
struct symbol *sym, *other;
- struct dict_iterator dict_iter;
+ struct mdict_iterator mdict_iter;
lookup_name_info lookup_name (name, symbol_name_match_type::FULL);
|| BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) == NULL);
other = NULL;
- for (sym = dict_iter_match_first (block->dict, lookup_name, &dict_iter);
+ for (sym
+ = mdict_iter_match_first (block->multidict, lookup_name, &mdict_iter);
sym != NULL;
- sym = dict_iter_match_next (lookup_name, &dict_iter))
+ sym = mdict_iter_match_next (lookup_name, &mdict_iter))
{
if (SYMBOL_DOMAIN (sym) == domain)
return sym;
/* This is used to store the symbols in the block. */
- struct dictionary *dict;
+ struct multidictionary *multidict;
/* Contains information about namespace-related info relevant to this block:
using directives and the current namespace scope. */
#define BLOCK_END(bl) (bl)->endaddr
#define BLOCK_FUNCTION(bl) (bl)->function
#define BLOCK_SUPERBLOCK(bl) (bl)->superblock
-#define BLOCK_DICT(bl) (bl)->dict
+#define BLOCK_MULTIDICT(bl) (bl)->multidict
#define BLOCK_NAMESPACE(bl) (bl)->namespace_info
/* Accessor for ranges field within block BL. */
enum block_enum which;
- /* The underlying dictionary iterator. */
+ /* The underlying multidictionary iterator. */
- struct dict_iterator dict_iter;
+ struct mdict_iterator mdict_iter;
};
/* Initialize ITERATOR to point at the first symbol in BLOCK, and
if (symbol)
{
- BLOCK_DICT (block)
- = dict_create_linear (&m_objfile->objfile_obstack,
- m_language, *listhead);
+ BLOCK_MULTIDICT (block)
+ = mdict_create_linear (&m_objfile->objfile_obstack, *listhead);
}
else
{
if (expandable)
{
- BLOCK_DICT (block) = dict_create_hashed_expandable (m_language);
- dict_add_pending (BLOCK_DICT (block), *listhead);
+ BLOCK_MULTIDICT (block) = mdict_create_hashed_expandable (m_language);
+ mdict_add_pending (BLOCK_MULTIDICT (block), *listhead);
}
else
{
- BLOCK_DICT (block) =
- dict_create_hashed (&m_objfile->objfile_obstack,
- m_language, *listhead);
+ BLOCK_MULTIDICT (block) =
+ mdict_create_hashed (&m_objfile->objfile_obstack, *listhead);
}
}
if (symbol)
{
struct type *ftype = SYMBOL_TYPE (symbol);
- struct dict_iterator iter;
+ struct mdict_iterator miter;
SYMBOL_BLOCK_VALUE (symbol) = block;
BLOCK_FUNCTION (block) = symbol;
/* Here we want to directly access the dictionary, because
we haven't fully initialized the block yet. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
{
if (SYMBOL_IS_ARGUMENT (sym))
nparams++;
iparams = 0;
/* Here we want to directly access the dictionary, because
we haven't fully initialized the block yet. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
{
if (iparams == nparams)
break;
{
struct block *block = BLOCKVECTOR_BLOCK (blockvector, block_i);
struct symbol *sym;
- struct dict_iterator iter;
+ struct mdict_iterator miter;
/* Inlined functions may have symbols not in the global or
static symbol lists. */
/* Note that we only want to fix up symbols from the local
blocks, not blocks coming from included symtabs. That is why
we use ALL_DICT_SYMBOLS here and not ALL_BLOCK_SYMBOLS. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (block), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (block), miter, sym)
if (symbol_symtab (sym) == NULL)
symbol_set_symtab (sym, symtab);
}
to the primary symtab. */
set_missing_symtab (m_file_symbols, cust);
- dict_add_pending (BLOCK_DICT (block), m_file_symbols);
+ mdict_add_pending (BLOCK_MULTIDICT (block), m_file_symbols);
}
if (m_global_symbols != NULL)
to the primary symtab. */
set_missing_symtab (m_global_symbols, cust);
- dict_add_pending (BLOCK_DICT (block),
+ mdict_add_pending (BLOCK_MULTIDICT (block),
m_global_symbols);
}
}
#include "symfile.h"
-/* An opaque type for dictionaries; only dictionary.c should know
- about its innards. */
+/* An opaque type for multi-language dictionaries; only dictionary.c should
+ know about its innards. */
-struct dictionary;
+struct multidictionary;
/* Other types needed for declarations. */
struct language_defn;
/* The creation functions for various implementations of
- dictionaries. */
+ multi-language dictionaries. */
-/* Create a dictionary of symbols of language LANGUAGE implemented via
+/* Create a multi-language dictionary of symbols implemented via
a fixed-size hashtable. All memory it uses is allocated on
OBSTACK; the environment is initialized from SYMBOL_LIST. */
-extern struct dictionary *dict_create_hashed (struct obstack *obstack,
- enum language language,
- const struct pending
- *symbol_list);
+extern struct multidictionary *
+ mdict_create_hashed (struct obstack *obstack,
+ const struct pending *symbol_list);
-/* Create a dictionary of symbols of language LANGUAGE, implemented
- via a hashtable that grows as necessary. The dictionary is
- initially empty; to add symbols to it, call dict_add_symbol().
- Call dict_free() when you're done with it. */
+/* Create a multi-language dictionary of symbols, implemented
+ via a hashtable that grows as necessary. The initial dictionary of
+ LANGUAGE is empty; to add symbols to it, call mdict_add_symbol().
+ Call mdict_free() when you're done with it. */
-extern struct dictionary *
- dict_create_hashed_expandable (enum language language);
+extern struct multidictionary *
+ mdict_create_hashed_expandable (enum language language);
-/* Create a dictionary of symbols of language LANGUAGE, implemented
+/* Create a multi-language dictionary of symbols, implemented
via a fixed-size array. All memory it uses is allocated on
OBSTACK; the environment is initialized from the SYMBOL_LIST. The
symbols are ordered in the same order that they're found in
SYMBOL_LIST. */
-extern struct dictionary *dict_create_linear (struct obstack *obstack,
- enum language language,
- const struct pending
- *symbol_list);
+extern struct multidictionary *
+ mdict_create_linear (struct obstack *obstack,
+ const struct pending *symbol_list);
-/* Create a dictionary of symbols of language LANGUAGE, implemented
- via an array that grows as necessary. The dictionary is initially
- empty; to add symbols to it, call dict_add_symbol(). Call
- dict_free() when you're done with it. */
+/* Create a multi-language dictionary of symbols, implemented
+ via an array that grows as necessary. The multidictionary initially
+ contains a single empty dictionary of LANGUAGE; to add symbols to it,
+ call mdict_add_symbol(). Call mdict_free() when you're done with it. */
-extern struct dictionary *
- dict_create_linear_expandable (enum language language);
+extern struct multidictionary *
+ mdict_create_linear_expandable (enum language language);
-/* The functions providing the interface to dictionaries. Note that
- the most common parts of the interface, namely symbol lookup, are
- only provided via iterator functions. */
+/* The functions providing the interface to multi-language dictionaries.
+ Note that the most common parts of the interface, namely symbol lookup,
+ are only provided via iterator functions. */
-/* Free the memory used by a dictionary that's not on an obstack. (If
+/* Free the memory used by a multidictionary that's not on an obstack. (If
any.) */
-extern void dict_free (struct dictionary *dict);
+extern void mdict_free (struct multidictionary *mdict);
-/* Add a symbol to an expandable dictionary. */
+/* Add a symbol to an expandable multidictionary. */
-extern void dict_add_symbol (struct dictionary *dict, struct symbol *sym);
+extern void mdict_add_symbol (struct multidictionary *mdict,
+ struct symbol *sym);
-/* Utility to add a list of symbols to a dictionary. */
+/* Utility to add a list of symbols to a multidictionary. */
-extern void dict_add_pending (struct dictionary *dict,
- const struct pending *symbol_list);
+extern void mdict_add_pending (struct multidictionary *mdict,
+ const struct pending *symbol_list);
-/* Is the dictionary empty? */
+/* Is the multidictionary empty? */
-extern int dict_empty (struct dictionary *dict);
+extern int mdict_empty (struct multidictionary *mdict);
/* A type containing data that is used when iterating over all symbols
in a dictionary. Don't ever look at its innards; this type would
unsigned short current_idx;
};
-/* Initialize ITERATOR to point at the first symbol in DICT, and
- return that first symbol, or NULL if DICT is empty. */
+/* Initialize ITERATOR to point at the first symbol in MDICT, and
+ return that first symbol, or NULL if MDICT is empty. */
-extern struct symbol *dict_iterator_first (const struct dictionary *dict,
- struct dict_iterator *iterator);
+extern struct symbol *
+ mdict_iterator_first (const struct multidictionary *mdict,
+ struct mdict_iterator *miterator);
-/* Advance ITERATOR, and return the next symbol, or NULL if there are
+/* Advance MITERATOR, and return the next symbol, or NULL if there are
no more symbols. Don't call this if you've previously received
- NULL from dict_iterator_first or dict_iterator_next on this
+ NULL from mdict_iterator_first or mdict_iterator_next on this
iteration. */
-extern struct symbol *dict_iterator_next (struct dict_iterator *iterator);
+extern struct symbol *mdict_iterator_next (struct mdict_iterator *miterator);
-/* Initialize ITERATOR to point at the first symbol in DICT whose
+/* Initialize MITERATOR to point at the first symbol in MDICT whose
SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (which must use
the same conventions as strcmp_iw and be compatible with any
dictionary hashing function), and return that first symbol, or NULL
if there are no such symbols. */
-extern struct symbol *dict_iter_match_first (const struct dictionary *dict,
- const lookup_name_info &name,
- struct dict_iterator *iterator);
+extern struct symbol *
+ mdict_iter_match_first (const struct multidictionary *mdict,
+ const lookup_name_info &name,
+ struct mdict_iterator *miterator);
-/* Advance ITERATOR to point at the next symbol in DICT whose
+/* Advance MITERATOR to point at the next symbol in MDICT whose
SYMBOL_SEARCH_NAME is NAME, as tested using COMPARE (see
dict_iter_match_first), or NULL if there are no more such symbols.
Don't call this if you've previously received NULL from
- dict_iterator_match_first or dict_iterator_match_next on this
- iteration. And don't call it unless ITERATOR was created by a
- previous call to dict_iter_match_first with the same NAME and COMPARE. */
+ mdict_iterator_match_first or mdict_iterator_match_next on this
+ iteration. And don't call it unless MITERATOR was created by a
+ previous call to mdict_iter_match_first with the same NAME and COMPARE. */
-extern struct symbol *dict_iter_match_next (const lookup_name_info &name,
- struct dict_iterator *iterator);
+extern struct symbol *mdict_iter_match_next (const lookup_name_info &name,
+ struct mdict_iterator *miterator);
-/* Return some notion of the size of the dictionary: the number of
+/* Return some notion of the size of the multidictionary: the number of
symbols if we have that, the number of hash buckets otherwise. */
-extern int dict_size (const struct dictionary *dict);
+extern int mdict_size (const struct multidictionary *mdict);
/* Macro to loop through all symbols in a dictionary DICT, in no
particular order. ITER is a struct dict_iterator (NOTE: __not__ a
early by a break if you desire. */
#define ALL_DICT_SYMBOLS(dict, iter, sym) \
- for ((sym) = dict_iterator_first ((dict), &(iter)); \
+ for ((sym) = mdict_iterator_first ((dict), &(iter)); \
(sym); \
- (sym) = dict_iterator_next (&(iter)))
+ (sym) = mdict_iterator_next (&(iter)))
#endif /* DICTIONARY_H */
size_t blockvector_size;
CORE_ADDR begin, end;
struct blockvector *bv;
- enum language language;
actual_nblocks = FIRST_LOCAL_BLOCK + stab->nblocks;
cust = allocate_compunit_symtab (objfile, stab->file_name);
allocate_symtab (cust, stab->file_name);
add_compunit_symtab_to_objfile (cust);
- language = compunit_language (cust);
/* JIT compilers compile in memory. */
COMPUNIT_DIRNAME (cust) = NULL;
TARGET_CHAR_BIT,
"void");
- BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
- language, NULL);
+ BLOCK_MULTIDICT (new_block)
+ = mdict_create_linear (&objfile->objfile_obstack, NULL);
/* The address range. */
BLOCK_START (new_block) = (CORE_ADDR) gdb_block_iter->begin;
BLOCK_END (new_block) = (CORE_ADDR) gdb_block_iter->end;
new_block = (i == GLOBAL_BLOCK
? allocate_global_block (&objfile->objfile_obstack)
: allocate_block (&objfile->objfile_obstack));
- BLOCK_DICT (new_block) = dict_create_linear (&objfile->objfile_obstack,
- language, NULL);
+ BLOCK_MULTIDICT (new_block)
+ = mdict_create_linear (&objfile->objfile_obstack, NULL);
BLOCK_SUPERBLOCK (new_block) = block_iter;
block_iter = new_block;
add_symbol (struct symbol *s, struct symtab *symtab, struct block *b)
{
symbol_set_symtab (s, symtab);
- dict_add_symbol (BLOCK_DICT (b), s);
+ mdict_add_symbol (BLOCK_MULTIDICT (b), s);
}
/* Add a new block B to a symtab S. */
}
/* Allocate and zero a new block of language LANGUAGE, and set its
- BLOCK_DICT. If function is non-zero, assume the block is
+ BLOCK_MULTIDICT. If function is non-zero, assume the block is
associated to a function, and make sure that the symbols are stored
linearly; otherwise, store them hashed. */
struct block *retval = XCNEW (struct block);
if (type == FUNCTION_BLOCK)
- BLOCK_DICT (retval) = dict_create_linear_expandable (language);
+ BLOCK_MULTIDICT (retval) = mdict_create_linear_expandable (language);
else
- BLOCK_DICT (retval) = dict_create_hashed_expandable (language);
+ BLOCK_MULTIDICT (retval) = mdict_create_hashed_expandable (language);
return retval;
}
{
struct block *b;
struct symbol *sym;
- struct dict_iterator iter;
+ struct mdict_iterator miter;
b = BLOCKVECTOR_BLOCK (bv, i);
BLOCK_START (b) += ANOFFSET (delta, block_line_section);
/* We only want to iterate over the local symbols, not any
symbols in included symtabs. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
{
relocate_one_symbol (sym, objfile, delta);
}
struct objfile *objfile = SYMTAB_OBJFILE (symtab);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
int i;
- struct dict_iterator iter;
+ struct mdict_iterator miter;
int len;
struct linetable *l;
const struct blockvector *bv;
even if we're using a hashtable, but nothing else but this message
wants it. */
fprintf_filtered (outfile, ", %d syms/buckets in ",
- dict_size (BLOCK_DICT (b)));
+ mdict_size (BLOCK_MULTIDICT (b)));
fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
fprintf_filtered (outfile, "..");
fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
/* Now print each symbol in this block (in no particular order, if
we're using a hashtable). Note that we only want this
block, not any blocks from included symtabs. */
- ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
+ ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
{
TRY
{
projects / binutils-gdb.git / commitdiff