mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-23 18:14:13 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

gdb/23712: Use new multidictionary API

Browse Source 
This patch builds on the previous by enabling the `new' multidictionary
API.  A lot of the hunks are simply textual replacements of "dict_"
with "mdict_" and similar transformations.

A word of warning, even with the use of multidictionaries, the code
still does not satisfactorily fix the reported problems with gdb/23712
(or gdb/23010). We still have additional changes to make before that
happens.

gdb/ChangeLog:

	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.
This commit is contained in:
Keith Seitz 2019-01-10 13:57:08 -08:00
parent c7748ee9ce
commit b026f59345
9 changed files with 125 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
gdb/ChangeLog
View File

@ -1,3 +1,21 @@
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

31
gdb/block.c
View File

@ -387,9 +387,9 @@ block_global_block (const struct block *block)
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 *
@ -544,10 +544,11 @@ block_iterator_step (struct block_iterator *iterator, int first)
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;
@ -569,7 +570,7 @@ block_iterator_first (const struct block *block,
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);
}
@ -580,7 +581,7 @@ struct symbol *
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);
}
@ -612,11 +613,11 @@ block_iter_match_step (struct block_iterator *iterator,
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;
@ -639,7 +640,8 @@ block_iter_match_first (const struct block *block,
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);
}
@ -651,7 +653,7 @@ block_iter_match_next (const lookup_name_info &name,
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);
}
@ -731,7 +733,7 @@ block_lookup_symbol_primary (const struct block *block, const char *name,
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);
@ -740,9 +742,10 @@ block_lookup_symbol_primary (const struct block *block, const char *name,
|| 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;

8
gdb/block.h
View File

@ -111,7 +111,7 @@ struct block
/* 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. */
@ -143,7 +143,7 @@ struct global_block
#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. */
@ -298,9 +298,9 @@ struct block_iterator
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

28
gdb/buildsym.c
View File

@ -227,22 +227,20 @@ buildsym_compunit::finish_block_internal
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);
}
}
@ -254,7 +252,7 @@ buildsym_compunit::finish_block_internal
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;
@ -268,7 +266,7 @@ buildsym_compunit::finish_block_internal
/* 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++;
@ -282,7 +280,7 @@ buildsym_compunit::finish_block_internal
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;
@ -1066,7 +1064,7 @@ buildsym_compunit::end_symtab_with_blockvector (struct block *static_block,
{
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. */
@ -1077,7 +1075,7 @@ buildsym_compunit::end_symtab_with_blockvector (struct block *static_block,
/* 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);
}
@ -1211,7 +1209,7 @@ buildsym_compunit::augment_type_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)
@ -1222,7 +1220,7 @@ buildsym_compunit::augment_type_symtab ()
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);
}
}

119
gdb/dictionary.h
View File

@ -25,10 +25,10 @@
#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. */
@ -38,65 +38,64 @@ struct pending;
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
@ -128,44 +127,46 @@ struct mdict_iterator
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
@ -175,8 +176,8 @@ extern int dict_size (const struct dictionary *dict);
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 */

10
gdb/jit.c
View File

@ -651,14 +651,12 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
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;
@ -702,8 +700,8 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
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;
@ -740,8 +738,8 @@ finalize_symtab (struct gdb_symtab *stab, struct objfile *objfile)
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;

8
gdb/mdebugread.c
View File

@ -4506,7 +4506,7 @@ static void
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. */
@ -4734,7 +4734,7 @@ new_bvect (int nblocks)
}
/* 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. */
@ -4747,9 +4747,9 @@ new_block (enum block_type type, enum language language)
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;
}

4
gdb/objfiles.c
View File

@ -818,7 +818,7 @@ objfile_relocate1 (struct objfile *objfile,
{
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);
@ -835,7 +835,7 @@ objfile_relocate1 (struct objfile *objfile,
/* 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);
}

6
gdb/symmisc.c
View File

@ -276,7 +276,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
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;
@ -332,7 +332,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
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);
@ -350,7 +350,7 @@ dump_symtab_1 (struct symtab *symtab, struct ui_file *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
{